diff --git a/sharing/certificates/fake_nearby_share_certificate_manager.cc b/sharing/certificates/fake_nearby_share_certificate_manager.cc
index d20d0a9d..ff783378 100644
--- a/sharing/certificates/fake_nearby_share_certificate_manager.cc
+++ b/sharing/certificates/fake_nearby_share_certificate_manager.cc
@@ -20,10 +20,12 @@
 #include <memory>
 #include <optional>
 #include <queue>
+#include <string>
 #include <utility>
 #include <vector>
 
 #include "location/nearby/sharing/lib/rpc/sharing_rpc_client.h"
+#include "absl/strings/string_view.h"
 #include "internal/base/file_path.h"
 #include "sharing/certificates/nearby_share_certificate_manager.h"
 #include "sharing/certificates/nearby_share_encrypted_metadata_key.h"
@@ -98,6 +100,12 @@ void FakeNearbyShareCertificateManager::ClearPublicCertificates(
   callback(true);
 }
 
+void FakeNearbyShareCertificateManager::AddBindingToPublicCertificate(
+    absl::string_view certificate_id, absl::string_view binding_id) {
+  add_binding_to_public_certificate_calls_.push_back(
+      {std::string(certificate_id), std::string(binding_id)});
+}
+
 std::optional<NearbySharePrivateCertificate>
 FakeNearbyShareCertificateManager::GetValidPrivateCertificate(
     DeviceVisibility visibility) const {
diff --git a/sharing/certificates/fake_nearby_share_certificate_manager.h b/sharing/certificates/fake_nearby_share_certificate_manager.h
index adf260c1..e5e74afb 100644
--- a/sharing/certificates/fake_nearby_share_certificate_manager.h
+++ b/sharing/certificates/fake_nearby_share_certificate_manager.h
@@ -86,6 +86,11 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
     CertDecryptedCallback callback;
   };
 
+  struct AddBindingToPublicCertificateCall {
+    std::string certificate_id;
+    std::string binding_id;
+  };
+
   FakeNearbyShareCertificateManager();
   ~FakeNearbyShareCertificateManager() override;
 
@@ -97,6 +102,8 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
   void ForceUploadPrivateCertificates() override {};
   void ClearPublicCertificates(std::function<void(bool)> callback) override;
   void SetVendorId(int32_t vendor_id) override {}
+  void AddBindingToPublicCertificate(
+      absl::string_view certificate_id, absl::string_view binding_id) override;
   void SetJoinBindingTime(absl::Time join_binding_time,
                           absl::Duration life_time) override {
     join_binding_time_ = join_binding_time;
@@ -127,6 +134,11 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
     return get_decrypted_public_certificate_calls_;
   }
 
+  const std::vector<AddBindingToPublicCertificateCall>&
+  add_binding_to_public_certificate_calls() const {
+    return add_binding_to_public_certificate_calls_;
+  }
+
  private:
   // NearbyShareCertificateManager:
   void OnStartScheduledTasks() override {}
@@ -141,6 +153,8 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
   size_t num_clear_public_certificates_calls_ = 0;
   std::vector<GetDecryptedPublicCertificateCall>
       get_decrypted_public_certificate_calls_;
+  std::vector<AddBindingToPublicCertificateCall>
+      add_binding_to_public_certificate_calls_;
   std::vector<uint8_t> next_salt_;
   absl::Time join_binding_time_;
   absl::Duration join_binding_life_time_;
diff --git a/sharing/certificates/fake_nearby_share_certificate_storage.cc b/sharing/certificates/fake_nearby_share_certificate_storage.cc
index f06fecf3..155767fe 100644
--- a/sharing/certificates/fake_nearby_share_certificate_storage.cc
+++ b/sharing/certificates/fake_nearby_share_certificate_storage.cc
@@ -106,7 +106,16 @@ void FakeNearbyShareCertificateStorage::GetPublicCertificate(
     std::function<
         void(bool, std::unique_ptr<nearby::sharing::proto::PublicCertificate>)>
         callback) {
-  get_public_certificate_callback_ = std::move(callback);
+  get_public_certificate_callback_ = callback;
+  if (is_sync_mode_) {
+    for (const auto& cert : public_certificates_) {
+      if (cert.secret_id() == id) {
+        callback(true, std::make_unique<PublicCertificate>(cert));
+        return;
+      }
+    }
+    callback(false, nullptr);
+  }
 }
 
 std::vector<NearbySharePrivateCertificate>
