diff --git a/app/brave_generated_resources.grd b/app/brave_generated_resources.grd
index 1488926b9604..85bc61442dd2 100644
--- a/app/brave_generated_resources.grd
+++ b/app/brave_generated_resources.grd
@@ -790,6 +790,15 @@ By installing this extension, you are agreeing to the Google Widevine Terms of U
       <message name="IDS_SETTINGS_IPNS_KEYS_START_NODE_ERROR" desc="The error message when node was unable to start on IPFS keys manager page">
         IPFS service launch error, more information is available on the <ph name="BEGIN_LINK">&lt;a target="_blank" rel="noopener noreferrer" style="text-decoration: underline;" href="chrome://ipfs-internals/"&gt;</ph>diagnostic page<ph name="END_LINK">&lt;/a&gt;</ph>
       </message>
+      <message name="IDS_SETTINGS_IPNS_KEYS_IMPORT_ERROR" desc="The error text if ipns keys import failed">
+        '<ph name="KEY_NAME">$1<ex>MyCustomKey</ex></ph>' key import failed
+      </message>
+      <message name="IDS_SETTINGS_IPNS_KEYS_IMPORT_BUTTON_TITLE" desc="The title of the button to import ipns keys">
+        Import
+      </message>
+      <message name="IDS_SETTINGS_IPNS_KEYS_GENERATE_BUTTON_TITLE" desc="The title of the button to import ipns keys">
+        Generate
+      </message>
       <message name="IDS_SETTINGS_IPNS_KEYS_START_NODE" desc="The button text to start node on IPFS keys manager page">
         Start node
       </message>
diff --git a/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.html b/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.html
index e1e1ba8aaa55..e8498e2c79e9 100644
--- a/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.html
+++ b/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.html
@@ -2,6 +2,9 @@
 <script type="module" src="../settings_shared_css.js"></script>
 
 <style include="settings-shared">
+  #submit {
+    margin-left : 10px;
+  }
 </style>
 <cr-dialog show-close-button show-on-attach>
   <div slot="title">$i18n{ipfsAddKeyDialogTitle}</div>
@@ -14,9 +17,12 @@
     </cr-input>
   </div>
   <div slot="button-container">
+    <cr-button class="action-button" on-click="onImportKeyTap_" disabled="[[!isSubmitButtonEnabled_]]">
+      $i18n{ipfsKeyImport}
+    </cr-button>
     <cr-button class="action-button" id="submit" on-click="handleSubmit_"
         disabled="[[!isSubmitButtonEnabled_]]">
-    Submit
+      $i18n{ipfsKeyGenerate}
     </cr-button>
   </div>
 </cr-dialog>
diff --git a/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.js b/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.js
index 7b2bfd2b889e..fe38e8b27a9d 100644
--- a/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.js
+++ b/browser/resources/settings/brave_ipfs_page/add_p2p_key_dialog.js
@@ -65,7 +65,10 @@ Polymer({
     this.isNameValid_ = value;
     this.isSubmitButtonEnabled_ = value;
   },
-
+  onImportKeyTap_: function(item) {
+    this.browserProxy_.importIpnsKey(this.$.key.value)
+    this.fire('close');
+  },
   handleSubmit_: function() {
     var name = this.$.key.value
     this.browserProxy_.addIpnsKey(name).then(json => {
diff --git a/browser/resources/settings/brave_ipfs_page/brave_ipfs_browser_proxy.js b/browser/resources/settings/brave_ipfs_page/brave_ipfs_browser_proxy.js
index b3b3031f9e6b..b8fc44c6b093 100644
--- a/browser/resources/settings/brave_ipfs_page/brave_ipfs_browser_proxy.js
+++ b/browser/resources/settings/brave_ipfs_page/brave_ipfs_browser_proxy.js
@@ -13,6 +13,7 @@ export class BraveIPFSBrowserProxy {
   getIPFSResolveMethodList () {}
   getIPFSEnabled () {}
   setIPFSStorageMax (value) {}
+  importIpnsKey () {}
 }
 
 /**
@@ -27,6 +28,10 @@ export class BraveIPFSBrowserProxyImpl {
     chrome.send('setIPFSStorageMax', [value])
   }
 
+  importIpnsKey (value) {
+    chrome.send('importIpnsKey', [value])
+  }
+
   launchIPFSService () {
     return new Promise(resolve => {
       if (!chrome.ipfs) {
diff --git a/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.html b/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.html
index c72ce82aab48..585ab2b7c3d5 100644
--- a/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.html
+++ b/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.html
@@ -55,13 +55,15 @@
     <div class="settings-row">
       <div class="flex cr-padded-text">
           $i18n{ipfsKeysListTitle}
+          <div class="secondary error-text" id="key-import-error" hidden="[[!importKeysError_]]">
+          </div>
       </div>
       <cr-button on-click="onAddKeyTap_" >
         $i18n{add}
       </cr-button>
     </div>
     <div class="flex" id="listContainer">
-      <iron-list items="[[keys_]]" class="flex"
+      <iron-list items="[[keys_]]" class="flex" id="keysList"
           preserve-focus risk-selection>
         <template>
           <div class="settings-box">
diff --git a/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.js b/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.js
index 246dff61e0c2..9d01f36c9455 100644
--- a/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.js
+++ b/browser/resources/settings/brave_ipfs_page/p2p_keys_subpage.js
@@ -47,6 +47,10 @@ Polymer({
       type: Boolean,
       value: false,
     },
+    importKeysError_: {
+      type: Boolean,
+      value: false,
+    },
     showAddp2pKeyDialog_: {
       type: Boolean,
       value: false,
@@ -64,13 +68,28 @@ Polymer({
     this.addWebUIListener('brave-ipfs-keys-loaded', (launched) => {
       this.updateKeys()
     })
+    this.addWebUIListener('brave-ipfs-key-imported', (key, value, success) => {
+      this.importKeysError_ = !success
+      if (this.importKeysError_ ) {
+        const errorLabel = (this.$$('#key-import-error'));
+        errorLabel.textContent = this.i18n('ipfsImporKeysError', key)
+        return;
+      }
+      this.keys_.push({ "name" : key, "value" : value});
+      const keysList =
+          /** @type {IronListElement} */ (this.$$('#keysList'));
+      if (keysList) {
+        keysList.notifyResize();
+      }
+    })
   },
 
   toggleUILayout: function(launched) {
     this.launchNodeButtonEnabled_ = !launched;
     this.localNodeLaunched = launched
+    this.importKeysError_ = false
     if (launched) {
-      this.localNodeLaunchError_ = false;
+      this.localNodeLaunchError_ = false
     } else {
       this.showAddp2pKeyDialog_ = false
     }
diff --git a/browser/ui/webui/settings/brave_default_extensions_handler.cc b/browser/ui/webui/settings/brave_default_extensions_handler.cc
index 774cc75d79da..34421d5bb812 100644
--- a/browser/ui/webui/settings/brave_default_extensions_handler.cc
+++ b/browser/ui/webui/settings/brave_default_extensions_handler.cc
@@ -5,6 +5,7 @@
 
 #include "brave/browser/ui/webui/settings/brave_default_extensions_handler.h"
 
+#include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ -25,6 +26,7 @@
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/flags_ui/flags_ui_constants.h"
@@ -57,6 +59,7 @@
 #if BUILDFLAG(IPFS_ENABLED)
 #include "brave/browser/ipfs/ipfs_service_factory.h"
 #include "brave/components/ipfs/ipfs_service.h"
+#include "brave/components/ipfs/keys/ipns_keys_manager.h"
 #include "brave/components/ipfs/pref_names.h"
 #endif
 
@@ -106,6 +109,10 @@ void BraveDefaultExtensionsHandler::RegisterMessages() {
       "setIPFSStorageMax",
       base::BindRepeating(&BraveDefaultExtensionsHandler::SetIPFSStorageMax,
                           base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "importIpnsKey",
+      base::BindRepeating(&BraveDefaultExtensionsHandler::ImportIpnsKey,
+                          base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "launchIPFSService",
       base::BindRepeating(&BraveDefaultExtensionsHandler::LaunchIPFSService,
@@ -509,6 +516,57 @@ void BraveDefaultExtensionsHandler::GetDecentralizedDnsResolveMethodList(
 }
 
 #if BUILDFLAG(IPFS_ENABLED)
+void BraveDefaultExtensionsHandler::FileSelected(const base::FilePath& path,
+                                                 int index,
+                                                 void* params) {
+  ipfs::IpfsService* service =
+      ipfs::IpfsServiceFactory::GetForContext(profile_);
+  if (!service)
+    return;
+  service->GetIpnsKeysManager()->ImportKey(
+      path, dialog_key_,
+      base::BindOnce(&BraveDefaultExtensionsHandler::OnKeyImported,
+                     base::Unretained(this)));
+  select_file_dialog_.reset();
+  dialog_key_.clear();
+}
+
+void BraveDefaultExtensionsHandler::OnKeyImported(const std::string& key,
+                                                  const std::string& value,
+                                                  bool success) {
+  FireWebUIListener("brave-ipfs-key-imported", base::Value(key),
+                    base::Value(value), base::Value(success));
+}
+
+void BraveDefaultExtensionsHandler::FileSelectionCanceled(void* params) {
+  select_file_dialog_.reset();
+  dialog_key_.clear();
+}
+
+void BraveDefaultExtensionsHandler::ImportIpnsKey(const base::ListValue* args) {
+  CHECK_EQ(args->GetSize(), 1U);
+  CHECK(profile_);
+  std::string key_name;
+  args->GetString(0, &key_name);
+  auto* web_contents = web_ui()->GetWebContents();
+  select_file_dialog_ = ui::SelectFileDialog::Create(
+      this, std::make_unique<ChromeSelectFilePolicy>(web_contents));
+  if (!select_file_dialog_) {
+    VLOG(1) << "Export already in progress";
+    return;
+  }
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  const base::FilePath directory = profile->last_selected_directory();
+  gfx::NativeWindow parent_window = web_contents->GetTopLevelNativeWindow();
+  ui::SelectFileDialog::FileTypeInfo file_types;
+  file_types.allowed_paths = ui::SelectFileDialog::FileTypeInfo::NATIVE_PATH;
+  dialog_key_ = key_name;
+  select_file_dialog_->SelectFile(
+      ui::SelectFileDialog::SELECT_OPEN_FILE, std::u16string(), directory,
+      &file_types, 0, FILE_PATH_LITERAL("key"), parent_window, nullptr);
+}
+
 void BraveDefaultExtensionsHandler::OnIpfsLaunched(bool result, int64_t pid) {
   if (!IsJavascriptAllowed())
     return;
diff --git a/browser/ui/webui/settings/brave_default_extensions_handler.h b/browser/ui/webui/settings/brave_default_extensions_handler.h
index 529b8e7cf3f2..4cf56f6ed1cc 100644
--- a/browser/ui/webui/settings/brave_default_extensions_handler.h
+++ b/browser/ui/webui/settings/brave_default_extensions_handler.h
@@ -20,6 +20,7 @@
 #if BUILDFLAG(IPFS_ENABLED)
 #include "brave/components/ipfs/ipfs_service.h"
 #include "brave/components/ipfs/ipfs_service_observer.h"
+#include "ui/shell_dialogs/select_file_dialog.h"
 #endif
 
 class Profile;
@@ -27,7 +28,8 @@ class Profile;
 class BraveDefaultExtensionsHandler : public settings::SettingsPageUIHandler
 #if BUILDFLAG(IPFS_ENABLED)
     ,
-                                      ipfs::IpfsServiceObserver
+                                      ipfs::IpfsServiceObserver,
+                                      public ui::SelectFileDialog::Listener
 #endif
 {
  public:
@@ -46,6 +48,7 @@ class BraveDefaultExtensionsHandler : public settings::SettingsPageUIHandler
   void SetIPFSCompanionEnabled(const base::ListValue* args);
   void SetMediaRouterEnabled(const base::ListValue* args);
   void SetIPFSStorageMax(const base::ListValue* args);
+  void ImportIpnsKey(const base::ListValue* args);
   void LaunchIPFSService(const base::ListValue* args);
   void ShutdownIPFSService(const base::ListValue* args);
 #if BUILDFLAG(BRAVE_WALLET_ENABLED)
@@ -74,10 +77,21 @@ class BraveDefaultExtensionsHandler : public settings::SettingsPageUIHandler
   bool IsRestartNeeded();
 
 #if BUILDFLAG(IPFS_ENABLED)
+  // ui::SelectFileDialog::Listener
+  void FileSelected(const base::FilePath& path,
+                    int index,
+                    void* params) override;
+  void FileSelectionCanceled(void* params) override;
+
+  void OnKeyImported(const std::string& key,
+                     const std::string& value,
+                     bool success);
   // ipfs::IpfsServiceObserver
   void OnIpfsLaunched(bool result, int64_t pid) override;
   void OnIpfsShutdown() override;
   void OnIpnsKeysLoaded(bool success) override;
+  std::string dialog_key_;
+  scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
 #endif
 
 #if BUILDFLAG(ENABLE_WIDEVINE)
diff --git a/chromium_src/chrome/browser/ui/webui/settings/settings_localized_strings_provider.cc b/chromium_src/chrome/browser/ui/webui/settings/settings_localized_strings_provider.cc
index 5d53330878d9..bc129c70c50f 100644
--- a/chromium_src/chrome/browser/ui/webui/settings/settings_localized_strings_provider.cc
+++ b/chromium_src/chrome/browser/ui/webui/settings/settings_localized_strings_provider.cc
@@ -282,6 +282,9 @@ void BraveAddCommonStrings(content::WebUIDataSource* html_source,
     {"ipfsKeysNodeNotLaunched", IDS_SETTINGS_IPNS_KEYS_NODE_NOT_LAUNCHED},
     {"ipfsKeysStartNode", IDS_SETTINGS_IPNS_KEYS_START_NODE},
     {"ipfsKeysNodeLaunchError", IDS_SETTINGS_IPNS_KEYS_START_NODE_ERROR},
+    {"ipfsKeyImport", IDS_SETTINGS_IPNS_KEYS_IMPORT_BUTTON_TITLE},
+    {"ipfsKeyGenerate", IDS_SETTINGS_IPNS_KEYS_GENERATE_BUTTON_TITLE},
+    {"ipfsImporKeysError", IDS_SETTINGS_IPNS_KEYS_IMPORT_ERROR},
   };
   html_source->AddLocalizedStrings(localized_strings);
   html_source->AddString("webRTCLearnMoreURL",
diff --git a/components/ipfs/ipfs_network_utils.cc b/components/ipfs/ipfs_network_utils.cc
index 39c7e61e7b85..f448d44db357 100644
--- a/components/ipfs/ipfs_network_utils.cc
+++ b/components/ipfs/ipfs_network_utils.cc
@@ -164,10 +164,6 @@ std::unique_ptr<storage::BlobDataBuilder> BuildBlobWithFolder(
 
 namespace ipfs {
 
-<<<<<<< HEAD
-=======
-
->>>>>>> 8ba05e73c8 (Implemented IPFS import refactoring)
 std::unique_ptr<network::SimpleURLLoader> CreateURLLoader(
     const GURL& gurl,
     const std::string& method,
@@ -252,13 +248,8 @@ void CreateRequestForFile(const base::FilePath& upload_file_path,
                           size_t file_size) {
   std::string mime_boundary = net::GenerateMimeMultipartBoundary();
   auto blob_builder_callback =
-<<<<<<< HEAD
       base::BindOnce(&BuildBlobWithFile, upload_file_path, mime_type, filename,
                      mime_boundary, file_size);
-=======
-      base::BindOnce(&BuildBlobWithFile, upload_file_path, mime_type,
-                     filename, mime_boundary, file_size);
->>>>>>> 8ba05e73c8 (Implemented IPFS import refactoring)
   std::string content_type = ipfs::kIPFSImportMultipartContentType;
   content_type += " boundary=";
   content_type += mime_boundary;
@@ -266,20 +257,11 @@ void CreateRequestForFile(const base::FilePath& upload_file_path,
   base::PostTaskAndReplyWithResult(
       FROM_HERE, {base::MayBlock(), content::BrowserThread::IO},
       base::BindOnce(&CreateResourceRequest, std::move(blob_builder_callback),
-<<<<<<< HEAD
                      content_type, std::move(storage)),
       std::move(request_callback));
 }
 
 std::vector<ImportFileInfo> EnumerateDirectoryFiles(base::FilePath dir_path) {
-=======
-                    content_type, std::move(storage)),
-      std::move(request_callback));
-}
-
-std::vector<ImportFileInfo> EnumerateDirectoryFiles(
-    base::FilePath dir_path) {
->>>>>>> 8ba05e73c8 (Implemented IPFS import refactoring)
   std::vector<ImportFileInfo> files;
   base::FileEnumerator file_enum(
       dir_path, true,
diff --git a/components/ipfs/ipfs_network_utils_unittest.cc b/components/ipfs/ipfs_network_utils_unittest.cc
index 093702f23b2c..23db54c4edd8 100644
--- a/components/ipfs/ipfs_network_utils_unittest.cc
+++ b/components/ipfs/ipfs_network_utils_unittest.cc
@@ -16,13 +16,11 @@
 #include "services/network/public/cpp/data_element.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_item.h"
-
-#include "services/network/public/cpp/data_element.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ipfs {
 
-class IpfsNetwrokUtilsUnitTest : public ChromeRenderViewHostTestHarness {
+class IpfsNetwrokUtilsUnitTest : public testing::Test {
  public:
   IpfsNetwrokUtilsUnitTest() {}
   ~IpfsNetwrokUtilsUnitTest() override = default;
diff --git a/components/ipfs/keys/ipns_keys_manager.cc b/components/ipfs/keys/ipns_keys_manager.cc
index 58398c3aefcc..97b99f3fa831 100644
--- a/components/ipfs/keys/ipns_keys_manager.cc
+++ b/components/ipfs/keys/ipns_keys_manager.cc
@@ -9,15 +9,22 @@
 #include <string>
 #include <utility>
 
+#include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "brave/components/ipfs/ipfs_constants.h"
 #include "brave/components/ipfs/ipfs_json_parser.h"
 #include "brave/components/ipfs/ipfs_network_utils.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/storage_partition.h"
+#include "net/base/mime_util.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
+#include "services/network/public/cpp/resource_request.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/cpp/simple_url_loader.h"
+#include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/blob_data_handle.h"
 
 namespace ipfs {
 
@@ -32,6 +39,26 @@ IpnsKeysManager::IpnsKeysManager(content::BrowserContext* context,
 
 IpnsKeysManager::~IpnsKeysManager() {}
 
+void IpnsKeysManager::ImportKey(const base::FilePath& upload_file_path,
+                                const std::string& name,
+                                ImportKeyCallback callback) {
+  auto blob_storage_context_getter =
+      content::BrowserContext::GetBlobStorageContext(context_);
+
+  auto upload_callback =
+      base::BindOnce(&IpnsKeysManager::UploadData, weak_factory_.GetWeakPtr(),
+                     std::move(callback), name);
+  auto filename = upload_file_path.BaseName().MaybeAsASCII();
+  auto file_request_callback =
+      base::BindOnce(&CreateRequestForFile, upload_file_path,
+                     std::move(blob_storage_context_getter),
+                     ipfs::kFileMimeType, filename, std::move(upload_callback));
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock()},
+      base::BindOnce(&CalculateFileSize, upload_file_path),
+      std::move(file_request_callback));
+}
+
 bool IpnsKeysManager::KeyExists(const std::string& name) const {
   return keys_.count(name);
 }
@@ -49,12 +76,12 @@ void IpnsKeysManager::RemoveKey(const std::string& name,
   GURL gurl =
       net::AppendQueryParameter(generate_endpoint, kArgQueryParam, name);
 
-  auto url_loader = CreateURLLoader(gurl, "POST");
+  auto url_loader = ipfs::CreateURLLoader(gurl, "POST");
 
   auto iter = url_loaders_.insert(url_loaders_.begin(), std::move(url_loader));
   iter->get()->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
       url_loader_factory_.get(),
-      base::BindOnce(&IpnsKeysManager::OnKeyRemoved, base::Unretained(this),
+      base::BindOnce(&IpnsKeysManager::OnKeyRemoved, weak_factory_.GetWeakPtr(),
                      iter, name, std::move(callback)));
 }
 
@@ -69,8 +96,6 @@ void IpnsKeysManager::OnKeyRemoved(SimpleURLLoaderList::iterator iter,
     response_code = url_loader->ResponseInfo()->headers->response_code();
   url_loaders_.erase(iter);
 
-  std::string name;
-  std::string value;
   bool success = (error_code == net::OK && response_code == net::HTTP_OK);
   std::unordered_map<std::string, std::string> removed_keys;
   success = success &&
@@ -104,7 +129,7 @@ void IpnsKeysManager::GenerateNewKey(const std::string& name,
   auto iter = url_loaders_.insert(url_loaders_.begin(), std::move(url_loader));
   iter->get()->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
       url_loader_factory_.get(),
-      base::BindOnce(&IpnsKeysManager::OnKeyCreated, base::Unretained(this),
+      base::BindOnce(&IpnsKeysManager::OnKeyCreated, weak_factory_.GetWeakPtr(),
                      iter, std::move(callback)));
 }
 
@@ -147,8 +172,58 @@ void IpnsKeysManager::LoadKeys(LoadKeysCallback callback) {
   auto iter = url_loaders_.insert(url_loaders_.begin(), std::move(url_loader));
 
   iter->get()->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
-      url_loader_factory_.get(), base::BindOnce(&IpnsKeysManager::OnKeysLoaded,
-                                                base::Unretained(this), iter));
+      url_loader_factory_.get(),
+      base::BindOnce(&IpnsKeysManager::OnKeysLoaded, weak_factory_.GetWeakPtr(),
+                     iter));
+}
+
+void IpnsKeysManager::UploadData(
+    ImportKeyCallback callback,
+    const std::string& name,
+    std::unique_ptr<network::ResourceRequest> request) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!request)
+    return;
+
+  auto generate_endpoint = server_endpoint_.Resolve(kAPIKeyImportEndpoint);
+  GURL url = net::AppendQueryParameter(generate_endpoint, kArgQueryParam, name);
+
+  auto url_loader = CreateURLLoader(url, "POST", std::move(request));
+  auto iter = url_loaders_.insert(url_loaders_.begin(), std::move(url_loader));
+  iter->get()->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
+      url_loader_factory_.get(),
+      base::BindOnce(&IpnsKeysManager::OnKeyImported,
+                     weak_factory_.GetWeakPtr(), iter, std::move(callback),
+                     name));
+}
+
+void IpnsKeysManager::OnKeyImported(
+    SimpleURLLoaderList::iterator iter,
+    ImportKeyCallback callback,
+    const std::string& key_name,
+    std::unique_ptr<std::string> response_body) {
+  auto* url_loader = iter->get();
+  int error_code = url_loader->NetError();
+  int response_code = -1;
+  if (url_loader->ResponseInfo() && url_loader->ResponseInfo()->headers)
+    response_code = url_loader->ResponseInfo()->headers->response_code();
+  url_loaders_.erase(iter);
+
+  bool success = (error_code == net::OK && response_code == net::HTTP_OK);
+  std::string name;
+  std::string value;
+  std::unordered_map<std::string, std::string> new_keys;
+  success = success && IPFSJSONParser::GetParseSingleKeyFromJSON(*response_body,
+                                                                 &name, &value);
+  if (success) {
+    DCHECK_EQ(key_name, name) << "Key names should be equal";
+    keys_[name] = value;
+  } else {
+    VLOG(1) << "Fail to import key, error_code = " << error_code
+            << " response_code = " << response_code;
+  }
+  if (callback)
+    std::move(callback).Run(key_name, value, success);
 }
 
 void IpnsKeysManager::OnIpfsShutdown() {
diff --git a/components/ipfs/keys/ipns_keys_manager.h b/components/ipfs/keys/ipns_keys_manager.h
index 19975f31d36e..08c73260daa7 100644
--- a/components/ipfs/keys/ipns_keys_manager.h
+++ b/components/ipfs/keys/ipns_keys_manager.h
@@ -14,7 +14,9 @@
 #include "base/callback.h"
 #include "base/containers/queue.h"
 #include "base/memory/scoped_refptr.h"
+#include "brave/components/ipfs/ipfs_network_utils.h"
 #include "brave/components/ipfs/ipfs_service_observer.h"
+#include "services/network/public/cpp/resource_request.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -24,6 +26,7 @@ class BrowserContext;
 namespace network {
 class SharedURLLoaderFactory;
 class SimpleURLLoader;
+struct ResourceRequest;
 }  // namespace network
 
 namespace ipfs {
@@ -43,6 +46,8 @@ class IpnsKeysManager : public IpfsServiceObserver {
   using GenerateKeyCallback =
       base::OnceCallback<void(bool, const std::string&, const std::string&)>;
   using RemoveKeyCallback = base::OnceCallback<void(const std::string&, bool)>;
+  using ImportKeyCallback =
+      base::OnceCallback<void(const std::string&, const std::string&, bool)>;
   using KeysMap = std::unordered_map<std::string, std::string>;
   void LoadKeys(LoadKeysCallback callback);
   void GenerateNewKey(const std::string& name, GenerateKeyCallback callback);
@@ -52,6 +57,9 @@ class IpnsKeysManager : public IpfsServiceObserver {
   const KeysMap& GetKeys() const { return keys_; }
   const std::string FindKey(const std::string& name) const;
 
+  void ImportKey(const base::FilePath& paths,
+                 const std::string& name,
+                 ImportKeyCallback callback);
   void SetServerEndpointForTest(const GURL& gurl);
   void SetLoadCallbackForTest(LoadKeysCallback callback);
 
@@ -61,7 +69,10 @@ class IpnsKeysManager : public IpfsServiceObserver {
 
   // ipfs::IpfsServiceObserver
   void OnIpfsShutdown() override;
-
+  void OnKeyImported(SimpleURLLoaderList::iterator iter,
+                     ImportKeyCallback callback,
+                     const std::string& key_name,
+                     std::unique_ptr<std::string> response_body);
   void OnKeyCreated(SimpleURLLoaderList::iterator iter,
                     GenerateKeyCallback callback,
                     std::unique_ptr<std::string> response_body);
@@ -69,18 +80,22 @@ class IpnsKeysManager : public IpfsServiceObserver {
                     const std::string& key_to_remove,
                     RemoveKeyCallback callback,
                     std::unique_ptr<std::string> response_body);
-
   void OnKeysLoaded(SimpleURLLoaderList::iterator iter,
                     std::unique_ptr<std::string> response_body);
 
   void NotifyKeysLoaded(bool result);
 
+  void UploadData(ImportKeyCallback callback,
+                  const std::string& name,
+                  std::unique_ptr<network::ResourceRequest> request);
+
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
   SimpleURLLoaderList url_loaders_;
   std::unordered_map<std::string, std::string> keys_;
   base::queue<LoadKeysCallback> pending_load_callbacks_;
   content::BrowserContext* context_ = nullptr;
   GURL server_endpoint_;
+  base::WeakPtrFactory<IpnsKeysManager> weak_factory_{this};
 };
 
 }  // namespace ipfs