diff --git a/quiche/quic/moqt/moqt_bidi_stream.h b/quiche/quic/moqt/moqt_bidi_stream.h
index 98971f8..e2bc925 100644
--- a/quiche/quic/moqt/moqt_bidi_stream.h
+++ b/quiche/quic/moqt/moqt_bidi_stream.h
@@ -139,9 +139,6 @@
   virtual void OnPublishMessage(const MoqtPublish& message) override {
     OnParsingError(wrong_message_error_, wrong_message_reason_);
   }
-  virtual void OnPublishOkMessage(const MoqtPublishOk& message) override {
-    OnParsingError(wrong_message_error_, wrong_message_reason_);
-  }
   virtual void OnObjectAckMessage(const MoqtObjectAck& message) override {
     OnParsingError(wrong_message_error_, wrong_message_reason_);
   }
diff --git a/quiche/quic/moqt/moqt_bidi_stream_test.cc b/quiche/quic/moqt/moqt_bidi_stream_test.cc
index dedd3c8..bc77125 100644
--- a/quiche/quic/moqt/moqt_bidi_stream_test.cc
+++ b/quiche/quic/moqt/moqt_bidi_stream_test.cc
@@ -190,13 +190,6 @@
   EXPECT_CALL(error_callback_,
               Call(MoqtError::kProtocolViolation,
                    "Message not allowed for this stream type"));
