diff --git a/Modules/CppRestSdk/include/mitkRESTClient.h b/Modules/CppRestSdk/include/mitkRESTClient.h
index 4d29b01642..fb08ec7495 100644
--- a/Modules/CppRestSdk/include/mitkRESTClient.h
+++ b/Modules/CppRestSdk/include/mitkRESTClient.h
@@ -1,61 +1,63 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKRESTCLIENT_H
 #define MITKRESTCLIENT_H
 
 #include "cpprest/asyncrt_utils.h"
 #include "cpprest/containerstream.h"
 #include "cpprest/filestream.h"
 #include "cpprest/http_client.h"
 #include "cpprest/json.h"
 #include "cpprest/producerconsumerstream.h"
 #include "cpprest/uri.h"
 
 // hm.. maybe go after that warning at some time? seems like a nasty hack, but works so far :)
 #pragma warning(disable : 4251)
 
 #include "MitkCppRestSdkExports.h"
 
 typedef web::http::client::http_client MitkClient;
 typedef web::http::http_request MitkRequest;
 typedef web::http::http_response MitkResponse;
 typedef web::http::methods MitkRESTMethods;
 typedef web::http::uri_builder MitkUriBuilder;
 typedef web::http::status_codes MitkRestStatusCodes;
 typedef web::json::json_exception MitkJsonException;
 
 namespace mitk
 {
   class MITKCPPRESTSDK_EXPORT RESTClient
   {
   public:;
     RESTClient(utility::string_t url);
     virtual ~RESTClient();
 
-	pplx::task<void> Post(utility::string_t uri);
+	pplx::task<void> Post(utility::string_t uri,
+                          utility::string_t contentType,
+                          concurrency::streams::streambuf<uint8_t> data);
     pplx::task<void> Get(const utility::string_t filePath, utility::string_t uri);
     pplx::task<void> WadoRS(const utility::string_t filePath, std::string studyUID, std::string seriesUID, std::string instanceUID);
     pplx::task<std::string> WadoRS(const utility::string_t filePath, std::string studyUID, std::string seriesUID);
-    pplx::task<void> StowRS(std::string studyUID);
+    pplx::task<void> StowRS(utility::string_t filePath, std::string studyUID);
 
   private:
     MitkClient m_Client;
 
   };
 };
 
 #endif // MITKRESTCLIENT_H
diff --git a/Modules/CppRestSdk/src/mitkRESTClient.cpp b/Modules/CppRestSdk/src/mitkRESTClient.cpp
index 349e97bb84..440bf9066d 100644
--- a/Modules/CppRestSdk/src/mitkRESTClient.cpp
+++ b/Modules/CppRestSdk/src/mitkRESTClient.cpp
@@ -1,143 +1,155 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkRESTClient.h"
 
 #include <mitkCommon.h>
 
 mitk::RESTClient::RESTClient(utility::string_t url) : m_Client(url) {
 }
 
 mitk::RESTClient::~RESTClient() {}
 
 pplx::task<void> mitk::RESTClient::Get(utility::string_t filePath, utility::string_t uri)
 {
   MITK_INFO << "Calling GET with " << utility::conversions::to_utf8string(uri) << " on client "
             << utility::conversions::to_utf8string(m_Client.base_uri().to_string()) << " save into "
             << utility::conversions::to_utf8string(filePath);
 
   auto fileBuffer = std::make_shared<concurrency::streams::streambuf<uint8_t>>();
 
   return concurrency::streams::file_buffer<uint8_t>::open(filePath, std::ios::out).then([=](concurrency::streams::streambuf<uint8_t> outFile) -> pplx::task<MitkResponse>
   {
     *fileBuffer = outFile;
 
     return m_Client.request(MitkRESTMethods::GET, uri);
   })
     // Write the response body into the file buffer.
     .then([=](MitkResponse response) -> pplx::task<size_t>
   {
       MITK_INFO << "Status code: " << response.status_code();
 
     return response.body().read_to_end(*fileBuffer);
   })
     // Close the file buffer.
     .then([=](size_t)
   {
     return fileBuffer->close();
   });
 }
 
