diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 70c76c72824..a928d8ab7bc 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -19,6 +19,7 @@
 import io.sentry.NoOpSocketTagger;
 import io.sentry.NoOpTransactionProfiler;
 import io.sentry.NoopVersionDetector;
+import io.sentry.ReplayBreadcrumbConverter;
 import io.sentry.ScopeType;
 import io.sentry.SendFireAndForgetEnvelopeSender;
 import io.sentry.SendFireAndForgetOutboxSender;
@@ -247,6 +248,14 @@ static void initializeIntegrationsAndProcessors(
       options.setCompositePerformanceCollector(new DefaultCompositePerformanceCollector(options));
     }
 
+    if (options.getReplayController() != null) { // TODO: Triple-check this should be a null check
+      ReplayBreadcrumbConverter replayBreadcrumbConverter = options.getReplayController().getBreadcrumbConverter();
+      replayBreadcrumbConverter.setUserBeforeBreadcrumbCallback(options.getBeforeBreadcrumb());
+      options.setBeforeBreadcrumb(
+        replayBreadcrumbConverter
+      );
+    }
+
     // Check if the profiler was already instantiated in the app start.
     // We use the Android profiler, that uses a global start/stop api, so we need to preserve the
     // state of the profiler, and it's only possible retaining the instance.
diff --git a/sentry-android-replay/api/sentry-android-replay.api b/sentry-android-replay/api/sentry-android-replay.api
index 5d6df28f7b3..1cbff1e2a88 100644
--- a/sentry-android-replay/api/sentry-android-replay.api
+++ b/sentry-android-replay/api/sentry-android-replay.api
@@ -10,6 +10,8 @@ public class io/sentry/android/replay/DefaultReplayBreadcrumbConverter : io/sent
 	public static final field $stable I
 	public fun <init> ()V
 	public fun convert (Lio/sentry/Breadcrumb;)Lio/sentry/rrweb/RRWebEvent;
