diff --git a/build/source_list.bzl b/build/source_list.bzl
index df02f45..ade85e5 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -13,6 +13,7 @@
     "common/capsule.h",
     "common/http/http_header_block.h",
     "common/http/http_header_storage.h",
+    "common/masque/connect_ip_datagram_payload.h",
     "common/masque/connect_udp_datagram_payload.h",
     "common/platform/api/quiche_bug_tracker.h",
     "common/platform/api/quiche_client_stats.h",
@@ -400,6 +401,7 @@
     "common/capsule.cc",
     "common/http/http_header_block.cc",
     "common/http/http_header_storage.cc",
+    "common/masque/connect_ip_datagram_payload.cc",
     "common/masque/connect_udp_datagram_payload.cc",
     "common/platform/api/quiche_hostname_utils.cc",
     "common/platform/api/quiche_mutex.cc",
@@ -1052,6 +1054,7 @@
     "common/capsule_test.cc",
     "common/http/http_header_block_test.cc",
     "common/http/http_header_storage_test.cc",
+    "common/masque/connect_ip_datagram_payload_test.cc",
     "common/masque/connect_udp_datagram_payload_test.cc",
     "common/platform/api/quiche_file_utils_test.cc",
     "common/platform/api/quiche_hostname_utils_test.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index 16a7eea..c514ab2 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -13,6 +13,7 @@
     "src/quiche/common/capsule.h",
     "src/quiche/common/http/http_header_block.h",
     "src/quiche/common/http/http_header_storage.h",
+    "src/quiche/common/masque/connect_ip_datagram_payload.h",
     "src/quiche/common/masque/connect_udp_datagram_payload.h",
     "src/quiche/common/platform/api/quiche_bug_tracker.h",
     "src/quiche/common/platform/api/quiche_client_stats.h",
@@ -400,6 +401,7 @@
     "src/quiche/common/capsule.cc",
     "src/quiche/common/http/http_header_block.cc",
     "src/quiche/common/http/http_header_storage.cc",
+    "src/quiche/common/masque/connect_ip_datagram_payload.cc",
     "src/quiche/common/masque/connect_udp_datagram_payload.cc",
     "src/quiche/common/platform/api/quiche_hostname_utils.cc",
     "src/quiche/common/platform/api/quiche_mutex.cc",
@@ -1053,6 +1055,7 @@
     "src/quiche/common/capsule_test.cc",
     "src/quiche/common/http/http_header_block_test.cc",
     "src/quiche/common/http/http_header_storage_test.cc",
+    "src/quiche/common/masque/connect_ip_datagram_payload_test.cc",
     "src/quiche/common/masque/connect_udp_datagram_payload_test.cc",
     "src/quiche/common/platform/api/quiche_file_utils_test.cc",
     "src/quiche/common/platform/api/quiche_hostname_utils_test.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 41946db..68779fa 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -12,6 +12,7 @@
     "quiche/common/capsule.h",
     "quiche/common/http/http_header_block.h",
     "quiche/common/http/http_header_storage.h",
+    "quiche/common/masque/connect_ip_datagram_payload.h",
     "quiche/common/masque/connect_udp_datagram_payload.h",
     "quiche/common/platform/api/quiche_bug_tracker.h",
     "quiche/common/platform/api/quiche_client_stats.h",
@@ -399,6 +400,7 @@
     "quiche/common/capsule.cc",
     "quiche/common/http/http_header_block.cc",
     "quiche/common/http/http_header_storage.cc",
+    "quiche/common/masque/connect_ip_datagram_payload.cc",
     "quiche/common/masque/connect_udp_datagram_payload.cc",
     "quiche/common/platform/api/quiche_hostname_utils.cc",
     "quiche/common/platform/api/quiche_mutex.cc",
@@ -1052,6 +1054,7 @@
     "quiche/common/capsule_test.cc",
     "quiche/common/http/http_header_block_test.cc",
     "quiche/common/http/http_header_storage_test.cc",
