diff --git a/app/ui/MainWindow.ui b/app/ui/MainWindow.ui
index 30bc87a..44aecb5 100644
--- a/app/ui/MainWindow.ui
+++ b/app/ui/MainWindow.ui
@@ -11,7 +11,7 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>QLop</string>
+   <string>SciQlop v0.0.1</string>
   </property>
   <property name="dockNestingEnabled">
    <bool>true</bool>
@@ -126,7 +126,7 @@
      <x>0</x>
      <y>0</y>
      <width>800</width>
-     <height>26</height>
+     <height>28</height>
     </rect>
    </property>
   </widget>
diff --git a/core/include/Data/IDataProvider.h b/core/include/Data/IDataProvider.h
index 6f4b5b6..59799d2 100644
--- a/core/include/Data/IDataProvider.h
+++ b/core/include/Data/IDataProvider.h
@@ -4,6 +4,7 @@
 #include <memory>
 
 #include <QObject>
+#include <QUuid>
 
 #include <Common/MetaTypes.h>
 
@@ -26,14 +27,11 @@ class IDataProvider : public QObject {
 public:
     virtual ~IDataProvider() noexcept = default;
 
-    virtual std::shared_ptr<IDataSeries>
-    retrieveData(const DataProviderParameters &parameters) const = 0;
-
-
-    virtual void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) = 0;
+    virtual void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) = 0;
 
 signals:
-    void dataProvided(std::shared_ptr<IDataSeries> dateSerie, const SqpDateTime &dateTime);
+    void dataProvided(QUuid token, std::shared_ptr<IDataSeries> dateSerie,
+                      const SqpDateTime &dateTime);
 };
 
 // Required for using shared_ptr in signals/slots
diff --git a/core/include/Network/NetworkController.h b/core/include/Network/NetworkController.h
new file mode 100644
index 0000000..0e36901
--- /dev/null
+++ b/core/include/Network/NetworkController.h
@@ -0,0 +1,30 @@
+#ifndef SCIQLOP_NETWORKCONTROLLER_H
+#define SCIQLOP_NETWORKCONTROLLER_H
+
+#include <QLoggingCategory>
+#include <QObject>
+
+#include <Common/spimpl.h>
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
+
+/**
+ * @brief The NetworkController class aims to handle all network connection of SciQlop.
+ */
+class NetworkController : public QObject {
+    Q_OBJECT
+public:
+    explicit NetworkController(QObject *parent = 0);
+
+
+    void initialize();
+    void finalize();
+
+private:
+    void waitForFinish();
+
+    class NetworkControllerPrivate;
+    spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
+};
+
+#endif // SCIQLOP_NETWORKCONTROLLER_H
diff --git a/core/src/Network/NetworkController.cpp b/core/src/Network/NetworkController.cpp
new file mode 100644
index 0000000..e015af4
--- /dev/null
+++ b/core/src/Network/NetworkController.cpp
@@ -0,0 +1,33 @@
+#include "Network/NetworkController.h"
+
+#include <QMutex>
+#include <QThread>
+
+Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
+
+struct NetworkController::NetworkControllerPrivate {
+    explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
+    QMutex m_WorkingMutex;
+};
+
+NetworkController::NetworkController(QObject *parent)
+        : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
+{
+}
+
+void NetworkController::initialize()
+{
+    qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
+    impl->m_WorkingMutex.lock();
+    qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
+}
+
+void NetworkController::finalize()
+{
+    impl->m_WorkingMutex.unlock();
+}
+
+void NetworkController::waitForFinish()
+{
+    QMutexLocker locker{&impl->m_WorkingMutex};
+}
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 0e58f7e..24bebc2 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -11,26 +11,13 @@
 #include <QDateTime>
 #include <QMutex>
 #include <QThread>
+#include <QUuid>
 #include <QtCore/QItemSelectionModel>
 
 #include <unordered_map>
 
 Q_LOGGING_CATEGORY(LOG_VariableController, "VariableController")
 