+	public fun execute (Lio/sentry/Breadcrumb;Lio/sentry/Hint;)Lio/sentry/Breadcrumb;
+	public fun setUserBeforeBreadcrumbCallback (Lio/sentry/SentryOptions$BeforeBreadcrumbCallback;)V
 }
 
 public final class io/sentry/android/replay/GeneratedVideo {
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
index 058417ed2a1..d2f746f828d 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverter.kt
@@ -1,16 +1,22 @@
 package io.sentry.android.replay
 
+import android.util.Log
 import io.sentry.Breadcrumb
+import io.sentry.Hint
 import io.sentry.ReplayBreadcrumbConverter
 import io.sentry.SentryLevel
+import io.sentry.SentryOptions.BeforeBreadcrumbCallback
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebEvent
 import io.sentry.rrweb.RRWebSpanEvent
+import io.sentry.util.network.NetworkRequestData
+import java.util.Collections
 import kotlin.LazyThreadSafetyMode.NONE
 
 public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   internal companion object {
+    private const val MAX_HTTP_NETWORK_DETAILS = 32
     private val snakecasePattern by lazy(NONE) { "_[a-z]".toRegex() }
     private val supportedNetworkData =
       HashSet<String>().apply {
@@ -24,10 +30,21 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
   }
 
   private var lastConnectivityState: String? = null
+  private val httpNetworkDetails =
+    Collections.synchronizedMap(
+      object : LinkedHashMap<Breadcrumb, NetworkRequestData>() {
+        override fun removeEldestEntry(
+          eldest: MutableMap.MutableEntry<Breadcrumb, NetworkRequestData>?
+        ): Boolean {
+          return size > MAX_HTTP_NETWORK_DETAILS
+        }
+      }
+    )
+  private var userBeforeBreadcrumbCallback: BeforeBreadcrumbCallback? = null
 
   override fun convert(breadcrumb: Breadcrumb): RRWebEvent? {
     var breadcrumbMessage: String? = null
-    var breadcrumbCategory: String? = null
+    val breadcrumbCategory: String?
     var breadcrumbLevel: SentryLevel? = null
     val breadcrumbData = mutableMapOf<String, Any?>()
     when {
@@ -120,10 +137,76 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     }
   }
 
-  private fun Breadcrumb.isValidForRRWebSpan(): Boolean =
-    !(data["url"] as? String).isNullOrEmpty() &&
-      SpanDataConvention.HTTP_START_TIMESTAMP in data &&
-      SpanDataConvention.HTTP_END_TIMESTAMP in data
+  override fun setUserBeforeBreadcrumbCallback(beforeBreadcrumbCallback: BeforeBreadcrumbCallback?) {
+    this.userBeforeBreadcrumbCallback = beforeBreadcrumbCallback
+  }
+
+  /** Delegate to user-provided callback (if exists) to provide the final breadcrumb to process. */
+  override fun execute(breadcrumb: Breadcrumb, hint: Hint): Breadcrumb? {
+    val callback = userBeforeBreadcrumbCallback
+    val result =
+      if (callback != null) {
+        callback.execute(breadcrumb, hint)
+      } else {
+        breadcrumb
+      }
+
+    result?.let { finalBreadcrumb ->
+      extractNetworkRequestDataFromHint(finalBreadcrumb, hint)?.let { networkData ->
+        httpNetworkDetails[finalBreadcrumb] = networkData
+      }
+    }
+
+    Log.d(
+      "SentryNetwork",
+      "SentryNetwork: BeforeBreadcrumbCallback - Hint: $hint, Breadcrumb: $result",
+    )
+    return result
+  }
+
+  private fun extractNetworkRequestDataFromHint(
+    breadcrumb: Breadcrumb,
+    breadcrumbHint: Hint,
+  ): NetworkRequestData? {
+    if (breadcrumb.type != "http" && breadcrumb.category != "http") {
+      return null
+    }
+
+    val networkDetails = breadcrumbHint.get("replay:networkDetails") as? NetworkRequestData
+    if (networkDetails != null) {
+      Log.d(
+        "SentryNetwork",
+        "SentryNetwork: Found structured NetworkRequestData in hint: $networkDetails",
+      )
+      return networkDetails
+    }
+
+    Log.d("SentryNetwork", "SentryNetwork: No structured NetworkRequestData found on hint")
+    return null
+  }
+
+  private fun Breadcrumb.isValidForRRWebSpan(): Boolean {
+    val url = data["url"] as? String
+    val hasStartTimestamp = SpanDataConvention.HTTP_START_TIMESTAMP in data
+    val hasEndTimestamp = SpanDataConvention.HTTP_END_TIMESTAMP in data
+
+    val urlValid = !url.isNullOrEmpty()
+    val isValid = urlValid && hasStartTimestamp && hasEndTimestamp
+
+    val reasons = mutableListOf<String>()
+    if (!urlValid) reasons.add("missing or empty URL")
+    if (!hasStartTimestamp) reasons.add("missing start timestamp")
+    if (!hasEndTimestamp) reasons.add("missing end timestamp")
+
+    Log.d(
+      "SentryReplay",
+      "Breadcrumb RRWeb span validation: ${if (isValid) "VALID" else "INVALID"}" +
+        if (!isValid) " (${reasons.joinToString(", ")})"
+        else "" + " - URL: ${url ?: "null"}, Category: ${category}",
+    )
+
+    return isValid
+  }
 
   private fun String.snakeToCamelCase(): String =
     replace(snakecasePattern) { it.value.last().toString().uppercase() }
@@ -132,6 +215,16 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
     val breadcrumb = this
     val httpStartTimestamp = breadcrumb.data[SpanDataConvention.HTTP_START_TIMESTAMP]
     val httpEndTimestamp = breadcrumb.data[SpanDataConvention.HTTP_END_TIMESTAMP]
+
+    // Get the NetworkRequestData if available and remove it from the map
+    val networkDetailData = httpNetworkDetails.remove(breadcrumb)
+
+    Log.d(
+      "SentryNetwork",
+      "SentryNetwork: convert(breadcrumb=${breadcrumb.type}) httpNetworkDetails map size: ${httpNetworkDetails.size}, " +
+        "found network data for current breadcrumb: ${networkDetailData != null}",
+    )
+
     return RRWebSpanEvent().apply {
       timestamp = breadcrumb.timestamp.time
       op = "resource.http"
@@ -151,6 +244,39 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
         }
 
       val breadcrumbData = mutableMapOf<String, Any?>()
+
+      // Add data from NetworkRequestData if available
+      networkDetailData?.let { networkData ->
+        networkData.method?.let { breadcrumbData["method"] = it }
+        networkData.statusCode?.let { breadcrumbData["statusCode"] = it }
+        networkData.requestBodySize?.let { breadcrumbData["requestBodySize"] = it }
+        networkData.responseBodySize?.let { breadcrumbData["responseBodySize"] = it }
+
+        networkData.request?.let { request ->
+          val requestData = mutableMapOf<String, Any?>()
+          request.size?.let { requestData["size"] = it }
+          request.body?.let { requestData["body"] = it }
+          if (request.headers.isNotEmpty()) {
+            requestData["headers"] = request.headers
+          }
+          if (requestData.isNotEmpty()) {
+            breadcrumbData["request"] = requestData
+          }
+        }
+
+        networkData.response?.let { response ->
+          val responseData = mutableMapOf<String, Any?>()
+          response.size?.let { responseData["size"] = it }
+          response.body?.let { responseData["body"] = it }
+          if (response.headers.isNotEmpty()) {
+            responseData["headers"] = response.headers
+          }
+          if (responseData.isNotEmpty()) {
+            breadcrumbData["response"] = responseData
+          }
+        }
+      }
+      // Original breadcrumb http data
       for ((key, value) in breadcrumb.data) {
         if (key in supportedNetworkData) {
           breadcrumbData[
@@ -158,6 +284,7 @@ public open class DefaultReplayBreadcrumbConverter : ReplayBreadcrumbConverter {
           ] = value
         }
       }
+
       data = breadcrumbData
     }
   }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index a12ae043154..5336740724f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -1,14 +1,21 @@
 package io.sentry.android.replay
 
 import io.sentry.Breadcrumb
+import io.sentry.Hint
 import io.sentry.SentryLevel
+import io.sentry.SentryOptions
 import io.sentry.SpanDataConvention
 import io.sentry.rrweb.RRWebBreadcrumbEvent
 import io.sentry.rrweb.RRWebSpanEvent
+import io.sentry.util.network.NetworkBody
+import io.sentry.util.network.NetworkRequestData
+import io.sentry.util.network.ReplayNetworkRequestOrResponse
 import java.util.Date
 import junit.framework.TestCase.assertEquals
 import kotlin.test.Test
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlin.test.assertSame
 
 class DefaultReplayBreadcrumbConverterTest {
   class Fixture {
@@ -318,4 +325,234 @@ class DefaultReplayBreadcrumbConverterTest {
     assertEquals(SentryLevel.ERROR, rrwebEvent.level)
     assertEquals("shiet", rrwebEvent.data!!["stuff"])
   }
+
+  // BeforeBreadcrumbCallback delegation tests
+
+  @Test
+  fun `returned breadcrumb is not modified when no user BeforeBreadcrumbCallback is provided`() {
+    val converter = fixture.getSut()
+    val breadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "test message"
+        category = "test.category"
+      }
+    val hint = Hint()
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertSame(breadcrumb, result)
+  }
+
+  @Test
+  fun `returned breadcrumb is modified according to user provided BeforeBreadcrumbCallback`() {
+    val converter = fixture.getSut()
+    val originalBreadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "original message"
+        category = "original.category"
+      }
+    val userModifiedBreadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "modified message"
+        category = "modified.category"
+      }
+    val hint = Hint()
+
+    val userBeforeBreadcrumbCallback =
+      SentryOptions.BeforeBreadcrumbCallback { _, _ -> userModifiedBreadcrumb }
+    converter.setUserBeforeBreadcrumbCallback(userBeforeBreadcrumbCallback)
+
+    val result = converter.execute(originalBreadcrumb, hint)
+
+    assertSame(userModifiedBreadcrumb, result)
+  }
+
+  @Test
+  fun `returns null when user BeforeBreadcrumbCallback returns null`() {
+    val converter = fixture.getSut()
+    val breadcrumb =
+      Breadcrumb(Date()).apply {
+        message = "test message"
+        category = "test.category"
+      }
+    val hint = Hint()
+
+    val userCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ -> null }
+    converter.setUserBeforeBreadcrumbCallback(userCallback)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertNull(result)
+  }
+
+  @Test
+  fun `network data is extracted from hint for http breadcrumbs with user callback`() {
+    val converter = fixture.getSut()
+    val httpBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "http"
+        category = "http"
+        data["url"] = "https://example.com"
+      }
+
+    val networkData =
+      NetworkRequestData(
+        "GET",
+        200,
+        100L,
+        500L,
+        ReplayNetworkRequestOrResponse(100L, null, mapOf("Content-Type" to "application/json")),
+        ReplayNetworkRequestOrResponse(500L, null, mapOf("Content-Type" to "application/json")),
+      )
+    val hint = Hint()
+    hint.set("replay:networkDetails", networkData)
+
+    val userCallback = SentryOptions.BeforeBreadcrumbCallback { b, _ -> b }
+    converter.setUserBeforeBreadcrumbCallback(userCallback)
+
+    val result = converter.execute(httpBreadcrumb, hint)
+
+    assertSame(httpBreadcrumb, result)
+  }
+
+  @Test
+  fun `network data is extracted from hint for http breadcrumbs without user callback`() {
+    val converter = fixture.getSut()
+    val httpBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "http"
+        category = "http"
+        data["url"] = "https://example.com"
+      }
+
+    val networkData =
+      NetworkRequestData(
+        "POST",
+        201,
+        200L,
+        400L,
+        ReplayNetworkRequestOrResponse(
+          200L,
+          NetworkBody.fromJsonObject(mapOf("body" to "request")),
+          mapOf(),
+        ),
+        ReplayNetworkRequestOrResponse(
+          400L,
+          NetworkBody.fromJsonObject(mapOf("body" to "response")),
+          mapOf(),
+        ),
+      )
+    val hint = Hint()
+    hint.set("replay:networkDetails", networkData)
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(httpBreadcrumb, hint)
+
+    assertSame(httpBreadcrumb, result)
+  }
+
+  @Test
+  fun `setUserBeforeBreadcrumbCallback updates the callback`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "test" }
+    val hint = Hint()
+
+    // First callback modifies the message
+    val firstCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+        b.message = "modified by first"
+        b
+      }
+    converter.setUserBeforeBreadcrumbCallback(firstCallback)
+    var result = converter.execute(breadcrumb, hint)
+    assertEquals("modified by first", result?.message)
+
+    // Second callback modifies differently
+    val secondCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, _ ->
+        b.message = "modified by second"
+        b
+      }
+    converter.setUserBeforeBreadcrumbCallback(secondCallback)
+
+    breadcrumb.message = "test" // Reset
+    result = converter.execute(breadcrumb, hint)
+    assertEquals("modified by second", result?.message)
+  }
+
+  @Test
+  fun `user callback receives same breadcrumb and hint objects`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "test" }
+    val hint = Hint()
+
+    var capturedBreadcrumb: Breadcrumb? = null
+    var capturedHint: Hint? = null
+
+    val capturingCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        capturedBreadcrumb = b
+        capturedHint = h
+        b
+      }
+    converter.setUserBeforeBreadcrumbCallback(capturingCallback)
+
+    converter.execute(breadcrumb, hint)
+
+    assertSame(breadcrumb, capturedBreadcrumb)
+    assertSame(hint, capturedHint)
+  }
+
+  @Test
+  fun `non-http breadcrumbs do not extract network data`() {
+    val converter = fixture.getSut()
+    val navigationBreadcrumb =
+      Breadcrumb(Date()).apply {
+        type = "navigation"
+        category = "navigation"
+      }
+    val hint = Hint()
+    hint.set("replay:networkDetails", NetworkRequestData("GET", 200, null, null, null, null))
+
+    converter.setUserBeforeBreadcrumbCallback(null)
+
+    val result = converter.execute(navigationBreadcrumb, hint)
+
+    assertSame(navigationBreadcrumb, result)
+    // Network data extraction only happens for http breadcrumbs
+  }
+
+  @Test
+  fun `chained callbacks work correctly`() {
+    val converter = fixture.getSut()
+    val breadcrumb = Breadcrumb(Date()).apply { message = "original" }
+    val hint = Hint()
+
+    val firstCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        b.message = "modified by first"
+        b
+      }
+
+    val secondCallback =
+      SentryOptions.BeforeBreadcrumbCallback { b, h ->
+        // This simulates what happens when ReplayBreadcrumbConverter
+        // wraps a user's callback
+        val result = firstCallback.execute(b, h)
+        result?.let {
+          it.message = "${it.message} and second"
+          it
+        }
+      }
+
+    converter.setUserBeforeBreadcrumbCallback(secondCallback)
+
+    val result = converter.execute(breadcrumb, hint)
+
+    assertNotNull(result)
+    assertEquals("modified by first and second", result.message)
+  }
 }
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index be1ee1caf37..e1c24e4a13d 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -9,6 +9,7 @@ import io.sentry.ISpan
 import io.sentry.ScopesAdapter
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryOptions.DEFAULT_PROPAGATION_TARGETS
+import io.sentry.SentryReplayOptions
 import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
 import io.sentry.TypeCheckHint.OKHTTP_REQUEST
