diff --git a/quiche/quic/moqt/moqt_failed_fetch.h b/quiche/quic/moqt/moqt_failed_fetch.h
index fd13a52..154c6fc 100644
--- a/quiche/quic/moqt/moqt_failed_fetch.h
+++ b/quiche/quic/moqt/moqt_failed_fetch.h
@@ -27,7 +27,7 @@
   void SetFetchResponseCallback(FetchResponseCallback callback) {
     MoqtFetchError error;
     error.subscribe_id = 0;
-    error.error_code = StatusToSubscribeErrorCode(status_);
+    error.error_code = StatusToRequestErrorCode(status_);
     error.reason_phrase = status_.message();
     std::move(callback)(error);
   }
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 7578166..43caa3a 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -501,7 +501,7 @@
 quiche::QuicheBuffer MoqtFramer::SerializeSubscribeError(
     const MoqtSubscribeError& message) {
   return SerializeControlMessage(
-      MoqtMessageType::kSubscribeError, WireVarInt62(message.subscribe_id),
+      MoqtMessageType::kSubscribeError, WireVarInt62(message.request_id),
       WireVarInt62(message.error_code),
       WireStringWithVarInt62Length(message.reason_phrase),
       WireVarInt62(message.track_alias));
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc
index 8d97e6e..b6c95ad 100644
--- a/quiche/quic/moqt/moqt_integration_test.cc
+++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -203,12 +203,11 @@
         matches = true;
         EXPECT_EQ(track_namespace, FullTrackName{"foo"});
         ASSERT_TRUE(error.has_value());
-        EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError);
+        EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "internal error");
       });
-  server_->session()->CancelAnnounce(FullTrackName{"foo"},
-                                     SubscribeErrorCode::kInternalError,
-                                     "internal error");
+  server_->session()->CancelAnnounce(
+      FullTrackName{"foo"}, RequestErrorCode::kInternalError, "internal error");
   success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
   EXPECT_TRUE(success);
 }
@@ -461,7 +460,7 @@
         matches = true;
         EXPECT_EQ(track_namespace, FullTrackName{"foo"});
         ASSERT_TRUE(error.has_value());
-        EXPECT_EQ(error->error_code, SubscribeErrorCode::kNotSupported);
+        EXPECT_EQ(error->error_code, RequestErrorCode::kNotSupported);
       });
   bool success =
       test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index 7e6f480..96e50cd 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -92,25 +92,63 @@
   return static_cast<MoqtObjectStatus>(integer);
 }
 
-SubscribeErrorCode StatusToSubscribeErrorCode(absl::Status status) {
+RequestErrorCode StatusToRequestErrorCode(absl::Status status) {
   QUICHE_DCHECK(!status.ok());
   switch (status.code()) {
     case absl::StatusCode::kPermissionDenied:
-    case absl::StatusCode::kUnauthenticated:
-      return SubscribeErrorCode::kUnauthorized;
+      return RequestErrorCode::kUnauthorized;
     case absl::StatusCode::kDeadlineExceeded:
-      return SubscribeErrorCode::kTimeout;
-    case absl::StatusCode::kUnavailable:
-      return SubscribeErrorCode::kNotSupported;
+      return RequestErrorCode::kTimeout;
+    case absl::StatusCode::kUnimplemented:
+      return RequestErrorCode::kNotSupported;
     case absl::StatusCode::kNotFound:
-      return SubscribeErrorCode::kDoesNotExist;
+      return RequestErrorCode::kTrackDoesNotExist;
     case absl::StatusCode::kOutOfRange:
-      return SubscribeErrorCode::kInvalidRange;
+      return RequestErrorCode::kInvalidRange;
+    case absl::StatusCode::kInvalidArgument:
+      return RequestErrorCode::kInvalidJoiningSubscribeId;
+    case absl::StatusCode::kUnauthenticated:
+      return RequestErrorCode::kExpiredAuthToken;
     default:
-      return SubscribeErrorCode::kInternalError;
+      return RequestErrorCode::kInternalError;
   }
 }
 
+absl::StatusCode RequestErrorCodeToStatusCode(RequestErrorCode error_code) {
+  switch (error_code) {
+    case RequestErrorCode::kInternalError:
+      return absl::StatusCode::kInternal;
+    case RequestErrorCode::kUnauthorized:
+      return absl::StatusCode::kPermissionDenied;
+    case RequestErrorCode::kTimeout:
+      return absl::StatusCode::kDeadlineExceeded;
+    case RequestErrorCode::kNotSupported:
+      return absl::StatusCode::kUnimplemented;
+    case RequestErrorCode::kTrackDoesNotExist:
+      // Equivalently, kUninterested and kNamespacePrefixUnknown.
+      return absl::StatusCode::kNotFound;
+    case RequestErrorCode::kInvalidRange:
+      // Equivalently, kNamespacePrefixOverlap.
+      return absl::StatusCode::kOutOfRange;
+    case RequestErrorCode::kNoObjects:
+      // Equivalently, kRetryTrackAlias.
+      return absl::StatusCode::kNotFound;
+    case RequestErrorCode::kInvalidJoiningSubscribeId:
+    case RequestErrorCode::kMalformedAuthToken:
+    case RequestErrorCode::kUnknownAuthTokenAlias:
+      return absl::StatusCode::kInvalidArgument;
+    case RequestErrorCode::kExpiredAuthToken:
+      return absl::StatusCode::kUnauthenticated;
+    default:
+      return absl::StatusCode::kUnknown;
+  }
+}
+
+absl::Status RequestErrorCodeToStatus(RequestErrorCode error_code,
+                                      absl::string_view reason_phrase) {
+  return absl::Status(RequestErrorCodeToStatusCode(error_code), reason_phrase);
+};
+
 MoqtError ValidateSetupParameters(const KeyValuePairList& parameters,
                                   bool webtrans,
                                   quic::Perspective perspective) {
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index fc525c2..ef7d3b0 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -241,29 +241,30 @@
 
 // Used for SUBSCRIBE_ERROR, ANNOUNCE_ERROR, ANNOUNCE_CANCEL,
 // SUBSCRIBE_ANNOUNCES_ERROR, and FETCH_ERROR.
-// TODO(martinduke): Create aliases like FetchErrorCode, etc. to hide the fact
-// that these are all the same enum.
-enum class QUICHE_EXPORT SubscribeErrorCode : uint64_t {
+enum class QUICHE_EXPORT RequestErrorCode : uint64_t {
   kInternalError = 0x0,
   kUnauthorized = 0x1,
   kTimeout = 0x2,
   kNotSupported = 0x3,
-  kDoesNotExist = 0x4,     // Can also mean "not interested" or "unknown".
-  kInvalidRange = 0x5,     // SUBSCRIBE_ERROR and FETCH_ERROR only.
-  kRetryTrackAlias = 0x6,  // SUBSCRIBE_ERROR only.
+  kTrackDoesNotExist = 0x4,          // SUBSCRIBE_ERROR and FETCH_ERROR only.
+  kUninterested = 0x4,               // ANNOUNCE_ERROR and ANNOUNCE_CANCEL only.
+  kNamespacePrefixUnknown = 0x4,     // SUBSCRIBE_ANNOUNCES_ERROR only.
+  kInvalidRange = 0x5,               // SUBSCRIBE_ERROR and FETCH_ERROR only.
+  kNamespacePrefixOverlap = 0x5,     // SUBSCRIBE_ANNOUNCES_ERROR only.
+  kRetryTrackAlias = 0x6,            // SUBSCRIBE_ERROR only.
+  kNoObjects = 0x6,                  // FETCH_ERROR only.
+  kInvalidJoiningSubscribeId = 0x7,  // FETCH_ERROR only.
   kMalformedAuthToken = 0x10,
   kUnknownAuthTokenAlias = 0x11,
   kExpiredAuthToken = 0x12,
 };
 
 struct MoqtSubscribeErrorReason {
-  SubscribeErrorCode error_code;
+  RequestErrorCode error_code;
   std::string reason_phrase;
 };
 using MoqtAnnounceErrorReason = MoqtSubscribeErrorReason;
 
-SubscribeErrorCode StatusToSubscribeErrorCode(absl::Status status);
-
 // Full track name represents a tuple of name elements. All higher order
 // elements MUST be present, but lower-order ones (like the name) can be
 // omitted.
@@ -548,8 +549,8 @@
 };
 
 struct QUICHE_EXPORT MoqtSubscribeError {
-  uint64_t subscribe_id;
-  SubscribeErrorCode error_code;
+  uint64_t request_id;
+  RequestErrorCode error_code;
   std::string reason_phrase;
   uint64_t track_alias;
 };
@@ -594,7 +595,7 @@
 
 struct QUICHE_EXPORT MoqtAnnounceError {
   FullTrackName track_namespace;
-  SubscribeErrorCode error_code;
+  RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
@@ -633,7 +634,7 @@
 
 struct QUICHE_EXPORT MoqtAnnounceCancel {
   FullTrackName track_namespace;
-  SubscribeErrorCode error_code;
+  RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
@@ -657,7 +658,7 @@
 
 struct QUICHE_EXPORT MoqtSubscribeAnnouncesError {
   FullTrackName track_namespace;
-  SubscribeErrorCode error_code;
+  RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
@@ -709,7 +710,7 @@
 
 struct QUICHE_EXPORT MoqtFetchError {
   uint64_t subscribe_id;
-  SubscribeErrorCode error_code;
+  RequestErrorCode error_code;
   std::string reason_phrase;
 };
 
@@ -728,6 +729,11 @@
   quic::QuicTimeDelta delta_from_deadline = quic::QuicTimeDelta::Zero();
 };
 
+RequestErrorCode StatusToRequestErrorCode(absl::Status status);
+absl::StatusCode RequestErrorCodeToStatusCode(RequestErrorCode error_code);
+absl::Status RequestErrorCodeToStatus(RequestErrorCode error_code,
+                                      absl::string_view reason_phrase);
+
 // Returns an error if the parameters are malformed or otherwise violate the
 // spec. |perspective| is the consumer of the message, not the sender.
 MoqtError ValidateSetupParameters(const KeyValuePairList& parameters,
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.h b/quiche/quic/moqt/moqt_outgoing_queue.h
index e8391be..d20f900 100644
--- a/quiche/quic/moqt/moqt_outgoing_queue.h
+++ b/quiche/quic/moqt/moqt_outgoing_queue.h
@@ -119,15 +119,15 @@
     }
     void SetFetchResponseCallback(FetchResponseCallback callback) override {
       if (!status_.ok()) {
-        MoqtFetchError error(0, StatusToSubscribeErrorCode(status_),
+        MoqtFetchError error(0, StatusToRequestErrorCode(status_),
                              std::string(status_.message()));
-        error.error_code = StatusToSubscribeErrorCode(status_);
+        error.error_code = StatusToRequestErrorCode(status_);
         error.reason_phrase = status_.message();
         std::move(callback)(error);
         return;
       }
       if (objects_.empty()) {
-        MoqtFetchError error(0, StatusToSubscribeErrorCode(status_),
+        MoqtFetchError error(0, StatusToRequestErrorCode(status_),
                              "No objects in range");
         std::move(callback)(error);
         return;
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index c84fa9f..8761ffb 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -514,13 +514,13 @@
 size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader) {
   MoqtSubscribeError subscribe_error;
   uint64_t error_code;
-  if (!reader.ReadVarInt62(&subscribe_error.subscribe_id) ||
+  if (!reader.ReadVarInt62(&subscribe_error.request_id) ||
       !reader.ReadVarInt62(&error_code) ||
       !reader.ReadStringVarInt62(subscribe_error.reason_phrase) ||
       !reader.ReadVarInt62(&subscribe_error.track_alias)) {
     return 0;
   }
-  subscribe_error.error_code = static_cast<SubscribeErrorCode>(error_code);
+  subscribe_error.error_code = static_cast<RequestErrorCode>(error_code);
   visitor_.OnSubscribeErrorMessage(subscribe_error);
   return reader.PreviouslyReadPayload().length();
 }
@@ -623,7 +623,7 @@
       !reader.ReadStringVarInt62(announce_error.reason_phrase)) {
     return 0;
   }
-  announce_error.error_code = static_cast<SubscribeErrorCode>(error_code);
+  announce_error.error_code = static_cast<RequestErrorCode>(error_code);
   visitor_.OnAnnounceErrorMessage(announce_error);
   return reader.PreviouslyReadPayload().length();
 }
@@ -638,7 +638,7 @@
       !reader.ReadStringVarInt62(announce_cancel.reason_phrase)) {
     return 0;
   }
-  announce_cancel.error_code = static_cast<SubscribeErrorCode>(error_code);
+  announce_cancel.error_code = static_cast<RequestErrorCode>(error_code);
   visitor_.OnAnnounceCancelMessage(announce_cancel);
   return reader.PreviouslyReadPayload().length();
 }
@@ -766,7 +766,7 @@
     return 0;
   }
   subscribe_namespace_error.error_code =
-      static_cast<SubscribeErrorCode>(error_code);
+      static_cast<RequestErrorCode>(error_code);
   visitor_.OnSubscribeAnnouncesErrorMessage(subscribe_namespace_error);
   return reader.PreviouslyReadPayload().length();
 }
@@ -906,7 +906,7 @@
       !reader.ReadStringVarInt62(fetch_error.reason_phrase)) {
     return 0;
   }
-  fetch_error.error_code = static_cast<SubscribeErrorCode>(error_code);
+  fetch_error.error_code = static_cast<RequestErrorCode>(error_code);
   visitor_.OnFetchErrorMessage(fetch_error);
   return reader.PreviouslyReadPayload().length();
 }
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 9a0b499..0c8e75e 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -287,7 +287,7 @@
     std::move(announce_callback)(
         track_namespace,
         MoqtAnnounceErrorReason{
-            SubscribeErrorCode::kInternalError,
+            RequestErrorCode::kInternalError,
             "ANNOUNCE message already outstanding for namespace"});
     return;
   }
@@ -319,7 +319,7 @@
 }
 
 void MoqtSession::CancelAnnounce(FullTrackName track_namespace,
-                                 SubscribeErrorCode code,
+                                 RequestErrorCode code,
                                  absl::string_view reason) {
   MoqtAnnounceCancel message{track_namespace, code, std::string(reason)};
 
@@ -913,10 +913,10 @@
 }
 
 void MoqtSession::ControlStream::SendSubscribeError(
-    uint64_t subscribe_id, SubscribeErrorCode error_code,
+    uint64_t request_id, RequestErrorCode error_code,
     absl::string_view reason_phrase, uint64_t track_alias) {
   MoqtSubscribeError subscribe_error;
-  subscribe_error.subscribe_id = subscribe_id;
+  subscribe_error.request_id = request_id;
   subscribe_error.error_code = error_code;
   subscribe_error.reason_phrase = reason_phrase;
   subscribe_error.track_alias = track_alias;
@@ -925,7 +925,7 @@
 }
 
 void MoqtSession::ControlStream::SendFetchError(
-    uint64_t subscribe_id, SubscribeErrorCode error_code,
+    uint64_t subscribe_id, RequestErrorCode error_code,
     absl::string_view reason_phrase) {
   MoqtFetchError fetch_error;
   fetch_error.subscribe_id = subscribe_id;
@@ -943,7 +943,7 @@
                   << message.full_track_name;
   if (session_->sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE after GOAWAY";
-    SendSubscribeError(message.request_id, SubscribeErrorCode::kUnauthorized,
+    SendSubscribeError(message.request_id, RequestErrorCode::kUnauthorized,
                        "SUBSCRIBE after GOAWAY", message.track_alias);
     return;
   }
@@ -959,7 +959,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "SUBSCRIBE for " << track_name
                     << " rejected by the application: "
                     << track_publisher.status();
-    SendSubscribeError(message.request_id, SubscribeErrorCode::kDoesNotExist,
+    SendSubscribeError(message.request_id, RequestErrorCode::kTrackDoesNotExist,
                        track_publisher.status().message(), message.track_alias);
     return;
   }
@@ -1025,10 +1025,10 @@
 
 void MoqtSession::ControlStream::OnSubscribeErrorMessage(
     const MoqtSubscribeError& message) {
-  RemoteTrack* track = session_->RemoteTrackById(message.subscribe_id);
+  RemoteTrack* track = session_->RemoteTrackById(message.request_id);
   if (track == nullptr) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received the SUBSCRIBE_ERROR for "
-                    << "subscribe_id = " << message.subscribe_id
+                    << "subscribe_id = " << message.request_id
                     << " but no track exists";
     // Subscription state might have been destroyed for internal reasons.
     return;
@@ -1044,7 +1044,7 @@
     return;
   }
   QUIC_DLOG(INFO) << ENDPOINT << "Received the SUBSCRIBE_ERROR for "
-                  << "subscribe_id = " << message.subscribe_id << " ("
+                  << "subscribe_id = " << message.request_id << " ("
                   << track->full_track_name() << ")"
                   << ", error = " << static_cast<int>(message.error_code)
                   << " (" << message.reason_phrase << ")";
@@ -1053,7 +1053,7 @@
   // an error due to a duplicate track name. The other entries for this
   // subscribe will be deleted after calling Subscribe().
   session_->subscribe_by_name_.erase(subscribe->full_track_name());
-  if (message.error_code == SubscribeErrorCode::kRetryTrackAlias) {
+  if (message.error_code == RequestErrorCode::kRetryTrackAlias) {
     // Automatically resubscribe with new alias.
     MoqtSubscribe& subscribe_message = subscribe->GetSubscribe();
     session_->Subscribe(subscribe_message, subscribe->visitor(),
@@ -1110,7 +1110,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "Received an ANNOUNCE after GOAWAY";
     MoqtAnnounceError error;
     error.track_namespace = message.track_namespace;
-    error.error_code = SubscribeErrorCode::kUnauthorized;
+    error.error_code = RequestErrorCode::kUnauthorized;
     error.reason_phrase = "ANNOUNCE after GOAWAY";
     SendOrBufferMessage(session_->framer_.SerializeAnnounceError(error));
     return;
@@ -1205,7 +1205,7 @@
                     << "Received a SUBSCRIBE_ANNOUNCES after GOAWAY";
     MoqtSubscribeAnnouncesError error;
     error.track_namespace = message.track_namespace;
-    error.error_code = SubscribeErrorCode::kUnauthorized;
+    error.error_code = RequestErrorCode::kUnauthorized;
     error.reason_phrase = "SUBSCRIBE_ANNOUNCES after GOAWAY";
     SendOrBufferMessage(
         session_->framer_.SerializeSubscribeAnnouncesError(error));
@@ -1288,7 +1288,7 @@
   }
   if (session_->sent_goaway_) {
     QUIC_DLOG(INFO) << ENDPOINT << "Received a FETCH after GOAWAY";
-    SendFetchError(message.fetch_id, SubscribeErrorCode::kUnauthorized,
+    SendFetchError(message.fetch_id, RequestErrorCode::kUnauthorized,
                    "FETCH after GOAWAY");
     return;
   }
@@ -1303,7 +1303,7 @@
       QUIC_DLOG(INFO) << ENDPOINT << "Received a JOINING_FETCH for "
                       << "subscribe_id " << joining_subscribe_id
                       << " that does not exist";
-      SendFetchError(message.fetch_id, SubscribeErrorCode::kDoesNotExist,
+      SendFetchError(message.fetch_id, RequestErrorCode::kTrackDoesNotExist,
                      "Joining Fetch for non-existent subscribe");
       return;
     }
@@ -1342,7 +1342,7 @@
     QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name
                     << " rejected by the application: "
                     << track_publisher.status();
-    SendFetchError(message.fetch_id, SubscribeErrorCode::kDoesNotExist,
+    SendFetchError(message.fetch_id, RequestErrorCode::kTrackDoesNotExist,
                    track_publisher.status().message());
     return;
   }
@@ -1354,7 +1354,7 @@
   if (!fetch->GetStatus().ok()) {
     QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name
                     << " could not initialize the task";
-    SendFetchError(message.fetch_id, SubscribeErrorCode::kInvalidRange,
+    SendFetchError(message.fetch_id, RequestErrorCode::kInvalidRange,
                    fetch->GetStatus().message());
     return;
   }
@@ -1365,7 +1365,7 @@
   if (!result.second) {  // Emplace failed.
     QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name
                     << " could not be added to the session";
-    SendFetchError(message.fetch_id, SubscribeErrorCode::kInternalError,
+    SendFetchError(message.fetch_id, RequestErrorCode::kInternalError,
                    "Could not initialize FETCH state");
   }
   MoqtFetchTask* fetch_task = result.first->second->fetch_task();
@@ -1466,30 +1466,8 @@
                   << ", error = " << static_cast<int>(message.error_code)
                   << " (" << message.reason_phrase << ")";
   UpstreamFetch* fetch = static_cast<UpstreamFetch*>(track);
-  absl::Status status;
-  switch (message.error_code) {
-    case SubscribeErrorCode::kInternalError:
-      status = absl::InternalError(message.reason_phrase);
-      break;
-    case SubscribeErrorCode::kInvalidRange:
-      status = absl::OutOfRangeError(message.reason_phrase);
-      break;
-    case SubscribeErrorCode::kDoesNotExist:
-      status = absl::NotFoundError(message.reason_phrase);
-      break;
-    case SubscribeErrorCode::kUnauthorized:
-      status = absl::UnauthenticatedError(message.reason_phrase);
-      break;
-    case SubscribeErrorCode::kTimeout:
-      status = absl::DeadlineExceededError(message.reason_phrase);
-      break;
-    case SubscribeErrorCode::kNotSupported:
-      status = absl::UnavailableError(message.reason_phrase);
-      break;
-    default:
-      status = absl::UnknownError(message.reason_phrase);
-      break;
-  }
+  absl::Status status =
+      RequestErrorCodeToStatus(message.error_code, message.reason_phrase);
   fetch->OnFetchResult(Location(0, 0), status, nullptr);
   session_->upstream_by_id_.erase(message.subscribe_id);
 }
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 85e20ce..77bc1fb 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -110,7 +110,7 @@
   bool Unannounce(FullTrackName track_namespace);
   // Allows the subscriber to declare it will not subscribe to |track_namespace|
   // anymore.
-  void CancelAnnounce(FullTrackName track_namespace, SubscribeErrorCode code,
+  void CancelAnnounce(FullTrackName track_namespace, RequestErrorCode code,
                       absl::string_view reason_phrase);
 
   // Returns true if SUBSCRIBE was sent. If there is already a subscription to
@@ -275,14 +275,13 @@
     // control credit.
     void SendOrBufferMessage(quiche::QuicheBuffer message, bool fin = false);
 
-    void SendSubscribeError(uint64_t subscribe_id,
-                            SubscribeErrorCode error_code,
+    void SendSubscribeError(uint64_t request_id, RequestErrorCode error_code,
                             absl::string_view reason_phrase,
                             uint64_t track_alias);
 
    private:
     friend class test::MoqtSessionPeer;
-    void SendFetchError(uint64_t subscribe_id, SubscribeErrorCode error_code,
+    void SendFetchError(uint64_t subscribe_id, RequestErrorCode error_code,
                         absl::string_view reason_phrase);
 
     MoqtSession* session_;
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h
index 39b5bfd..3b0271a 100644
--- a/quiche/quic/moqt/moqt_session_callbacks.h
+++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -50,7 +50,7 @@
     const FullTrackName& /*track_namespace*/,
     std::optional<VersionSpecificParameters> /*parameters*/) {
   return std::optional(MoqtAnnounceErrorReason{
-      SubscribeErrorCode::kNotSupported,
+      RequestErrorCode::kNotSupported,
       "This endpoint does not accept incoming ANNOUNCE messages"});
 };
 
@@ -59,7 +59,7 @@
     const FullTrackName& track_namespace,
     std::optional<VersionSpecificParameters> /*parameters*/) {
   return MoqtSubscribeErrorReason{
-      SubscribeErrorCode::kUnauthorized,
+      RequestErrorCode::kNotSupported,
       "This endpoint does not support incoming SUBSCRIBE_ANNOUNCES messages"};
 }
 
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index 1bf2eb2..f26266d 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -27,7 +27,7 @@
     std::optional<MoqtAnnounceErrorReason> error)>;
 
 using MoqtOutgoingSubscribeAnnouncesCallback = quiche::SingleUseCallback<void(
-    FullTrackName track_namespace, std::optional<SubscribeErrorCode> error,
+    FullTrackName track_namespace, std::optional<RequestErrorCode> error,
     absl::string_view reason)>;
 
 class MoqtSessionInterface {
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 70c6a24..bbc41ad 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -379,7 +379,7 @@
 
   MoqtAnnounceCancel cancel = {
       /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/SubscribeErrorCode::kInternalError,
+      /*error_code=*/RequestErrorCode::kInternalError,
       /*reason_phrase=*/"Test error",
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
@@ -387,7 +387,7 @@
                     std::optional<MoqtAnnounceErrorReason> error) {
         EXPECT_EQ(track_namespace, FullTrackName{"foo"});
         ASSERT_TRUE(error.has_value());
-        EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError);
+        EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "Test error");
       });
   stream_input->OnAnnounceCancelMessage(cancel);
@@ -444,7 +444,7 @@
 
   MoqtAnnounceError error = {
       /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/SubscribeErrorCode::kInternalError,
+      /*error_code=*/RequestErrorCode::kInternalError,
       /*reason_phrase=*/"Test error",
   };
   EXPECT_CALL(announce_resolved_callback, Call(_, _))
@@ -452,7 +452,7 @@
                     std::optional<MoqtAnnounceErrorReason> error) {
         EXPECT_EQ(track_namespace, FullTrackName{"foo"});
         ASSERT_TRUE(error.has_value());
-        EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError);
+        EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
         EXPECT_EQ(error->reason_phrase, "Test error");
       });
   stream_input->OnAnnounceErrorMessage(error);
@@ -491,8 +491,7 @@
       mock_stream_,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
   listener->OnSubscribeRejected(
-      MoqtSubscribeErrorReason(SubscribeErrorCode::kInternalError,
-                               "Test error"),
+      MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"),
       request.track_alias);
   EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, 1), nullptr);
 }
@@ -800,7 +799,7 @@
 
   MoqtSubscribeError error = {
       /*request_id=*/0,
-      /*error_code=*/SubscribeErrorCode::kInvalidRange,
+      /*error_code=*/RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"deadbeef",
       /*track_alias=*/2,
   };
@@ -874,10 +873,10 @@
   stream_input->OnAnnounceMessage(announce);
   EXPECT_CALL(mock_stream_,
               Writev(SerializedControlMessage(MoqtAnnounceCancel{
-                         track_namespace, SubscribeErrorCode::kInternalError,
+                         track_namespace, RequestErrorCode::kInternalError,
                          "deadbeef"}),
                      _));
-  session_.CancelAnnounce(track_namespace, SubscribeErrorCode::kInternalError,
+  session_.CancelAnnounce(track_namespace, RequestErrorCode::kInternalError,
                           "deadbeef");
 }
 
@@ -893,7 +892,7 @@
       *parameters,
   };
   MoqtAnnounceErrorReason error = {
-      SubscribeErrorCode::kNotSupported,
+      RequestErrorCode::kNotSupported,
       "deadbeef",
   };
   EXPECT_CALL(session_callbacks_.incoming_announce_callback,
@@ -918,7 +917,7 @@
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
   session_.SubscribeAnnounces(
       track_namespace,
-      [&](const FullTrackName& ftn, std::optional<SubscribeErrorCode> error,
+      [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
         got_callback = true;
         EXPECT_EQ(track_namespace, ftn);
@@ -949,18 +948,18 @@
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _));
   session_.SubscribeAnnounces(
       track_namespace,
-      [&](const FullTrackName& ftn, std::optional<SubscribeErrorCode> error,
+      [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error,
           absl::string_view reason) {
         got_callback = true;
         EXPECT_EQ(track_namespace, ftn);
         ASSERT_TRUE(error.has_value());
-        EXPECT_EQ(*error, SubscribeErrorCode::kInvalidRange);
+        EXPECT_EQ(*error, RequestErrorCode::kInvalidRange);
         EXPECT_EQ(reason, "deadbeef");
       },
       VersionSpecificParameters());
   MoqtSubscribeAnnouncesError error = {
       /*track_namespace=*/track_namespace,
-      /*error_code=*/SubscribeErrorCode::kInvalidRange,
+      /*error_code=*/RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"deadbeef",
   };
   stream_input->OnSubscribeAnnouncesErrorMessage(error);
@@ -1130,7 +1129,7 @@
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
       /*request_id=*/1,
-      /*error_code=*/SubscribeErrorCode::kRetryTrackAlias,
+      /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/3,
   };
@@ -1152,7 +1151,7 @@
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
       /*request_id=*/1,
-      /*error_code=*/SubscribeErrorCode::kRetryTrackAlias,
+      /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/3,
   };
@@ -1172,7 +1171,7 @@
   // SUBSCRIBE_ERROR arrives
   MoqtSubscribeError subscribe_error = {
       /*request_id=*/1,
-      /*error_code=*/SubscribeErrorCode::kRetryTrackAlias,
+      /*error_code=*/RequestErrorCode::kRetryTrackAlias,
       /*reason_phrase=*/"foo",
       /*track_alias =*/2,
   };
@@ -2289,7 +2288,7 @@
 
   MoqtFetchError expected_error;
   expected_error.subscribe_id = fetch.fetch_id;
-  expected_error.error_code = SubscribeErrorCode::kDoesNotExist;
+  expected_error.error_code = RequestErrorCode::kTrackDoesNotExist;
   expected_error.reason_phrase = "foo";
   EXPECT_CALL(mock_stream_,
               Writev(SerializedControlMessage(expected_error), _));
@@ -2392,7 +2391,7 @@
   fetch.joining_fetch = {1, 2};
   MoqtFetchError expected_error = {
       /*request_id=*/1,
-      /*error_code=*/SubscribeErrorCode::kDoesNotExist,
+      /*error_code=*/RequestErrorCode::kTrackDoesNotExist,
       /*reason_phrase=*/"Joining Fetch for non-existent subscribe",
   };
   EXPECT_CALL(mock_stream_,
@@ -2538,7 +2537,7 @@
   EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
               Call(_, parameters))
       .WillOnce(Return(
-          MoqtSubscribeErrorReason{SubscribeErrorCode::kUnauthorized, "foo"}));
+          MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"}));
   EXPECT_CALL(
       control_stream,
       Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError),
@@ -2588,12 +2587,12 @@
       VersionSpecificParameters());
   MoqtFetchError error = {
       /*request_id=*/0,
-      /*error_code=*/SubscribeErrorCode::kUnauthorized,
+      /*error_code=*/RequestErrorCode::kUnauthorized,
       /*reason_phrase=*/"No username provided",
   };
   stream_input->OnFetchErrorMessage(error);
   ASSERT_NE(fetch_task, nullptr);
-  EXPECT_TRUE(absl::IsUnauthenticated(fetch_task->GetStatus()));
+  EXPECT_TRUE(absl::IsPermissionDenied(fetch_task->GetStatus()));
   EXPECT_EQ(fetch_task->GetStatus().message(), "No username provided");
 }
 
@@ -3070,7 +3069,7 @@
   EXPECT_FALSE(session_.SubscribeAnnounces(
       FullTrackName{"foo"},
       +[](FullTrackName /*track_namespace*/,
-          std::optional<SubscribeErrorCode> /*error*/,
+          std::optional<RequestErrorCode> /*error*/,
           absl::string_view /*reason*/) {},
       VersionSpecificParameters()));
   session_.Announce(
@@ -3131,7 +3130,7 @@
   EXPECT_FALSE(session_.SubscribeAnnounces(
       FullTrackName{"foo"},
       +[](FullTrackName /*track_namespace*/,
-          std::optional<SubscribeErrorCode> /*error*/,
+          std::optional<RequestErrorCode> /*error*/,
           absl::string_view /*reason*/) {},
       VersionSpecificParameters()));
   session_.Announce(
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index b30d63c..2ef9c8b 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -623,8 +623,8 @@
 
   bool EqualFieldValues(MessageStructuredData& values) const override {
     auto cast = std::get<MoqtSubscribeError>(values);
-    if (cast.subscribe_id != subscribe_error_.subscribe_id) {
-      QUIC_LOG(INFO) << "SUBSCRIBE ERROR subscribe_id mismatch";
+    if (cast.request_id != subscribe_error_.request_id) {
+      QUIC_LOG(INFO) << "SUBSCRIBE ERROR request_id mismatch";
       return false;
     }
     if (cast.error_code != subscribe_error_.error_code) {
@@ -651,15 +651,15 @@
  private:
   uint8_t raw_packet_[10] = {
       0x05, 0x00, 0x07,
-      0x02,                    // subscribe_id = 2
+      0x02,                    // request_id = 2
       0x05,                    // error_code = 5
       0x03, 0x62, 0x61, 0x72,  // reason_phrase = "bar"
       0x04,                    // track_alias = 4
   };
 
   MoqtSubscribeError subscribe_error_ = {
-      /*subscribe_id=*/2,
-      /*subscribe=*/SubscribeErrorCode::kInvalidRange,
+      /*request_id=*/2,
+      /*error_code=*/RequestErrorCode::kInvalidRange,
       /*reason_phrase=*/"bar",
       /*track_alias=*/4,
   };
@@ -910,7 +910,7 @@
 
   MoqtAnnounceError announce_error_ = {
       /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/SubscribeErrorCode::kNotSupported,
+      /*error_code=*/RequestErrorCode::kNotSupported,
       /*reason_phrase=*/"bar",
   };
 };
@@ -954,7 +954,7 @@
 
   MoqtAnnounceCancel announce_cancel_ = {
       /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/SubscribeErrorCode::kNotSupported,
+      /*error_code=*/RequestErrorCode::kNotSupported,
       /*reason_phrase=*/"bar",
   };
 };
@@ -1227,7 +1227,7 @@
 
   MoqtSubscribeAnnouncesError subscribe_namespace_error_ = {
       /*track_namespace=*/FullTrackName{"foo"},
-      /*error_code=*/SubscribeErrorCode::kUnauthorized,
+      /*error_code=*/RequestErrorCode::kUnauthorized,
       /*reason_phrase=*/"bar",
   };
 };
@@ -1625,7 +1625,7 @@
 
   MoqtFetchError fetch_error_ = {
       /*subscribe_id =*/1,
-      /*error_code=*/SubscribeErrorCode::kUnauthorized,
+      /*error_code=*/RequestErrorCode::kUnauthorized,
       /*reason_phrase=*/"bar",
   };
 };
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index ef42e85..72349a4 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -59,7 +59,7 @@
   if (!track_name.has_value()) {
     std::cout << "ANNOUNCE rejected, invalid namespace\n";
     return std::make_optional<MoqtAnnounceErrorReason>(
-        SubscribeErrorCode::kDoesNotExist, "Not a subscribed namespace");
+        RequestErrorCode::kTrackDoesNotExist, "Not a subscribed namespace");
   }
   if (other_users_.contains(*track_name)) {
     std::cout << "Duplicate ANNOUNCE, send OK and ignore\n";
@@ -237,8 +237,7 @@
   // chat-id}
   MoqtOutgoingSubscribeAnnouncesCallback subscribe_announces_callback =
       [this](FullTrackName track_namespace,
-             std::optional<SubscribeErrorCode> error,
-             absl::string_view reason) {
+             std::optional<RequestErrorCode> error, absl::string_view reason) {
         if (error.has_value()) {
           std::cout << "SUBSCRIBE_ANNOUNCES rejected, " << reason << "\n";
           session_->Error(MoqtError::kInternalError,
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc
index f09395b..08bcd62 100644
--- a/quiche/quic/moqt/tools/chat_server.cc
+++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -39,7 +39,7 @@
                                                 GetChatId(track_namespace));
   if (!track_name_.has_value()) {
     std::cout << "Malformed ANNOUNCE namespace\n";
-    return MoqtAnnounceErrorReason(SubscribeErrorCode::kDoesNotExist,
+    return MoqtAnnounceErrorReason(RequestErrorCode::kTrackDoesNotExist,
                                    "Not a valid namespace for this chat.");
   }
   if (!parameters.has_value()) {
@@ -96,7 +96,7 @@
         if (!IsValidChatNamespace(chat_namespace)) {
           std::cout << "Not a valid moq-chat namespace.\n";
           return std::make_optional(
-              MoqtSubscribeErrorReason{SubscribeErrorCode::kDoesNotExist,
+              MoqtSubscribeErrorReason{RequestErrorCode::kTrackDoesNotExist,
                                        "Not a valid namespace for this chat."});
         }
         if (!parameters.has_value()) {
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
index 0fdf4ac..4b4aefc 100644
--- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -126,7 +126,7 @@
                               "disallowed characters; namespace: "
                            << track_namespace;
       return MoqtAnnounceErrorReason{
-          SubscribeErrorCode::kInternalError,
+          RequestErrorCode::kInternalError,
           "Track namespace contains disallowed characters"};
     }
 
@@ -145,7 +145,7 @@
       subscribed_namespaces_.erase(it);
       QUICHE_LOG(ERROR) << "Failed to create directory " << directory_path
                         << "; " << status;
-      return MoqtAnnounceErrorReason{SubscribeErrorCode::kInternalError,
+      return MoqtAnnounceErrorReason{RequestErrorCode::kInternalError,
                                      "Failed to create output directory"};
     }