@@ -135,6 +144,19 @@ void FakeNearbyShareCertificateStorage::AddPublicCertificates(
                                      public_certificates.end()),
       callback);
   if (is_sync_mode_) {
+    for (const auto& cert : public_certificates) {
+      bool found = false;
+      for (auto& existing_cert : public_certificates_) {
+        if (existing_cert.secret_id() == cert.secret_id()) {
+          existing_cert = cert;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        public_certificates_.push_back(cert);
+      }
+    }
     callback(add_public_certificates_result_);
   }
 }
@@ -152,6 +174,12 @@ void FakeNearbyShareCertificateStorage::ClearPublicCertificates(
   clear_public_certificates_callbacks_.push_back(std::move(callback));
 }
 
+void FakeNearbyShareCertificateStorage::SetPublicCertificates(
+    absl::Span<const PublicCertificate> public_certificates) {
+  public_certificates_ = std::vector<PublicCertificate>(
+      public_certificates.begin(), public_certificates.end());
+}
+
 void FakeNearbyShareCertificateStorage::SetPublicCertificateIds(
     absl::Span<const absl::string_view> ids) {
   public_certificate_ids_ = std::vector<std::string>(ids.begin(), ids.end());
diff --git a/sharing/certificates/fake_nearby_share_certificate_storage.h b/sharing/certificates/fake_nearby_share_certificate_storage.h
index a86a2d43..e545acc0 100644
--- a/sharing/certificates/fake_nearby_share_certificate_storage.h
+++ b/sharing/certificates/fake_nearby_share_certificate_storage.h
@@ -123,6 +123,9 @@ class FakeNearbyShareCertificateStorage : public NearbyShareCertificateStorage {
   void ClearPublicCertificates(ResultCallback callback) override;
 
   void SetPublicCertificateIds(absl::Span<const absl::string_view> ids);
+  void SetPublicCertificates(
+      absl::Span<const nearby::sharing::proto::PublicCertificate>
+          public_certificates);
   void SetNextPublicCertificateExpirationTime(absl::Time time);
 
   std::vector<PublicCertificateCallback>& get_public_certificates_callbacks() {
@@ -156,6 +159,7 @@ class FakeNearbyShareCertificateStorage : public NearbyShareCertificateStorage {
   absl::Mutex mutex_;
   absl::Time next_public_certificate_expiration_time_ = absl::InfiniteFuture();
   std::vector<std::string> public_certificate_ids_;
+  std::vector<nearby::sharing::proto::PublicCertificate> public_certificates_;
   std::vector<NearbySharePrivateCertificate> private_certificates_
       ABSL_GUARDED_BY(mutex_);
   std::vector<PublicCertificateCallback> get_public_certificates_callbacks_;
diff --git a/sharing/certificates/nearby_share_certificate_manager.h b/sharing/certificates/nearby_share_certificate_manager.h
index 2b79b8f2..3fc76e9d 100644
--- a/sharing/certificates/nearby_share_certificate_manager.h
+++ b/sharing/certificates/nearby_share_certificate_manager.h
@@ -22,6 +22,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "absl/types/span.h"
 #include "internal/base/observer_list.h"
@@ -135,6 +136,9 @@ class NearbyShareCertificateManager {
   // Dump certificates ID information for troubleshooting.
   virtual std::string Dump() const = 0;
 
+  virtual void AddBindingToPublicCertificate(
+      absl::string_view certificate_id, absl::string_view binding_id) = 0;
+
  protected:
   virtual void OnStartScheduledTasks() = 0;
   virtual void OnStopScheduledTasks() = 0;
diff --git a/sharing/certificates/nearby_share_certificate_manager_impl.cc b/sharing/certificates/nearby_share_certificate_manager_impl.cc
index 364cea6c..a6ca1f9f 100644
--- a/sharing/certificates/nearby_share_certificate_manager_impl.cc
+++ b/sharing/certificates/nearby_share_certificate_manager_impl.cc
@@ -912,6 +912,32 @@ bool NearbyShareCertificateManagerImpl::RefreshPrivateCertificatesInExecutor(
   return true;
 }
 
+void NearbyShareCertificateManagerImpl::AddBindingToPublicCertificate(
+    absl::string_view certificate_id, absl::string_view binding_id) {
+  LOG(INFO) << "Adding binding to public certificate: "
+            << absl::BytesToHexString(certificate_id);
+  absl::Notification notification;
+  certificate_storage_->GetPublicCertificate(
+      certificate_id,
+      [this, id = std::string(binding_id), &notification](
+          bool success, std::unique_ptr<PublicCertificate> certificate) {
+        if (success && certificate != nullptr) {
+          certificate->set_binding_id(id);
+          certificate_storage_->AddPublicCertificates(
+              {*certificate}, [](bool success) {
+                if (!success) {
+                  LOG(WARNING)
+                      << "Failed to add binding to public certificate.";
+                }
+              });
+        } else {
+          LOG(WARNING) << "Failed to add binding to public certificate.";
+        }
+        notification.Notify();
+      });
+  notification.WaitForNotification();
+}
+
 void NearbyShareCertificateManagerImpl::ForceUploadPrivateCertificates() {
   executor_->PostTask([this]() {
     private_certificate_expiration_scheduler_->HandleResult(
diff --git a/sharing/certificates/nearby_share_certificate_manager_impl.h b/sharing/certificates/nearby_share_certificate_manager_impl.h
index 6ce399c9..3f1bf793 100644
--- a/sharing/certificates/nearby_share_certificate_manager_impl.h
+++ b/sharing/certificates/nearby_share_certificate_manager_impl.h
@@ -28,6 +28,7 @@
 #include "absl/base/nullability.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
 #include "absl/time/time.h"
 #include "internal/base/file_path.h"
 #include "internal/platform/task_runner.h"
@@ -95,6 +96,8 @@ class NearbyShareCertificateManagerImpl
   void SetJoinBindingTime(absl::Time join_binding_time,
                           absl::Duration life_time) override;
   std::string Dump() const override;
+  void AddBindingToPublicCertificate(
+      absl::string_view certificate_id, absl::string_view binding_id) override;
 
  private:
   // Class for maintaining a single instance of public certificate download
diff --git a/sharing/certificates/nearby_share_certificate_manager_impl_test.cc b/sharing/certificates/nearby_share_certificate_manager_impl_test.cc
index 09717a4a..b8cc98d1 100644
--- a/sharing/certificates/nearby_share_certificate_manager_impl_test.cc
+++ b/sharing/certificates/nearby_share_certificate_manager_impl_test.cc
@@ -1173,4 +1173,24 @@ TEST_F(NearbyShareCertificateManagerImplTest,
       PrefNames::kAdvancedProtectionEnabled, /*default_value=*/false));
 }
 
+TEST_F(NearbyShareCertificateManagerImplTest, AddBindingToPublicCertificate) {
+  Initialize();
+
+  PublicCertificate cert;
+  cert.set_secret_id("test_cert_id");
+  cert.set_binding_id("old_binding_id");
+
+  cert_store_->SetPublicCertificates({cert});
+  cert_store_->SetAddPublicCertificatesResult(true);
+
+  cert_manager_->AddBindingToPublicCertificate("test_cert_id",
+                                               "new_binding_id");
+
+  ASSERT_EQ(cert_store_->add_public_certificates_calls().size(), 1u);
+  const auto& call = cert_store_->add_public_certificates_calls().back();
+  ASSERT_EQ(call.public_certificates.size(), 1u);
+  EXPECT_EQ(call.public_certificates[0].secret_id(), "test_cert_id");
+  EXPECT_EQ(call.public_certificates[0].binding_id(), "new_binding_id");
+}
+
 }  // namespace nearby::sharing
diff --git a/sharing/certificates/nearby_share_certificate_storage_impl.cc b/sharing/certificates/nearby_share_certificate_storage_impl.cc
index b242e4b4..54e2d627 100644
--- a/sharing/certificates/nearby_share_certificate_storage_impl.cc
+++ b/sharing/certificates/nearby_share_certificate_storage_impl.cc
@@ -342,7 +342,8 @@ void NearbyShareCertificateStorageImpl::GetPublicCertificate(
         });
     return;
   }
-  VLOG(1) << __func__ << ": Calling LoadCertificate on database, key: " << id;
+  VLOG(1) << __func__ << ": Calling LoadCertificate on database, key: "
+          << absl::BytesToHexString(id);
   public_certificate_database_->LoadCertificate(id, std::move(callback));
 }