diff --git a/include/bat/ledger/ledger.h b/include/bat/ledger/ledger.h
index 9603a44fce08..704962ad44bf 100644
--- a/include/bat/ledger/ledger.h
+++ b/include/bat/ledger/ledger.h
@@ -26,7 +26,11 @@ LEDGER_EXPORT struct VisitData {
             const std::string& _path,
             uint32_t _tab_id,
             PUBLISHER_MONTH _local_month,
-            int _local_year);
+            int _local_year,
+            const std::string& name,
+            const std::string& url,
+            const std::string& provider,
+            const std::string& favicon_url);
   VisitData(const VisitData& data);
   ~VisitData();
 
@@ -36,7 +40,10 @@ LEDGER_EXPORT struct VisitData {
   uint32_t tab_id;
   PUBLISHER_MONTH local_month;
   int local_year;
-  std::string favIconURL;
+  std::string name;
+  std::string url;
+  std::string provider;
+  std::string favicon_url;
 };
 
 LEDGER_EXPORT struct PaymentData {
@@ -110,11 +117,10 @@ class LEDGER_EXPORT Ledger {
                                 PublisherInfoCallback callback) = 0;
   virtual void GetPublisherInfo(const ledger::PublisherInfoFilter& filter,
                                 PublisherInfoCallback callback) = 0;
-  virtual void SetMediaPublisherInfo(const uint64_t& duration, std::unique_ptr<MediaPublisherInfo> media_publisher_info,
-                                const ledger::VisitData& visit_data,
-                                MediaPublisherInfoCallback callback) = 0;
-  virtual void GetMediaPublisherInfo(const std::string& publisher_key,
-                                MediaPublisherInfoCallback callback) = 0;
+  virtual void SetMediaPublisherInfo(const std::string& media_key,
+                                const std::string& publisher_id) = 0;
+  virtual void GetMediaPublisherInfo(const std::string& media_key,
+                                PublisherInfoCallback callback) = 0;
   virtual std::vector<ContributionInfo> GetRecurringDonationPublisherInfo() = 0;
   virtual void GetPublisherInfoList(uint32_t start, uint32_t limit,
                                     const ledger::PublisherInfoFilter& filter,
@@ -152,7 +158,7 @@ class LEDGER_EXPORT Ledger {
   virtual std::map<std::string, ledger::BalanceReportInfo> GetAllBalanceReports() const = 0;
 
   virtual void RecoverWallet(const std::string& passPhrase) const = 0;
-  virtual void SaveMediaVisit(const ledger::VisitData& visit_data, const uint64_t& duration) = 0;
+  virtual void SaveMediaVisit(const std::string& publisher_id, const ledger::VisitData& visit_data, const uint64_t& duration) = 0;
 };
 
 }  // namespace ledger
diff --git a/include/bat/ledger/ledger_client.h b/include/bat/ledger/ledger_client.h
index 9d697e315f6e..03dda0dfd2d5 100644
--- a/include/bat/ledger/ledger_client.h
+++ b/include/bat/ledger/ledger_client.h
@@ -29,8 +29,6 @@ LEDGER_EXPORT enum URL_METHOD {
 
 using PublisherInfoCallback = std::function<void(Result,
     std::unique_ptr<PublisherInfo>)>;
-using MediaPublisherInfoCallback = std::function<void(Result,
-    std::unique_ptr<MediaPublisherInfo>)>;
 using GetPublisherInfoListCallback =
     std::function<void(const PublisherInfoList&, uint32_t /* next_record */)>;
 
@@ -65,10 +63,10 @@ class LEDGER_EXPORT LedgerClient {
                                 PublisherInfoCallback callback) = 0;
   virtual void LoadPublisherInfo(PublisherInfoFilter filter,
                                 PublisherInfoCallback callback) = 0;
-  virtual void LoadMediaPublisherInfo(const std::string& publisher_id,
-                                MediaPublisherInfoCallback callback) = 0;
-  virtual void SaveMediaPublisherInfo(std::unique_ptr<MediaPublisherInfo> media_publisher_info,
-                                MediaPublisherInfoCallback callback) = 0;
+  virtual void LoadMediaPublisherInfo(const std::string& media_key,
+                                PublisherInfoCallback callback) = 0;
+  virtual void SaveMediaPublisherInfo(const std::string& media_key,
+                                const std::string& publisher_id) = 0;
   virtual void LoadPublisherInfoList(uint32_t start, uint32_t limit,
                                     PublisherInfoFilter filter,
                                     GetPublisherInfoListCallback callback) = 0;
diff --git a/include/bat/ledger/media_publisher_info.h b/include/bat/ledger/media_publisher_info.h
index e2ab29d1848a..63ddcccb126d 100644
--- a/include/bat/ledger/media_publisher_info.h
+++ b/include/bat/ledger/media_publisher_info.h
@@ -6,6 +6,7 @@
 #define BAT_LEDGER_MEDIA_PUBLISHER_INFO_HANDLER_
 
 #include "bat/ledger/export.h"
+#include "bat/ledger/publisher_info.h"
 
 namespace ledger {
 
@@ -19,23 +20,6 @@ LEDGER_EXPORT struct TwitchEventInfo {
   std::string status_;
 };
 
-LEDGER_EXPORT struct MediaPublisherInfo {
-  MediaPublisherInfo(const std::string& publisher_id);
-  MediaPublisherInfo(const MediaPublisherInfo& info);
-  ~MediaPublisherInfo();
-
-  static std::unique_ptr<MediaPublisherInfo> FromJSON(const std::string& json);
-  const std::string ToJSON() const;
-
-  std::string publisher_id_;
-  std::string publisherName_;
-  std::string publisherURL_;
-  std::string favIconURL_;
-  std::string channelName_;
-  std::string publisher_;
-  TwitchEventInfo twitchEventInfo_;
-};
-
 }  // namespace ledger
 
 #endif  // BAT_LEDGER_MEDIA_PUBLISHER_INFO_HANDLER_
diff --git a/include/bat/ledger/publisher_info.h b/include/bat/ledger/publisher_info.h
index e1f558fab99c..6fd5354056cc 100644
--- a/include/bat/ledger/publisher_info.h
+++ b/include/bat/ledger/publisher_info.h
@@ -67,14 +67,14 @@ LEDGER_EXPORT struct ContributionInfo {
 };
 
 LEDGER_EXPORT struct PublisherInfo {
-  typedef std::string id_type;
-  PublisherInfo(const id_type& publisher_id, PUBLISHER_MONTH month, int year);
+  PublisherInfo();
+  PublisherInfo(const std::string& publisher_id, PUBLISHER_MONTH month, int year);
   PublisherInfo(const PublisherInfo& info);
   ~PublisherInfo();
 
   bool is_valid() const;
 
-  const id_type id;
+  std::string id;
   uint64_t duration;
   double score;
   uint32_t visits;
@@ -84,8 +84,11 @@ LEDGER_EXPORT struct PublisherInfo {
   PUBLISHER_CATEGORY category;
   PUBLISHER_MONTH month;
   int year;
-  std::string favIconURL;
   bool verified;
+  std::string name;
+  std::string url;
+  std::string provider;
+  std::string favicon_url;
 
   std::vector<ContributionInfo> contributions;
 };
diff --git a/src/bat/ledger/ledger.cc b/src/bat/ledger/ledger.cc
index 253dbfb6267c..03614583f900 100644
--- a/src/bat/ledger/ledger.cc
+++ b/src/bat/ledger/ledger.cc
@@ -23,13 +23,21 @@ VisitData::VisitData(const std::string& _tld,
             const std::string& _path,
             uint32_t _tab_id,
             PUBLISHER_MONTH _local_month,
-            int _local_year) :
+            int _local_year,
+            const std::string& _name,
+            const std::string& _url,
+            const std::string& _provider,
+            const std::string& _favicon_url) :
     tld(_tld),
     domain(_domain),
     path(_path),
     tab_id(_tab_id),
     local_month(_local_month),
-    local_year(_local_year) {}
+    local_year(_local_year),
+    name(_name),
+    url(_url),
+    provider(_provider),
+    favicon_url(_favicon_url) {}
 
 VisitData::VisitData(const VisitData& data) :
     tld(data.tld),
@@ -38,7 +46,10 @@ VisitData::VisitData(const VisitData& data) :
     tab_id(data.tab_id),
     local_month(data.local_month),
     local_year(data.local_year),
-    favIconURL(data.favIconURL) {}
+    name(data.name),
+    url(data.url),
+    provider(data.provider),
+    favicon_url(data.favicon_url) {}
 
 VisitData::~VisitData() {}
 
@@ -82,7 +93,21 @@ PublisherInfoFilter::PublisherInfoFilter(const PublisherInfoFilter& filter) :
     year(filter.year) {}
 PublisherInfoFilter::~PublisherInfoFilter() {}
 
-PublisherInfo::PublisherInfo(const id_type& publisher_id,
+PublisherInfo::PublisherInfo() :
+    duration(0u),
+    score(.0),
+    visits(0u),
+    percent(0u),
+    weight(.0),
+    excluded(PUBLISHER_EXCLUDE::DEFAULT),
+    category(PUBLISHER_CATEGORY::AUTO_CONTRIBUTE),
+    verified(false),
+    name(""),
+    url(""),
+    provider(""),
+    favicon_url("") {}
+
+PublisherInfo::PublisherInfo(const std::string& publisher_id,
                              PUBLISHER_MONTH _month,
                              int _year) :
     id(publisher_id),
@@ -95,7 +120,11 @@ PublisherInfo::PublisherInfo(const id_type& publisher_id,
     category(PUBLISHER_CATEGORY::AUTO_CONTRIBUTE),
     month(_month),
     year(_year),
-    verified(false) {}
+    verified(false),
+    name(""),
+    url(""),
+    provider(""),
+    favicon_url("") {}
 
 PublisherInfo::PublisherInfo(const PublisherInfo& info) :
     id(info.id),
@@ -108,8 +137,11 @@ PublisherInfo::PublisherInfo(const PublisherInfo& info) :
     category(info.category),
     month(info.month),
     year(info.year),
-    favIconURL(info.favIconURL),
     verified(info.verified),
+    name(info.name),
+    url(info.url),
+    provider(info.provider),
+    favicon_url(info.favicon_url),
     contributions(info.contributions) {}
 
 PublisherInfo::~PublisherInfo() {}
@@ -131,93 +163,6 @@ TwitchEventInfo::TwitchEventInfo(const TwitchEventInfo& info):
 TwitchEventInfo::~TwitchEventInfo() {}
 
 
-MediaPublisherInfo::MediaPublisherInfo(const std::string& publisher_id):
-  publisher_id_(publisher_id) {}
-
-MediaPublisherInfo::MediaPublisherInfo(const MediaPublisherInfo& info):
-  publisher_id_(info.publisher_id_),
-  publisherName_(info.publisherName_),
-  publisherURL_(info.publisherURL_),
-  favIconURL_(info.favIconURL_),
-  channelName_(info.channelName_),
-  publisher_(info.publisher_),
-  twitchEventInfo_(info.twitchEventInfo_) {}
-
-MediaPublisherInfo::~MediaPublisherInfo() {}
-
-// static
-std::unique_ptr<MediaPublisherInfo> MediaPublisherInfo::FromJSON(
-    const std::string& json) {
-  std::unique_ptr<MediaPublisherInfo> info;
-
-  rapidjson::Document d;
-  d.Parse(json.c_str());
-
-  if (d.HasParseError() ||
-      !d["id"].IsString() ||
-      !d["publisherName"].IsString() ||
-      !d["publisherURL"].IsString() ||
-      !d["favIconURL"].IsString() ||
-      !d["channelName"].IsString() ||
-      !d["publisher"].IsString() ||
-      !d["twitch_event"].IsString() ||
-      !d["twitch_time"].IsString() ||
-      !d["twitch_status"].IsString()) {
-    return info;
-  }
-
-  info = std::make_unique<MediaPublisherInfo>(d["id"].GetString());
-  info->publisherName_ = d["publisherName"].GetString();
-  info->publisherURL_ = d["publisherURL"].GetString();
-  info->favIconURL_ = d["favIconURL"].GetString();
-  info->channelName_ = d["channelName"].GetString();
-  info->publisher_ = d["publisher"].GetString();
-  info->twitchEventInfo_.event_ = d["twitch_event"].GetString();
-  info->twitchEventInfo_.time_ = d["twitch_time"].GetString();
-  info->twitchEventInfo_.status_ = d["twitch_status"].GetString();
-
-  return info;
-}
-
-const std::string MediaPublisherInfo::ToJSON() const {
-  rapidjson::StringBuffer buffer;
-  rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-
-  writer.StartObject();
-
-  writer.String("id");
-  writer.String(publisher_id_.c_str());
-
-  writer.String("publisherName");
-  writer.String(publisherName_.c_str());
-
-  writer.String("publisherURL");
-  writer.String(publisherURL_.c_str());
-
-  writer.String("favIconURL");
-  writer.String(favIconURL_.c_str());
-
-  writer.String("channelName");
-  writer.String(channelName_.c_str());
-
-  writer.String("publisher");
-  writer.String(publisher_.c_str());
-
-  writer.String("twitch_event");
-  writer.String(twitchEventInfo_.event_.c_str());
-
-  writer.String("twitch_time");
-  writer.String(twitchEventInfo_.time_.c_str());
-
-  writer.String("twitch_status");
-  writer.String(twitchEventInfo_.status_.c_str());
-
-  writer.EndObject();
-
-  return buffer.GetString();
-}
-
-
 // static
 ledger::Ledger* Ledger::CreateInstance(LedgerClient* client) {
   return new bat_ledger::LedgerImpl(client);
diff --git a/src/bat_get_media.cc b/src/bat_get_media.cc
index c352d6e49f05..37d1dc8afb3d 100644
--- a/src/bat_get_media.cc
+++ b/src/bat_get_media.cc
@@ -18,7 +18,7 @@ using namespace std::placeholders;
 namespace braveledger_bat_get_media {
 
 void onVisitSavedDummy(ledger::Result result,
-  std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info) {
+  std::unique_ptr<ledger::PublisherInfo> media_publisher_info) {
 // OnMediaPublisherInfoUpdated will always be called by LedgerImpl so do nothing
 }
 
@@ -61,15 +61,12 @@ void BatGetMedia::processMedia(const std::map<std::string, std::string>& parts,
   if (mediaId.empty()) {
     return;
   }
-  //LOG(ERROR) << "!!!mediaId == " << mediaId;
-  std::string mediaKey = braveledger_bat_helper::getMediaKey(mediaId, type);
-  //LOG(ERROR) << "!!!mediaKey == " << mediaKey;
+  std::string media_key = braveledger_bat_helper::getMediaKey(mediaId, type);
   uint64_t duration = 0;
   ledger::TwitchEventInfo twitchEventInfo;
-  if (YOUTUBE_MEDIA_TYPE == type) {
-    duration = braveledger_bat_helper::getMediaDuration(parts, mediaKey, type);
-    //LOG(ERROR) << "!!!duration == " << duration;
-  } else if (TWITCH_MEDIA_TYPE == type) {
+  if (type == YOUTUBE_MEDIA_TYPE) {
+    duration = braveledger_bat_helper::getMediaDuration(parts, media_key, type);
+  } else if (type == TWITCH_MEDIA_TYPE) {
     std::map<std::string, std::string>::const_iterator iter = parts.find("event");
     if (iter != parts.end()) {
       twitchEventInfo.event_ = iter->second;
@@ -80,26 +77,32 @@ void BatGetMedia::processMedia(const std::map<std::string, std::string>& parts,
     }
   }
 
-  getPublisherFromMediaProps(mediaId, mediaKey, type, duration, twitchEventInfo, visit_data);
+  getPublisherFromMediaProps(mediaId, media_key, type, duration, twitchEventInfo, visit_data);
 }
 
-void BatGetMedia::getPublisherFromMediaProps(const std::string& mediaId, const std::string& mediaKey,
-   const std::string& providerName, const uint64_t& duration, 
+void BatGetMedia::getPublisherFromMediaProps(const std::string& mediaId, const std::string& media_key,
+   const std::string& providerName, const uint64_t& duration,
    const ledger::TwitchEventInfo& twitchEventInfo, const ledger::VisitData& visit_data) {
-  ledger_->GetMediaPublisherInfo(mediaKey, std::bind(&BatGetMedia::getPublisherInfoDataCallback, this,
-                    mediaId, mediaKey, providerName, duration, twitchEventInfo, visit_data, _1, _2));
+  ledger_->GetMediaPublisherInfo(media_key, std::bind(&BatGetMedia::getPublisherInfoDataCallback, this,
+                    mediaId, media_key, providerName, duration, twitchEventInfo, visit_data, _1, _2));
 }
 
-void BatGetMedia::getPublisherInfoDataCallback(const std::string& mediaId, const std::string& mediaKey, const std::string& providerName,
+void BatGetMedia::getPublisherInfoDataCallback(const std::string& mediaId, const std::string& media_key, const std::string& providerName,
       const uint64_t& duration, const ledger::TwitchEventInfo& twitchEventInfo, const ledger::VisitData& visit_data,
-      ledger::Result result, std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info) {
-  if (result != ledger::Result::OK) {
+      ledger::Result result, std::unique_ptr<ledger::PublisherInfo> publisher_info) {
+  if (result != ledger::Result::OK && result != ledger::Result::NOT_FOUND) {
     // TODO error handling
     return;
   }
 
-  if (!media_publisher_info.get()) {
-    std::string mediaURL = getMediaURL(mediaId, providerName);
+  std::vector<std::string> split = braveledger_bat_helper::split(mediaId, '_');
+  std::string new_media_id = mediaId;
+  if (!split.empty()) {
+    new_media_id = split[0];
+  }
+
+  if (!publisher_info.get()) {
+    std::string mediaURL = getMediaURL(new_media_id, providerName);
     if (YOUTUBE_MEDIA_TYPE == providerName) {
       auto request = ledger_->LoadURL((std::string)YOUTUBE_PROVIDER_URL + "?format=json&url=" + ledger_->URIEncode(mediaURL),
         std::vector<std::string>(), "", "", ledger::URL_METHOD::GET, &handler_);
@@ -107,59 +110,72 @@ void BatGetMedia::getPublisherInfoDataCallback(const std::string& mediaId, const
           std::bind(&BatGetMedia::getPublisherFromMediaPropsCallback,
           this,
           duration,
-          mediaKey,
+          media_key,
           providerName,
           mediaURL,
           visit_data,
           _1,
           _2));
     } else if (TWITCH_MEDIA_TYPE == providerName) {
-
-      std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info(new ledger::MediaPublisherInfo(mediaKey));
-      media_publisher_info->favIconURL_ = "";
-      media_publisher_info->channelName_ = getMediaURL(mediaId, providerName);
-      media_publisher_info->publisherURL_ = media_publisher_info->channelName_ + "/videos";
-      media_publisher_info->publisher_ = providerName + "#author:";
-      size_t pos = media_publisher_info->channelName_.rfind("/");
-      if (pos != std::string::npos && pos < media_publisher_info->channelName_.length() - 1) {
-        media_publisher_info->publisher_ += media_publisher_info->channelName_.substr(pos + 1);
-        //LOG(ERROR) << "!!!publisher == " << publisherInfo.publisher_;
+      const std::string mediaUrl = getMediaURL(new_media_id, providerName);
+      std::unique_ptr<ledger::PublisherInfo> new_publisher_info(new ledger::PublisherInfo());
+      new_publisher_info->favicon_url = "";
+      new_publisher_info->url = mediaUrl + "/videos";
+      std::string id = providerName + "#author:" + new_media_id;
+      new_publisher_info->name = new_media_id;
+      new_publisher_info->id = id;
+
+      ledger::TwitchEventInfo oldEvent;
+      std::map<std::string, ledger::TwitchEventInfo>::const_iterator iter = twitchEvents.find(media_key);
+      if (iter != twitchEvents.end()) {
+        oldEvent = iter->second;
       }
-      media_publisher_info->publisherName_ = media_publisher_info->publisher_;
-      //LOG(ERROR) << "!!!publisherName == " << media_publisher_info->publisherName_;
 
-      media_publisher_info->twitchEventInfo_ = twitchEventInfo;
-      media_publisher_info->twitchEventInfo_.status_ = getTwitchStatus(ledger::TwitchEventInfo(), twitchEventInfo);
+      ledger::TwitchEventInfo newEvent(twitchEventInfo);
+      newEvent.status_ = getTwitchStatus(oldEvent, newEvent);
+
+      uint64_t realDuration = getTwitchDuration(oldEvent, newEvent);
+      twitchEvents[media_key] = newEvent;
 
-      uint64_t realDuration = getTwitchDuration(ledger::TwitchEventInfo(), twitchEventInfo);
-      //LOG(ERROR) << "!!!realDuration == " << realDuration;
-      if (0 == realDuration) {
+      if (realDuration == 0) {
         return;
       }
+
       ledger::VisitData updated_visit_data(visit_data);
-      updated_visit_data.tld = media_publisher_info->publisherName_ + " on " + TWITCH_PROVIDER_NAME;
-      updated_visit_data.favIconURL = media_publisher_info->favIconURL_;
-      ledger_->SetMediaPublisherInfo(realDuration, std::move(media_publisher_info), updated_visit_data,
-        std::bind(&onVisitSavedDummy, _1, _2));
+      updated_visit_data.favicon_url = new_publisher_info->favicon_url;
+      updated_visit_data.provider = TWITCH_PROVIDER_NAME;
+      updated_visit_data.name = new_publisher_info->name;
+      updated_visit_data.url = new_publisher_info->url;
+      ledger_->SaveMediaVisit(id, updated_visit_data, realDuration);
+      ledger_->SetMediaPublisherInfo(media_key, id);
     }
   } else {
     ledger::VisitData updated_visit_data(visit_data);
-    updated_visit_data.tld = media_publisher_info->publisherName_ + " on ";
+    updated_visit_data.name = publisher_info->name;
+    updated_visit_data.url = publisher_info->url;
     if (YOUTUBE_MEDIA_TYPE == providerName) {
-      updated_visit_data.tld += YOUTUBE_PROVIDER_NAME;
-      updated_visit_data.favIconURL = media_publisher_info->favIconURL_;
-      ledger_->SaveMediaVisit(updated_visit_data, duration);
+      updated_visit_data.provider = YOUTUBE_PROVIDER_NAME;
+      updated_visit_data.favicon_url = publisher_info->favicon_url;
+      std::string id = publisher_info->id;
+      ledger_->SaveMediaVisit(id, updated_visit_data, duration);
     } else if (TWITCH_MEDIA_TYPE == providerName) {
-      updated_visit_data.tld += TWITCH_PROVIDER_NAME;
-      updated_visit_data.favIconURL = media_publisher_info->favIconURL_;
-      uint64_t realDuration = getTwitchDuration(media_publisher_info->twitchEventInfo_, twitchEventInfo);
-      //LOG(ERROR) << "!!!realDuration == " << realDuration;
-      ledger::TwitchEventInfo oldInfo = media_publisher_info->twitchEventInfo_;
-      media_publisher_info->twitchEventInfo_ = twitchEventInfo;
-      media_publisher_info->twitchEventInfo_.status_ = getTwitchStatus(oldInfo, twitchEventInfo);
-
-      ledger_->SetMediaPublisherInfo(realDuration, std::move(media_publisher_info), updated_visit_data,
-        std::bind(&onVisitSavedDummy, _1, _2));
+      updated_visit_data.provider = TWITCH_PROVIDER_NAME;
+      updated_visit_data.favicon_url = publisher_info->url;
+
+      ledger::TwitchEventInfo oldEvent;
+      std::map<std::string, ledger::TwitchEventInfo>::const_iterator iter = twitchEvents.find(media_key);
+      if (iter != twitchEvents.end()) {
+        oldEvent = iter->second;
+      }
+
+      ledger::TwitchEventInfo newEvent(twitchEventInfo);
+      newEvent.status_ = getTwitchStatus(oldEvent, newEvent);
+
+      uint64_t realDuration = getTwitchDuration(oldEvent, newEvent);
+      twitchEvents[media_key] = newEvent;
+
+      std::string id = publisher_info->id;
+      ledger_->SaveMediaVisit(id, updated_visit_data, realDuration);
     }
   }
 }
@@ -249,17 +265,14 @@ uint64_t BatGetMedia::getTwitchDuration(const ledger::TwitchEventInfo& oldEventI
   return (uint64_t)(time * 1000.0);
 }
 
-void BatGetMedia::getPublisherFromMediaPropsCallback(const uint64_t& duration, const std::string& mediaKey,
+void BatGetMedia::getPublisherFromMediaPropsCallback(const uint64_t& duration, const std::string& media_key,
     const std::string& providerName, const std::string& mediaURL, const ledger::VisitData& visit_data, 
-    bool result, const std::string& response) {
-  //LOG(ERROR) << "!!!!getPublisherFromMediaPropsCallback response == " << response;
-  if (YOUTUBE_MEDIA_TYPE == providerName) {
+    bool success, const std::string& response) {
+  if (success && YOUTUBE_MEDIA_TYPE == providerName) {
     std::string publisherURL;
     braveledger_bat_helper::getJSONValue("author_url", response, publisherURL);
     std::string publisherName;
     braveledger_bat_helper::getJSONValue("author_name", response, publisherName);
-    //LOG(ERROR) << "!!!!publisherURL == " << publisherURL;
-    //LOG(ERROR) << "!!!!publisherName == " << publisherName;
 
     auto request = ledger_->LoadURL(publisherURL,
         std::vector<std::string>(), "", "", ledger::URL_METHOD::GET, &handler_);
@@ -267,7 +280,7 @@ void BatGetMedia::getPublisherFromMediaPropsCallback(const uint64_t& duration, c
         std::bind(&BatGetMedia::getPublisherInfoCallback,
                   this,
                   duration,
-                  mediaKey,
+                  media_key,
                   providerName,
                   mediaURL,
                   publisherURL,
@@ -278,52 +291,51 @@ void BatGetMedia::getPublisherFromMediaPropsCallback(const uint64_t& duration, c
   }
 }
 
-void BatGetMedia::getPublisherInfoCallback(const uint64_t& duration, const std::string& mediaKey,
+void BatGetMedia::getPublisherInfoCallback(const uint64_t& duration, const std::string& media_key,
     const std::string& providerName, const std::string& mediaURL, const std::string& publisherURL,
-    const std::string& publisherName, const ledger::VisitData& visit_data, bool result, const std::string& response) {
-  LOG(ERROR) << "!!!!getPublisherInfoCallback == " << response;
-  if (YOUTUBE_MEDIA_TYPE == providerName) {
-    size_t pos = response.find("<div id=\"img-preload\"");
+    const std::string& publisherName, const ledger::VisitData& visit_data, bool success, const std::string& response) {
+  if (success && YOUTUBE_MEDIA_TYPE == providerName) {
     std::string favIconURL;
-    // TODO it doesn't always work on Android
-    do {
-      if (pos != std::string::npos) {
-        pos = response.find("<img src=\"", pos);
-        if (pos != std::string::npos) {
-          size_t posEnd = response.find("\">", pos);
-          if (posEnd != std::string::npos) {
-            favIconURL = response.substr(pos + 10, posEnd - pos - 10);
-          }
-        }
-      } else {
-        break;
-      }
-      pos++;
-      if (pos > response.length() - 1) {
-        pos = std::string::npos;
-      }
-    } while (favIconURL.find("photo.jpg") == std::string::npos);
-    LOG(ERROR) << "publisher's picture URL == " << favIconURL;
-    std::string channelName = publisherURL + "/videos";
-    pos = publisherURL.rfind("/");
-    std::string publisher = providerName + "#channel:";
+//    size_t pos = response.find("<div id=\"img-preload\"");
+//
+//    do {
+//      if (pos != std::string::npos) {
+//        pos = response.find("<img src=\"", pos);
+//        if (pos != std::string::npos) {
+//          size_t posEnd = response.find("\">", pos);
+//          if (posEnd != std::string::npos) {
+//            favIconURL = response.substr(pos + 10, posEnd - pos - 10);
+//          }
+//        }
+//      } else {
+//        break;
+//      }
+//      pos++;
+//      if (pos > response.length() - 1) {
+//        pos = std::string::npos;
+//      }
+//    } while (favIconURL.find("photo.jpg") == std::string::npos);
+//    LOG(ERROR) << "publisher's picture URL == " << favIconURL;
+    std::string mediaURL = publisherURL + "/videos";
+    size_t pos = publisherURL.rfind("/");
+    std::string publisher_id = providerName + "#channel:";
     if (pos != std::string::npos && pos < publisherURL.length() - 1) {
-      publisher += publisherURL.substr(pos + 1);
-      //LOG(ERROR) << "!!!publisher == " << publisher;
+      publisher_id += publisherURL.substr(pos + 1);
     }
-    std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info(new ledger::MediaPublisherInfo(mediaKey));
-    //LOG(ERROR) << "!!!publisherName == " << publisherName;
-    media_publisher_info->publisherName_ = publisherName;
-    media_publisher_info->publisherURL_ = publisherURL;
-    media_publisher_info->favIconURL_ = favIconURL;
-    media_publisher_info->channelName_ = channelName;
-    media_publisher_info->publisher_ = publisher;
+    std::unique_ptr<ledger::PublisherInfo> publisher_info(new ledger::PublisherInfo());
+    publisher_info->name = publisherName;
+    publisher_info->url = mediaURL;
+    publisher_info->favicon_url = favIconURL;
+    publisher_info->id = publisher_id;
 
     ledger::VisitData updated_visit_data(visit_data);
-    updated_visit_data.tld = publisherName + " on " + YOUTUBE_PROVIDER_NAME;
-    updated_visit_data.favIconURL = media_publisher_info->favIconURL_;
-    ledger_->SetMediaPublisherInfo(duration, std::move(media_publisher_info), updated_visit_data,
-      std::bind(&onVisitSavedDummy, _1, _2));
+    updated_visit_data.favicon_url = publisher_info->favicon_url;
+    updated_visit_data.provider = YOUTUBE_PROVIDER_NAME;
+    updated_visit_data.name = publisher_info->name;
+    updated_visit_data.url = publisher_info->url;
+
+    ledger_->SaveMediaVisit(publisher_id, updated_visit_data, duration);
+    ledger_->SetMediaPublisherInfo(media_key, publisher_id);
   }
 }
 
diff --git a/src/bat_get_media.h b/src/bat_get_media.h
index 0761b64a0e93..8333a47e5fc0 100644
--- a/src/bat_get_media.h
+++ b/src/bat_get_media.h
@@ -32,29 +32,31 @@ class BatGetMedia {
 
   void processMedia(const std::map<std::string, std::string>& parts, const std::string& type, const ledger::VisitData& visit_data);
 
-  void getPublisherFromMediaProps(const std::string& mediaId, const std::string& mediaKey, const std::string& providerName,
+  void getPublisherFromMediaProps(const std::string& mediaId, const std::string& media_key, const std::string& providerName,
       const uint64_t& duration, const ledger::TwitchEventInfo& twitchEventInfo,
       const ledger::VisitData& visit_data);
 
  private:
   std::string getMediaURL(const std::string& mediaId, const std::string& providerName);
-  void getPublisherFromMediaPropsCallback(const uint64_t& duration, const std::string& mediaKey,
+  void getPublisherFromMediaPropsCallback(const uint64_t& duration, const std::string& media_key,
     const std::string& providerName, const std::string& mediaURL, const ledger::VisitData& visit_data, 
     bool result, const std::string& response);
-  void getPublisherInfoCallback(const uint64_t& duration, const std::string& mediaKey,
+  void getPublisherInfoCallback(const uint64_t& duration, const std::string& media_key,
     const std::string& providerName, const std::string& mediaURL, const std::string& publisherURL,
     const std::string& publisherName, const ledger::VisitData& visit_data, bool result, const std::string& response);
   uint64_t getTwitchDuration(const ledger::TwitchEventInfo& oldEventInfo, const ledger::TwitchEventInfo& newEventInfo);
   std::string getTwitchStatus(const ledger::TwitchEventInfo& oldEventInfo, const ledger::TwitchEventInfo& newEventInfo);
 
-  void getPublisherInfoDataCallback(const std::string& mediaId, const std::string& mediaKey, const std::string& providerName,
+  void getPublisherInfoDataCallback(const std::string& mediaId, const std::string& media_key, const std::string& providerName,
       const uint64_t& duration, const ledger::TwitchEventInfo& twitchEventInfo,
       const ledger::VisitData& visit_data, ledger::Result result,
-      std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info);
+      std::unique_ptr<ledger::PublisherInfo> media_publisher_info);
 
   bat_ledger::LedgerImpl* ledger_;  // NOT OWNED
 
   bat_ledger::URLRequestHandler handler_;
+
+  std::map<std::string, ledger::TwitchEventInfo> twitchEvents;
 };
 
 }  // namespace braveledger_bat_get_media
diff --git a/src/bat_helper.cc b/src/bat_helper.cc
index 14df5c3d17d9..05703e05bcc1 100644
--- a/src/bat_helper.cc
+++ b/src/bat_helper.cc
@@ -1108,7 +1108,7 @@ namespace braveledger_bat_helper {
     publisherURL_(mediaPublisherInfo.publisherURL_),
     favIconURL_(mediaPublisherInfo.favIconURL_),
     channelName_(mediaPublisherInfo.channelName_),
-    publisher_(mediaPublisherInfo.publisher_),
+    publisher_id_(mediaPublisherInfo.publisher_id_),
     twitchEventInfo_(mediaPublisherInfo.twitchEventInfo_) {}
 
   MEDIA_PUBLISHER_INFO::~MEDIA_PUBLISHER_INFO() {}
@@ -1125,7 +1125,7 @@ namespace braveledger_bat_helper {
         d.HasMember("publisherURL") && d["publisherURL"].IsString() &&
         d.HasMember("favIconURL") && d["favIconURL"].IsString() &&
         d.HasMember("channelName") && d["channelName"].IsString() &&
-        d.HasMember("publisher") && d["publisher"].IsString() &&
+        d.HasMember("publisherId") && d["publisherId"].IsString() &&
         d.HasMember("twitch_event") && d["twitch_event"].IsString() &&
         d.HasMember("twitch_time") && d["twitch_time"].IsString() &&
         d.HasMember("twitch_status") && d["twitch_status"].IsString());
@@ -1136,7 +1136,7 @@ namespace braveledger_bat_helper {
       publisherURL_ = d["publisherURL"].GetString();
       favIconURL_ = d["favIconURL"].GetString();
       channelName_ = d["channelName"].GetString();
-      publisher_ = d["publisher"].GetString();
+      publisher_id_ = d["publisherId"].GetString();
       twitchEventInfo_.event_ = d["twitch_event"].GetString();
       twitchEventInfo_.time_ = d["twitch_time"].GetString();
       twitchEventInfo_.status_ = d["twitch_status"].GetString();
@@ -1159,8 +1159,8 @@ namespace braveledger_bat_helper {
     writer.String("channelName");
     writer.String(data.channelName_.c_str());
 
-    writer.String("publisher");
-    writer.String(data.publisher_.c_str());
+    writer.String("publisherId");
+    writer.String(data.publisher_id_.c_str());
 
     writer.String("twitch_event");
     writer.String(data.twitchEventInfo_.event_.c_str());
@@ -1829,7 +1829,7 @@ namespace braveledger_bat_helper {
     return type + "_" + mediaId;
   }
 
-  uint64_t getMediaDuration(const std::map<std::string, std::string>& data, const std::string& mediaKey, const std::string& type) {
+  uint64_t getMediaDuration(const std::map<std::string, std::string>& data, const std::string& media_key, const std::string& type) {
     uint64_t duration = 0;
 
     if (YOUTUBE_MEDIA_TYPE == type) {
@@ -1853,7 +1853,7 @@ namespace braveledger_bat_helper {
           tempST >> st;
           tempTime = et - st;
         }
-        duration = (uint64_t)(tempTime * 1000.0);
+        duration = (uint64_t)tempTime;
       }
     } else if (TWITCH_MEDIA_TYPE == type) {
       // We set the correct duration for twitch in BatGetMedia class
@@ -1891,4 +1891,15 @@ namespace braveledger_bat_helper {
 
     return url + prefix + path;
   }
+
+  std::vector<std::string> split(const std::string& s, char delim) {
+      std::stringstream ss(s);
+      std::string item;
+      std::vector<std::string> result;
+      while (getline(ss, item, delim)) {
+          result.push_back(item);
+      }
+
+      return result;
+  }
 }  // namespace braveledger_bat_helper
diff --git a/src/bat_helper.h b/src/bat_helper.h
index ea2228722702..46f7c5a37064 100644
--- a/src/bat_helper.h
+++ b/src/bat_helper.h
@@ -306,7 +306,7 @@ namespace braveledger_bat_helper {
     std::string publisherURL_;
     std::string favIconURL_;
     std::string channelName_;
-    std::string publisher_;
+    std::string publisher_id_;
     TWITCH_EVENT_INFO twitchEventInfo_;
   };
 
@@ -345,9 +345,7 @@ namespace braveledger_bat_helper {
     bool excluded;
   };
 
-  using GetMediaPublisherInfoSignature = void(uint64_t, const braveledger_bat_helper::MEDIA_PUBLISHER_INFO&);
   using SaveVisitSignature = void(const std::string&, uint64_t);
-  using GetMediaPublisherInfoCallback = std::function<GetMediaPublisherInfoSignature>;
   using SaveVisitCallback = std::function<SaveVisitSignature>;
 
   bool getJSONValue(const std::string& fieldName, const std::string& json, std::string & value);
@@ -413,9 +411,11 @@ namespace braveledger_bat_helper {
 
   std::string getMediaKey(const std::string& mediaId, const std::string& type);
 
-  uint64_t getMediaDuration(const std::map<std::string, std::string>& data, const std::string& mediaKey, const std::string& type);
+  uint64_t getMediaDuration(const std::map<std::string, std::string>& data, const std::string& media_key, const std::string& type);
 
   std::string buildURL(const std::string& path, const std::string& prefix = "", const SERVER_TYPES& server = SERVER_TYPES::LEDGER);
+
+  std::vector<std::string> split(const std::string& s, char delim);
 }  // namespace braveledger_bat_helper
 
 #endif  // BRAVELEDGER_BAT_HELPER_H_
diff --git a/src/bat_publishers.cc b/src/bat_publishers.cc
index 845d24528460..1fc280112521 100644
--- a/src/bat_publishers.cc
+++ b/src/bat_publishers.cc
@@ -59,17 +59,7 @@ double BatPublishers::concaveScore(const uint64_t& duration) {
   return (std::sqrt(b2_ + a4_ * duration) - b_) / (double)a2_;
 }
 
-const ledger::PublisherInfo::id_type getPublisherID(
-    const ledger::VisitData& visit_data) {
-  return visit_data.tld;
-}
-
-const ledger::PublisherInfo::id_type getPublisherID(
-    const ledger::PaymentData& payment_data) {
-  return payment_data.publisher_id;
-}
-
-std::string getProviderName(const ledger::PublisherInfo::id_type publisher_id) {
+std::string getProviderName(const std::string& publisher_id) {
   // TODO - this is for the media stuff
   if (publisher_id.find(YOUTUBE_PROVIDER_NAME) != std::string::npos) {
     return YOUTUBE_PROVIDER_NAME;
@@ -79,7 +69,7 @@ std::string getProviderName(const ledger::PublisherInfo::id_type publisher_id) {
   return "";
 }
 
-bool ignoreMinTime(const ledger::PublisherInfo::id_type publisher_id) {
+bool ignoreMinTime(const std::string& publisher_id) {
   return !getProviderName(publisher_id).empty();
 }
 
@@ -89,7 +79,7 @@ void BatPublishers::AddRecurringPayment(const std::string& publisher_id, const d
 }
 
 void BatPublishers::MakePayment(const ledger::PaymentData& payment_data) {
-  auto filter = CreatePublisherFilter(getPublisherID(payment_data),
+  auto filter = CreatePublisherFilter(payment_data.publisher_id,
                                       payment_data.category,
                                       payment_data.local_month,
                                       payment_data.local_year);
@@ -98,13 +88,11 @@ void BatPublishers::MakePayment(const ledger::PaymentData& payment_data) {
           payment_data, _1, _2));
 }
 
-void BatPublishers::saveVisit(const ledger::VisitData& visit_data,
+void BatPublishers::saveVisit(const std::string& publisher_id,
+                              const ledger::VisitData& visit_data,
                               const uint64_t& duration) {
-  const ledger::PublisherInfo::id_type publisher_id =
-      getPublisherID(visit_data);
-
-  if (!ignoreMinTime(publisher_id) &&
-      duration < state_->min_pubslisher_duration_)
+  if (publisher_id.empty() || (!ignoreMinTime(publisher_id) &&
+      duration < state_->min_pubslisher_duration_))
     return;
 
   auto filter = CreatePublisherFilter(publisher_id,
@@ -113,7 +101,7 @@ void BatPublishers::saveVisit(const ledger::VisitData& visit_data,
       visit_data.local_year);
   ledger_->GetPublisherInfo(filter,
       std::bind(&BatPublishers::saveVisitInternal, this,
-          visit_data, duration, _1, _2));
+          publisher_id, visit_data, duration, _1, _2));
 }
 
 ledger::PublisherInfoFilter BatPublishers::CreatePublisherFilter(
@@ -151,7 +139,7 @@ void BatPublishers::makePaymentInternal(
   }
 
   if (!publisher_info.get())
-    publisher_info.reset(new ledger::PublisherInfo(getPublisherID(payment_data),
+    publisher_info.reset(new ledger::PublisherInfo(payment_data.publisher_id,
                                                    payment_data.local_month,
                                                    payment_data.local_year));
   publisher_info->category = payment_data.category;
@@ -163,6 +151,7 @@ void BatPublishers::makePaymentInternal(
 }
 
 void BatPublishers::saveVisitInternal(
+    std::string publisher_id,
     ledger::VisitData visit_data,
     uint64_t duration,
     ledger::Result result,
@@ -174,7 +163,7 @@ void BatPublishers::saveVisitInternal(
   }
 
   if (!publisher_info.get())
-    publisher_info.reset(new ledger::PublisherInfo(getPublisherID(visit_data),
+    publisher_info.reset(new ledger::PublisherInfo(publisher_id,
                                                    visit_data.local_month,
                                                    visit_data.local_year));
 
@@ -183,7 +172,10 @@ void BatPublishers::saveVisitInternal(
   }
 
 
-  publisher_info->favIconURL = visit_data.favIconURL;
+  publisher_info->favicon_url = visit_data.favicon_url;
+  publisher_info->name = visit_data.name;
+  publisher_info->provider = visit_data.provider;
+  publisher_info->url = visit_data.url;
   publisher_info->duration += duration;
   publisher_info->visits += 1;
   publisher_info->category = ledger::PUBLISHER_CATEGORY::AUTO_CONTRIBUTE;
@@ -371,7 +363,7 @@ std::vector<braveledger_bat_helper::PUBLISHER_ST> BatPublishers::topN() {
   return res;
 }
 
-bool BatPublishers::isVerified(const ledger::PublisherInfo::id_type& publisher_id) {
+bool BatPublishers::isVerified(const std::string& publisher_id) {
   if (server_list_.empty()) {
     return false;
   }
@@ -387,7 +379,7 @@ bool BatPublishers::isVerified(const ledger::PublisherInfo::id_type& publisher_i
   return values.verified;
 }
 
-bool BatPublishers::isExcluded(const ledger::PublisherInfo::id_type& publisher_id, const ledger::PUBLISHER_EXCLUDE& excluded) {
+bool BatPublishers::isExcluded(const std::string& publisher_id, const ledger::PUBLISHER_EXCLUDE& excluded) {
   if (excluded == ledger::PUBLISHER_EXCLUDE::INCLUDED || server_list_.empty()) {
     return false;
   }
diff --git a/src/bat_publishers.h b/src/bat_publishers.h
index 86c622d59047..e253e958c1bf 100644
--- a/src/bat_publishers.h
+++ b/src/bat_publishers.h
@@ -35,7 +35,9 @@ class BatPublishers : public ledger::LedgerCallbackHandler {
 
   bool loadState(const std::string& data);
 
-  void saveVisit(const ledger::VisitData& visit_data, const uint64_t& duration);
+  void saveVisit(const std::string& publisher_id,
+                 const ledger::VisitData& visit_data,
+                 const uint64_t& duration);
 
   void MakePayment(const ledger::PaymentData& payment_data);
 
@@ -88,9 +90,10 @@ class BatPublishers : public ledger::LedgerCallbackHandler {
   void OnPublisherStateSaved(ledger::Result result) override;
 
   bool isEligableForContribution(const ledger::PublisherInfo& info);
-  bool isVerified(const ledger::PublisherInfo::id_type& publisher_id);
-  bool isExcluded(const ledger::PublisherInfo::id_type& publisher_id, const ledger::PUBLISHER_EXCLUDE& excluded);
+  bool isVerified(const std::string& publisher_id);
+  bool isExcluded(const std::string& publisher_id, const ledger::PUBLISHER_EXCLUDE& excluded);
   void saveVisitInternal(
+      std::string publisher_id,
       ledger::VisitData visit_data,
       uint64_t duration,
       ledger::Result result,
diff --git a/src/ledger_impl.cc b/src/ledger_impl.cc
index bffbe0e9a090..65e44387fa18 100644
--- a/src/ledger_impl.cc
+++ b/src/ledger_impl.cc
@@ -78,8 +78,6 @@ void LedgerImpl::OnLoad(const ledger::VisitData& visit_data, const uint64_t& cur
     last_tab_active_time_ = current_time;
   }
   current_pages_[visit_data.tab_id] = visit_data;
-  //LOG(ERROR) << "!!!LedgerImpl::OnLoad tab_id == " << visit_data.tab_id << ", domain == " << visit_data.domain
-  //  << ", tld == " << visit_data.tld << ", path == " << visit_data.path;
 }
 
 void LedgerImpl::OnUnload(uint32_t tab_id, const uint64_t& current_time) {
@@ -107,7 +105,7 @@ void LedgerImpl::OnHide(uint32_t tab_id, const uint64_t& current_time) {
   }
   //LOG(ERROR) << "!!!LedgerImpl::OnHide tab_id == " << tab_id << ", time == " << (current_time - last_tab_active_time_);
   DCHECK(last_tab_active_time_);
-  bat_publishers_->saveVisit(iter->second, current_time - last_tab_active_time_);
+  bat_publishers_->saveVisit(iter->second.tld, iter->second, current_time - last_tab_active_time_);
   last_tab_active_time_ = 0;
 }
 
@@ -139,16 +137,11 @@ void LedgerImpl::OnXHRLoad(
     const std::string& first_party_url,
     const std::string& referrer,
     const ledger::VisitData& visit_data) {
-  // TODO
-  //LOG(ERROR) << "!!!LedgerImpl::OnXHRLoad first_party_url == " << first_party_url;
-  //LOG(ERROR) << "!!!LedgerImpl::OnXHRLoad referrer == " << referrer;
   std::string type = bat_get_media_->GetLinkType(url, first_party_url, referrer);
   if (type.empty()) {
     // It is not a media supported type
     return;
   }
-  //LOG(ERROR) << "!!!LedgerImpl::OnXHRLoad url == " << url;
-  LOG(ERROR) << "!!!type == " << type;
   bat_get_media_->processMedia(parts, type, visit_data);
 }
 
@@ -282,25 +275,15 @@ void LedgerImpl::SetPublisherInfo(std::unique_ptr<ledger::PublisherInfo> info,
       std::bind(&LedgerImpl::OnSetPublisherInfo, this, callback, _1, _2));
 }
 
-void LedgerImpl::SetMediaPublisherInfo(const uint64_t& duration,
-                                std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info,
-                                const ledger::VisitData& visit_data,
-                                ledger::MediaPublisherInfoCallback callback) {
-  ledger_client_->SaveMediaPublisherInfo(std::move(media_publisher_info),
-      std::bind(&LedgerImpl::OnSetMediaPublisherInfo, this, duration, visit_data, callback, _1, _2));
-}
-
-void LedgerImpl::OnSetMediaPublisherInfo(const uint64_t& duration,
-                          const ledger::VisitData& visit_data,
-                          ledger::MediaPublisherInfoCallback callback,
-                          ledger::Result result,
-                          std::unique_ptr<ledger::MediaPublisherInfo> info) {
-  SaveMediaVisit(visit_data, duration);
-  callback(result, std::move(info));
+void LedgerImpl::SetMediaPublisherInfo(const std::string& media_key,
+                                const std::string& publisher_id) {
+  if (!media_key.empty() && !publisher_id.empty()) {
+    ledger_client_->SaveMediaPublisherInfo(media_key, publisher_id);
+  }
 }
 
-void LedgerImpl::SaveMediaVisit(const ledger::VisitData& visit_data, const uint64_t& duration) {
-  bat_publishers_->saveVisit(visit_data, duration);
+void LedgerImpl::SaveMediaVisit(const std::string& publisher_id, const ledger::VisitData& visit_data, const uint64_t& duration) {
+  bat_publishers_->saveVisit(publisher_id, visit_data, duration);
 }
 
 void LedgerImpl::OnSetPublisherInfo(ledger::PublisherInfoCallback callback,
@@ -320,9 +303,9 @@ void LedgerImpl::GetPublisherInfo(
   ledger_client_->LoadPublisherInfo(filter, callback);
 }
 
-void LedgerImpl::GetMediaPublisherInfo(const std::string& publisher_key,
-                                ledger::MediaPublisherInfoCallback callback) {
-  ledger_client_->LoadMediaPublisherInfo(publisher_key, callback);
+void LedgerImpl::GetMediaPublisherInfo(const std::string& media_key,
+                                ledger::PublisherInfoCallback callback) {
+  ledger_client_->LoadMediaPublisherInfo(media_key, callback);
 }
 
 void LedgerImpl::GetPublisherInfoList(uint32_t start, uint32_t limit,
diff --git a/src/ledger_impl.h b/src/ledger_impl.h
index 135bd4bbb9ec..c613994488fb 100644
--- a/src/ledger_impl.h
+++ b/src/ledger_impl.h
@@ -52,12 +52,10 @@ class LedgerImpl : public ledger::Ledger,
                         ledger::PublisherInfoCallback callback) override;
   void GetPublisherInfo(const ledger::PublisherInfoFilter& filter,
                         ledger::PublisherInfoCallback callback) override;
-  void GetMediaPublisherInfo(const std::string& publisher_key,
-                                ledger::MediaPublisherInfoCallback callback) override;
-  void SetMediaPublisherInfo(const uint64_t& duration,
-                            std::unique_ptr<ledger::MediaPublisherInfo> media_publisher_info,
-                            const ledger::VisitData& visit_data,
-                            ledger::MediaPublisherInfoCallback callback) override;
+  void GetMediaPublisherInfo(const std::string& media_key,
+                                ledger::PublisherInfoCallback callback) override;
+  void SetMediaPublisherInfo(const std::string& media_key,
+                            const std::string& publisher_id) override;
   std::vector<ledger::ContributionInfo> GetRecurringDonationPublisherInfo() override;
   void GetPublisherInfoList(uint32_t start, uint32_t limit,
                             const ledger::PublisherInfoFilter& filter,
@@ -132,7 +130,7 @@ class LedgerImpl : public ledger::Ledger,
   void RunIOTask(LedgerTaskRunnerImpl::Task task);
   void RunTask(LedgerTaskRunnerImpl::Task task);
   std::string URIEncode(const std::string& value) override;
-  void SaveMediaVisit(const ledger::VisitData& visit_data, const uint64_t& duration) override;
+  void SaveMediaVisit(const std::string& publisher_id, const ledger::VisitData& visit_data, const uint64_t& duration) override;
 
  private:
   void MakePayment(const ledger::PaymentData& payment_data) override;
@@ -164,11 +162,6 @@ class LedgerImpl : public ledger::Ledger,
   void OnSetPublisherInfo(ledger::PublisherInfoCallback callback,
                           ledger::Result result,
                           std::unique_ptr<ledger::PublisherInfo> info);
-  void OnSetMediaPublisherInfo(const uint64_t& duration,
-                          const ledger::VisitData& visit_data,
-                          ledger::MediaPublisherInfoCallback callback,
-                          ledger::Result result,
-                          std::unique_ptr<ledger::MediaPublisherInfo> info);
 
   void saveVisitCallback(const std::string& publisher,
                          uint64_t verifiedTimestamp);