@@ -21,9 +22,14 @@ import io.sentry.util.PropagationTargetsUtils
 import io.sentry.util.SpanUtils
 import io.sentry.util.TracingUtils
 import io.sentry.util.UrlUtils
+import io.sentry.util.network.NetworkBody
+import io.sentry.util.network.NetworkBodyParser
+import io.sentry.util.network.NetworkDetailCaptureUtils
+import io.sentry.util.network.NetworkRequestData
 import java.io.IOException
 import okhttp3.Interceptor
 import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 
 /**
@@ -53,6 +59,18 @@ public open class SentryOkHttpInterceptor(
       SentryIntegrationPackageStorage.getInstance()
         .addPackage("maven:io.sentry:sentry-okhttp", BuildConfig.VERSION_NAME)
     }
+
+    /**
+     * Fake options for testing network detail capture
+     * TODO: Remove before landing.
+     */
+    private val FAKE_OPTIONS = object {
+      val networkDetailAllowUrls: Array<String> = arrayOf(".*")
+      val networkDetailDenyUrls: Array<String>? = null
+      val networkCaptureBodies: Boolean = true
+      val networkRequestHeaders: Array<String> = arrayOf("User-Agent", "Accept", "sentry-trace", "Content-Type")
+      val networkResponseHeaders: Array<String> = arrayOf("User-Agent", "access-control-allow-origin", "x-ratelimit-resource")
+    }
   }
 
   public constructor() : this(ScopesAdapter.getInstance())
@@ -97,6 +115,13 @@ public open class SentryOkHttpInterceptor(
     var response: Response? = null
     var code: Int? = null
 
+    var networkDetailData = NetworkDetailCaptureUtils.initializeForUrl(
+      request.url.toString(),
+      request.method,
+      FAKE_OPTIONS.networkDetailAllowUrls,
+      FAKE_OPTIONS.networkDetailDenyUrls,
+    )
+
     try {
       val requestBuilder = request.newBuilder()
 
@@ -120,6 +145,40 @@ public open class SentryOkHttpInterceptor(
           }
       }
 
+      val requestContentLength = request.body?.contentLength()
+
+      networkDetailData?.setRequestDetails(
+        NetworkDetailCaptureUtils.createRequest(
+          request,
+          requestContentLength,
+          FAKE_OPTIONS.networkCaptureBodies,
+          { req ->
+            req.body?.let { originalBody ->
+              try {
+                val buffer = okio.Buffer()
+                originalBody.writeTo(buffer)
+                val bodyBytes = buffer.readByteArray()
+
+                // Create fresh RequestBody and update the request being built
+                val newRequestBody = bodyBytes.toRequestBody(originalBody.contentType())
+                requestBuilder.method(request.method, newRequestBody)
+
+                // Parse the buffered bytes into NetworkBody for capture
+                safeExtractRequestBody(bodyBytes, originalBody.contentType())
+              } catch (e: Exception) {
+                scopes.options.logger.log(
+                  io.sentry.SentryLevel.DEBUG,
+                  "Failed to buffer request body for network detail capture: ${e.message}",
+                )
+                null
+              }
+            }
+          },
+          FAKE_OPTIONS.networkRequestHeaders,
+          { req: Request -> req.headers.toMap() },
+        )
+      )
+
       request = requestBuilder.build()
       response = chain.proceed(request)
       code = response.code
@@ -153,11 +212,31 @@ public open class SentryOkHttpInterceptor(
       // this only works correctly if SentryOkHttpInterceptor is the last one in the chain
       okHttpEvent?.setRequest(request)
 
+      response?.let { response ->
+        networkDetailData?.setResponseDetails(
+          response.code,
+          NetworkDetailCaptureUtils.createResponse(
+            response,
+            response.body?.contentLength(),
+            FAKE_OPTIONS.networkCaptureBodies,
+            { resp: Response -> resp.extractResponseBody() },
+            FAKE_OPTIONS.networkResponseHeaders,
+            { resp: Response -> resp.headers.toMap() },
+          ),
+        )
+      }
+
       finishSpan(span, request, response, isFromEventListener, okHttpEvent)
 
       // The SentryOkHttpEventListener will send the breadcrumb itself if used for this call
       if (!isFromEventListener) {
-        sendBreadcrumb(request, code, response, startTimestamp)
+        sendBreadcrumb(
+          request,
+          code,
+          response,
+          startTimestamp,
+          networkDetailData,
+        )
       }
     }
   }
@@ -170,20 +249,29 @@ public open class SentryOkHttpInterceptor(
     code: Int?,
     response: Response?,
     startTimestamp: Long,
+    networkDetailData: NetworkRequestData?
   ) {
     val breadcrumb = Breadcrumb.http(request.url.toString(), request.method, code)
+
+    // Track request and response body sizes for the breadcrumb
     request.body?.contentLength().ifHasValidLength {
       breadcrumb.setData("http.request_content_length", it)
     }
 
-    val hint = Hint().also { it.set(OKHTTP_REQUEST, request) }
-    response?.let {
-      it.body?.contentLength().ifHasValidLength { responseBodySize ->
-        breadcrumb.setData(SpanDataConvention.HTTP_RESPONSE_CONTENT_LENGTH_KEY, responseBodySize)
+    response?.body?.contentLength().ifHasValidLength {
+      breadcrumb.setData(SpanDataConvention.HTTP_RESPONSE_CONTENT_LENGTH_KEY, it)
+    }
+
+    val hint =
+      Hint().also {
+        it.set(OKHTTP_REQUEST, request)
+        response?.let { resp -> it[OKHTTP_RESPONSE] = resp }
+
+        if (networkDetailData != null) {
+          it.set("replay:networkDetails", networkDetailData)
+        }
       }
 
-      hint[OKHTTP_RESPONSE] = it
-    }
     // needs this as unix timestamp for rrweb
     breadcrumb.setData(SpanDataConvention.HTTP_START_TIMESTAMP, startTimestamp)
     breadcrumb.setData(
@@ -194,6 +282,87 @@ public open class SentryOkHttpInterceptor(
     scopes.addBreadcrumb(breadcrumb, hint)
   }
 
+  /** Extracts headers from OkHttp Headers object into a map */
+  private fun okhttp3.Headers.toMap(): Map<String, String> {
+    val headers = mutableMapOf<String, String>()
+    for (name in names()) {
+      headers[name] = get(name) ?: ""
+    }
+    return headers
+  }
+
+  /**
+   * Extracts NetworkBody from already buffered request body data.
+   */
+  private fun safeExtractRequestBody(
+    bufferedBody: ByteArray?,
+    contentType: okhttp3.MediaType?,
+  ): NetworkBody? {
+    if (bufferedBody == null) {
+      return null
+    }
+
+    try {
+      val contentTypeString = contentType?.toString()
+      val maxBodySize = SentryReplayOptions.MAX_NETWORK_BODY_SIZE
+      val charset = contentType?.charset(Charsets.UTF_8)?.name() ?: "UTF-8"
+
+      return NetworkBodyParser.fromBytes(
+        bufferedBody,
+        contentTypeString,
+        charset,
+        maxBodySize,
+        scopes.options,
+      )
+    } catch (e: Exception) {
+      scopes.options.logger.log(
+        io.sentry.SentryLevel.DEBUG,
+        "Failed to parse buffered request body: ${e.message}",
+      )
+      return null
+    }
+  }
+
+  /** Extracts the body content from an OkHttp Response safely */
+  private fun Response.extractResponseBody(): NetworkBody? {
+    return body?.let { responseBody ->
+      try {
+        val contentType = responseBody.contentType()
+        val contentTypeString = contentType?.toString()
+        val maxBodySize = SentryReplayOptions.MAX_NETWORK_BODY_SIZE
+
+        val contentLength = responseBody.contentLength()
+        if (contentLength > maxBodySize * 2) {
+          scopes.options.logger.log(
+            io.sentry.SentryLevel.DEBUG,
+            "Response body too large: $contentLength bytes (max: $maxBodySize)",
+          )
+          return NetworkBody.fromString("[Response body too large: $contentLength bytes]")
+        }
+
+        // Peek at the body (doesn't consume it)
+        val peekBody = peekBody(maxBodySize.toLong())
+        val bodyBytes = peekBody.bytes()
+
+        val charset = contentType?.charset(Charsets.UTF_8)?.name() ?: "UTF-8"
+        return NetworkBodyParser.fromBytes(
+          bodyBytes,
+          contentTypeString,
+          charset,
+          maxBodySize,
+          scopes.options,
+        )
+      } catch (e: Exception) {
+        // If body reading fails, log and return null
+        scopes.options.logger.log(
+          io.sentry.SentryLevel.DEBUG,
+          "Failed to read response body safely: ${e.message}",
+        )
+        null
+      }
+    }
+  }
+
   private fun finishSpan(
     span: ISpan?,
     request: Request,
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 65445d85706..ad681855840 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -75,6 +75,9 @@
       <activity android:name=".FrameDataForSpansActivity"
         android:exported="false"/>
 
+      <activity android:name=".TriggerHttpRequestActivity"
+        android:exported="false"/>
+
         <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
         <meta-data android:name="io.sentry.dsn" android:value="https://1053864c67cc410aa1ffc9701bd6f93d@o447951.ingest.us.sentry.io/5428559" />
 
@@ -82,7 +85,7 @@
         <meta-data android:name="io.sentry.debug" android:value="${sentryDebug}" />
 
         <!--    how to disable verbose logging of the session replay feature-->
-        <meta-data android:name="io.sentry.session-replay.debug" android:value="false" />
+        <meta-data android:name="io.sentry.session-replay.debug" android:value="true" />
 
         <!--    how to set a custom debug level-->
         <!--    <meta-data android:name="io.sentry.debug.level" android:value="info" />-->
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
index 25907655f7f..5a62ed607fc 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.java
@@ -341,6 +341,9 @@ public void run() {
                   });
         });
 
+    binding.openHttpRequestActivity.setOnClickListener(
+        view -> startActivity(new Intent(this, TriggerHttpRequestActivity.class)));
+
     Sentry.logger().log(SentryLogLevel.INFO, "Creating content view");
     setContentView(binding.getRoot());
 
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
new file mode 100644
index 00000000000..14ed1d9d1dc
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TriggerHttpRequestActivity.java
@@ -0,0 +1,270 @@
+package io.sentry.samples.android;
+
+import android.os.Bundle;
+import android.text.method.ScrollingMovementMethod;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.appcompat.app.AppCompatActivity;
+import io.sentry.HttpStatusCodeRange;
+import io.sentry.Sentry;
+import io.sentry.SentryLevel;
+import io.sentry.okhttp.SentryOkHttpEventListener;
+import io.sentry.okhttp.SentryOkHttpInterceptor;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Locale;
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.ResponseBody;
+import org.json.JSONObject;
+
+public class TriggerHttpRequestActivity extends AppCompatActivity {
+
+    private EditText urlInput;
+    private TextView requestDisplay;
+    private TextView responseDisplay;
+    private ProgressBar loadingIndicator;
+    private Button getButton;
+    private Button postButton;
+    private Button clearButton;
+
+    private OkHttpClient okHttpClient;
+    private SimpleDateFormat dateFormat;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_trigger_http_request);
+
+        dateFormat = new SimpleDateFormat("HH:mm:ss.SSS", Locale.getDefault());
+
+        initializeViews();
+        setupOkHttpClient();
+        setupClickListeners();
+    }
+
+    private void initializeViews() {
+        urlInput = findViewById(R.id.url_input);
+        requestDisplay = findViewById(R.id.request_display);
+        responseDisplay = findViewById(R.id.response_display);
+        loadingIndicator = findViewById(R.id.loading_indicator);
+        getButton = findViewById(R.id.trigger_get_request);
+        postButton = findViewById(R.id.trigger_post_request);
+        clearButton = findViewById(R.id.clear_display);
+
+        requestDisplay.setMovementMethod(new ScrollingMovementMethod());
+        responseDisplay.setMovementMethod(new ScrollingMovementMethod());
+    }
+
+    private void setupOkHttpClient() {
+        // OkHttpClient with Sentry integration for monitoring HTTP requests
+        okHttpClient = new OkHttpClient.Builder()
+            .connectTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .readTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            // performance monitoring
+//            .eventListener(new SentryOkHttpEventListener())
+            // breadcrumbs and failed request capture
+            .addInterceptor(new SentryOkHttpInterceptor())
+            .build();
+    }
+
+    private void setupClickListeners() {
+        getButton.setOnClickListener(v -> performGetRequest());
+        postButton.setOnClickListener(v -> performPostRequest());
+        clearButton.setOnClickListener(v -> clearDisplays());
+    }
+
+    private void performGetRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        Request request = new Request.Builder()
+            .url(url)
+            .get()
+            .addHeader("User-Agent", "Sentry-Sample-Android")
+            .addHeader("Accept", "application/json")
+            .build();
+
+        displayRequest("GET", request);
+        executeRequest(request);
+    }
+
+    private void performPostRequest() {
+        String url = getUrl();
+        if (url.isEmpty()) {
+            Toast.makeText(this, "Please enter a URL", Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        try {
+            JSONObject json = new JSONObject();
+            json.put("message", "Hello from Sentry Android Sample");
+            json.put("timestamp", System.currentTimeMillis());
+            json.put("device", android.os.Build.MODEL);
+
+            RequestBody body = RequestBody.create(
+                json.toString(),
+                MediaType.get("application/json; charset=utf-8")
+            );
+
+            Request request = new Request.Builder()
+                .url(url)
+                .post(body)
+                .addHeader("User-Agent", "Sentry-Sample-Android")
+                .addHeader("Content-Type", "application/json")
+                .addHeader("Accept", "application/json")
+                .build();
+
+            displayRequest("POST", request, json.toString(2));
+            executeRequest(request);
+        } catch (Exception e) {
+            Sentry.captureException(e);
+            Toast.makeText(this, "Error creating request: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private void executeRequest(Request request) {
+        showLoading(true);
+
+        okHttpClient.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Call call, IOException e) {
+                Sentry.captureException(e);
+                runOnUiThread(() -> {
+                    showLoading(false);
+                    displayResponse(
+                        "ERROR",
+                        null,
+                        "Request failed: " + e.getMessage(),
+                        0
+                    );
+                });
+            }
+
+            @Override
+            public void onResponse(Call call, Response response) throws IOException {
+                final long startTime = System.currentTimeMillis();
+                final int statusCode = response.code();
+                final String statusMessage = response.message();
+                ResponseBody responseBody = response.body();
+                String body = "";
+
+                try {
+                    if (responseBody != null) {
+                        body = responseBody.string();
+                    }
+                } catch (IOException e) {
+                    body = "Error reading response body: " + e.getMessage();
+                    Sentry.captureException(e);
+                }
+
+                final long responseTime = System.currentTimeMillis() - startTime;
+                final String finalBody = body;
+
+                runOnUiThread(() -> {
+                    showLoading(false);
+                    displayResponse(statusMessage, statusCode, finalBody, responseTime);
+                });
+
+                response.close();
+            }
+        });
+    }
+
+    private void displayRequest(String method, Request request) {
+        displayRequest(method, request, null);
+    }
+
+    private void displayRequest(String method, Request request, String body) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[").append(getCurrentTime()).append("]\n");
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━\n");
+        sb.append("METHOD: ").append(method).append("\n");
+        sb.append("URL: ").append(request.url()).append("\n\n");
+        sb.append("HEADERS:\n");
+
+        for (int i = 0; i < request.headers().size(); i++) {
+            sb.append("  ").append(request.headers().name(i)).append(": ")
+              .append(request.headers().value(i)).append("\n");
+        }
+
+        if (body != null && !body.isEmpty()) {
+            sb.append("\nBODY:\n").append(body).append("\n");
+        }
+
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━");
+
+        requestDisplay.setText(sb.toString());
+    }
+
+    private void displayResponse(String status, Integer code, String body, long responseTime) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("[").append(getCurrentTime()).append("]\n");
+        sb.append("━━━━━━━━━━━━━━━━━━━━━━━━\n");
+
+        if (code != null) {
+            sb.append("STATUS: ").append(code).append(" ").append(status).append("\n");
+            sb.append("RESPONSE TIME: ").append(responseTime).append("ms\n\n");
+        } else {
+            sb.append("STATUS: ").append(status).append("\n\n");
+        }
+
+        if (body != null && !body.isEmpty()) {
+            try {
+                if (body.trim().startsWith("{") || body.trim().startsWith("[")) {
+                    JSONObject json = new JSONObject(body);
+                    sb.append("BODY (JSON):\n").append(json.toString(2));
+                } else {
+                    sb.append("BODY:\n").append(body);
+                }
+            } catch (Exception e) {
+                sb.append("BODY:\n").append(body);
+            }
+        }
+
+        sb.append("\n━━━━━━━━━━━━━━━━━━━━━━━━");
+
+        responseDisplay.setText(sb.toString());
+    }
+
+    private void clearDisplays() {
+        requestDisplay.setText("No request yet...");
+        responseDisplay.setText("No response yet...");
+    }
+
+    private String getUrl() {
+        String url = urlInput.getText().toString().trim();
+        if (url.isEmpty()) {
+            return "https://api.github.com/users/getsentry";
+        }
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            url = "https://" + url;
+        }
+        return url;
+    }
+
+    private void showLoading(boolean show) {
+        loadingIndicator.setVisibility(show ? View.VISIBLE : View.GONE);
+        getButton.setEnabled(!show);
+        postButton.setEnabled(!show);
+    }
+
+    private String getCurrentTime() {
+        return dateFormat.format(new Date());
+    }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
index 0083fae8f93..64e35b12748 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_main.xml
@@ -176,6 +176,12 @@
       android:layout_height="wrap_content"
       android:text="@string/check_for_update"/>
 
+    <Button
+      android:id="@+id/open_http_request_activity"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="@string/open_http_request_activity"/>
+
   </LinearLayout>
 
 </ScrollView>
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
new file mode 100644
index 00000000000..ee216d4ae47
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_trigger_http_request.xml
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:fillViewport="true"
+  tools:context=".TriggerHttpRequestActivity">
+
+  <LinearLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:padding="16dp">
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="HTTP Request Debugger"
+      android:textSize="24sp"
+      android:textStyle="bold"
+      android:layout_marginBottom="16dp"/>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <EditText
+        android:id="@+id/url_input"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:hint="Enter URL (or use default)"
+        android:text="https://api.github.com/users/getsentry"
+        android:inputType="textUri"/>
+
+    </LinearLayout>
+
+    <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      android:layout_marginBottom="16dp">
+
+      <Button
+        android:id="@+id/trigger_get_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="GET Request"
+        android:layout_marginEnd="8dp"/>
+
+      <Button
+        android:id="@+id/trigger_post_request"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="POST Request"
+        android:layout_marginStart="8dp"/>
+
+    </LinearLayout>
+
+    <Button
+      android:id="@+id/clear_display"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="Clear"
+      android:layout_marginBottom="16dp"/>
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="REQUEST:"
+      android:textStyle="bold"
+      android:textSize="16sp"
+      android:layout_marginBottom="8dp"/>
+
+    <TextView
+      android:id="@+id/request_display"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:padding="12dp"
+      android:textSize="12sp"
+      android:textColor="@android:color/holo_blue_dark"
+      android:background="#F0F8FF"
+      android:fontFamily="monospace"
+      android:scrollbars="vertical"
+      android:text="No request yet..."
+      android:layout_marginBottom="16dp"/>
+
+    <TextView
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:text="RESPONSE:"
+      android:textStyle="bold"
+      android:textSize="16sp"
+      android:layout_marginBottom="8dp"/>
+
+    <TextView
+      android:id="@+id/response_display"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:padding="12dp"
+      android:textSize="12sp"
+      android:textColor="@android:color/holo_green_dark"
+      android:background="#F0FFF0"
+      android:fontFamily="monospace"
+      android:scrollbars="vertical"
+      android:text="No response yet..."
+      android:layout_marginBottom="16dp"/>
+
+    <ProgressBar
+      android:id="@+id/loading_indicator"
+      android:layout_width="wrap_content"
+      android:layout_height="wrap_content"
+      android:layout_gravity="center"
+      android:visibility="gone"/>
+
+  </LinearLayout>
+
+</ScrollView>
\ No newline at end of file
diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
index fe984bbff13..da326e9450d 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
@@ -50,4 +50,6 @@ Nulla interdum gravida augue, vel fringilla lorem bibendum vel. In hac habitasse
   <string name="profiling_no_dir_set">No profiling dir path set</string>
   <string name="profiling_start">Start Profiling</string>
   <string name="profiling_result">Profile trace file size = %d bytes \nItem payload size = %d bytes \nData sent to Sentry size = %d bytes</string>
+  <string name="open_http_request_activity">Open Trigger HTTP Request Activity</string>
+  <string name="trigger_okhttp_request">Trigger OkHttp Request</string>
 </resources>
diff --git a/sentry/src/main/java/io/sentry/Breadcrumb.java b/sentry/src/main/java/io/sentry/Breadcrumb.java
index d5bb66d33e1..d3b30b0222b 100644
--- a/sentry/src/main/java/io/sentry/Breadcrumb.java
+++ b/sentry/src/main/java/io/sentry/Breadcrumb.java
@@ -721,8 +721,9 @@ public boolean equals(Object o) {
   }
 
   @Override
+  @SuppressWarnings("JavaUtilDate")
   public int hashCode() {
-    return Objects.hash(timestamp, message, type, category, origin, level);
+    return Objects.hash(getTimestamp().getTime(), message, type, category, origin, level);
   }
 
   // region json
diff --git a/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java b/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
index d71a57e440f..4d1d4ee886a 100644
--- a/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
+++ b/sentry/src/main/java/io/sentry/NoOpReplayBreadcrumbConverter.java
@@ -18,4 +18,14 @@ private NoOpReplayBreadcrumbConverter() {}
   public @Nullable RRWebEvent convert(final @NotNull Breadcrumb breadcrumb) {
     return null;
   }