-  stream_->OnPublishOkMessage(MoqtPublishOk{});
-  stream_ = std::make_unique<MoqtBidiStreamBase>(
-      &framer_, deleted_callback_.AsStdFunction(),
-      error_callback_.AsStdFunction());
-  EXPECT_CALL(error_callback_,
-              Call(MoqtError::kProtocolViolation,
-                   "Message not allowed for this stream type"));
   stream_->OnObjectAckMessage(MoqtObjectAck{});
   stream_ = std::make_unique<MoqtBidiStreamBase>(
       &framer_, deleted_callback_.AsStdFunction(),
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index e8e2d2b..6206ff9 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -716,13 +716,6 @@
       WireKeyValuePairList(message.extensions, false));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializePublishOk(
-    const MoqtPublishOk& message) {
-  return SerializeControlMessage(
-      MoqtMessageType::kPublishOk, WireVarInt62(message.request_id),
-      WireKeyValuePairList(message.parameters.ToKeyValuePairList()));
-}
-
 quiche::QuicheBuffer MoqtFramer::SerializeObjectAck(
     const MoqtObjectAck& message) {
   return SerializeControlMessage(
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index f1e56e0..499ba34 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -75,7 +75,6 @@
   quiche::QuicheBuffer SerializeRequestsBlocked(
       const MoqtRequestsBlocked& message);
   quiche::QuicheBuffer SerializePublish(const MoqtPublish& message);
-  quiche::QuicheBuffer SerializePublishOk(const MoqtPublishOk& message);
   quiche::QuicheBuffer SerializeObjectAck(const MoqtObjectAck& message);
 
   bool using_webtrans() const { return using_webtrans_; }
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index d63e2b6..45403c7 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -57,7 +57,6 @@
       MoqtMessageType::kFetchOk,
       MoqtMessageType::kRequestsBlocked,
       MoqtMessageType::kPublish,
-      MoqtMessageType::kPublishOk,
       MoqtMessageType::kObjectAck,
       MoqtMessageType::kClientSetup,
       MoqtMessageType::kServerSetup,
@@ -207,10 +206,6 @@
         auto data = std::get<MoqtPublish>(structured_data);
         return framer_.SerializePublish(data);
       }
-      case moqt::MoqtMessageType::kPublishOk: {
-        auto data = std::get<MoqtPublishOk>(structured_data);
-        return framer_.SerializePublishOk(data);
-      }
       case moqt::MoqtMessageType::kObjectAck: {
         auto data = std::get<MoqtObjectAck>(structured_data);
         return framer_.SerializeObjectAck(data);
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 7281cf8..ed48af6 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -50,11 +50,10 @@
     MoqtMessageType::kPublishNamespace,
     MoqtMessageType::kTrackStatus,
     MoqtMessageType::kFetch};
-const std::array<MoqtMessageType, 7> kAllowsDeliveryTimeout = {
+const std::array<MoqtMessageType, 6> kAllowsDeliveryTimeout = {
     MoqtMessageType::kTrackStatus,  MoqtMessageType::kRequestOk,
-    MoqtMessageType::kPublish,      MoqtMessageType::kPublishOk,
-    MoqtMessageType::kSubscribe,    MoqtMessageType::kSubscribeOk,
-    MoqtMessageType::kRequestUpdate};
+    MoqtMessageType::kPublish,      MoqtMessageType::kSubscribe,
+    MoqtMessageType::kSubscribeOk,  MoqtMessageType::kRequestUpdate};
 bool MessageParametersAllowedByMessage(
     const MessageParameters& parameters, MoqtMessageType message_type) {
   if (!parameters.authorization_tokens.empty() &&
@@ -109,8 +108,6 @@
       return "MAX_REQUEST_ID";
     case MoqtMessageType::kPublish:
       return "PUBLISH";
-    case MoqtMessageType::kPublishOk:
-      return "PUBLISH_OK";
     case MoqtMessageType::kFetch:
       return "FETCH";
     case MoqtMessageType::kFetchCancel:
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 3c7552f..ed13591 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -214,7 +214,6 @@
   kFetchOk = 0x18,
   kRequestsBlocked = 0x1a,
   kPublish = 0x1d,
-  kPublishOk = 0x1e,
   kClientSetup = 0x20,
   kServerSetup = 0x21,
 
@@ -526,11 +525,6 @@
   TrackExtensions extensions;
 };
 
-struct QUICHE_EXPORT MoqtPublishOk {
-  uint64_t request_id;
-  MessageParameters parameters;
-};
-
 // All of the four values in this message are encoded as varints.
 // `delta_from_deadline` is encoded as an absolute value, with the lowest bit
 // indicating the sign (0 if positive).
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index 19d864e..310e532 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -1002,19 +1002,6 @@
   return publish;
 }
 
-absl::StatusOr<MoqtPublishOk> MoqtControlMessageParser::ProcessPublishOk(
-    absl::string_view data) const {
-  quic::QuicDataReader reader(data);
-  MoqtPublishOk publish_ok;
-  if (!reader.ReadVarInt62(&publish_ok.request_id)) {
-    return absl::InvalidArgumentError("Message missing fields");
-  }
-  QUICHE_RETURN_IF_ERROR(
-      FillAndValidateMessageParameters(reader, publish_ok.parameters));
-  QUICHE_RETURN_IF_ERROR(CheckForTrailingData(reader));
-  return publish_ok;
-}
-
 absl::StatusOr<MoqtObjectAck> MoqtControlMessageParser::ProcessObjectAck(
     absl::string_view data) const {
   quic::QuicDataReader reader(data);
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index 9a62066..35e3c2f 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -73,7 +73,6 @@
   virtual void OnFetchOkMessage(const MoqtFetchOk& message) = 0;
   virtual void OnRequestsBlockedMessage(const MoqtRequestsBlocked& message) = 0;
   virtual void OnPublishMessage(const MoqtPublish& message) = 0;
-  virtual void OnPublishOkMessage(const MoqtPublishOk& message) = 0;
   virtual void OnObjectAckMessage(const MoqtObjectAck& message) = 0;
 
   virtual void OnParsingError(MoqtError code, absl::string_view reason) = 0;
@@ -204,7 +203,6 @@
   absl::StatusOr<MoqtRequestsBlocked> ProcessRequestsBlocked(
       absl::string_view data) const;
   absl::StatusOr<MoqtPublish> ProcessPublish(absl::string_view data) const;
-  absl::StatusOr<MoqtPublishOk> ProcessPublishOk(absl::string_view data) const;
   absl::StatusOr<MoqtObjectAck> ProcessObjectAck(absl::string_view data) const;
 
   // Parse a raw message and call a callback on it if successful.
@@ -269,8 +267,6 @@
         return parse(&MoqtControlMessageParser::ProcessRequestsBlocked);
       case MoqtMessageType::kPublish:
         return parse(&MoqtControlMessageParser::ProcessPublish);
-      case MoqtMessageType::kPublishOk:
-        return parse(&MoqtControlMessageParser::ProcessPublishOk);
       case MoqtMessageType::kObjectAck:
         return parse(&MoqtControlMessageParser::ProcessObjectAck);
       default:
@@ -425,10 +421,6 @@
                            visitor_.OnPublishMessage(message);
                            return absl::OkStatus();
                          },
-                         [&](const MoqtPublishOk& message) {
-                           visitor_.OnPublishOkMessage(message);
-                           return absl::OkStatus();
-                         },
                          [&](const MoqtObjectAck& message) {
                            visitor_.OnObjectAckMessage(message);
                            return absl::OkStatus();
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index e395a82..5ad95bb 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -68,7 +68,6 @@
     MoqtMessageType::kFetchOk,
     MoqtMessageType::kRequestsBlocked,
     MoqtMessageType::kPublish,
-    MoqtMessageType::kPublishOk,
     MoqtMessageType::kObjectAck,
 };
 
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 59e2084..13df94e 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -281,7 +281,6 @@
     void OnFetchOkMessage(const MoqtFetchOk& message) override;
     void OnRequestsBlockedMessage(const MoqtRequestsBlocked& message) override;
     void OnPublishMessage(const MoqtPublish& message) override;
-    void OnPublishOkMessage(const MoqtPublishOk& /*message*/) override {}
     void OnObjectAckMessage(const MoqtObjectAck& message) override {
       auto subscription_it =
           session_->published_subscriptions_.find(message.subscribe_id);
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index 39ea217..87dc14b 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -85,9 +85,6 @@
   quiche::QuicheBuffer operator()(const MoqtPublish& message) {
     return framer.SerializePublish(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtPublishOk& message) {
-    return framer.SerializePublishOk(message);
-  }
   quiche::QuicheBuffer operator()(const MoqtObjectAck& message) {
     return framer.SerializeObjectAck(message);
   }
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index 0e4326b..86f1d18 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -19,14 +19,15 @@
 
 namespace moqt::test {
 
-using AnyMoqtControlMessage = std::variant<
-    MoqtClientSetup, MoqtServerSetup, MoqtRequestOk, MoqtRequestError,
-    MoqtSubscribe, MoqtSubscribeOk, MoqtUnsubscribe, MoqtPublishDone,
-    MoqtRequestUpdate, MoqtPublishNamespace, MoqtPublishNamespaceDone,
-    MoqtPublishNamespaceCancel, MoqtTrackStatus, MoqtGoAway,
-    MoqtSubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel,
-    MoqtFetchOk, MoqtRequestsBlocked, MoqtPublish, MoqtPublishOk, MoqtNamespace,
-    MoqtNamespaceDone, MoqtObjectAck>;
+using AnyMoqtControlMessage =
+    std::variant<MoqtClientSetup, MoqtServerSetup, MoqtRequestOk,
+                 MoqtRequestError, MoqtSubscribe, MoqtSubscribeOk,
+                 MoqtUnsubscribe, MoqtPublishDone, MoqtRequestUpdate,
+                 MoqtPublishNamespace, MoqtPublishNamespaceDone,
+                 MoqtPublishNamespaceCancel, MoqtTrackStatus, MoqtGoAway,
+                 MoqtSubscribeNamespace, MoqtMaxRequestId, MoqtFetch,
+                 MoqtFetchCancel, MoqtFetchOk, MoqtRequestsBlocked, MoqtPublish,
+                 MoqtNamespace, MoqtNamespaceDone, MoqtObjectAck>;
 
 std::string SerializeGenericMessage(const AnyMoqtControlMessage& frame,
                                     bool use_webtrans = false);
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index f1da5ad..b502e14 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -113,7 +113,7 @@
       MoqtPublishNamespaceDone, MoqtPublishNamespaceCancel, MoqtTrackStatus,
       MoqtGoAway, MoqtSubscribeNamespace, MoqtMaxRequestId, MoqtFetch,
       MoqtFetchCancel, MoqtFetchOk, MoqtRequestsBlocked, MoqtPublish,
-      MoqtPublishOk, MoqtNamespace, MoqtNamespaceDone, MoqtObjectAck>;
+      MoqtNamespace, MoqtNamespaceDone, MoqtObjectAck>;
 
   // The total actual size of the message.
   size_t total_message_size() const { return wire_image_size_; }
@@ -1745,54 +1745,6 @@
   };
 };
 
-class QUICHE_NO_EXPORT PublishOkMessage : public TestMessageBase {
- public:
-  PublishOkMessage() : TestMessageBase() {
-    SetWireImage(raw_packet_, sizeof(raw_packet_));
-    publish_ok_.parameters.delivery_timeout =
-        quic::QuicTimeDelta::FromMilliseconds(10000);
-    publish_ok_.parameters.set_forward(true);
-    publish_ok_.parameters.subscriber_priority = 2;
-    publish_ok_.parameters.group_order = MoqtDeliveryOrder::kAscending;
-    publish_ok_.parameters.subscription_filter =
-        SubscriptionFilter(Location(5, 4), 6);
-  }
-  bool EqualFieldValues(const MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtPublishOk>(values);
-    if (cast.request_id != publish_ok_.request_id) {
-      QUIC_LOG(INFO) << "PUBLISH_OK request_id mismatch";
-      return false;
-    }
-    if (cast.parameters != publish_ok_.parameters) {
-      QUIC_LOG(INFO) << "PUBLISH_OK parameters mismatch";
-      return false;
-    }
-    return true;
-  }
-
-  void ExpandVarints() override { ExpandVarintsImpl("vvv--vvvvvv----vv"); }
-
-  MessageStructuredData structured_data() const override {
-    return TestMessageBase::MessageStructuredData(publish_ok_);
-  }
-
- private:
-  uint8_t raw_packet_[20] = {
-      0x1e, 0x00, 0x11,
-      0x01,                                // request_id = 1
-      0x05,                                // 5 parameters
-      0x02, 0x67, 0x10,                    // delivery_timeout = 10000 ms
-      0x0e, 0x01,                          // forward = true
-      0x10, 0x02,                          // subscriber_priority = 2
-      0x01, 0x04, 0x04, 0x05, 0x04, 0x06,  // subscription filter: (5, 4) to 6
-      0x01, 0x01,                          // group_order = kAscending
-  };
-  MoqtPublishOk publish_ok_ = {
-      /*request_id=*/1,
-      MessageParameters(),  // set in constructor.
-  };
-};
-
 class QUICHE_NO_EXPORT ObjectAckMessage : public TestMessageBase {
  public:
   ObjectAckMessage() : TestMessageBase() {
@@ -1887,8 +1839,6 @@
       return std::make_unique<RequestsBlockedMessage>();
     case MoqtMessageType::kPublish:
       return std::make_unique<PublishMessage>();
-    case MoqtMessageType::kPublishOk:
-      return std::make_unique<PublishOkMessage>();
     case MoqtMessageType::kObjectAck:
       return std::make_unique<ObjectAckMessage>();
     case MoqtMessageType::kClientSetup: