diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index b6cf1b3..7c7f649 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -206,8 +206,8 @@
       parameters.perspective == quic::Perspective::IS_CLIENT) {
     out.insert(SetupParameter::kPath, parameters.path);
   }
-  if (parameters.max_subscribe_id > 0) {
-    out.insert(SetupParameter::kMaxRequestId, parameters.max_subscribe_id);
+  if (parameters.max_request_id > 0) {
+    out.insert(SetupParameter::kMaxRequestId, parameters.max_request_id);
   }
   if (parameters.max_auth_token_cache_size > 0) {
     out.insert(SetupParameter::kMaxAuthTokenCacheSize,
@@ -658,10 +658,10 @@
       WireFullTrackName(message.track_namespace, false));
 }
 
-quiche::QuicheBuffer MoqtFramer::SerializeMaxSubscribeId(
-    const MoqtMaxSubscribeId& message) {
-  return SerializeControlMessage(MoqtMessageType::kMaxSubscribeId,
-                                 WireVarInt62(message.max_subscribe_id));
+quiche::QuicheBuffer MoqtFramer::SerializeMaxRequestId(
+    const MoqtMaxRequestId& message) {
+  return SerializeControlMessage(MoqtMessageType::kMaxRequestId,
+                                 WireVarInt62(message.max_request_id));
 }
 
 quiche::QuicheBuffer MoqtFramer::SerializeFetch(const MoqtFetch& message) {
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index 6dae728..d0c7996 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -64,8 +64,7 @@
       const MoqtSubscribeAnnouncesError& message);
   quiche::QuicheBuffer SerializeUnsubscribeAnnounces(
       const MoqtUnsubscribeAnnounces& message);
-  quiche::QuicheBuffer SerializeMaxSubscribeId(
-      const MoqtMaxSubscribeId& message);
+  quiche::QuicheBuffer SerializeMaxRequestId(const MoqtMaxRequestId& message);
   quiche::QuicheBuffer SerializeFetch(const MoqtFetch& message);
   quiche::QuicheBuffer SerializeFetchCancel(const MoqtFetchCancel& message);
   quiche::QuicheBuffer SerializeFetchOk(const MoqtFetchOk& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index 96780f6..80002a2 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -52,7 +52,7 @@
       MoqtMessageType::kSubscribeAnnouncesOk,
       MoqtMessageType::kSubscribeAnnouncesError,
       MoqtMessageType::kUnsubscribeAnnounces,
-      MoqtMessageType::kMaxSubscribeId,
+      MoqtMessageType::kMaxRequestId,
       MoqtMessageType::kFetch,
       MoqtMessageType::kFetchCancel,
       MoqtMessageType::kFetchOk,
@@ -184,9 +184,9 @@
         auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data);
         return framer_.SerializeUnsubscribeAnnounces(data);
       }
-      case moqt::MoqtMessageType::kMaxSubscribeId: {
-        auto data = std::get<MoqtMaxSubscribeId>(structured_data);
-        return framer_.SerializeMaxSubscribeId(data);
+      case moqt::MoqtMessageType::kMaxRequestId: {
+        auto data = std::get<MoqtMaxRequestId>(structured_data);
+        return framer_.SerializeMaxRequestId(data);
       }
       case moqt::MoqtMessageType::kFetch: {
         auto data = std::get<MoqtFetch>(structured_data);
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 967a816..e8aed25 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -232,8 +232,8 @@
       return "SUBSCRIBE_NAMESPACE_ERROR";
     case MoqtMessageType::kUnsubscribeAnnounces:
       return "UNSUBSCRIBE_NAMESPACE";
-    case MoqtMessageType::kMaxSubscribeId:
-      return "MAX_SUBSCRIBE_ID";
+    case MoqtMessageType::kMaxRequestId:
+      return "MAX_REQUEST_ID";
     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 51b5861..c227832 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -58,20 +58,19 @@
         using_webtrans(false),
         path(std::move(path)) {}
   MoqtSessionParameters(quic::Perspective perspective, std::string path,
-                        uint64_t max_subscribe_id)
+                        uint64_t max_request_id)
       : perspective(perspective),
         using_webtrans(true),
         path(std::move(path)),
-        max_subscribe_id(max_subscribe_id) {}
-  MoqtSessionParameters(quic::Perspective perspective,
-                        uint64_t max_subscribe_id)
-      : perspective(perspective), max_subscribe_id(max_subscribe_id) {}
+        max_request_id(max_request_id) {}
+  MoqtSessionParameters(quic::Perspective perspective, uint64_t max_request_id)
+      : perspective(perspective), max_request_id(max_request_id) {}
   bool operator==(const MoqtSessionParameters& other) {
     return version == other.version &&
            deliver_partial_objects == other.deliver_partial_objects &&
            perspective == other.perspective &&
            using_webtrans == other.using_webtrans && path == other.path &&
-           max_subscribe_id == other.max_subscribe_id &&
+           max_request_id == other.max_request_id &&
            max_auth_token_cache_size == other.max_auth_token_cache_size &&
            support_object_acks == other.support_object_acks;
   }
@@ -81,7 +80,7 @@
   quic::Perspective perspective = quic::Perspective::IS_SERVER;
   bool using_webtrans = true;
   std::string path = "";
-  uint64_t max_subscribe_id = kDefaultInitialMaxRequestId;
+  uint64_t max_request_id = kDefaultInitialMaxRequestId;
   uint64_t max_auth_token_cache_size = kDefaultMaxAuthTokenCacheSize;
   bool support_object_acks = false;
 };
@@ -123,7 +122,7 @@
   kSubscribeAnnouncesOk = 0x12,
   kSubscribeAnnouncesError = 0x13,
   kUnsubscribeAnnounces = 0x14,
-  kMaxSubscribeId = 0x15,
+  kMaxRequestId = 0x15,
   kFetch = 0x16,
   kFetchCancel = 0x17,
   kFetchOk = 0x18,
@@ -674,8 +673,8 @@
   FullTrackName track_namespace;
 };
 
-struct QUICHE_EXPORT MoqtMaxSubscribeId {
-  uint64_t max_subscribe_id;
+struct QUICHE_EXPORT MoqtMaxRequestId {
+  uint64_t max_request_id;
 };
 
 enum class QUICHE_EXPORT FetchType : uint64_t {
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index 8b3ba02..2776499 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -139,7 +139,7 @@
         SetupParameter parameter = static_cast<SetupParameter>(key);
         switch (parameter) {
           case SetupParameter::kMaxRequestId:
-            out.max_subscribe_id = value;
+            out.max_request_id = value;
             break;
           case SetupParameter::kMaxAuthTokenCacheSize:
             out.max_auth_token_cache_size = value;
@@ -304,8 +304,8 @@
     case MoqtMessageType::kUnsubscribeAnnounces:
       bytes_read = ProcessUnsubscribeAnnounces(reader);
       break;
-    case MoqtMessageType::kMaxSubscribeId:
-      bytes_read = ProcessMaxSubscribeId(reader);
+    case MoqtMessageType::kMaxRequestId:
+      bytes_read = ProcessMaxRequestId(reader);
       break;
     case MoqtMessageType::kFetch:
       bytes_read = ProcessFetch(reader);
@@ -767,12 +767,12 @@
   return reader.PreviouslyReadPayload().length();
 }
 
-size_t MoqtControlParser::ProcessMaxSubscribeId(quic::QuicDataReader& reader) {
-  MoqtMaxSubscribeId max_subscribe_id;
-  if (!reader.ReadVarInt62(&max_subscribe_id.max_subscribe_id)) {
+size_t MoqtControlParser::ProcessMaxRequestId(quic::QuicDataReader& reader) {
+  MoqtMaxRequestId max_request_id;
+  if (!reader.ReadVarInt62(&max_request_id.max_request_id)) {
     return 0;
   }
-  visitor_.OnMaxSubscribeIdMessage(max_subscribe_id);
+  visitor_.OnMaxRequestIdMessage(max_request_id);
   return reader.PreviouslyReadPayload().length();
 }
 
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index 36c8f31..efd90dd 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -56,7 +56,7 @@
       const MoqtSubscribeAnnouncesError& message) = 0;
   virtual void OnUnsubscribeAnnouncesMessage(
       const MoqtUnsubscribeAnnounces& message) = 0;
-  virtual void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) = 0;
+  virtual void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) = 0;
   virtual void OnFetchMessage(const MoqtFetch& message) = 0;
   virtual void OnFetchCancelMessage(const MoqtFetchCancel& message) = 0;
   virtual void OnFetchOkMessage(const MoqtFetchOk& message) = 0;
@@ -125,7 +125,7 @@
   size_t ProcessSubscribeAnnouncesOk(quic::QuicDataReader& reader);
   size_t ProcessSubscribeAnnouncesError(quic::QuicDataReader& reader);
   size_t ProcessUnsubscribeAnnounces(quic::QuicDataReader& reader);
-  size_t ProcessMaxSubscribeId(quic::QuicDataReader& reader);
+  size_t ProcessMaxRequestId(quic::QuicDataReader& reader);
   size_t ProcessFetch(quic::QuicDataReader& reader);
   size_t ProcessFetchCancel(quic::QuicDataReader& reader);
   size_t ProcessFetchOk(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index 84f4f60..d5b189c 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -52,7 +52,7 @@
     MoqtMessageType::kSubscribeAnnouncesOk,
     MoqtMessageType::kSubscribeAnnouncesError,
     MoqtMessageType::kUnsubscribeAnnounces,
-    MoqtMessageType::kMaxSubscribeId,
+    MoqtMessageType::kMaxRequestId,
     MoqtMessageType::kFetch,
     MoqtMessageType::kFetchCancel,
     MoqtMessageType::kFetchOk,
@@ -198,7 +198,7 @@
       const MoqtUnsubscribeAnnounces& message) override {
     OnControlMessage(message);
   }
-  void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override {
+  void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override {
     OnControlMessage(message);
   }
   void OnFetchMessage(const MoqtFetch& message) override {
@@ -642,7 +642,7 @@
   EXPECT_EQ(visitor_.parsing_error_code_, MoqtError::kInvalidPath);
 }
 
-TEST_F(MoqtMessageSpecificTest, ServerSetupMaxSubscribeIdAppearsTwice) {
+TEST_F(MoqtMessageSpecificTest, ServerSetupMaxRequestIdAppearsTwice) {
   webtransport::test::InMemoryStream stream(/*stream_id=*/0);
   MoqtControlParser parser(kRawQuic, &stream, visitor_);
   char setup[] = {
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index b04a678..25a133b 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -99,7 +99,7 @@
       callbacks_(std::move(callbacks)),
       framer_(quiche::SimpleBufferAllocator::Get(), parameters.using_webtrans),
       publisher_(DefaultPublisher::GetInstance()),
-      local_max_request_id_(parameters.max_subscribe_id),
+      local_max_request_id_(parameters.max_request_id),
       alarm_factory_(std::move(alarm_factory)),
       liveness_token_(std::make_shared<Empty>()) {
   if (parameters_.using_webtrans) {
@@ -383,11 +383,11 @@
                         MoqtPriority priority,
                         std::optional<MoqtDeliveryOrder> delivery_order,
                         VersionSpecificParameters parameters) {
-  if (next_subscribe_id_ >= peer_max_subscribe_id_) {
+  if (next_request_id_ >= peer_max_request_id_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send FETCH with ID "
-                    << next_subscribe_id_
+                    << next_request_id_
                     << " which is greater than the maximum ID "
-                    << peer_max_subscribe_id_;
+                    << peer_max_request_id_;
     return false;
   }
   if (received_goaway_ || sent_goaway_) {
@@ -396,7 +396,7 @@
   }
   MoqtFetch message;
   message.full_track_name = name;
-  message.fetch_id = next_subscribe_id_++;
+  message.fetch_id = next_request_id_++;
   message.start_object = start;
   message.end_group = end_group;
   message.end_object = end_object;
@@ -417,8 +417,7 @@
                                VersionSpecificParameters parameters) {
   return JoiningFetch(
       name, visitor,
-      [this,
-       id = next_subscribe_id_](std::unique_ptr<MoqtFetchTask> fetch_task) {
+      [this, id = next_request_id_](std::unique_ptr<MoqtFetchTask> fetch_task) {
         // Move the fetch_task to the subscribe to plumb into its visitor.
         RemoteTrack* track = RemoteTrackById(id);
         if (track == nullptr || track->is_fetch()) {
@@ -440,11 +439,11 @@
                                MoqtPriority priority,
                                std::optional<MoqtDeliveryOrder> delivery_order,
                                VersionSpecificParameters parameters) {
-  if ((next_subscribe_id_ + 1) >= peer_max_subscribe_id_) {
+  if ((next_request_id_ + 1) >= peer_max_request_id_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send JOINING_FETCH with ID "
-                    << (next_subscribe_id_ + 1)
+                    << (next_request_id_ + 1)
                     << " which is greater than the maximum ID "
-                    << peer_max_subscribe_id_;
+                    << peer_max_request_id_;
     return false;
   }
   MoqtSubscribe subscribe;
@@ -459,7 +458,7 @@
     return false;
   }
   MoqtFetch fetch;
-  fetch.fetch_id = next_subscribe_id_++;
+  fetch.fetch_id = next_request_id_++;
   fetch.subscriber_priority = priority;
   fetch.group_order = delivery_order;
   fetch.joining_fetch = {subscribe.subscribe_id, num_previous_groups};
@@ -586,19 +585,19 @@
                             SubscribeRemoteTrack::Visitor* visitor,
                             std::optional<uint64_t> provided_track_alias) {
   // TODO(martinduke): support authorization info
-  if (next_subscribe_id_ >= peer_max_subscribe_id_) {
+  if (next_request_id_ >= peer_max_request_id_) {
     if (!last_subscribes_blocked_sent_.has_value() ||
-        peer_max_subscribe_id_ > *last_subscribes_blocked_sent_) {
+        peer_max_request_id_ > *last_subscribes_blocked_sent_) {
       MoqtSubscribesBlocked subscribes_blocked;
-      subscribes_blocked.max_subscribe_id = peer_max_subscribe_id_;
+      subscribes_blocked.max_subscribe_id = peer_max_request_id_;
       SendControlMessage(
           framer_.SerializeSubscribesBlocked(subscribes_blocked));
-      last_subscribes_blocked_sent_ = peer_max_subscribe_id_;
+      last_subscribes_blocked_sent_ = peer_max_request_id_;
     }
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE with ID "
-                    << next_subscribe_id_
+                    << next_request_id_
                     << " which is greater than the maximum ID "
-                    << peer_max_subscribe_id_;
+                    << peer_max_request_id_;
     return false;
   }
   if (subscribe_by_name_.contains(message.full_track_name)) {
@@ -616,7 +615,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE after GOAWAY";
     return false;
   }
-  message.subscribe_id = next_subscribe_id_++;
+  message.subscribe_id = next_request_id_++;
   if (provided_track_alias.has_value()) {
     message.track_alias = *provided_track_alias;
     next_remote_track_alias_ =
@@ -777,11 +776,11 @@
   }
 }
 
-void MoqtSession::GrantMoreSubscribes(uint64_t num_subscribes) {
-  local_max_request_id_ += num_subscribes;
-  MoqtMaxSubscribeId message;
-  message.max_subscribe_id = local_max_request_id_;
-  SendControlMessage(framer_.SerializeMaxSubscribeId(message));
+void MoqtSession::GrantMoreRequests(uint64_t num_requests) {
+  local_max_request_id_ += num_requests;
+  MoqtMaxRequestId message;
+  message.max_request_id = local_max_request_id_;
+  SendControlMessage(framer_.SerializeMaxRequestId(message));
 }
 
 bool MoqtSession::ValidateRequestId(uint64_t request_id) {
@@ -791,7 +790,7 @@
     return false;
   }
   if (request_id < next_incoming_request_id_) {
-    QUIC_DLOG(INFO) << ENDPOINT << "Subscribe ID not monotonically increasing";
+    QUIC_DLOG(INFO) << ENDPOINT << "Request ID not monotonically increasing";
     Error(MoqtError::kInvalidRequestId,
           "Request ID not monotonically increasing");
     return false;
@@ -855,7 +854,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "Sent the SETUP message";
   }
   // TODO: handle path.
-  session_->peer_max_subscribe_id_ = message.parameters.max_subscribe_id;
+  session_->peer_max_request_id_ = message.parameters.max_request_id;
   std::move(session_->callbacks_.session_established_callback)();
 }
 
@@ -876,7 +875,7 @@
   session_->peer_supports_object_ack_ = message.parameters.support_object_acks;
   QUIC_DLOG(INFO) << ENDPOINT << "Received the SETUP message";
   // TODO: handle path.
-  session_->peer_max_subscribe_id_ = message.parameters.max_subscribe_id;
+  session_->peer_max_request_id_ = message.parameters.max_request_id;
   std::move(session_->callbacks_.session_established_callback)();
 }
 
@@ -1237,17 +1236,17 @@
           message.track_namespace, std::nullopt);
 }
 
-void MoqtSession::ControlStream::OnMaxSubscribeIdMessage(
-    const MoqtMaxSubscribeId& message) {
-  if (message.max_subscribe_id < session_->peer_max_subscribe_id_) {
+void MoqtSession::ControlStream::OnMaxRequestIdMessage(
+    const MoqtMaxRequestId& message) {
+  if (message.max_request_id < session_->peer_max_request_id_) {
     QUIC_DLOG(INFO) << ENDPOINT
-                    << "Peer sent MAX_SUBSCRIBE_ID message with "
+                    << "Peer sent MAX_REQUEST_ID message with "
                        "lower value than previous";
     session_->Error(MoqtError::kProtocolViolation,
-                    "MAX_SUBSCRIBE_ID message has lower value than previous");
+                    "MAX_REQUEST_ID has lower value than previous");
     return;
   }
-  session_->peer_max_subscribe_id_ = message.max_subscribe_id;
+  session_->peer_max_request_id_ = message.max_request_id;
 }
 
 void MoqtSession::ControlStream::OnFetchMessage(const MoqtFetch& message) {
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 78fabf3..70a7b59 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -192,7 +192,7 @@
       std::optional<webtransport::SendOrder> old_send_order,
       std::optional<webtransport::SendOrder> new_send_order);
 
-  void GrantMoreSubscribes(uint64_t num_subscribes);
+  void GrantMoreRequests(uint64_t num_requests);
 
   void UseAlternateDeliveryTimeout() { alternate_delivery_timeout_ = true; }
 
@@ -240,7 +240,7 @@
         const MoqtSubscribeAnnouncesError& message) override;
     void OnUnsubscribeAnnouncesMessage(
         const MoqtUnsubscribeAnnounces& message) override;
-    void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override;
+    void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override;
     void OnFetchMessage(const MoqtFetch& message) override;
     void OnFetchCancelMessage(const MoqtFetchCancel& message) override {}
     void OnFetchOkMessage(const MoqtFetchOk& message) override;
@@ -684,9 +684,9 @@
   // The next track alias to guess on a SUBSCRIBE.
   uint64_t next_remote_track_alias_ = 0;
   // The next subscribe ID that the local endpoint can send.
-  uint64_t next_subscribe_id_ = 0;
+  uint64_t next_request_id_ = 0;
   // The local endpoint can send subscribe IDs less than this value.
-  uint64_t peer_max_subscribe_id_ = 0;
+  uint64_t peer_max_request_id_ = 0;
   std::optional<uint64_t> last_subscribes_blocked_sent_;
 
   // All open incoming subscriptions, indexed by track name, used to check for
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index af38819..bdfb51c 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -112,8 +112,8 @@
                  std::make_unique<quic::test::TestAlarmFactory>(),
                  session_callbacks_.AsSessionCallbacks()) {
     session_.set_publisher(&publisher_);
-    MoqtSessionPeer::set_peer_max_subscribe_id(&session_,
-                                               kDefaultInitialMaxRequestId);
+    MoqtSessionPeer::set_peer_max_request_id(&session_,
+                                             kDefaultInitialMaxRequestId);
     ON_CALL(mock_session_, GetStreamById).WillByDefault(Return(&mock_stream_));
   }
   ~MoqtSessionTest() {
@@ -597,8 +597,8 @@
 }
 
 TEST_F(MoqtSessionTest, TooManySubscribes) {
-  MoqtSessionPeer::set_next_subscribe_id(&session_,
-                                         kDefaultInitialMaxRequestId - 1);
+  MoqtSessionPeer::set_next_request_id(&session_,
+                                       kDefaultInitialMaxRequestId - 1);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -663,9 +663,8 @@
   stream_input->OnSubscribeOkMessage(ok);
 }
 
-TEST_F(MoqtSessionTest, MaxSubscribeIdChangesResponse) {
-  MoqtSessionPeer::set_next_subscribe_id(&session_,
-                                         kDefaultInitialMaxRequestId);
+TEST_F(MoqtSessionTest, MaxRequestIdChangesResponse) {
+  MoqtSessionPeer::set_next_request_id(&session_, kDefaultInitialMaxRequestId);
   MockSubscribeRemoteTrackVisitor remote_track_visitor;
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
@@ -677,10 +676,10 @@
   EXPECT_FALSE(session_.SubscribeCurrentObject(FullTrackName("foo", "bar"),
                                                &remote_track_visitor,
                                                VersionSpecificParameters()));
-  MoqtMaxSubscribeId max_subscribe_id = {
-      /*max_subscribe_id=*/kDefaultInitialMaxRequestId + 1,
+  MoqtMaxRequestId max_request_id = {
+      /*max_request_id=*/kDefaultInitialMaxRequestId + 1,
   };
-  stream_input->OnMaxSubscribeIdMessage(max_subscribe_id);
+  stream_input->OnMaxRequestIdMessage(max_request_id);
 
   EXPECT_CALL(mock_stream_,
               Writev(ControlMessageOfType(MoqtMessageType::kSubscribe), _));
@@ -689,27 +688,25 @@
                                               VersionSpecificParameters()));
 }
 
-TEST_F(MoqtSessionTest, LowerMaxSubscribeIdIsAnError) {
-  MoqtMaxSubscribeId max_subscribe_id = {
-      /*max_subscribe_id=*/kDefaultInitialMaxRequestId - 1,
+TEST_F(MoqtSessionTest, LowerMaxRequestIdIsAnError) {
+  MoqtMaxRequestId max_request_id = {
+      /*max_request_id=*/kDefaultInitialMaxRequestId - 1,
   };
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
-  EXPECT_CALL(
-      mock_session_,
-      CloseSession(static_cast<uint64_t>(MoqtError::kProtocolViolation),
-                   "MAX_SUBSCRIBE_ID message has lower value than previous"))
+  EXPECT_CALL(mock_session_,
+              CloseSession(static_cast<uint64_t>(MoqtError::kProtocolViolation),
+                           "MAX_REQUEST_ID has lower value than previous"))
       .Times(1);
-  stream_input->OnMaxSubscribeIdMessage(max_subscribe_id);
+  stream_input->OnMaxRequestIdMessage(max_request_id);
 }
 
-TEST_F(MoqtSessionTest, GrantMoreSubscribes) {
+TEST_F(MoqtSessionTest, GrantMoreRequests) {
   std::unique_ptr<MoqtControlParserVisitor> stream_input =
       MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
-  EXPECT_CALL(
-      mock_stream_,
-      Writev(ControlMessageOfType(MoqtMessageType::kMaxSubscribeId), _));
-  session_.GrantMoreSubscribes(1);
+  EXPECT_CALL(mock_stream_,
+              Writev(ControlMessageOfType(MoqtMessageType::kMaxRequestId), _));
+  session_.GrantMoreRequests(1);
   // Peer subscribes to (0, 0)
   MoqtSubscribe request = DefaultSubscribe();
   request.subscribe_id = kDefaultInitialMaxRequestId;
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index 9f7aadf..534ddf0 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -86,8 +86,8 @@
   MoqtMessageType operator()(const MoqtUnsubscribeAnnounces&) {
     return MoqtMessageType::kUnsubscribeAnnounces;
   }
-  MoqtMessageType operator()(const MoqtMaxSubscribeId&) {
-    return MoqtMessageType::kMaxSubscribeId;
+  MoqtMessageType operator()(const MoqtMaxRequestId&) {
+    return MoqtMessageType::kMaxRequestId;
   }
   MoqtMessageType operator()(const MoqtFetch&) {
     return MoqtMessageType::kFetch;
@@ -170,8 +170,8 @@
   quiche::QuicheBuffer operator()(const MoqtUnsubscribeAnnounces& message) {
     return framer.SerializeUnsubscribeAnnounces(message);
   }
-  quiche::QuicheBuffer operator()(const MoqtMaxSubscribeId& message) {
-    return framer.SerializeMaxSubscribeId(message);
+  quiche::QuicheBuffer operator()(const MoqtMaxRequestId& message) {
+    return framer.SerializeMaxRequestId(message);
   }
   quiche::QuicheBuffer operator()(const MoqtFetch& message) {
     return framer.SerializeFetch(message);
@@ -261,7 +261,7 @@
   void OnUnsubscribeAnnouncesMessage(const MoqtUnsubscribeAnnounces& message) {
     frames_.push_back(message);
   }
-  void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) {
+  void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) {
     frames_.push_back(message);
   }
   void OnFetchMessage(const MoqtFetch& message) { frames_.push_back(message); }
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index ac5760b..7b39419 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -32,7 +32,7 @@
                  MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
                  MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
                  MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
-                 MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
+                 MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
                  MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
 
 MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame);
diff --git a/quiche/quic/moqt/test_tools/moqt_session_peer.h b/quiche/quic/moqt/test_tools/moqt_session_peer.h
index d654aff..9fa1bf3 100644
--- a/quiche/quic/moqt/test_tools/moqt_session_peer.h
+++ b/quiche/quic/moqt/test_tools/moqt_session_peer.h
@@ -143,12 +143,12 @@
     return session->RemoteTrackByAlias(track_alias);
   }
 
-  static void set_next_subscribe_id(MoqtSession* session, uint64_t id) {
-    session->next_subscribe_id_ = id;
+  static void set_next_request_id(MoqtSession* session, uint64_t id) {
+    session->next_request_id_ = id;
   }
 
-  static void set_peer_max_subscribe_id(MoqtSession* session, uint64_t id) {
-    session->peer_max_subscribe_id_ = id;
+  static void set_peer_max_request_id(MoqtSession* session, uint64_t id) {
+    session->peer_max_request_id_ = id;
   }
 
   static MoqtSession::PublishedFetch* GetFetch(MoqtSession* session,
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 8478fcd..3b14ad5 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -46,7 +46,7 @@
                    MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
                    MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk,
                    MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces,
-                   MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
+                   MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
                    MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>;
 
   // The total actual size of the message.
@@ -1256,16 +1256,16 @@
   };
 };
 
-class QUICHE_NO_EXPORT MaxSubscribeIdMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT MaxRequestIdMessage : public TestMessageBase {
  public:
-  MaxSubscribeIdMessage() : TestMessageBase() {
+  MaxRequestIdMessage() : TestMessageBase() {
     SetWireImage(raw_packet_, sizeof(raw_packet_));
   }
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
-    auto cast = std::get<MoqtMaxSubscribeId>(values);
-    if (cast.max_subscribe_id != max_subscribe_id_.max_subscribe_id) {
-      QUIC_LOG(INFO) << "MAX_SUBSCRIBE_ID mismatch";
+    auto cast = std::get<MoqtMaxRequestId>(values);
+    if (cast.max_request_id != max_request_id_.max_request_id) {
+      QUIC_LOG(INFO) << "MAX_REQUEST_ID mismatch";
       return false;
     }
     return true;
@@ -1274,7 +1274,7 @@
   void ExpandVarints() override { ExpandVarintsImpl("vvv"); }
 
   MessageStructuredData structured_data() const override {
-    return TestMessageBase::MessageStructuredData(max_subscribe_id_);
+    return TestMessageBase::MessageStructuredData(max_request_id_);
   }
 
  private:
@@ -1284,8 +1284,8 @@
       0x0b,
   };
 
-  MoqtMaxSubscribeId max_subscribe_id_ = {
-      /*max_subscribe_id =*/11,
+  MoqtMaxRequestId max_request_id_ = {
+      /*max_request_id =*/11,
   };
 };
 
@@ -1741,8 +1741,8 @@
       return std::make_unique<SubscribeAnnouncesErrorMessage>();
     case MoqtMessageType::kUnsubscribeAnnounces:
       return std::make_unique<UnsubscribeAnnouncesMessage>();
-    case MoqtMessageType::kMaxSubscribeId:
-      return std::make_unique<MaxSubscribeIdMessage>();
+    case MoqtMessageType::kMaxRequestId:
+      return std::make_unique<MaxRequestIdMessage>();
     case MoqtMessageType::kFetch:
       return std::make_unique<FetchMessage>();
     case MoqtMessageType::kFetchCancel: