diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index 75f55ca..4e761b3 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -59,12 +59,14 @@
 // The following constants define minimum and maximum allowed values for some of
 // the parameters. These come from the "Transport Parameter Definitions"
 // section of draft-ietf-quic-transport.
-const uint64_t kMinMaxPacketSizeTransportParam = 1200;
-const uint64_t kMaxAckDelayExponentTransportParam = 20;
-const uint64_t kDefaultAckDelayExponentTransportParam = 3;
-const uint64_t kMaxMaxAckDelayTransportParam = 16383;
-const uint64_t kDefaultMaxAckDelayTransportParam = 25;
-const size_t kStatelessResetTokenLength = 16;
+constexpr uint64_t kMinMaxPacketSizeTransportParam = 1200;
+constexpr uint64_t kMaxAckDelayExponentTransportParam = 20;
+constexpr uint64_t kDefaultAckDelayExponentTransportParam = 3;
+constexpr uint64_t kMaxMaxAckDelayTransportParam = 16383;
+constexpr uint64_t kDefaultMaxAckDelayTransportParam = 25;
+constexpr size_t kStatelessResetTokenLength = 16;
+constexpr uint64_t kMinActiveConnectionIdLimitTransportParam = 2;
+constexpr uint64_t kDefaultActiveConnectionIdLimitTransportParam = 2;
 
 std::string TransportParameterIdToString(
     TransportParameters::TransportParameterId param_id) {
@@ -449,7 +451,10 @@
                     0,
                     kMaxMaxAckDelayTransportParam),
       disable_migration(false),
-      active_connection_id_limit(kActiveConnectionIdLimit),
+      active_connection_id_limit(kActiveConnectionIdLimit,
+                                 kDefaultActiveConnectionIdLimitTransportParam,
+                                 kMinActiveConnectionIdLimitTransportParam,
+                                 kVarInt62MaxValue),
       max_datagram_frame_size(kMaxDatagramFrameSize)
 // Important note: any new transport parameters must be added
 // to TransportParameters::AreValid, SerializeTransportParameters and
diff --git a/quic/core/crypto/transport_parameters.h b/quic/core/crypto/transport_parameters.h
index d4dd82f..9f9e616 100644
--- a/quic/core/crypto/transport_parameters.h
+++ b/quic/core/crypto/transport_parameters.h
@@ -181,7 +181,7 @@
   IntegerParameter active_connection_id_limit;
 
   // Indicates support for the DATAGRAM frame and the maximum frame size that
-  // the sender accepts. See draft-pauly-quic-datagram.
+  // the sender accepts. See draft-ietf-quic-datagram.
   IntegerParameter max_datagram_frame_size;
 
   // Transport parameters used by Google QUIC but not IETF QUIC. This is
diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc
index 72654a7..c3d5d57 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -388,6 +388,29 @@
               "Invalid transport parameters [Client ack_delay_exponent 21 "
               "(Invalid)]");
   }
+  {
+    TransportParameters params;
+    std::string error_details;
+    params.perspective = Perspective::IS_CLIENT;
+    EXPECT_TRUE(params.AreValid(&error_details));
+    EXPECT_TRUE(error_details.empty());
+    params.active_connection_id_limit.set_value(2);
+    EXPECT_TRUE(params.AreValid(&error_details));
+    EXPECT_TRUE(error_details.empty());
+    params.active_connection_id_limit.set_value(999999);
+    EXPECT_TRUE(params.AreValid(&error_details));
+    EXPECT_TRUE(error_details.empty());
+    params.active_connection_id_limit.set_value(1);
+    EXPECT_FALSE(params.AreValid(&error_details));
+    EXPECT_EQ(error_details,
+              "Invalid transport parameters [Client active_connection_id_limit"
+              " 1 (Invalid)]");
+    params.active_connection_id_limit.set_value(0);
+    EXPECT_FALSE(params.AreValid(&error_details));
+    EXPECT_EQ(error_details,
+              "Invalid transport parameters [Client active_connection_id_limit"
+              " 0 (Invalid)]");
+  }
 }
 
 TEST_P(TransportParametersTest, NoClientParamsWithStatelessResetToken) {
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 0eaf9d6..d0f42b7 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -453,7 +453,8 @@
       max_ack_delay_ms_(kMAD, PRESENCE_OPTIONAL),
       ack_delay_exponent_(kADE, PRESENCE_OPTIONAL),
       max_packet_size_(0, PRESENCE_OPTIONAL),
-      max_datagram_frame_size_(0, PRESENCE_OPTIONAL) {
+      max_datagram_frame_size_(0, PRESENCE_OPTIONAL),
+      active_connection_id_limit_(0, PRESENCE_OPTIONAL) {
   SetDefaults();
 }
 
@@ -652,6 +653,23 @@
   return max_datagram_frame_size_.GetReceivedValue();
 }
 
+void QuicConfig::SetActiveConnectionIdLimitToSend(
+    uint64_t active_connection_id_limit) {
+  active_connection_id_limit_.SetSendValue(active_connection_id_limit);
+}
+
+uint64_t QuicConfig::GetActiveConnectionIdLimitToSend() const {
+  return active_connection_id_limit_.GetSendValue();
+}
+
+bool QuicConfig::HasReceivedActiveConnectionIdLimit() const {
+  return active_connection_id_limit_.HasReceivedValue();
+}
+
+uint64_t QuicConfig::ReceivedActiveConnectionIdLimit() const {
+  return active_connection_id_limit_.GetReceivedValue();
+}
+
 bool QuicConfig::HasSetBytesForConnectionIdToSend() const {
   return bytes_for_connection_id_.HasSendValue();
 }
@@ -1115,6 +1133,11 @@
             preferred_address);
   }
 