+
+  @Override
+  public void setUserBeforeBreadcrumbCallback(
+      SentryOptions.@Nullable BeforeBreadcrumbCallback beforeBreadcrumbCallback) {}
+
+  @Override
+  public @Nullable Breadcrumb execute(
+      final @NotNull Breadcrumb breadcrumb, final @NotNull Hint hint) {
+    return breadcrumb;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java b/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
index dadd5d9b6fd..adada160cbe 100644
--- a/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
+++ b/sentry/src/main/java/io/sentry/ReplayBreadcrumbConverter.java
@@ -5,8 +5,17 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * ReplayBreadcrumbConverter will always be the registered {@link
+ * io.sentry.SentryOptions.BeforeBreadcrumbCallback} for extending replays with data from breadcrumb
+ * {@link io.sentry.Hint}s. As such, implementations need to wrap and delegate to any user-provided
+ * BeforeBreadcrumbCallback {@link ReplayBreadcrumbConverter#setUserBeforeBreadcrumbCallback} .
+ */
 @ApiStatus.Internal
-public interface ReplayBreadcrumbConverter {
+public interface ReplayBreadcrumbConverter extends SentryOptions.BeforeBreadcrumbCallback {
   @Nullable
   RRWebEvent convert(@NotNull Breadcrumb breadcrumb);
+
+  void setUserBeforeBreadcrumbCallback(
+      @Nullable SentryOptions.BeforeBreadcrumbCallback beforeBreadcrumbCallback);
 }
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index 3cddf4705ab..87abfda537f 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -20,6 +20,13 @@ public final class SentryReplayOptions {
   public static final String EXOPLAYER_STYLED_CLASS_NAME =
       "com.google.android.exoplayer2.ui.StyledPlayerView";
 
+  /**
+   * Maximum size in bytes for network request/response bodies to be captured in replays. Bodies
+   * larger than this will be truncated or replaced with a placeholder message. Default is 150KB
+   * (153600 bytes).
+   */
+  @ApiStatus.Internal public static final int MAX_NETWORK_BODY_SIZE = 150 * 1024;
+
   public enum SentryReplayQuality {
     /** Video Scale: 80% Bit Rate: 50.000 JPEG Compression: 10 */
     LOW(0.8f, 50_000, 10),
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
new file mode 100644
index 00000000000..6fb6f56002d
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -0,0 +1,219 @@
+package io.sentry.util.network;
+
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Represents the body content of a network request or response. Can be one of: JSON object, JSON
+ * array, or string.
+ *
+ * <p>See
+ * https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts
+ */
+public interface NetworkBody {
+
+  /**
+   * Creates a NetworkBody from a JSON object.
+   *
+   * @param value The map representing the JSON object
+   * @return A NetworkBody instance for the JSON object
+   */
+  static @NotNull NetworkBody fromJsonObject(@NotNull Map<String, Object> value) {
+    return new JsonObjectImpl(value);
+  }
+
+  /**
+   * Creates a NetworkBody from a JSON array.
+   *
+   * @param value The list representing the JSON array
+   * @return A NetworkBody instance for the JSON array
+   */
+  static @NotNull NetworkBody fromJsonArray(@NotNull List<Object> value) {
+    return new JsonArrayImpl(value);
+  }
+
+  /**
+   * Creates a NetworkBody from string content.
+   *
+   * @param value The string content
+   * @return A NetworkBody instance for the string
+   */
+  static @NotNull NetworkBody fromString(@NotNull String value) {
+    return new StringBodyImpl(value);
+  }
+
+  /**
+   * Gets the underlying value of this NetworkBody.
+   *
+   * @return The value as an Object (could be Map, List, or String)
+   */
+  @NotNull
+  Object getValue();
+
+  /**
+   * Checks if this NetworkBody represents a JSON object.
+   *
+   * @return true if this is a JSON object
+   */
+  default boolean isJsonObject() {
+    return getValue() instanceof Map;
+  }
+
+  /**
+   * Checks if this NetworkBody represents a JSON array.
+   *
+   * @return true if this is a JSON array
+   */
+  default boolean isJsonArray() {
+    return getValue() instanceof List;
+  }
+
+  /**
+   * Checks if this NetworkBody represents string content.
+   *
+   * @return true if this is a string
+   */
+  default boolean isString() {
+    return getValue() instanceof String;
+  }
+
+  /**
+   * Gets the value as a JSON object (Map).
+   *
+   * @return The Map if this is a JSON object, null otherwise
+   */
+  default @Nullable Map<String, Object> asJsonObject() {
+    Object value = getValue();
+    if (value instanceof Map) {
+      @SuppressWarnings("unchecked")
+      Map<String, Object> map = (Map<String, Object>) value;
+      return map;
+    }
+    return null;
+  }
+
+  /**
+   * Gets the value as a JSON array (List).
+   *
+   * @return The List if this is a JSON array, null otherwise
+   */
+  default @Nullable List<Object> asJsonArray() {
+    Object value = getValue();
+    if (value instanceof List) {
+      @SuppressWarnings("unchecked")
+      List<Object> list = (List<Object>) value;
+      return list;
+    }
+    return null;
+  }
+
+  /**
+   * Gets the value as a string.
+   *
+   * @return The String if this is string content, null otherwise
+   */
+  default @Nullable String asString() {
+    Object value = getValue();
+    return value instanceof String ? (String) value : null;
+  }
+
+  // Private implementation classes
+
+  /** Implementation for JSON object bodies */
+  final class JsonObjectImpl implements NetworkBody {
+    private final @NotNull Map<String, Object> value;
+
+    JsonObjectImpl(@NotNull Map<String, Object> value) {
+      this.value = value;
+    }
+
+    @Override
+    public @NotNull Map<String, Object> getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "NetworkBody.JsonObject{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof JsonObjectImpl)) return false;
+      JsonObjectImpl that = (JsonObjectImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
+    }
+  }
+
+  /** Implementation for JSON array bodies */
+  final class JsonArrayImpl implements NetworkBody {
+    private final @NotNull List<Object> value;
+
+    JsonArrayImpl(@NotNull List<Object> value) {
+      this.value = value;
+    }
+
+    @Override
+    public @NotNull List<Object> getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "NetworkBody.JsonArray{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof JsonArrayImpl)) return false;
+      JsonArrayImpl that = (JsonArrayImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
+    }
+  }
+
+  /** Implementation for string bodies */
+  final class StringBodyImpl implements NetworkBody {
+    private final @NotNull String value;
+
+    StringBodyImpl(@NotNull String value) {
+      this.value = value;
+    }
+
+    @Override
+    public @NotNull String getValue() {
+      return value;
+    }
+
+    @Override
+    public String toString() {
+      return "NetworkBody.StringBody{" + value + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) return true;
+      if (!(obj instanceof StringBodyImpl)) return false;
+      StringBodyImpl that = (StringBodyImpl) obj;
+      return value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return value.hashCode();
+    }
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
new file mode 100644
index 00000000000..9620aa4da75
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
@@ -0,0 +1,178 @@
+package io.sentry.util.network;
+
+import io.sentry.JsonObjectReader;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import java.io.StringReader;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** Utility class for parsing and creating NetworkBody instances. */
+public final class NetworkBodyParser {
+
+  private NetworkBodyParser() {}
+
+  /**
+   * Creates a NetworkBody from raw bytes with content type information. This is useful for handling
+   * binary or unknown content types.
+   *
+   * @param bytes The raw bytes of the body
+   * @param contentType Optional content type hint to help with parsing
+   * @param charset Optional charset to use for text conversion (defaults to UTF-8)
+   * @param maxSizeBytes Maximum size to process
+   * @param logger Optional logger
+   * @return A NetworkBody or null if bytes are null/empty
+   */
+  public static @Nullable NetworkBody fromBytes(
+      @Nullable byte[] bytes,
+      @Nullable String contentType,
+      @Nullable String charset,
+      int maxSizeBytes,
+      @Nullable SentryOptions logger) {
+
+    if (bytes == null || bytes.length == 0) {
+      return null;
+    }
+
+    // Check binary content type
+    if (contentType != null && isBinaryContentType(contentType)) {
+      // For binary content, return a description instead of the actual content
+      return NetworkBody.fromString(
+          "[Binary data, " + bytes.length + " bytes, type: " + contentType + "]");
+    }
+
+    // Convert to string and parse
+    try {
+      String effectiveCharset = charset != null ? charset : "UTF-8";
+      String content = new String(bytes, effectiveCharset);
+      return parse(content, contentType, maxSizeBytes, logger);
+    } catch (UnsupportedEncodingException e) {
+      if (logger != null) {
+        logger.getLogger().log(SentryLevel.DEBUG, "Failed to decode bytes: " + e.getMessage());
+      }
+      return NetworkBody.fromString("[Failed to decode bytes, " + bytes.length + " bytes]");
+    }
+  }
+
+  private static @Nullable NetworkBody parse(
+      @Nullable String content,
+      @Nullable String contentType,
+      int maxSizeBytes,
+      @Nullable SentryOptions logger) {
+
+    if (content == null || content.isEmpty()) {
+      return null;
+    }
+
+    // Check size limit
+    if (content.getBytes(StandardCharsets.UTF_8).length > maxSizeBytes) {
+      if (logger != null) {
+        logger
+            .getLogger()
+            .log(SentryLevel.DEBUG, "Content exceeds max size limit of " + maxSizeBytes + " bytes");
+      }
+      // Return truncated string
+      int truncateAt = Math.min(content.length(), maxSizeBytes);
+      return NetworkBody.fromString(content.substring(0, truncateAt) + "...[truncated]");
+    }
+
+    // Handle based on content type hint if provided
+    if (contentType != null) {
+      String lowerContentType = contentType.toLowerCase();
+
+      if (lowerContentType.contains("application/x-www-form-urlencoded")) {
+        return parseFormUrlEncoded(content, logger);
+      }
+
+      if (lowerContentType.contains("xml")) {
+        // For XML, return as string (could be enhanced to parse XML structure)
+        return NetworkBody.fromString(content);
+      }
+    }
+
+    // Try to parse as JSON using the existing JsonObjectReader
+    String trimmed = content.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try (JsonObjectReader reader = new JsonObjectReader(new StringReader(trimmed))) {
+        Object parsed = reader.nextObjectOrNull();
+        if (parsed instanceof Map) {
+          @SuppressWarnings("unchecked")
+          Map<String, Object> map = (Map<String, Object>) parsed;
+          return NetworkBody.fromJsonObject(map);
+        } else if (parsed instanceof List) {
+          @SuppressWarnings("unchecked")
+          List<Object> list = (List<Object>) parsed;
+          return NetworkBody.fromJsonArray(list);
+        }
+      } catch (Exception e) {
+        if (logger != null) {
+          logger.getLogger().log(SentryLevel.DEBUG, "Failed to parse JSON: " + e.getMessage());
+        }
+      }
+    }
+
+    // Default to string representation
+    return NetworkBody.fromString(content);
+  }
+
+  /** Parses URL-encoded form data into a JsonObject NetworkBody. */
+  private static @Nullable NetworkBody parseFormUrlEncoded(
+      @NotNull String content, @Nullable SentryOptions logger) {
+    try {
+      Map<String, Object> params = new HashMap<>();
+      String[] pairs = content.split("&", -1);
+
+      for (String pair : pairs) {
+        int idx = pair.indexOf("=");
+        if (idx > 0) {
+          String key = URLDecoder.decode(pair.substring(0, idx), "UTF-8");
+          String value =
+              idx < pair.length() - 1 ? URLDecoder.decode(pair.substring(idx + 1), "UTF-8") : "";
+
+          // Handle multiple values for the same key
+          if (params.containsKey(key)) {
+            Object existing = params.get(key);
+            if (existing instanceof List) {
+              @SuppressWarnings("unchecked")
+              List<String> list = (List<String>) existing;
+              list.add(value);
+            } else {
+              List<String> list = new ArrayList<>();
+              list.add((String) existing);
+              list.add(value);
+              params.put(key, list);
+            }
+          } else {
+            params.put(key, value);
+          }
+        }
+      }
+
+      return NetworkBody.fromJsonObject(params);
+    } catch (UnsupportedEncodingException e) {
+      if (logger != null) {
+        logger.getLogger().log(SentryLevel.DEBUG, "Failed to parse form data: " + e.getMessage());
+      }
+      return null;
+    }
+  }
+
+  /** Checks if the content type is binary and shouldn't be converted to string. */
+  private static boolean isBinaryContentType(@NotNull String contentType) {
+    String lower = contentType.toLowerCase();
+    return lower.contains("image/")
+        || lower.contains("video/")
+        || lower.contains("audio/")
+        || lower.contains("application/octet-stream")
+        || lower.contains("application/pdf")
+        || lower.contains("application/zip")
+        || lower.contains("application/gzip");
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
new file mode 100644
index 00000000000..065fa34309d
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
@@ -0,0 +1,155 @@
+package io.sentry.util.network;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Utility class for network capture operations shared across HTTP client integrations. Provides
+ * common logic for determining what network data to capture and filtering headers.
+ */
+public final class NetworkDetailCaptureUtils {
+
+  private NetworkDetailCaptureUtils() {}
+
+  /** Functional interface for extracting network body content from HTTP objects. */
+  public interface NetworkBodyExtractor<T> {
+    @Nullable
+    NetworkBody extract(@NotNull T httpObject);
+  }
+
+  /** Functional interface for extracting headers from HTTP objects. */
+  public interface NetworkHeaderExtractor<T> {
+    @NotNull
+    Map<String, String> extract(@NotNull T httpObject);
+  }
+
+  public static @Nullable NetworkRequestData initializeForUrl(
+      @NotNull String url,
+      @Nullable String method,
+      @Nullable String[] networkDetailAllowUrls,
+      @Nullable String[] networkDetailDenyUrls) {
+
+    if (!shouldCaptureUrl(url, networkDetailAllowUrls, networkDetailDenyUrls)) {
+      return null;
+    }
+
+    return new NetworkRequestData(method, null, null, null, null, null);
+  }
+
+  /**
+   * Creates a ReplayNetworkRequestOrResponse for a request, extracting body and headers based on
+   * configuration.
+   */
+  public static <T> @NotNull ReplayNetworkRequestOrResponse createRequest(
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] networkRequestHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    return createRequestOrResponseInternal(
+        httpObject,
+        bodySize,
+        networkCaptureBodies,
+        bodyExtractor,
+        networkRequestHeaders,
+        headerExtractor);
+  }
+
+  public static <T> @NotNull ReplayNetworkRequestOrResponse createResponse(
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] networkResponseHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    return createRequestOrResponseInternal(
+        httpObject,
+        bodySize,
+        networkCaptureBodies,
+        bodyExtractor,
+        networkResponseHeaders,
+        headerExtractor);
+  }
+
+  /**
+   * Determines if detailed network data should be captured for the given URL. See
+   * <a href="https://docs.sentry.io/platforms/javascript/session-replay/configuration/">docs.sentry.io</a>
+   *
+   * @param url The URL to check
+   * @param networkDetailAllowUrls Array of regex patterns that allow capture (null means allow all)
+   * @param networkDetailDenyUrls Array of regex patterns that deny capture (null means deny none)
+   * @return true if the URL should be captured, false otherwise
+   */
+  private static boolean shouldCaptureUrl(
+      @NotNull String url,
+      @Nullable String[] networkDetailAllowUrls,
+      @Nullable String[] networkDetailDenyUrls) {
+
+    // If there are deny patterns and URL matches any, don't capture.
+    if (networkDetailDenyUrls != null) {
+      for (String pattern : networkDetailDenyUrls) {
+        if (pattern != null && url.matches(pattern)) {
+          return false;
+        }
+      }
+    }
+
+    // Only capture developer-provided urls.
+    if (networkDetailAllowUrls == null) {
+      return false;
+    }
+
+    // If there are allow patterns, URL must match at least one
+    for (String pattern : networkDetailAllowUrls) {
+      if (pattern != null && url.matches(pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private static @NotNull Map<String, String> getCaptureHeaders(
+      @Nullable Map<String, String> allHeaders, @NotNull String[] allowedHeaders) {
+
+    Map<String, String> capturedHeaders = new HashMap<>();
+
+    if (allHeaders == null) {
+      return capturedHeaders;
+    }
+
+    for (String header : allowedHeaders) {
+      String value = allHeaders.get(header);
+      if (value != null) {
+        capturedHeaders.put(header, value);
+      }
+    }
+
+    return capturedHeaders;
+  }
+
+  private static <T> @NotNull ReplayNetworkRequestOrResponse createRequestOrResponseInternal(
+      @NotNull T httpObject,
+      @Nullable Long bodySize,
+      boolean networkCaptureBodies,
+      @NotNull NetworkBodyExtractor<T> bodyExtractor,
+      @NotNull String[] allowedHeaders,
+      @NotNull NetworkHeaderExtractor<T> headerExtractor) {
+
+    NetworkBody body = null;
+
+    if (networkCaptureBodies) {
+      body = bodyExtractor.extract(httpObject);
+    }
+
+    Map<String, String> headers =
+        getCaptureHeaders(headerExtractor.extract(httpObject), allowedHeaders);
+
+    return new ReplayNetworkRequestOrResponse(bodySize, body, headers);
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
new file mode 100644
index 00000000000..397cb402147
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkRequestData.java
@@ -0,0 +1,99 @@
+package io.sentry.util.network;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
+
+/**
+ * Data class for tracking network request and response information in replays. Used by various HTTP
+ * integrations (OkHttp, Apache HttpClient, etc.) to capture network data for replay functionality.
+ * see
+ * https://github.com/getsentry/sentry-javascript/blob/632f0b953d99050c11b0edafb9f80b5f3ba88045/packages/replay-internal/src/types/performance.ts#L133-L140
+ */
+public final class NetworkRequestData {
+  private @Nullable String method;
+  private @Nullable Integer statusCode;
+  private @Nullable Long requestBodySize;
+  private @Nullable Long responseBodySize;
+  private @Nullable ReplayNetworkRequestOrResponse request;
+  private @Nullable ReplayNetworkRequestOrResponse response;
+
+  @VisibleForTesting
+  public NetworkRequestData(
+      @Nullable String method,
+      @Nullable Integer statusCode,
+      @Nullable Long requestBodySize,
+      @Nullable Long responseBodySize,
+      @Nullable ReplayNetworkRequestOrResponse request,
+      @Nullable ReplayNetworkRequestOrResponse response) {
+    this.method = method;
+    this.statusCode = statusCode;
+    this.requestBodySize = requestBodySize;
+    this.responseBodySize = responseBodySize;
+    this.request = request;
+    this.response = response;
+  }
+
+  public @Nullable String getMethod() {
+    return method;
+  }
+
+  public @Nullable Integer getStatusCode() {
+    return statusCode;
+  }
+
+  public @Nullable Long getRequestBodySize() {
+    return requestBodySize;
+  }
+
+  public @Nullable Long getResponseBodySize() {
+    return responseBodySize;
+  }
+
+  public @Nullable ReplayNetworkRequestOrResponse getRequest() {
+    return request;
+  }
+
+  public @Nullable ReplayNetworkRequestOrResponse getResponse() {
+    return response;
+  }
+
+  /**
+   * Populates this instance with request details obtained via {@link
+   * NetworkDetailCaptureUtils#createRequest}
+   */
+  public void setRequestDetails(@NotNull ReplayNetworkRequestOrResponse requestData) {
+    this.request = requestData;
+    this.requestBodySize = requestData.getSize();
+  }
+
+  /**
+   * Populates this instance with request details obtained via {@link
+   * NetworkDetailCaptureUtils#createResponse}
+   */
+  public void setResponseDetails(
+      int statusCode, @NotNull ReplayNetworkRequestOrResponse responseData) {
+    this.statusCode = statusCode;
+    this.response = responseData;
+    this.responseBodySize = responseData.getSize();
+  }
+
+  @Override
+  public String toString() {
+    return "NetworkRequestData{"
+        + "method='"
+        + method
+        + '\''
+        + ", statusCode="
+        + statusCode
+        + ", requestBodySize="
+        + requestBodySize
+        + ", responseBodySize="
+        + responseBodySize
+        + ", request="
+        + request
+        + ", response="
+        + response
+        + '}';
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
new file mode 100644
index 00000000000..0c99481f145
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/network/ReplayNetworkRequestOrResponse.java
@@ -0,0 +1,47 @@
+package io.sentry.util.network;
+
+import java.util.Collections;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Data class for tracking HTTP request or response information in replays. See
+ * <a href="https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/types/request.ts">JS SDK types</a>
+ */
+public final class ReplayNetworkRequestOrResponse {
+  private final @Nullable Long size;
+  private final @Nullable NetworkBody body;
+  private final @NotNull Map<String, String> headers;
+
+  public ReplayNetworkRequestOrResponse(
+      @Nullable Long size, @Nullable NetworkBody body, @NotNull Map<String, String> headers) {
+    this.size = size;
+    this.body = body;
+    this.headers = headers;
+  }
+
+  public @Nullable Long getSize() {
+    return size;
+  }
+
+  public @Nullable NetworkBody getBody() {
+    return body;
+  }
+
+  public @NotNull Map<String, String> getHeaders() {
+    return headers;
+  }
+
+  @Override
+  public String toString() {
+    return "ReplayNetworkRequestOrResponse{"
+        + "size="
+        + size
+        + ", body="
+        + body
+        + ", headers="
+        + headers
+        + '}';
+  }
+}