-namespace {
-
-/// @todo Generates default dataseries, according to the provider passed in parameter. This method
-/// will be deleted when the timerange is recovered from SciQlop
-std::shared_ptr<IDataSeries> generateDefaultDataSeries(const IDataProvider &provider,
-                                                       const SqpDateTime &dateTime) noexcept
-{
-    auto parameters = DataProviderParameters{dateTime};
-
-    return provider.retrieveData(parameters);
-}
-
-} // namespace
-
 struct VariableController::VariableControllerPrivate {
     explicit VariableControllerPrivate(VariableController *parent)
             : m_WorkingMutex{},
@@ -51,6 +38,7 @@ struct VariableController::VariableControllerPrivate {
 
     std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
         m_VariableToProviderMap;
+    std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToToken;
 };
 
 VariableController::VariableController(QObject *parent)
@@ -132,16 +120,21 @@ void VariableController::createVariable(const QString &name,
     /// in sciqlop
     auto dateTime = impl->m_TimeController->dateTime();
     if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
+        auto token = QUuid::createUuid();
 
         // store the provider
         impl->m_VariableToProviderMap[newVariable] = provider;
+        impl->m_VariableToToken[newVariable] = token;
 
         auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
-            auto dataSeriesAcquired, auto dateTimeToPutInCache)
+            QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
         {
             if (auto variable = varW.lock()) {
-                impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
-                variable->setDataSeries(dataSeriesAcquired);
+                auto varToken = impl->m_VariableToToken.at(variable);
+                if (varToken == token) {
+                    impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
+                    variable->setDataSeries(dataSeriesAcquired);
+                }
             }
         };
 
@@ -180,8 +173,9 @@ void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable
 
         if (!dateTimeListNotInCache.empty()) {
             // Ask the provider for each data on the dateTimeListNotInCache
+            auto token = impl->m_VariableToToken.at(variable);
             impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                std::move(dateTimeListNotInCache));
+                token, std::move(dateTimeListNotInCache));
         }
         else {
             emit variable->updated();
diff --git a/gui/include/SqpApplication.h b/gui/include/SqpApplication.h
index 87bc813..a23bd7f 100644
--- a/gui/include/SqpApplication.h
+++ b/gui/include/SqpApplication.h
@@ -16,6 +16,7 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
 #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
 
 class DataSourceController;
+class NetworkController;
 class TimeController;
 class VariableController;
 class VisualizationController;
@@ -38,6 +39,7 @@ public:
 
     /// Accessors for the differents sciqlop controllers
     DataSourceController &dataSourceController() noexcept;
+    NetworkController &networkController() noexcept;
     TimeController &timeController() noexcept;
     VariableController &variableController() noexcept;
     VisualizationController &visualizationController() noexcept;
diff --git a/gui/src/SqpApplication.cpp b/gui/src/SqpApplication.cpp
index c79f0f7..a50fa86 100644
--- a/gui/src/SqpApplication.cpp
+++ b/gui/src/SqpApplication.cpp
@@ -2,6 +2,7 @@
 
 #include <Data/IDataProvider.h>
 #include <DataSource/DataSourceController.h>
+#include <Network/NetworkController.h>
 #include <QThread>
 #include <Time/TimeController.h>
 #include <Variable/Variable.h>
@@ -14,18 +15,11 @@ class SqpApplication::SqpApplicationPrivate {
 public:
     SqpApplicationPrivate()
             : m_DataSourceController{std::make_unique<DataSourceController>()},
+              m_NetworkController{std::make_unique<NetworkController>()},
               m_TimeController{std::make_unique<TimeController>()},
               m_VariableController{std::make_unique<VariableController>()},
               m_VisualizationController{std::make_unique<VisualizationController>()}
     {
-        QThread::currentThread()->setObjectName("MainThread");
-        m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
-        m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
-        m_VariableController->moveToThread(&m_VariableControllerThread);
-        m_VariableControllerThread.setObjectName("VariableControllerThread");
-        m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
-        m_VisualizationControllerThread.setObjectName("VisualizationControllerThread");
-
         // /////////////////////////////// //
         // Connections between controllers //
         // /////////////////////////////// //
@@ -43,6 +37,12 @@ public:
                 SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
 
 
+        m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
+        m_NetworkController->moveToThread(&m_NetworkControllerThread);
+        m_VariableController->moveToThread(&m_VariableControllerThread);
+        m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
+
+
         // Additionnal init
         m_VariableController->setTimeController(m_TimeController.get());
     }
@@ -53,6 +53,9 @@ public:
         m_DataSourceControllerThread.quit();
         m_DataSourceControllerThread.wait();
 
+        m_NetworkControllerThread.quit();
+        m_NetworkControllerThread.wait();
+
         m_VariableControllerThread.quit();
         m_VariableControllerThread.wait();
 
@@ -63,8 +66,10 @@ public:
     std::unique_ptr<DataSourceController> m_DataSourceController;
     std::unique_ptr<VariableController> m_VariableController;
     std::unique_ptr<TimeController> m_TimeController;
+    std::unique_ptr<NetworkController> m_NetworkController;
     std::unique_ptr<VisualizationController> m_VisualizationController;
     QThread m_DataSourceControllerThread;
+    QThread m_NetworkControllerThread;
     QThread m_VariableControllerThread;
     QThread m_VisualizationControllerThread;
 };
@@ -80,6 +85,11 @@ SqpApplication::SqpApplication(int &argc, char **argv)
     connect(&impl->m_DataSourceControllerThread, &QThread::finished,
             impl->m_DataSourceController.get(), &DataSourceController::finalize);
 
+    connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
+            &NetworkController::initialize);
+    connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
+            &NetworkController::finalize);
+
     connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
             &VariableController::initialize);
     connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
@@ -91,6 +101,7 @@ SqpApplication::SqpApplication(int &argc, char **argv)
             impl->m_VisualizationController.get(), &VisualizationController::finalize);
 
     impl->m_DataSourceControllerThread.start();
+    impl->m_NetworkControllerThread.start();
     impl->m_VariableControllerThread.start();
     impl->m_VisualizationControllerThread.start();
 }
@@ -108,6 +119,11 @@ DataSourceController &SqpApplication::dataSourceController() noexcept
     return *impl->m_DataSourceController;
 }
 
+NetworkController &SqpApplication::networkController() noexcept
+{
+    return *impl->m_NetworkController;
+}
+
 TimeController &SqpApplication::timeController() noexcept
 {
     return *impl->m_TimeController;
diff --git a/plugins/amda/CMakeLists.txt b/plugins/amda/CMakeLists.txt
index bfa7e21..1b66326 100644
--- a/plugins/amda/CMakeLists.txt
+++ b/plugins/amda/CMakeLists.txt
@@ -13,7 +13,7 @@ INCLUDE_DIRECTORIES(${RESOURCES_DIR})
 #
 # Find Qt modules
 #
-SCIQLOP_FIND_QT(Core Widgets)
+SCIQLOP_FIND_QT(Core Widgets Network)
 
 #
 # Find dependent libraries
@@ -68,7 +68,7 @@ INSTALL(TARGETS ${SQPAMDA_LIBRARY_NAME}
 
 
 TARGET_LINK_LIBRARIES(${SQPAMDA_LIBRARY_NAME} ${LIBRARIES})
-qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets)
+qt5_use_modules(${SQPAMDA_LIBRARY_NAME} Core Widgets Network)
 
 add_dependencies(${SQPAMDA_LIBRARY_NAME} ${SQPPLUGIN_LIBRARY_NAME} ${SQPGUI_LIBRARY_NAME} ${SQPCORE_LIBRARY_NAME})
 	
diff --git a/plugins/amda/include/AmdaProvider.h b/plugins/amda/include/AmdaProvider.h
new file mode 100644
index 0000000..38c5924
--- /dev/null
+++ b/plugins/amda/include/AmdaProvider.h
@@ -0,0 +1,36 @@
+#ifndef SCIQLOP_AMDAPROVIDER_H
+#define SCIQLOP_AMDAPROVIDER_H
+
+#include "AmdaGlobal.h"
+
+#include <Common/spimpl.h>
+
+#include <Data/IDataProvider.h>
+
+#include <QLoggingCategory>
+
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
+
+/**
+ * @brief The AmdaProvider class is an example of how a data provider can generate data
+ */
+class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
+public:
+    explicit AmdaProvider();
+
+    void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
+
+private:
+    void retrieveData(QUuid token, const DataProviderParameters &parameters) const;
+
+    class AmdaProviderPrivate;
+    spimpl::unique_impl_ptr<AmdaProviderPrivate> impl;
+
+private slots:
+    void httpFinished() noexcept;
+    void httpDownloadFinished() noexcept;
+    void httpDownloadReadyRead() noexcept;
+};
+
+#endif // SCIQLOP_AMDAPROVIDER_H
diff --git a/plugins/amda/include/AmdaResultParser.h b/plugins/amda/include/AmdaResultParser.h
new file mode 100644
index 0000000..8c4bc61
--- /dev/null
+++ b/plugins/amda/include/AmdaResultParser.h
@@ -0,0 +1,19 @@
+#ifndef SCIQLOP_AMDARESULTPARSER_H
+#define SCIQLOP_AMDARESULTPARSER_H
+
+#include "AmdaGlobal.h"
+
+#include <QLoggingCategory>
+
+#include <memory>
+
+class IDataSeries;
+
+Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaResultParser)
+
+struct SCIQLOP_AMDA_EXPORT AmdaResultParser {
+
+    static std::shared_ptr<IDataSeries> readTxt(const QString &filePath) noexcept;
+};
+
+#endif // SCIQLOP_AMDARESULTPARSER_H
diff --git a/plugins/amda/src/AmdaPlugin.cpp b/plugins/amda/src/AmdaPlugin.cpp
index 555755d..af18f76 100644
--- a/plugins/amda/src/AmdaPlugin.cpp
+++ b/plugins/amda/src/AmdaPlugin.cpp
@@ -1,8 +1,10 @@
 #include "AmdaPlugin.h"
 #include "AmdaParser.h"
+#include "AmdaProvider.h"
 
 #include <DataSource/DataSourceController.h>
 #include <DataSource/DataSourceItem.h>
+#include <DataSource/DataSourceItemAction.h>
 
 #include <SqpApplication.h>
 
@@ -16,6 +18,28 @@ const auto DATA_SOURCE_NAME = QStringLiteral("AMDA");
 /// Path of the file used to generate the data source item for AMDA
 const auto JSON_FILE_PATH = QStringLiteral(":/samples/AmdaSample.json");
 
+void associateActions(DataSourceItem &item, const QUuid &dataSourceUid)
+{
+    if (item.type() == DataSourceItemType::PRODUCT) {
+        auto itemName = item.name();
+
+        item.addAction(std::make_unique<DataSourceItemAction>(
+            QObject::tr("Load %1 product").arg(itemName),
+            [itemName, dataSourceUid](DataSourceItem &item) {
+                if (auto app = sqpApp) {
+                    app->dataSourceController().loadProductItem(dataSourceUid, item);
+                }
+            }));
+    }
+
+    auto count = item.childCount();
+    for (auto i = 0; i < count; ++i) {
+        if (auto child = item.child(i)) {
+            associateActions(*child, dataSourceUid);
+        }
+    }
+}
+
 } // namespace
 
 void AmdaPlugin::initialize()
@@ -27,11 +51,16 @@ void AmdaPlugin::initialize()
 
         // Sets data source tree
         if (auto dataSourceItem = AmdaParser::readJson(JSON_FILE_PATH)) {
+            associateActions(*dataSourceItem, dataSourceUid);
+
             dataSourceController.setDataSourceItem(dataSourceUid, std::move(dataSourceItem));
         }
         else {
             qCCritical(LOG_AmdaPlugin()) << tr("No data source item could be generated for AMDA");
         }