+  if (active_connection_id_limit_.HasSendValue()) {
+    params->active_connection_id_limit.set_value(
+        active_connection_id_limit_.GetSendValue());
+  }
+
   if (!params->google_quic_params) {
     params->google_quic_params = std::make_unique<CryptoHandshakeMessage>();
   }
@@ -1217,6 +1240,9 @@
     connection_migration_disabled_.SetReceivedValue(1u);
   }
 
+  active_connection_id_limit_.SetReceivedValue(
+      params.active_connection_id_limit.value());
+
   const CryptoHandshakeMessage* peer_params = params.google_quic_params.get();
   if (peer_params != nullptr) {
     QuicErrorCode error = initial_round_trip_time_us_.ProcessPeerHello(
diff --git a/quic/core/quic_config.h b/quic/core/quic_config.h
index f2ca652..893e3e7 100644
--- a/quic/core/quic_config.h
+++ b/quic/core/quic_config.h
@@ -432,6 +432,12 @@
   bool HasReceivedMaxDatagramFrameSize() const;
   uint64_t ReceivedMaxDatagramFrameSize() const;
 
+  // IETF QUIC active_connection_id_limit transport parameter.
+  void SetActiveConnectionIdLimitToSend(uint64_t active_connection_id_limit);
+  uint64_t GetActiveConnectionIdLimitToSend() const;
+  bool HasReceivedActiveConnectionIdLimit() const;
+  uint64_t ReceivedActiveConnectionIdLimit() const;
+
   bool negotiated() const;
 
   void SetCreateSessionTagIndicators(QuicTagVector tags);
@@ -584,6 +590,10 @@
   // Uses the max_datagram_frame_size transport parameter in IETF QUIC.
   QuicFixedUint62 max_datagram_frame_size_;
 
+  // Maximum number of connection IDs from the peer.
+  // Uses the active_connection_id_limit transport parameter in IETF QUIC.
+  QuicFixedUint62 active_connection_id_limit_;
+
   // Sent by the server when it has previously sent a RETRY packet.
   // Uses the original_connection_id transport parameter in IETF QUIC.
   quiche::QuicheOptional<QuicConnectionId> original_connection_id_to_send_;
diff --git a/quic/core/quic_config_test.cc b/quic/core/quic_config_test.cc
index dbdd0f8..4aa10ef 100644
--- a/quic/core/quic_config_test.cc
+++ b/quic/core/quic_config_test.cc
@@ -22,13 +22,14 @@
 namespace test {
 namespace {
 
-const uint32_t kMaxPacketSizeForTest = 1234;
-const uint32_t kMaxDatagramFrameSizeForTest = 1333;
-const uint8_t kFakeStatelessResetTokenData[16] = {
+constexpr uint32_t kMaxPacketSizeForTest = 1234;
+constexpr uint32_t kMaxDatagramFrameSizeForTest = 1333;
+constexpr uint8_t kFakeStatelessResetTokenData[16] = {
     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
     0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F};
-const uint64_t kFakeAckDelayExponent = 10;
-const uint64_t kFakeMaxAckDelay = 51;
+constexpr uint64_t kFakeAckDelayExponent = 10;
+constexpr uint64_t kFakeMaxAckDelay = 51;
+constexpr uint64_t kFakeActiveConnectionIdLimit = 52;
 
 // TODO(b/153726130): Consider merging this with methods in
 // transport_parameters_test.cc.
@@ -465,6 +466,7 @@
       4 * kMinimumFlowControlSendWindow);
   config_.SetMaxPacketSizeToSend(kMaxPacketSizeForTest);
   config_.SetMaxDatagramFrameSizeToSend(kMaxDatagramFrameSizeForTest);
+  config_.SetActiveConnectionIdLimitToSend(kFakeActiveConnectionIdLimit);
 
   TransportParameters params;
   config_.FillTransportParameters(&params);
@@ -482,6 +484,8 @@
   EXPECT_EQ(kMaxPacketSizeForTest, params.max_packet_size.value());
   EXPECT_EQ(kMaxDatagramFrameSizeForTest,
             params.max_datagram_frame_size.value());
+  EXPECT_EQ(kFakeActiveConnectionIdLimit,
+            params.active_connection_id_limit.value());
 }
 
 TEST_P(QuicConfigTest, ProcessTransportParametersServer) {
@@ -504,6 +508,7 @@
   params.stateless_reset_token = CreateFakeStatelessResetToken();
   params.max_ack_delay.set_value(kFakeMaxAckDelay);
   params.ack_delay_exponent.set_value(kFakeAckDelayExponent);
+  params.active_connection_id_limit.set_value(kFakeActiveConnectionIdLimit);
 
   std::string error_details;
   EXPECT_THAT(config_.ProcessTransportParameters(
@@ -600,6 +605,10 @@
 
   ASSERT_TRUE(config_.HasReceivedAckDelayExponent());
   EXPECT_EQ(config_.ReceivedAckDelayExponent(), kFakeAckDelayExponent);
+
+  ASSERT_TRUE(config_.HasReceivedActiveConnectionIdLimit());
+  EXPECT_EQ(config_.ReceivedActiveConnectionIdLimit(),
+            kFakeActiveConnectionIdLimit);
 }
 
 TEST_P(QuicConfigTest, DisableMigrationTransportParameter) {