diff --git a/lib/ops/keyserver-store-ops.js b/lib/ops/keyserver-store-ops.js
--- a/lib/ops/keyserver-store-ops.js
+++ b/lib/ops/keyserver-store-ops.js
@@ -1,15 +1,18 @@
 // @flow
 
 import { type BaseStoreOpsHandlers } from './base-ops.js';
+import type { PersistedKeyserverInfo } from '../shared/transforms/keyserver-store-transform.js';
 import {
   transformKeyserverInfoToPersistedKeyserverInfo,
   transformPersistedKeyserverInfoToKeyserverInfo,
 } from '../shared/transforms/keyserver-store-transform.js';
-import type {
-  KeyserverInfo,
-  KeyserverInfos,
-  KeyserverStore,
+import {
+  type KeyserverInfo,
+  type KeyserverInfos,
+  type KeyserverStore,
+  defaultKeyserverInfo,
 } from '../types/keyserver-types.js';
+import { getConfig } from '../utils/config.js';
 
 // client types
 export type ReplaceKeyserverOperation = {
@@ -35,6 +38,7 @@
 export type ClientDBKeyserverInfo = {
   +id: string,
   +keyserverInfo: string,
+  +syncedKeyserverInfo: string,
 };
 
 export type ClientDBReplaceKeyserverOperation = {
@@ -47,6 +51,8 @@
   | RemoveKeyserversOperation
   | RemoveAllKeyserversOperation;
 
+type SyncedKeyserverInfoData = { +urlPrefix: string };
+
 function convertKeyserverInfoToClientDBKeyserverInfo({
   id,
   keyserverInfo,
@@ -56,16 +62,48 @@
 }): ClientDBKeyserverInfo {
   const persistedKeyserverInfo =
     transformKeyserverInfoToPersistedKeyserverInfo(keyserverInfo);
+  const { urlPrefix, ...nonSyncedData } = persistedKeyserverInfo;
+  const syncedData: SyncedKeyserverInfoData = { urlPrefix };
   return {
     id,
-    keyserverInfo: JSON.stringify(persistedKeyserverInfo),
+    keyserverInfo: JSON.stringify(nonSyncedData),
+    syncedKeyserverInfo: JSON.stringify(syncedData),
   };
 }
 
 function convertClientDBKeyserverInfoToKeyserverInfo(
   dbKeyserverInfo: ClientDBKeyserverInfo,
 ): KeyserverInfo {
-  const persistedKeyserverInfo = JSON.parse(dbKeyserverInfo.keyserverInfo);
+  const persistedSyncedKeyserverInfo: SyncedKeyserverInfoData = JSON.parse(
+    dbKeyserverInfo.syncedKeyserverInfo,
+  );
+
+  let persistedKeyserverInfo: PersistedKeyserverInfo;
+  if (dbKeyserverInfo.keyserverInfo.length > 0) {
+    const persistedNonSyncedKeyserverInfo: $Diff<
+      PersistedKeyserverInfo,
+      SyncedKeyserverInfoData,
+    > = JSON.parse(dbKeyserverInfo.keyserverInfo);
+
+    persistedKeyserverInfo = {
+      ...persistedNonSyncedKeyserverInfo,
+      ...persistedSyncedKeyserverInfo,
+    };
+  } else {
+    const defaultPersistedNonSyncedKeyserverInfo =
+      transformKeyserverInfoToPersistedKeyserverInfo(
+        defaultKeyserverInfo(
+          persistedSyncedKeyserverInfo.urlPrefix,
+          getConfig().platformDetails.platform,
+        ),
+      );
+
+    persistedKeyserverInfo = {
+      ...defaultPersistedNonSyncedKeyserverInfo,
+      ...persistedSyncedKeyserverInfo,
+    };
+  }
+
   return transformPersistedKeyserverInfoToKeyserverInfo(persistedKeyserverInfo);
 }
 
diff --git a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
--- a/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
@@ -1575,17 +1575,29 @@
     const KeyserverInfo &keyserver_info) const {
   static std::string replaceKeyserverSQL =
       "REPLACE INTO keyservers (id, keyserver_info) "
-      "VALUES (?, ?);";
+      "VALUES (:id, :keyserver_info);";
   replaceEntity<KeyserverInfo>(
       SQLiteQueryExecutor::getConnection(),
       replaceKeyserverSQL,
       keyserver_info);
+
+  static std::string replaceKeyserverSyncedSQL =
+      "REPLACE INTO keyservers_synced (id, keyserver_info) "
+      "VALUES (:id, :synced_keyserver_info);";
+  replaceEntity<KeyserverInfo>(
+      SQLiteQueryExecutor::getConnection(),
+      replaceKeyserverSyncedSQL,
+      keyserver_info);
 }
 
 void SQLiteQueryExecutor::removeAllKeyservers() const {
   static std::string removeAllKeyserversSQL = "DELETE FROM keyservers;";
   removeAllEntities(
       SQLiteQueryExecutor::getConnection(), removeAllKeyserversSQL);
+  static std::string removeAllKeyserversSyncedSQL =
+      "DELETE FROM keyservers_synced;";
+  removeAllEntities(
+      SQLiteQueryExecutor::getConnection(), removeAllKeyserversSyncedSQL);
 }
 
 void SQLiteQueryExecutor::removeKeyservers(
@@ -1594,21 +1606,38 @@
     return;
   }
 
+  auto idArray = getSQLStatementArray(ids.size());
+
   std::stringstream removeKeyserversByKeysSQLStream;
   removeKeyserversByKeysSQLStream << "DELETE FROM keyservers "
                                      "WHERE id IN "
-                                  << getSQLStatementArray(ids.size()) << ";";
+                                  << idArray << ";";
 
   removeEntitiesByKeys(
       SQLiteQueryExecutor::getConnection(),
       removeKeyserversByKeysSQLStream.str(),
       ids);
+
+  std::stringstream removeKeyserversSyncedByKeysSQLStream;
+  removeKeyserversSyncedByKeysSQLStream << "DELETE FROM keyservers_synced "
+                                           "WHERE id IN "
+                                        << idArray << ";";
+
+  removeEntitiesByKeys(
+      SQLiteQueryExecutor::getConnection(),
+      removeKeyserversSyncedByKeysSQLStream.str(),
+      ids);
 }
 
 std::vector<KeyserverInfo> SQLiteQueryExecutor::getAllKeyservers() const {
   static std::string getAllKeyserversSQL =
-      "SELECT * "
-      "FROM keyservers;";
+      "SELECT "
+      "   synced.id, "
+      "   COALESCE(keyservers.keyserver_info, ''), "
+      "   synced.keyserver_info "
+      "FROM keyservers_synced synced "
+      "LEFT JOIN keyservers "
+      "   ON synced.id = keyservers.id;";
   return getAllEntities<KeyserverInfo>(
       SQLiteQueryExecutor::getConnection(), getAllKeyserversSQL);
 }
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/KeyserverInfo.h b/native/cpp/CommonCpp/DatabaseManagers/entities/KeyserverInfo.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/KeyserverInfo.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/KeyserverInfo.h
@@ -9,15 +9,35 @@
 struct KeyserverInfo {
   std::string id;
   std::string keyserver_info;
+  std::string synced_keyserver_info;
 
   static KeyserverInfo fromSQLResult(sqlite3_stmt *sqlRow, int idx) {
     return KeyserverInfo{
-        getStringFromSQLRow(sqlRow, idx), getStringFromSQLRow(sqlRow, idx + 1)};
+        getStringFromSQLRow(sqlRow, idx),
+        getStringFromSQLRow(sqlRow, idx + 1),
+        getStringFromSQLRow(sqlRow, idx + 2)};
   }
 
   int bindToSQL(sqlite3_stmt *sql, int idx) const {
-    bindStringToSQL(id, sql, idx);
-    return bindStringToSQL(keyserver_info, sql, idx + 1);
+    int err;
+
+    int id_index = sqlite3_bind_parameter_index(sql, ":id");
+    err = bindStringToSQL(id, sql, id_index);
+
+    int keyserver_info_index =
+        sqlite3_bind_parameter_index(sql, ":keyserver_info");
+    if (keyserver_info_index) {
+      err = bindStringToSQL(keyserver_info, sql, keyserver_info_index);
+    }
+
+    int synced_keyserver_info_index =
+        sqlite3_bind_parameter_index(sql, ":synced_keyserver_info");
+    if (synced_keyserver_info_index) {
+      err = bindStringToSQL(
+          synced_keyserver_info, sql, synced_keyserver_info_index);
+    }
+
+    return err;
   }
 };
 
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.cpp
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.cpp
@@ -24,6 +24,8 @@
     jsi::Object jsiKeyserver = jsi::Object(rt);
     jsiKeyserver.setProperty(rt, "id", keyserver.id);
     jsiKeyserver.setProperty(rt, "keyserverInfo", keyserver.keyserver_info);
+    jsiKeyserver.setProperty(
+        rt, "syncedKeyserverInfo", keyserver.synced_keyserver_info);
     jsiKeyservers.setValueAtIndex(rt, writeIdx++, jsiKeyserver);
   }
   return jsiKeyservers;
@@ -60,8 +62,12 @@
       std::string id = payloadObj.getProperty(rt, "id").asString(rt).utf8(rt);
       std::string keyserver_info =
           payloadObj.getProperty(rt, "keyserverInfo").asString(rt).utf8(rt);
+      std::string synced_keyserver_info =
+          payloadObj.getProperty(rt, "syncedKeyserverInfo")
+              .asString(rt)
+              .utf8(rt);
 
-      KeyserverInfo keyserver{id, keyserver_info};
+      KeyserverInfo keyserver{id, keyserver_info, synced_keyserver_info};
 
       keyserverStoreOps.push_back(
           std::make_unique<ReplaceKeyserverOperation>(std::move(keyserver)));
diff --git a/web/cpp/SQLiteQueryExecutorBindings.cpp b/web/cpp/SQLiteQueryExecutorBindings.cpp
--- a/web/cpp/SQLiteQueryExecutorBindings.cpp
+++ b/web/cpp/SQLiteQueryExecutorBindings.cpp
@@ -45,7 +45,8 @@
       .field("userInfo", &UserInfo::user_info);
   value_object<KeyserverInfo>("KeyserverInfo")
       .field("id", &KeyserverInfo::id)
-      .field("keyserverInfo", &KeyserverInfo::keyserver_info);
+      .field("keyserverInfo", &KeyserverInfo::keyserver_info)
+      .field("syncedKeyserverInfo", &KeyserverInfo::synced_keyserver_info);
   value_object<MessageStoreThread>("MessageStoreThreads")
       .field("id", &MessageStoreThread::id)
       .field("startReached", &MessageStoreThread::start_reached);
diff --git a/web/shared-worker/_generated/comm_query_executor.wasm b/web/shared-worker/_generated/comm_query_executor.wasm
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001

diff --git a/web/shared-worker/worker/process-operations.js b/web/shared-worker/worker/process-operations.js
--- a/web/shared-worker/worker/process-operations.js
+++ b/web/shared-worker/worker/process-operations.js
@@ -139,8 +139,12 @@
         const { ids } = operation.payload;
         sqliteQueryExecutor.removeKeyservers(ids);
       } else if (operation.type === 'replace_keyserver') {
-        const { id, keyserverInfo } = operation.payload;
-        sqliteQueryExecutor.replaceKeyserver({ id, keyserverInfo });
+        const { id, keyserverInfo, syncedKeyserverInfo } = operation.payload;
+        sqliteQueryExecutor.replaceKeyserver({
+          id,
+          keyserverInfo,
+          syncedKeyserverInfo,
+        });
       } else {
         throw new Error('Unsupported keyserver operation');
       }