+    "quiche/common/masque/connect_ip_datagram_payload_test.cc",
     "quiche/common/masque/connect_udp_datagram_payload_test.cc",
     "quiche/common/platform/api/quiche_file_utils_test.cc",
     "quiche/common/platform/api/quiche_hostname_utils_test.cc",
diff --git a/quiche/common/masque/connect_ip_datagram_payload.cc b/quiche/common/masque/connect_ip_datagram_payload.cc
new file mode 100644
index 0000000..cf97c21
--- /dev/null
+++ b/quiche/common/masque/connect_ip_datagram_payload.cc
@@ -0,0 +1,131 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/common/masque/connect_ip_datagram_payload.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_bug_tracker.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_data_reader.h"
+#include "quiche/common/quiche_data_writer.h"
+
+namespace quiche {
+
+// static
+std::unique_ptr<ConnectIpDatagramPayload> ConnectIpDatagramPayload::Parse(
+    absl::string_view datagram_payload) {
+  QuicheDataReader data_reader(datagram_payload);
+
+  uint64_t context_id;
+  if (!data_reader.ReadVarInt62(&context_id)) {
+    QUICHE_DVLOG(1) << "Could not parse malformed IP proxy payload";
+    return nullptr;
+  }
+
+  if (ContextId{context_id} == ConnectIpDatagramIpPacketPayload::kContextId) {
+    return std::make_unique<ConnectIpDatagramIpPacketPayload>(
+        data_reader.ReadRemainingPayload());
+  } else {
+    return std::make_unique<ConnectIpDatagramUnknownPayload>(
+        ContextId{context_id}, data_reader.ReadRemainingPayload());
+  }
+}
+
+std::string ConnectIpDatagramPayload::Serialize() const {
+  std::string buffer(SerializedLength(), '\0');
+  QuicheDataWriter writer(buffer.size(), buffer.data());
+
+  bool result = SerializeTo(writer);
+  QUICHE_DCHECK(result);
+  QUICHE_DCHECK_EQ(writer.remaining(), 0u);
+
+  return buffer;
+}
+
+ConnectIpDatagramIpPacketPayload::ConnectIpDatagramIpPacketPayload(
+    absl::string_view ip_packet)
+    : ip_packet_(ip_packet) {}
+
+ConnectIpDatagramPayload::ContextId
+ConnectIpDatagramIpPacketPayload::GetContextId() const {
+  return kContextId;
+}
+
+ConnectIpDatagramPayload::Type ConnectIpDatagramIpPacketPayload::GetType()
+    const {
+  return Type::kIpPacket;
+}
+
+absl::string_view ConnectIpDatagramIpPacketPayload::GetIpProxyingPayload()
+    const {
+  return ip_packet_;
+}
+
+size_t ConnectIpDatagramIpPacketPayload::SerializedLength() const {
+  return ip_packet_.size() +
+         QuicheDataWriter::GetVarInt62Len(uint64_t{kContextId});
+}
+
+bool ConnectIpDatagramIpPacketPayload::SerializeTo(
+    QuicheDataWriter& writer) const {
+  if (!writer.WriteVarInt62(uint64_t{kContextId})) {
+    return false;
+  }
+
+  if (!writer.WriteStringPiece(ip_packet_)) {
+    return false;
+  }
+
+  return true;
+}
+
+ConnectIpDatagramUnknownPayload::ConnectIpDatagramUnknownPayload(
+    ContextId context_id, absl::string_view ip_proxying_payload)
+    : context_id_(context_id), ip_proxying_payload_(ip_proxying_payload) {
+  if (context_id == ConnectIpDatagramIpPacketPayload::kContextId) {
+    QUICHE_BUG(ip_proxy_unknown_payload_ip_context)
+        << "ConnectIpDatagramUnknownPayload created with IP packet context "
+           "ID (0). Should instead create a "
+           "ConnectIpDatagramIpPacketPayload.";
+  }
+}
+
+ConnectIpDatagramPayload::ContextId
+ConnectIpDatagramUnknownPayload::GetContextId() const {
+  return context_id_;
+}
+
+ConnectIpDatagramPayload::Type ConnectIpDatagramUnknownPayload::GetType()
+    const {
+  return Type::kUnknown;
+}
+absl::string_view ConnectIpDatagramUnknownPayload::GetIpProxyingPayload()
+    const {
+  return ip_proxying_payload_;
+}
+
+size_t ConnectIpDatagramUnknownPayload::SerializedLength() const {
+  return ip_proxying_payload_.size() +
+         QuicheDataWriter::GetVarInt62Len(uint64_t{context_id_});
+}
+
+bool ConnectIpDatagramUnknownPayload::SerializeTo(
+    QuicheDataWriter& writer) const {
+  if (!writer.WriteVarInt62(uint64_t{context_id_})) {
+    return false;
+  }
+
+  if (!writer.WriteStringPiece(ip_proxying_payload_)) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace quiche
diff --git a/quiche/common/masque/connect_ip_datagram_payload.h b/quiche/common/masque/connect_ip_datagram_payload.h
new file mode 100644
index 0000000..978b74c
--- /dev/null
+++ b/quiche/common/masque/connect_ip_datagram_payload.h
@@ -0,0 +1,100 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_COMMON_MASQUE_CONNECT_IP_DATAGRAM_PAYLOAD_H_
+#define QUICHE_COMMON_MASQUE_CONNECT_IP_DATAGRAM_PAYLOAD_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_data_writer.h"
+
+namespace quiche {
+
+// IP-proxying HTTP Datagram payload for use with CONNECT-IP. See RFC 9484,
+// Section 6.
+class QUICHE_EXPORT ConnectIpDatagramPayload {
+ public:
+  using ContextId = uint64_t;
+  enum class Type { kIpPacket, kUnknown };
+
+  // Parse from `datagram_payload` (a wire-format IP-proxying HTTP datagram
+  // payload). Returns nullptr on error. The created ConnectIpDatagramPayload
+  // object may use absl::string_views pointing into `datagram_payload`, so the
+  // data pointed to by `datagram_payload` must outlive the created
+  // ConnectIpDatagramPayload object.
+  static std::unique_ptr<ConnectIpDatagramPayload> Parse(
+      absl::string_view datagram_payload);
+
+  ConnectIpDatagramPayload() = default;
+
+  ConnectIpDatagramPayload(const ConnectIpDatagramPayload&) = delete;
+  ConnectIpDatagramPayload& operator=(const ConnectIpDatagramPayload&) = delete;
+
+  virtual ~ConnectIpDatagramPayload() = default;
+
+  virtual ContextId GetContextId() const = 0;
+  virtual Type GetType() const = 0;
+  // Get the inner payload (the IP Proxying Payload).
+  virtual absl::string_view GetIpProxyingPayload() const = 0;
+
+  // Length of this IP-proxying HTTP datagram payload in wire format.
+  virtual size_t SerializedLength() const = 0;
+  // Write a wire-format buffer for the payload. Returns false on write failure
+  // (typically due to `writer` buffer being full).
+  virtual bool SerializeTo(QuicheDataWriter& writer) const = 0;
+
+  // Write a wire-format buffer.
+  std::string Serialize() const;
+};
+
+// IP-proxying HTTP Datagram payload that encodes an IP packet.
+class QUICHE_EXPORT ConnectIpDatagramIpPacketPayload final
+    : public ConnectIpDatagramPayload {
+ public:
+  static constexpr ContextId kContextId = 0;
+
+  // The string pointed to by `ip_packet` must outlive the created
+  // ConnectIpDatagramIpPacketPayload.
+  explicit ConnectIpDatagramIpPacketPayload(absl::string_view ip_packet);
+
+  ContextId GetContextId() const override;
+  Type GetType() const override;
+  absl::string_view GetIpProxyingPayload() const override;
+  size_t SerializedLength() const override;
+  bool SerializeTo(QuicheDataWriter& writer) const override;
+
+  absl::string_view ip_packet() const { return ip_packet_; }
+
+ private:
+  absl::string_view ip_packet_;
+};
+
+class QUICHE_EXPORT ConnectIpDatagramUnknownPayload final
+    : public ConnectIpDatagramPayload {
+ public:
+  // `ip_proxying_payload` represents the inner payload contained by the IP-
+  // proxying HTTP datagram payload. The string pointed to by `inner_payload`
+  // must outlive the created ConnectIpDatagramUnknownPayload.
+  ConnectIpDatagramUnknownPayload(ContextId context_id,
+                                  absl::string_view ip_proxying_payload);
+
+  ContextId GetContextId() const override;
+  Type GetType() const override;
+  absl::string_view GetIpProxyingPayload() const override;
+  size_t SerializedLength() const override;
+  bool SerializeTo(QuicheDataWriter& writer) const override;
+
+ private:
+  ContextId context_id_;
+  absl::string_view ip_proxying_payload_;  // The inner payload.
+};
+
+}  // namespace quiche
+
+#endif  // QUICHE_COMMON_MASQUE_CONNECT_IP_DATAGRAM_PAYLOAD_H_
diff --git a/quiche/common/masque/connect_ip_datagram_payload_test.cc b/quiche/common/masque/connect_ip_datagram_payload_test.cc
new file mode 100644
index 0000000..2eb6f51
--- /dev/null
+++ b/quiche/common/masque/connect_ip_datagram_payload_test.cc
@@ -0,0 +1,62 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/common/masque/connect_ip_datagram_payload.h"
+
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "quiche/common/platform/api/quiche_test.h"
+
+namespace quiche::test {
+namespace {
+
+TEST(ConnectIpDatagramPayloadTest, ParseIpPacket) {
+  static constexpr char kDatagramPayload[] = "\x00packet";
+
+  std::unique_ptr<ConnectIpDatagramPayload> parsed =
+      ConnectIpDatagramPayload::Parse(
+          absl::string_view(kDatagramPayload, sizeof(kDatagramPayload) - 1));
+  ASSERT_TRUE(parsed);
+
+  EXPECT_EQ(parsed->GetContextId(),
+            ConnectIpDatagramIpPacketPayload::kContextId);
+  EXPECT_EQ(parsed->GetType(), ConnectIpDatagramPayload::Type::kIpPacket);
+  EXPECT_EQ(parsed->GetIpProxyingPayload(), "packet");
+}
+
+TEST(ConnectIpDatagramPayloadTest, SerializeIpPacket) {
+  static constexpr absl::string_view kIpPacket = "packet";
+
+  ConnectIpDatagramIpPacketPayload payload(kIpPacket);
+  EXPECT_EQ(payload.GetIpProxyingPayload(), kIpPacket);
+
+  EXPECT_EQ(payload.Serialize(), std::string("\x00packet", 7));
+}
+
+TEST(ConnectIpDatagramPayloadTest, ParseUnknownPacket) {
+  static constexpr char kDatagramPayload[] = "\x05packet";
+
+  std::unique_ptr<ConnectIpDatagramPayload> parsed =
+      ConnectIpDatagramPayload::Parse(
+          absl::string_view(kDatagramPayload, sizeof(kDatagramPayload) - 1));
+  ASSERT_TRUE(parsed);
+
+  EXPECT_EQ(parsed->GetContextId(), 5);
+  EXPECT_EQ(parsed->GetType(), ConnectIpDatagramPayload::Type::kUnknown);
+  EXPECT_EQ(parsed->GetIpProxyingPayload(), "packet");
+}
+
+TEST(ConnectIpDatagramPayloadTest, SerializeUnknownPacket) {
+  static constexpr absl::string_view kInnerIpProxyingPayload = "packet";
+
+  ConnectIpDatagramUnknownPayload payload(4u, kInnerIpProxyingPayload);
+  EXPECT_EQ(payload.GetIpProxyingPayload(), kInnerIpProxyingPayload);
+
+  EXPECT_EQ(payload.Serialize(), std::string("\x04packet", 7));
+}
+
+}  // namespace
+}  // namespace quiche::test