+
+        // Sets data provider
+        dataSourceController.setDataProvider(dataSourceUid, std::make_unique<AmdaProvider>());
     }
     else {
         qCWarning(LOG_AmdaPlugin()) << tr("Can't access to SciQlop application");
diff --git a/plugins/amda/src/AmdaProvider.cpp b/plugins/amda/src/AmdaProvider.cpp
new file mode 100644
index 0000000..88777fc
--- /dev/null
+++ b/plugins/amda/src/AmdaProvider.cpp
@@ -0,0 +1,134 @@
+#include "AmdaProvider.h"
+#include "AmdaResultParser.h"
+
+#include <Data/DataProviderParameters.h>
+
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QTemporaryFile>
+
+Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
+
+namespace {
+
+/// URL format for a request on AMDA server. The parameters are as follows:
+/// - %1: start date
+/// - %2: end date
+/// - %3: parameter id
+const auto AMDA_URL_FORMAT = QStringLiteral(
+    "http://amda.irap.omp.eu/php/rest/"
+    "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&sampling=60&outputFormat=ASCII&"
+    "timeFormat=ISO8601&gzip=0");
+
+/// Dates format passed in the URL (e.g 2013-09-23T09:00)
+const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:ss");
+
+/// Formats a time to a date that can be passed in URL
+QString dateFormat(double sqpDateTime) noexcept
+{
+    auto dateTime = QDateTime::fromMSecsSinceEpoch(sqpDateTime * 1000.);
+    return dateTime.toString(AMDA_TIME_FORMAT);
+}
+
+} // namespace
+
+struct AmdaProvider::AmdaProviderPrivate {
+    DataProviderParameters m_Params{};
+    std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
+    QNetworkReply *m_Reply{nullptr};
+    std::unique_ptr<QTemporaryFile> m_File{nullptr};
+    QUuid m_Token;
+};
+
+AmdaProvider::AmdaProvider() : impl{spimpl::make_unique_impl<AmdaProviderPrivate>()}
+{
+}
+
+void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
+{
+    // NOTE: Try to use multithread if possible
+    for (const auto &dateTime : dateTimeList) {
+        retrieveData(token, DataProviderParameters{dateTime});
+    }
+}
+
+void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters) const
+{
+    // /////////// //
+    // Creates URL //
+    // /////////// //
+
+    auto startDate = dateFormat(parameters.m_Time.m_TStart);
+    auto endDate = dateFormat(parameters.m_Time.m_TEnd);
+    auto productId = QStringLiteral("imf(0)");
+
+    auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
+
+    // //////////////// //
+    // Executes request //
+    // //////////////// //
+
+    impl->m_Token = token;
+    impl->m_Params = parameters;
+    impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
+    impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{url});
+    connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpFinished);
+}
+
+void AmdaProvider::httpFinished() noexcept
+{
+    // ////////////////////// //
+    // Gets download file url //
+    // ////////////////////// //
+
+    auto downloadFileUrl = QUrl{QString{impl->m_Reply->readAll()}};
+
+    // ///////////////////////////////////// //
+    // Executes request for downloading file //
+    // ///////////////////////////////////// //
+
+    // Deletes old reply
+    impl->m_Reply->deleteLater();
+    impl->m_Reply = nullptr;
+
+    // Creates destination file
+    impl->m_File = std::make_unique<QTemporaryFile>();
+    if (impl->m_File->open()) {
+        qCDebug(LOG_AmdaProvider()) << "Temp file: " << impl->m_File->fileName();
+
+        // Executes request
+        impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
+        impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{downloadFileUrl});
+        connect(impl->m_Reply, &QNetworkReply::finished, this,
+                &AmdaProvider::httpDownloadReadyRead);
+        connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpDownloadFinished);
+    }
+}
+
+void AmdaProvider::httpDownloadFinished() noexcept
+{
+    if (impl->m_File) {
+        impl->m_File->close();
+
+        // Parse results file
+        if (auto dataSeries = AmdaResultParser::readTxt(impl->m_File->fileName())) {
+            emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
+        }
+        else {
+            /// @todo ALX : debug
+        }
+
+        impl->m_File = nullptr;
+    }
+
+    // Deletes reply
+    impl->m_Reply->deleteLater();
+    impl->m_Reply = nullptr;
+}
+
+void AmdaProvider::httpDownloadReadyRead() noexcept
+{
+    if (impl->m_File) {
+        impl->m_File->write(impl->m_Reply->readAll());
+    }
+}
diff --git a/plugins/amda/src/AmdaResultParser.cpp b/plugins/amda/src/AmdaResultParser.cpp
new file mode 100644
index 0000000..b929c7b
--- /dev/null
+++ b/plugins/amda/src/AmdaResultParser.cpp
@@ -0,0 +1,70 @@
+#include "AmdaResultParser.h"
+
+#include <Data/ScalarSeries.h>
+
+#include <QDateTime>
+#include <QFile>
+
+Q_LOGGING_CATEGORY(LOG_AmdaResultParser, "AmdaResultParser")
+
+namespace {
+
+/// Format for dates in result files
+const auto DATE_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss.zzz");
+
+/// @todo ALX
+double doubleDate(const QString &stringDate) noexcept
+{
+    auto dateTime = QDateTime::fromString(stringDate, DATE_FORMAT);
+    return dateTime.toMSecsSinceEpoch() / 1000.;
+}
+
+} // namespace
+
+std::shared_ptr<IDataSeries> AmdaResultParser::readTxt(const QString &filePath) noexcept
+{
+    QFile file{filePath};
+
+    if (!file.open(QFile::ReadOnly | QIODevice::Text)) {
+        qCCritical(LOG_AmdaResultParser())
+            << QObject::tr("Can't retrieve AMDA data from file %1: %2")
+                   .arg(filePath, file.errorString());
+        return nullptr;
+    }
+
+    auto xData = QVector<double>{};
+    auto valuesData = QVector<double>{};
+
+    QTextStream stream{&file};
+
+    // Ignore comment lines (3 lines)
+    stream.readLine();
+    stream.readLine();
+    stream.readLine();
+
+    QString line{};
+    auto lineRegex = QRegExp{QStringLiteral("\\s+")};
+    while (stream.readLineInto(&line)) {
+        auto lineData = line.split(lineRegex, QString::SkipEmptyParts);
+        if (lineData.size() == 2) {
+            // X : the data is converted from date to double (in secs)
+            xData.push_back(doubleDate(lineData.at(0)));
+
+            // Value
+            valuesData.push_back(lineData.at(1).toDouble());
+        }
+        else {
+            /// @todo ALX : log
+        }
+    }
+
+    /// @todo ALX : handle units
+    auto scalarSeries = std::make_shared<ScalarSeries>(xData.size(), Unit{"nT", true}, Unit{});
+
+    const auto count = xData.size();
+    for (auto i = 0; i < count; ++i) {
+        scalarSeries->setData(i, xData.at(i), valuesData.at(i));
+    }
+
+    return scalarSeries;
+}
diff --git a/plugins/mockplugin/include/CosinusProvider.h b/plugins/mockplugin/include/CosinusProvider.h
index 7fbe76e..41e7db4 100644
--- a/plugins/mockplugin/include/CosinusProvider.h
+++ b/plugins/mockplugin/include/CosinusProvider.h
@@ -14,14 +14,12 @@ Q_DECLARE_LOGGING_CATEGORY(LOG_CosinusProvider)
  */
 class SCIQLOP_MOCKPLUGIN_EXPORT CosinusProvider : public IDataProvider {
 public:
-    /// @sa IDataProvider::retrieveData()
-    std::shared_ptr<IDataSeries>
-    retrieveData(const DataProviderParameters &parameters) const override;
-
-    void requestDataLoading(const QVector<SqpDateTime> &dateTimeList) override;
+    void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
 
 
 private:
+    /// @sa IDataProvider::retrieveData()
+    std::shared_ptr<IDataSeries> retrieveData(const DataProviderParameters &parameters) const;
     std::shared_ptr<IDataSeries> retrieveDataSeries(const SqpDateTime &dateTime);
 };
 
diff --git a/plugins/mockplugin/src/CosinusProvider.cpp b/plugins/mockplugin/src/CosinusProvider.cpp
index 8bb61dc..f3fab7d 100644
--- a/plugins/mockplugin/src/CosinusProvider.cpp
+++ b/plugins/mockplugin/src/CosinusProvider.cpp
@@ -38,13 +38,13 @@ CosinusProvider::retrieveData(const DataProviderParameters &parameters) const
     return scalarSeries;
 }
 
-void CosinusProvider::requestDataLoading(const QVector<SqpDateTime> &dateTimeList)
+void CosinusProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
 {
     qCDebug(LOG_CosinusProvider()) << "CosinusProvider::requestDataLoading"
                                    << QThread::currentThread()->objectName();
     // NOTE: Try to use multithread if possible
     for (const auto &dateTime : dateTimeList) {
         auto scalarSeries = this->retrieveData(DataProviderParameters{dateTime});
-        emit dataProvided(scalarSeries, dateTime);
+        emit dataProvided(token, scalarSeries, dateTime);
     }
 }