-pplx::task<void> mitk::RESTClient::Post(utility::string_t uri)
+pplx::task<void> mitk::RESTClient::Post(utility::string_t uri,
+                                        utility::string_t contentType,
+                                        concurrency::streams::streambuf<uint8_t> data)
 {
   MITK_INFO << "Calling POST with " << utility::conversions::to_utf8string(uri) << " on client "
             << utility::conversions::to_utf8string(m_Client.base_uri().to_string());
 
-  return m_Client.request(MitkRESTMethods::POST, uri).then([&](MitkResponse response)
+  MitkRequest postRequest(MitkRESTMethods::POST);
+  postRequest.set_request_uri(uri);
+  postRequest.headers().add(U("Content-Type"), contentType);
+  postRequest.set_body(data);
+
+  return m_Client.request(postRequest).then([&](MitkResponse response)
   {
       MITK_INFO << "Status code: " << response.status_code(); 
   });
 }
 
 pplx::task<void> mitk::RESTClient::WadoRS(utility::string_t filePath, std::string studyUID, std::string seriesUID, std::string instanceUID)
 {
   MitkUriBuilder builder(U("wado"));
   builder.append_query(U("requestType"), U("WADO"));
   builder.append_query(U("studyUID"), utility::conversions::to_string_t(studyUID));
   builder.append_query(U("seriesUID"), utility::conversions::to_string_t(seriesUID));
   builder.append_query(U("objectUID"), utility::conversions::to_string_t(instanceUID));
   builder.append_query(U("contentType"), U("application/dicom"));
   return Get(filePath, builder.to_string());
 }
 
 pplx::task<std::string> mitk::RESTClient::WadoRS(const utility::string_t folderPath, std::string studyUID, std::string seriesUID)
 {
   // this is actually a quido-rs request, should be packed into a seperate method.. at some time.. 
    //but there are many possible requests to support: http://dicom.nema.org/medical/dicom/current/output/chtml/part18/sect_6.7.html
   MitkUriBuilder builder(U("rs/instances"));
   builder.append_query(U("StudyInstanceUID"), utility::conversions::to_string_t(studyUID));
   builder.append_query(U("SeriesInstanceUID"), utility::conversions::to_string_t(seriesUID));
 
   MITK_INFO << utility::conversions::to_utf8string(builder.to_string());
   MitkRequest getSeries(MitkRESTMethods::GET);
   getSeries.set_request_uri(builder.to_string());
   getSeries.headers().add(U("Accept"), U("application/json"));
 
   return m_Client.request(getSeries).then([=](MitkResponse response) -> pplx::task<std::string>
   {
     MITK_INFO << "search for instances in series with uid " << seriesUID
               << " status: " << response.status_code();
 
     auto jsonListResult = response.extract_json().get();
     auto resultArray = jsonListResult.as_array();
 
 	auto firstFileName = std::string();
 
     std::vector<pplx::task<void>> tasks;
 
     for (unsigned short i = 0; i < resultArray.size(); i++)
     {
       try 
       {
         auto firstResult = resultArray[i];
         auto sopInstanceUIDKey = firstResult.at(U("00080018"));
         auto sopInstanceObject = sopInstanceUIDKey.as_object();
         auto valueKey = sopInstanceObject.at(U("Value"));
         auto valueArray = valueKey.as_array();
         auto sopInstanceUID = valueArray[0].as_string();
 
 		auto fileName = sopInstanceUID.append(U(".dcm"));
 
 		// save first file name as result to load series
 		if (i == 0)
 		{
 			firstFileName = utility::conversions::to_utf8string(fileName);
 		}
 
         auto filePath = utility::string_t(folderPath).append(fileName);
         auto task = WadoRS(filePath, studyUID, seriesUID, utility::conversions::to_utf8string(sopInstanceUID));
         tasks.push_back(task);
       }
       catch (const web::json::json_exception& e) 
       {
         MITK_ERROR << e.what();
       }
     }
 
     auto joinTask = pplx::when_all(begin(tasks), end(tasks));
     return joinTask.then([=](void) 
 	{ 
 		return firstFileName;
 	});
   });
 }
 
-pplx::task<void> mitk::RESTClient::StowRS(std::string studyUID) {
-	// TODO: add data
+pplx::task<void> mitk::RESTClient::StowRS(utility::string_t filePath, std::string studyUID)
+{
+  // TODO: add data
   MitkUriBuilder builder(U("rs/studies"));
   builder.append_query(utility::conversions::to_string_t(studyUID));
-  return Post(builder.to_string());
+
+  concurrency::streams::file_buffer<uint8_t>::open(filePath, std::ios::in)
+    .then([&](concurrency::streams::streambuf<uint8_t> data) {
+      return Post(builder.to_string(), U("multipart/related; type='application/dicom'; boundary='boundary'"), data);
+    });
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
index b59b9fc386..a1673c0a5a 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.cpp
@@ -1,167 +1,177 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "SegmentationReworkView.h"
 
 // Qt
 #include <QMessageBox>
 
 #include <mitkIOUtil.h>
 
 const std::string SegmentationReworkView::VIEW_ID = "org.mitk.views.segmentationreworkview";
 
 void SegmentationReworkView::SetFocus() {}
 
 void SegmentationReworkView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   connect(m_Controls.buttonUpload, &QPushButton::clicked, this, &SegmentationReworkView::UploadNewSegmentation);
 
   utility::string_t port = U("2020");
   utility::string_t address = U("http://127.0.0.1:");
   address.append(port);
 
   m_HttpHandler = std::unique_ptr<SegmentationReworkREST>(new SegmentationReworkREST(address));
 
   connect(m_HttpHandler.get(),
           &SegmentationReworkREST::InvokeUpdateChartWidget,
           this,
           &SegmentationReworkView::UpdateChartWidget);
 
   m_HttpHandler->SetPutCallback(std::bind(&SegmentationReworkView::RESTPutCallback, this, std::placeholders::_1));
   m_HttpHandler->Open().wait();
 
   MITK_INFO << "Listening for requests at: " << utility::conversions::to_utf8string(address);
 
   utility::string_t pacsHost = U("http://193.174.48.78:8090/dcm4chee-arc/aets/DCM4CHEE");
   m_RestClient = new mitk::RESTClient(pacsHost);
 }
 
 void SegmentationReworkView::RESTPutCallback(const SegmentationReworkREST::DicomDTO &dto)
 {
   SetSimilarityGraph(dto.simScoreArray, dto.minSliceStart);
 
   MITK_INFO << "Loading image series";
   std::string folderPathSeries = "/temp/downloadSeries/";
+
+  m_CurrentStudyUID = dto.studyUID;
+
   m_RestClient->WadoRS(utility::conversions::to_string_t(folderPathSeries), dto.studyUID, dto.imageSeriesUID)
     .then([&](std::string fileName) {
       MITK_INFO << "Loading image series into data storage";
       auto folderPath = folderPathSeries;
       auto firstFilePath = folderPath.append(fileName);
       mitk::IOUtil::Load(firstFilePath, *this->GetDataStorage());
 
       MITK_INFO << "Loading segmentations...";
 
 	  auto filePathSegA = U("/temp/segA.dcm");
       auto filePathSegB = U("/temp/segB.dcm");
 
       m_RestClient->WadoRS(filePathSegA, dto.studyUID, dto.segSeriesUIDA, dto.segInstanceUIDA).then([&] {
        mitk::IOUtil::Load(utility::conversions::to_utf8string(filePathSegA), *this->GetDataStorage());
       });
 
       m_RestClient->WadoRS(filePathSegB, dto.studyUID, dto.segSeriesUIDB, dto.segInstanceUIDB).then([&] {
         mitk::IOUtil::Load(utility::conversions::to_utf8string(filePathSegB), *this->GetDataStorage());
       });
     });
 }
 
 void SegmentationReworkView::UpdateChartWidget()
 {
   m_Controls.chartWidget->Show();
 }
 
 void SegmentationReworkView::SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart)
 {
   std::map<double, double> map;
   MITK_INFO << simScoreArray.size();
 
   double sliceIndex = sliceMinStart;
   for (double score : simScoreArray)
   {
     map.insert(std::map<double, double>::value_type(sliceIndex, score));
     sliceIndex++;
   }
   m_Controls.chartWidget->AddData2D(map, "similarity score");
   m_Controls.chartWidget->SetChartType("similarity score", QmitkChartWidget::ChartType::line);
   m_Controls.chartWidget->SetXAxisLabel("slice number");
   m_Controls.chartWidget->SetYAxisLabel("similarity score");
 }
 
 void SegmentationReworkView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach (mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()))
     {
       m_Controls.labelWarning->setVisible(false);
       return;
     }
   }
 
   m_Controls.labelWarning->setVisible(true);
 }
 
-void SegmentationReworkView::UploadNewSegmentation() {}
+void SegmentationReworkView::UploadNewSegmentation() 
+{
+  auto filePath = U("path/to/dicomSeg.dcm");
+  m_RestClient->StowRS(filePath, m_CurrentStudyUID).then([] 
+  {
+	  MITK_INFO << "SEG uploaded";
+  });
+}
 
 void SegmentationReworkView::DoImageProcessing()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty())
     return;
 
   mitk::DataNode *node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData *data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     mitk::Image *image = dynamic_cast<mitk::Image *>(data);
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << "Performing image processing for image ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
       MITK_INFO << message.str();
 
       // actually do something here...
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
index b24a7a8e16..844fe96189 100644
--- a/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation.rework/src/internal/SegmentationReworkView.h
@@ -1,74 +1,76 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef SegmentationReworkView_h
 #define SegmentationReworkView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_SegmentationReworkViewControls.h"
 
 #include "SegmentationReworkRest.h"
 #include <mitkRESTClient.h>
 
 /**
   \brief SegmentationReworkView
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class SegmentationReworkView : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   void RESTPutCallback(const SegmentationReworkREST::DicomDTO& dto);
 
   void UpdateChartWidget();
 
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
 
   virtual void SetFocus() override;
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   /// \brief Called when the user clicks the GUI button
   void DoImageProcessing();
 
   void UploadNewSegmentation();
 
   Ui::SegmentationReworkViewControls m_Controls;
 
 private:
 
   void SetSimilarityGraph(std::vector<double> simScoreArray, int sliceMinStart);
 
   std::unique_ptr<SegmentationReworkREST> m_HttpHandler;
   mitk::RESTClient* m_RestClient;
+
+  std::string m_CurrentStudyUID;
 };
 
 #endif // SegmentationReworkView_h