diff --git a/Sentry.xcodeproj/project.pbxproj b/Sentry.xcodeproj/project.pbxproj
index c6fd97719aa..e972a73648d 100644
--- a/Sentry.xcodeproj/project.pbxproj
+++ b/Sentry.xcodeproj/project.pbxproj
@@ -743,6 +743,9 @@
 		A8F17B2E2901765900990B25 /* SentryRequest.m in Sources */ = {isa = PBXBuildFile; fileRef = A8F17B2D2901765900990B25 /* SentryRequest.m */; };
 		A8F17B342902870300990B25 /* SentryHttpStatusCodeRange.m in Sources */ = {isa = PBXBuildFile; fileRef = A8F17B332902870300990B25 /* SentryHttpStatusCodeRange.m */; };
 		D8019910286B089000C277F0 /* SentryCrashReportSinkTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D801990F286B089000C277F0 /* SentryCrashReportSinkTests.swift */; };
+		D80694C42B7CC9AE00B820E6 /* SentryReplayEventTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80694C22B7CC86E00B820E6 /* SentryReplayEventTests.swift */; };
+		D80694C72B7CD22B00B820E6 /* SentryReplayRecordingTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80694C52B7CCFA100B820E6 /* SentryReplayRecordingTests.swift */; };
+		D80694CA2B7CD65800B820E6 /* SentryReplayEnvelopeItemHeaderTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D80694C82B7CD65500B820E6 /* SentryReplayEnvelopeItemHeaderTests.swift */; };
 		D808FB88281AB33C009A2A33 /* SentryUIEventTrackerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D808FB86281AB31D009A2A33 /* SentryUIEventTrackerTests.swift */; };
 		D808FB8B281BCE96009A2A33 /* TestSentrySwizzleWrapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = D808FB89281BCE46009A2A33 /* TestSentrySwizzleWrapper.swift */; };
 		D808FB92281BF6EC009A2A33 /* SentryUIEventTrackingIntegrationTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D808FB90281BF6E9009A2A33 /* SentryUIEventTrackingIntegrationTests.swift */; };
@@ -791,6 +794,8 @@
 		D867063E27C3BC2400048851 /* SentryCoreDataSwizzling.h in Headers */ = {isa = PBXBuildFile; fileRef = D867063B27C3BC2400048851 /* SentryCoreDataSwizzling.h */; };
 		D867063F27C3BC2400048851 /* SentryCoreDataTracker.h in Headers */ = {isa = PBXBuildFile; fileRef = D867063C27C3BC2400048851 /* SentryCoreDataTracker.h */; };
 		D86B6835294348A400B8B1FC /* SentryAttachment+Private.h in Headers */ = {isa = PBXBuildFile; fileRef = D86B6834294348A400B8B1FC /* SentryAttachment+Private.h */; };
+		D86B7B5C2B7A529C0017E8D9 /* SentryReplayEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = D86B7B5A2B7A529C0017E8D9 /* SentryReplayEvent.h */; };
+		D86B7B5D2B7A529C0017E8D9 /* SentryReplayEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = D86B7B5B2B7A529C0017E8D9 /* SentryReplayEvent.m */; };
 		D86F419827C8FEFA00490520 /* SentryCoreDataTrackerExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = D86F419727C8FEFA00490520 /* SentryCoreDataTrackerExtension.swift */; };
 		D8751FA5274743710032F4DE /* SentryNSURLSessionTaskSearchTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D8751FA4274743710032F4DE /* SentryNSURLSessionTaskSearchTests.swift */; };
 		D875ED0B276CC84700422FAC /* SentryNSDataTrackerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D875ED0A276CC84700422FAC /* SentryNSDataTrackerTests.swift */; };
@@ -801,6 +806,10 @@
 		D88817D826D7149100BF2251 /* SentryTraceContext.m in Sources */ = {isa = PBXBuildFile; fileRef = D88817D626D7149100BF2251 /* SentryTraceContext.m */; };
 		D88817DA26D72AB800BF2251 /* SentryTraceContext.h in Headers */ = {isa = PBXBuildFile; fileRef = D88817D926D72AB800BF2251 /* SentryTraceContext.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		D88817DD26D72BA500BF2251 /* SentryTraceStateTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = D88817DB26D72B7B00BF2251 /* SentryTraceStateTests.swift */; };
+		D88D6C1D2B7B5A8800C8C633 /* SentryReplayRecording.h in Headers */ = {isa = PBXBuildFile; fileRef = D88D6C1B2B7B5A8800C8C633 /* SentryReplayRecording.h */; };
+		D88D6C1E2B7B5A8800C8C633 /* SentryReplayRecording.m in Sources */ = {isa = PBXBuildFile; fileRef = D88D6C1C2B7B5A8800C8C633 /* SentryReplayRecording.m */; };
+		D88D6C212B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.h in Headers */ = {isa = PBXBuildFile; fileRef = D88D6C1F2B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.h */; };
+		D88D6C222B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.m in Sources */ = {isa = PBXBuildFile; fileRef = D88D6C202B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.m */; };
 		D8918B222849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift in Sources */ = {isa = PBXBuildFile; fileRef = D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */; };
 		D8AB40DB2806EC1900E5E9F7 /* SentryScreenshotIntegration.h in Headers */ = {isa = PBXBuildFile; fileRef = D8AB40DA2806EC1900E5E9F7 /* SentryScreenshotIntegration.h */; };
 		D8ABB0BC29264275005D1E24 /* Sentry.swift in Sources */ = {isa = PBXBuildFile; fileRef = D81A349B291D0C0B005A27A9 /* Sentry.swift */; };
@@ -1724,6 +1733,9 @@
 		A8F17B332902870300990B25 /* SentryHttpStatusCodeRange.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryHttpStatusCodeRange.m; sourceTree = "<group>"; };
 		D800942628F82F3A005D3943 /* SwiftDescriptor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SwiftDescriptor.swift; sourceTree = "<group>"; };
 		D801990F286B089000C277F0 /* SentryCrashReportSinkTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryCrashReportSinkTests.swift; sourceTree = "<group>"; };
+		D80694C22B7CC86E00B820E6 /* SentryReplayEventTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryReplayEventTests.swift; sourceTree = "<group>"; };
+		D80694C52B7CCFA100B820E6 /* SentryReplayRecordingTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryReplayRecordingTests.swift; sourceTree = "<group>"; };
+		D80694C82B7CD65500B820E6 /* SentryReplayEnvelopeItemHeaderTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryReplayEnvelopeItemHeaderTests.swift; sourceTree = "<group>"; };
 		D808FB86281AB31D009A2A33 /* SentryUIEventTrackerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryUIEventTrackerTests.swift; sourceTree = "<group>"; };
 		D808FB89281BCE46009A2A33 /* TestSentrySwizzleWrapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestSentrySwizzleWrapper.swift; sourceTree = "<group>"; };
 		D808FB90281BF6E9009A2A33 /* SentryUIEventTrackingIntegrationTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryUIEventTrackingIntegrationTests.swift; sourceTree = "<group>"; };
@@ -1779,6 +1791,8 @@
 		D867063C27C3BC2400048851 /* SentryCoreDataTracker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryCoreDataTracker.h; path = include/SentryCoreDataTracker.h; sourceTree = "<group>"; };
 		D86B6820293F39E000B8B1FC /* TestSentryViewHierarchy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = TestSentryViewHierarchy.h; sourceTree = "<group>"; };
 		D86B6834294348A400B8B1FC /* SentryAttachment+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "SentryAttachment+Private.h"; path = "include/SentryAttachment+Private.h"; sourceTree = "<group>"; };
+		D86B7B5A2B7A529C0017E8D9 /* SentryReplayEvent.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryReplayEvent.h; path = include/SentryReplayEvent.h; sourceTree = "<group>"; };
+		D86B7B5B2B7A529C0017E8D9 /* SentryReplayEvent.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryReplayEvent.m; sourceTree = "<group>"; };
 		D86F419727C8FEFA00490520 /* SentryCoreDataTrackerExtension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryCoreDataTrackerExtension.swift; sourceTree = "<group>"; };
 		D8751FA4274743710032F4DE /* SentryNSURLSessionTaskSearchTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryNSURLSessionTaskSearchTests.swift; sourceTree = "<group>"; };
 		D8757D142A209F7300BFEFCC /* SentrySampleDecision+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = "SentrySampleDecision+Private.h"; path = "include/SentrySampleDecision+Private.h"; sourceTree = "<group>"; };
@@ -1790,6 +1804,10 @@
 		D88817D626D7149100BF2251 /* SentryTraceContext.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryTraceContext.m; sourceTree = "<group>"; };
 		D88817D926D72AB800BF2251 /* SentryTraceContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryTraceContext.h; path = include/SentryTraceContext.h; sourceTree = "<group>"; };
 		D88817DB26D72B7B00BF2251 /* SentryTraceStateTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentryTraceStateTests.swift; sourceTree = "<group>"; };
+		D88D6C1B2B7B5A8800C8C633 /* SentryReplayRecording.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryReplayRecording.h; path = include/SentryReplayRecording.h; sourceTree = "<group>"; };
+		D88D6C1C2B7B5A8800C8C633 /* SentryReplayRecording.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryReplayRecording.m; sourceTree = "<group>"; };
+		D88D6C1F2B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SentryReplayEnvelopeItemHeader.h; path = include/SentryReplayEnvelopeItemHeader.h; sourceTree = "<group>"; };
+		D88D6C202B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = SentryReplayEnvelopeItemHeader.m; sourceTree = "<group>"; };
 		D8918B212849FA6D00701F9A /* SentrySDKIntegrationTestsBase.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SentrySDKIntegrationTestsBase.swift; sourceTree = "<group>"; };
 		D8AB40DA2806EC1900E5E9F7 /* SentryScreenshotIntegration.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SentryScreenshotIntegration.h; path = include/SentryScreenshotIntegration.h; sourceTree = "<group>"; };
 		D8ACE3C42762187200F5A213 /* SentryNSDataSwizzling.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SentryNSDataSwizzling.m; sourceTree = "<group>"; };
@@ -2758,6 +2776,7 @@
 				7BE0DC40272AEA0A004FA8B7 /* Performance */,
 				7BE0DC3F272AE9F0004FA8B7 /* Session */,
 				7BE0DC3E272AE9DC004FA8B7 /* SentryCrash */,
+				D80694C12B7CC85800B820E6 /* SessionReplay */,
 				7B59398324AB481B0003AAD2 /* NotificationCenterTestCase.swift */,
 				0A2D8D8628992260008720F6 /* SentryBaseIntegrationTests.swift */,
 			);
@@ -3358,6 +3377,16 @@
 			path = Swift;
 			sourceTree = "<group>";
 		};
+		D80694C12B7CC85800B820E6 /* SessionReplay */ = {
+			isa = PBXGroup;
+			children = (
+				D80694C22B7CC86E00B820E6 /* SentryReplayEventTests.swift */,
+				D80694C52B7CCFA100B820E6 /* SentryReplayRecordingTests.swift */,
+				D80694C82B7CD65500B820E6 /* SentryReplayEnvelopeItemHeaderTests.swift */,
+			);
+			path = SessionReplay;
+			sourceTree = "<group>";
+		};
 		D808FB85281AB2EF009A2A33 /* UIEvents */ = {
 			isa = PBXGroup;
 			children = (
@@ -3370,6 +3399,12 @@
 		D80CD8D52B752FD9002F710B /* SessionReplay */ = {
 			isa = PBXGroup;
 			children = (
+				D86B7B5A2B7A529C0017E8D9 /* SentryReplayEvent.h */,
+				D86B7B5B2B7A529C0017E8D9 /* SentryReplayEvent.m */,
+				D88D6C1B2B7B5A8800C8C633 /* SentryReplayRecording.h */,
+				D88D6C1C2B7B5A8800C8C633 /* SentryReplayRecording.m */,
+				D88D6C1F2B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.h */,
+				D88D6C202B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.m */,
 			);
 			name = SessionReplay;
 			sourceTree = "<group>";
@@ -3658,6 +3693,7 @@
 				7B7D873224864BB900D2ECFF /* SentryCrashMachineContextWrapper.h in Headers */,
 				861265F92404EC1500C4AFDE /* NSArray+SentrySanitize.h in Headers */,
 				63FE712320DA4C1000CDBAE8 /* SentryCrashID.h in Headers */,
+				D88D6C1D2B7B5A8800C8C633 /* SentryReplayRecording.h in Headers */,
 				7DC27EC523997EB7006998B5 /* SentryAutoBreadcrumbTrackingIntegration.h in Headers */,
 				63FE707F20DA4C1000CDBAE8 /* SentryCrashVarArgs.h in Headers */,
 				03F84D2627DD414C008FE43F /* SentryThreadMetadataCache.hpp in Headers */,
@@ -3721,6 +3757,7 @@
 				63FE70F920DA4C1000CDBAE8 /* SentryCrashMonitor.h in Headers */,
 				D8BD2E6829361A0F00D96C6A /* PrivatesHeader.h in Headers */,
 				7B98D7CB25FB64EC00C5A389 /* SentryWatchdogTerminationTrackingIntegration.h in Headers */,
+				D88D6C212B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.h in Headers */,
 				63FE710920DA4C1000CDBAE8 /* SentryCrashFileUtils.h in Headers */,
 				03F84D1F27DD414C008FE43F /* SentryAsyncSafeLogging.h in Headers */,
 				7BE3C76B2445C27A00A38442 /* SentryCurrentDateProvider.h in Headers */,
@@ -3769,6 +3806,7 @@
 				D8AB40DB2806EC1900E5E9F7 /* SentryScreenshotIntegration.h in Headers */,
 				7B3B83722833832B0001FDEB /* SentrySpanOperations.h in Headers */,
 				7BF9EF722722A84800B5BBEF /* SentryClassRegistrator.h in Headers */,
+				D86B7B5C2B7A529C0017E8D9 /* SentryReplayEvent.h in Headers */,
 				63FE715520DA4C1100CDBAE8 /* SentryCrashStackCursor_MachineContext.h in Headers */,
 				62E081A929ED4260000F69FC /* SentryBreadcrumbDelegate.h in Headers */,
 				15360CF02433A16D00112302 /* SentryInstallation.h in Headers */,
@@ -4184,6 +4222,7 @@
 				639FCFA91EBC80CC00778193 /* SentryFrame.m in Sources */,
 				D858FA672A29EAB3002A3503 /* SentryBinaryImageCache.m in Sources */,
 				8E564AEA267AF22600FE117D /* SentryNetworkTracker.m in Sources */,
+				D88D6C222B7BA25400C8C633 /* SentryReplayEnvelopeItemHeader.m in Sources */,
 				15360CED2433A15500112302 /* SentryInstallation.m in Sources */,
 				7B98D7E825FB7BCD00C5A389 /* SentryAppState.m in Sources */,
 				D8370B6A273DF1E900F66E2D /* SentryNSURLSessionTaskSearch.m in Sources */,
@@ -4227,6 +4266,7 @@
 				7B56D73324616D9500B842DA /* SentryConcurrentRateLimitsDictionary.m in Sources */,
 				8ECC674825C23A20000E2BF6 /* SentryTransaction.m in Sources */,
 				0A80E433291017C300095219 /* SentryWatchdogTerminationScopeObserver.m in Sources */,
+				D88D6C1E2B7B5A8800C8C633 /* SentryReplayRecording.m in Sources */,
 				7BECF42826145CD900D9826E /* SentryMechanismMeta.m in Sources */,
 				8E7C982F2693D56000E6336C /* SentryTraceHeader.m in Sources */,
 				63FE715F20DA4C1100CDBAE8 /* SentryCrashID.c in Sources */,
@@ -4330,6 +4370,7 @@
 				861265FA2404EC1500C4AFDE /* NSArray+SentrySanitize.m in Sources */,
 				D8603DD6284F8497000E1227 /* SentryBaggage.m in Sources */,
 				63FE711520DA4C1000CDBAE8 /* SentryCrashJSONCodec.c in Sources */,
+				D86B7B5D2B7A529C0017E8D9 /* SentryReplayEvent.m in Sources */,
 				03F84D3327DD4191008FE43F /* SentryMachLogging.cpp in Sources */,
 				84F993C42A62A74000EC0190 /* SentryCurrentDateProvider.m in Sources */,
 				D85852BA27EDDC5900C6D8AE /* SentryUIApplication.m in Sources */,
@@ -4425,6 +4466,7 @@
 				D8137D54272B53070082656C /* TestSentrySpan.m in Sources */,
 				7BECF432261463E600D9826E /* SentryMechanismMetaTests.swift in Sources */,
 				7BE8E8462593313500C4DA1F /* SentryAttachment+Equality.m in Sources */,
+				D80694C72B7CD22B00B820E6 /* SentryReplayRecordingTests.swift in Sources */,
 				63FE721F20DA66EC00CDBAE8 /* SentryCrashSignalInfo_Tests.m in Sources */,
 				0ADC33F128D9BE940078D980 /* TestSentryUIDeviceWrapper.swift in Sources */,
 				63FE721420DA66EC00CDBAE8 /* SentryCrashMemory_Tests.m in Sources */,
@@ -4458,6 +4500,7 @@
 				7BBD188D2448453600427C76 /* SentryHttpDateParserTests.swift in Sources */,
 				7B72D23A28D074BC0014798A /* TestExtensions.swift in Sources */,
 				7BBD18BB24530D2600427C76 /* SentryFileManagerTests.swift in Sources */,
+				D80694CA2B7CD65800B820E6 /* SentryReplayEnvelopeItemHeaderTests.swift in Sources */,
 				63FE722020DA66EC00CDBAE8 /* SentryCrashObjC_Tests.m in Sources */,
 				7B58816727FC5D790098B121 /* SentryDiscardReasonMapperTests.swift in Sources */,
 				63FE720320DA66EC00CDBAE8 /* SentryCrashCPU_Tests.m in Sources */,
@@ -4516,6 +4559,7 @@
 				63FE721A20DA66EC00CDBAE8 /* SentryCrashSysCtl_Tests.m in Sources */,
 				8431F00529B2849A00D8DC56 /* (null) in Sources */,
 				7B88F30424BC8E6500ADF90A /* SentrySerializationTests.swift in Sources */,
+				D80694C42B7CC9AE00B820E6 /* SentryReplayEventTests.swift in Sources */,
 				7B34721728086A9D0041F047 /* SentrySwizzleWrapperTests.swift in Sources */,
 				8EC4CF5025C3A0070093DEE9 /* SentrySpanContextTests.swift in Sources */,
 				7BE0DC2F272ABAF6004FA8B7 /* SentryAutoBreadcrumbTrackingIntegrationTests.swift in Sources */,
diff --git a/Sources/Sentry/SentryClient.m b/Sources/Sentry/SentryClient.m
index 82e79df0475..03cfa1d1a70 100644
--- a/Sources/Sentry/SentryClient.m
+++ b/Sources/Sentry/SentryClient.m
@@ -34,8 +34,12 @@
 #import "SentryOptions+Private.h"
 #import "SentryPropagationContext.h"
 #import "SentryRandom.h"
+#import "SentryReplayEnvelopeItemHeader.h"
+#import "SentryReplayEvent.h"
+#import "SentryReplayRecording.h"
 #import "SentrySDK+Private.h"
 #import "SentryScope+Private.h"
+#import "SentrySerialization.h"
 #import "SentrySession.h"
 #import "SentryStacktraceBuilder.h"
 #import "SentrySwift.h"
@@ -472,13 +476,53 @@ - (void)captureSession:(SentrySession *)session
     }
 
     SentryEnvelopeItem *item = [[SentryEnvelopeItem alloc] initWithSession:session];
-    SentryEnvelopeHeader *envelopeHeader = [[SentryEnvelopeHeader alloc] initWithId:nil
-                                                                       traceContext:nil];
-    SentryEnvelope *envelope = [[SentryEnvelope alloc] initWithHeader:envelopeHeader
+    SentryEnvelope *envelope = [[SentryEnvelope alloc] initWithHeader:[SentryEnvelopeHeader empty]
                                                            singleItem:item];
     [self captureEnvelope:envelope];
 }
 
+- (void)captureReplayEvent:(SentryReplayEvent *)replayEvent
+           replayRecording:(SentryReplayRecording *)replayRecording
+                     video:(NSURL *)videoURL
+{
+    replayEvent = (SentryReplayEvent *)[self prepareEvent:replayEvent
+                                                withScope:[[SentryScope alloc] init]
+                                   alwaysAttachStacktrace:NO];
+
+    if (replayEvent == nil) {
+        return;
+    } else if (![replayEvent isKindOfClass:SentryReplayEvent.class]) {
+        SENTRY_LOG_DEBUG(@"The event preprocessor didn't update the replay event in place. The "
+                         @"replay was discarded.");
+        return;
+    }
+
+    // breadcrumbs for replay will be send with ReplayRecording
+    replayEvent.breadcrumbs = nil;
+
+    SentryEnvelopeItem *eventEnvelopeItem = [[SentryEnvelopeItem alloc] initWithEvent:replayEvent];
+
+    NSData *recording = [SentrySerialization dataWithJSONObject:[replayRecording serialize]];
+    SentryEnvelopeItem *recordingEnvelopeItem = [[SentryEnvelopeItem alloc]
+        initWithHeader:[SentryReplayEnvelopeItemHeader
+                           replayRecordingHeaderWithSegmentId:replayRecording.segmentId
+                                                       length:recording.length]
+                  data:recording];
+
+    NSData *video = [NSData dataWithContentsOfURL:videoURL];
+    SentryEnvelopeItem *videoEnvelopeItem = [[SentryEnvelopeItem alloc]
+        initWithHeader:[SentryReplayEnvelopeItemHeader
+                           replayVideoHeaderWithSegmentId:replayRecording.segmentId
+                                                   length:video.length]
+                  data:video];
+
+    SentryEnvelope *envelope = [[SentryEnvelope alloc]
+        initWithHeader:[SentryEnvelopeHeader empty]
+                 items:@[ eventEnvelopeItem, recordingEnvelopeItem, videoEnvelopeItem ]];
+
+    [self captureEnvelope:envelope];
+}
+
 - (void)captureEnvelope:(SentryEnvelope *)envelope
 {
     if ([self isDisabled]) {
diff --git a/Sources/Sentry/SentryDateUtil.m b/Sources/Sentry/SentryDateUtil.m
index f362b345fc1..30e19e10d10 100644
--- a/Sources/Sentry/SentryDateUtil.m
+++ b/Sources/Sentry/SentryDateUtil.m
@@ -38,6 +38,11 @@ + (NSDate *_Nullable)getMaximumDate:(NSDate *_Nullable)first andOther:(NSDate *_
     }
 }
 
++ (long)javascriptDate:(NSDate *)date
+{
+    return (NSInteger)([date timeIntervalSince1970] * 1000);
+}
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/SentryEnvelope.m b/Sources/Sentry/SentryEnvelope.m
index fbe35f5c2d7..068d1c8b94a 100644
--- a/Sources/Sentry/SentryEnvelope.m
+++ b/Sources/Sentry/SentryEnvelope.m
@@ -48,6 +48,11 @@ - (instancetype)initWithId:(nullable SentryId *)eventId
     return self;
 }
 
++ (instancetype)empty
+{
+    return [[SentryEnvelopeHeader alloc] initWithId:nil traceContext:nil];
+}
+
 @end
 
 @implementation SentryEnvelopeItem
diff --git a/Sources/Sentry/SentryReplayEnvelopeItemHeader.m b/Sources/Sentry/SentryReplayEnvelopeItemHeader.m
new file mode 100644
index 00000000000..59ae939c3e5
--- /dev/null
+++ b/Sources/Sentry/SentryReplayEnvelopeItemHeader.m
@@ -0,0 +1,35 @@
+#import "SentryReplayEnvelopeItemHeader.h"
+#import "SentryEnvelopeItemType.h"
+
+@implementation SentryReplayEnvelopeItemHeader
+
+- (instancetype)initWithType:(NSString *)type
+                   segmentId:(NSInteger)segmentId
+                      length:(NSUInteger)length
+{
+    if (self = [super initWithType:type length:length]) {
+        self.segmentId = segmentId;
+    }
+    return self;
+}
+
++ (instancetype)replayRecordingHeaderWithSegmentId:(NSInteger)segmentId length:(NSUInteger)length
+{
+    return [[self alloc] initWithType:SentryEnvelopeItemTypeReplayRecording
+                            segmentId:segmentId
+                               length:length];
+}
+
++ (instancetype)replayVideoHeaderWithSegmentId:(NSInteger)segmentId length:(NSUInteger)length
+{
+    return [[self alloc] initWithType:SentryEnvelopeItemTypeReplayVideo
+                            segmentId:segmentId
+                               length:length];
+}
+
+- (NSDictionary *)serialize
+{
+    return @{ @"type" : self.type, @"length" : @(self.length), @"segment_id" : @(self.segmentId) };
+}
+
+@end
diff --git a/Sources/Sentry/SentryReplayEvent.m b/Sources/Sentry/SentryReplayEvent.m
new file mode 100644
index 00000000000..a28de9a8cff
--- /dev/null
+++ b/Sources/Sentry/SentryReplayEvent.m
@@ -0,0 +1,28 @@
+#import "SentryReplayEvent.h"
+#import "SentryDateUtil.h"
+#import "SentryId.h"
+
+@implementation SentryReplayEvent
+
+- (NSDictionary *)serialize
+{
+    NSMutableDictionary *result = [[super serialize] mutableCopy];
+
+    NSMutableArray *trace_ids = [NSMutableArray array];
+
+    for (SentryId *traceId in self.traceIds) {
+        [trace_ids addObject:traceId.sentryIdString];
+    }
+
+    result[@"urls"] = self.urls;
+    result[@"replay_start_timestamp"] =
+        @([SentryDateUtil javascriptDate:self.replayStartTimestamp]);
+    result[@"trace_ids"] = trace_ids;
+    result[@"replay_id"] = self.replayId.sentryIdString;
+    result[@"segment_id"] = @(self.segmentId);
+    result[@"replay_type"] = @"buffer";
+
+    return result;
+}
+
+@end
diff --git a/Sources/Sentry/SentryReplayRecording.m b/Sources/Sentry/SentryReplayRecording.m
new file mode 100644
index 00000000000..55a639967bd
--- /dev/null
+++ b/Sources/Sentry/SentryReplayRecording.m
@@ -0,0 +1,64 @@
+#import "SentryReplayRecording.h"
+#import "SentryDateUtil.h"
+
+@implementation SentryReplayRecording
+
+- (instancetype)initWithSegmentId:(NSInteger)segmentId
+                             size:(NSInteger)size
+                            start:(NSDate *)start
+                         duration:(NSTimeInterval)duration
+                       frameCount:(NSInteger)frameCount
+                        frameRate:(NSInteger)frameRate
+                           height:(NSInteger)height
+                            width:(NSInteger)width
+{
+    if (self = [super init]) {
+        self.segmentId = segmentId;
+        self.size = size;
+        self.start = start;
+        self.duration = duration;
+        self.frameCount = frameCount;
+        self.frameRate = frameRate;
+        self.height = height;
+        self.width = width;
+    }
+    return self;
+}
+
+- (nonnull NSArray<NSDictionary<NSString *, id> *> *)serialize
+{
+
+    long timestamp = [SentryDateUtil javascriptDate:self.start];
+
+    NSDictionary *metaInfo = @{
+        @"type" : @4,
+        @"timestamp" : @(timestamp),
+        @"data" : @ { @"href" : @"", @"height" : @(self.height), @"width" : @(self.width) }
+    };
+
+    NSDictionary *recordingInfo = @{
+        @"type" : @5,
+        @"timestamp" : @(timestamp),
+        @"data" : @ {
+            @"tag" : @"video",
+            @"payload" : @ {
+                @"segmentId" : @(self.segmentId),
+                @"size" : @(self.size),
+                @"duration" : @(self.duration),
+                @"encoding" : @"h264",
+                @"container" : @"mp4",
+                @"height" : @(self.height),
+                @"width" : @(self.width),
+                @"frameCount" : @(self.frameCount),
+                @"frameRateType" : @"constant",
+                @"frameRate" : @(self.frameRate),
+                @"left" : @0,
+                @"top" : @0,
+            }
+        }
+    };
+
+    return @[ metaInfo, recordingInfo ];
+}
+
+@end
diff --git a/Sources/Sentry/SentrySerialization.m b/Sources/Sentry/SentrySerialization.m
index 27fe09500f0..6e16cb05b97 100644
--- a/Sources/Sentry/SentrySerialization.m
+++ b/Sources/Sentry/SentrySerialization.m
@@ -16,15 +16,15 @@
 
 @implementation SentrySerialization
 
-+ (NSData *_Nullable)dataWithJSONObject:(NSDictionary *)dictionary
++ (NSData *_Nullable)dataWithJSONObject:(id)jsonObject
 {
-    if (![NSJSONSerialization isValidJSONObject:dictionary]) {
+    if (![NSJSONSerialization isValidJSONObject:jsonObject]) {
         SENTRY_LOG_ERROR(@"Dictionary is not a valid JSON object.");
         return nil;
     }
 
     NSError *error = nil;
-    NSData *data = [NSJSONSerialization dataWithJSONObject:dictionary options:0 error:&error];
+    NSData *data = [NSJSONSerialization dataWithJSONObject:jsonObject options:0 error:&error];
     if (error) {
         SENTRY_LOG_ERROR(@"Internal error while serializing JSON: %@", error);
     }
diff --git a/Sources/Sentry/include/HybridPublic/SentryEnvelope.h b/Sources/Sentry/include/HybridPublic/SentryEnvelope.h
index 8006c6d07ac..4d7efdafe85 100644
--- a/Sources/Sentry/include/HybridPublic/SentryEnvelope.h
+++ b/Sources/Sentry/include/HybridPublic/SentryEnvelope.h
@@ -68,6 +68,8 @@ SENTRY_NO_INIT
  */
 @property (nullable, nonatomic, copy) NSDate *sentAt;
 
++ (instancetype)empty;
+
 @end
 
 @interface SentryEnvelopeItem : NSObject
diff --git a/Sources/Sentry/include/HybridPublic/SentryEnvelopeItemType.h b/Sources/Sentry/include/HybridPublic/SentryEnvelopeItemType.h
index d999cfdd47e..8619dca5ab5 100644
--- a/Sources/Sentry/include/HybridPublic/SentryEnvelopeItemType.h
+++ b/Sources/Sentry/include/HybridPublic/SentryEnvelopeItemType.h
@@ -5,3 +5,5 @@ static NSString *const SentryEnvelopeItemTypeTransaction = @"transaction";
 static NSString *const SentryEnvelopeItemTypeAttachment = @"attachment";
 static NSString *const SentryEnvelopeItemTypeClientReport = @"client_report";
 static NSString *const SentryEnvelopeItemTypeProfile = @"profile";
+static NSString *const SentryEnvelopeItemTypeReplayVideo = @"replay_video";
+static NSString *const SentryEnvelopeItemTypeReplayRecording = @"replay_recording";
diff --git a/Sources/Sentry/include/SentryClient+Private.h b/Sources/Sentry/include/SentryClient+Private.h
index a9bcd469818..bd1fbd85949 100644
--- a/Sources/Sentry/include/SentryClient+Private.h
+++ b/Sources/Sentry/include/SentryClient+Private.h
@@ -3,7 +3,7 @@
 #import "SentryDiscardReason.h"
 
 @class SentrySession, SentryEnvelopeItem, SentryId, SentryAttachment, SentryThreadInspector,
-    SentryEnvelope;
+    SentryReplayEvent, SentryReplayRecording, SentryEnvelope;
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -42,6 +42,10 @@ SentryClient ()
     additionalEnvelopeItems:(NSArray<SentryEnvelopeItem *> *)additionalEnvelopeItems
     NS_SWIFT_NAME(capture(event:scope:additionalEnvelopeItems:));
 
+- (void)captureReplayEvent:(SentryReplayEvent *)replayEvent
+           replayRecording:(SentryReplayRecording *)replayRecording
+                     video:(NSURL *)videoURL;
+
 - (void)captureSession:(SentrySession *)session NS_SWIFT_NAME(capture(session:));
 
 /**
diff --git a/Sources/Sentry/include/SentryDateUtil.h b/Sources/Sentry/include/SentryDateUtil.h
index 60c8fdb6562..98fa11de6bb 100644
--- a/Sources/Sentry/include/SentryDateUtil.h
+++ b/Sources/Sentry/include/SentryDateUtil.h
@@ -9,6 +9,8 @@ NS_SWIFT_NAME(DateUtil)
 
 + (NSDate *_Nullable)getMaximumDate:(NSDate *_Nullable)first andOther:(NSDate *_Nullable)second;
 
++ (long)javascriptDate:(NSDate *)date;
+
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentryReplayEnvelopeItemHeader.h b/Sources/Sentry/include/SentryReplayEnvelopeItemHeader.h
new file mode 100644
index 00000000000..77d4d782bc1
--- /dev/null
+++ b/Sources/Sentry/include/SentryReplayEnvelopeItemHeader.h
@@ -0,0 +1,20 @@
+#import "SentryEnvelopeItemHeader.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface SentryReplayEnvelopeItemHeader : SentryEnvelopeItemHeader
+
+@property (nonatomic) NSInteger segmentId;
+
+- (instancetype)initWithType:(NSString *)type
+                   segmentId:(NSInteger)segmentId
+                      length:(NSUInteger)length;
+
++ (instancetype)replayRecordingHeaderWithSegmentId:(NSInteger)segmentId length:(NSUInteger)length;
+
++ (instancetype)replayVideoHeaderWithSegmentId:(NSInteger)segmentId length:(NSUInteger)length;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentryReplayEvent.h b/Sources/Sentry/include/SentryReplayEvent.h
new file mode 100644
index 00000000000..74f2beb22ff
--- /dev/null
+++ b/Sources/Sentry/include/SentryReplayEvent.h
@@ -0,0 +1,39 @@
+#import "SentryEvent.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SentryId;
+
+@interface SentryReplayEvent : SentryEvent
+
+/**
+ * Start time of the replay segment
+ */
+@property (nonatomic, strong) NSDate *replayStartTimestamp;
+
+/**
+ * Number of the segment in the replay.
+ * This is an incremental number
+ */
+@property (nonatomic) NSInteger segmentId;
+
+/**
+ * This will be used to store the name of the screens
+ * that appear during the duration of the replay segment.
+ */
+@property (nonatomic, strong) NSArray<NSString *> *urls;
+
+/**
+ * Trace ids happening during the duration of the replay segment.
+ */
+@property (nonatomic, strong) NSArray<SentryId *> *traceIds;
+
+/**
+ * The replay id to which this segment belongs to.
+ */
+@property (nonatomic, strong) SentryId *replayId;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentryReplayRecording.h b/Sources/Sentry/include/SentryReplayRecording.h
new file mode 100644
index 00000000000..66dfe526034
--- /dev/null
+++ b/Sources/Sentry/include/SentryReplayRecording.h
@@ -0,0 +1,42 @@
+#import "SentrySerializable.h"
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SentryId;
+
+@interface SentryReplayRecording : NSObject
+
+@property (nonatomic) NSInteger segmentId;
+
+/**
+ * Video file size
+ */
+@property (nonatomic) NSInteger size;
+
+@property (nonatomic, strong) NSDate *start;
+
+@property (nonatomic) NSTimeInterval duration;
+
+@property (nonatomic) NSInteger frameCount;
+
+@property (nonatomic) NSInteger frameRate;
+
+@property (nonatomic) NSInteger height;
+
+@property (nonatomic) NSInteger width;
+
+- (instancetype)initWithSegmentId:(NSInteger)segmentId
+                             size:(NSInteger)size
+                            start:(NSDate *)start
+                         duration:(NSTimeInterval)duration
+                       frameCount:(NSInteger)frameCount
+                        frameRate:(NSInteger)frameRate
+                           height:(NSInteger)height
+                            width:(NSInteger)width;
+
+- (nonnull NSArray<NSDictionary<NSString *, id> *> *)serialize;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Sources/Sentry/include/SentrySerialization.h b/Sources/Sentry/include/SentrySerialization.h
index fbfcec32e4d..704e9b5cfd7 100644
--- a/Sources/Sentry/include/SentrySerialization.h
+++ b/Sources/Sentry/include/SentrySerialization.h
@@ -8,7 +8,7 @@ static int const SENTRY_BAGGAGE_MAX_SIZE = 8192;
 
 @interface SentrySerialization : NSObject
 
-+ (NSData *_Nullable)dataWithJSONObject:(NSDictionary *)dictionary;
++ (NSData *_Nullable)dataWithJSONObject:(id)jsonObject;
 
 + (NSData *_Nullable)dataWithSession:(SentrySession *)session;
 
diff --git a/Tests/SentryTests/Helper/SentryDateUtilTests.swift b/Tests/SentryTests/Helper/SentryDateUtilTests.swift
index 507b1a3b3ad..bb3e5e30b44 100644
--- a/Tests/SentryTests/Helper/SentryDateUtilTests.swift
+++ b/Tests/SentryTests/Helper/SentryDateUtilTests.swift
@@ -1,3 +1,4 @@
+import Nimble
 import SentryTestUtils
 import XCTest
 
@@ -54,4 +55,11 @@ class SentryDateUtilTests: XCTestCase {
         XCTAssertNil(DateUtil.getMaximumDate(nil, andOther: nil))
     }
 
+    func testJavascriptDate() {
+        let testDate = Date(timeIntervalSince1970: 60)
+        let timestamp = DateUtil.javascriptDate(testDate)
+        
+        expect(timestamp) == 60_000
+    }
+    
 }
diff --git a/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEnvelopeItemHeaderTests.swift b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEnvelopeItemHeaderTests.swift
new file mode 100644
index 00000000000..1d809b72243
--- /dev/null
+++ b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEnvelopeItemHeaderTests.swift
@@ -0,0 +1,44 @@
+import Foundation
+import Nimble
+import XCTest
+
+class SentryReplayEnvelopeItemHeaderTests: XCTestCase {
+   
+    func testInitWithTypeSegmentIdLength() {
+         let header = SentryReplayEnvelopeItemHeader(type: "testType", segmentId: 1, length: 100)
+         
+         expect(header.type) == "testType"
+         expect(header.segmentId) == 1
+         expect(header.length) == 100
+     }
+     
+     func testReplayRecordingHeader() {
+         let header = SentryReplayEnvelopeItemHeader.replayRecordingHeader(withSegmentId: 2, length: 200)
+         
+         expect(header.type) == SentryEnvelopeItemTypeReplayRecording
+         expect(header.segmentId) == 2
+         expect(header.length) == 200
+     }
+     
+     func testReplayVideoHeader() {
+         let header = SentryReplayEnvelopeItemHeader.replayVideoHeader(withSegmentId: 3, length: 300)
+         
+         expect(header.type) == SentryEnvelopeItemTypeReplayVideo
+         expect(header.segmentId) == 3
+         expect(header.length) == 300
+     }
+     
+     func testSerialize() {
+         let header = SentryReplayEnvelopeItemHeader(type: "testType", segmentId: 4, length: 400)
+         let serialized = header.serialize()
+         
+         expect(serialized["type"] as? String) == "testType"
+         expect(serialized["length"] as? Int) == 400
+         expect(serialized["segment_id"] as? Int) == 4
+     }
+    
+    func testEnvelopeItemHeaderType() {
+        expect(SentryEnvelopeItemTypeReplayVideo) == "replay_video"
+        expect(SentryEnvelopeItemTypeReplayRecording) == "replay_recording"
+    }
+}
diff --git a/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEventTests.swift b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEventTests.swift
new file mode 100644
index 00000000000..96391581a46
--- /dev/null
+++ b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayEventTests.swift
@@ -0,0 +1,30 @@
+import Foundation
+import Nimble
+import XCTest
+
+class SentryReplayEventTests: XCTestCase {
+ 
+    func test_Serialize() {
+        let sut = SentryReplayEvent()
+        sut.urls = ["Screen 1", "Screen 2"]
+        sut.replayStartTimestamp = Date(timeIntervalSince1970: 1)
+
+        let traceIds = [SentryId(), SentryId()]
+        sut.traceIds = traceIds
+        
+        let replayId = SentryId()
+        sut.replayId = replayId
+        
+        sut.segmentId = 3
+        
+        let result = sut.serialize()
+        
+        expect(result["urls"] as? [String]) == ["Screen 1", "Screen 2"]
+        expect(result["replay_start_timestamp"] as? Int) == 1_000
+        expect(result["trace_ids"] as? [String]) == [ traceIds[0].sentryIdString, traceIds[1].sentryIdString]
+        expect(result["replay_id"] as? String) == replayId.sentryIdString
+        expect(result["segment_id"] as? Int) == 3
+        expect(result["replay_type"] as? String) == "buffer"
+    }
+    
+}
diff --git a/Tests/SentryTests/Integrations/SessionReplay/SentryReplayRecordingTests.swift b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayRecordingTests.swift
new file mode 100644
index 00000000000..3d8f01c3da3
--- /dev/null
+++ b/Tests/SentryTests/Integrations/SessionReplay/SentryReplayRecordingTests.swift
@@ -0,0 +1,41 @@
+import Foundation
+import Nimble
+import XCTest
+
+class SentryReplayRecordingTests: XCTestCase {
+    
+    func test_serialize() {
+        let sut = SentryReplayRecording(segmentId: 3, size: 200, start: Date(timeIntervalSince1970: 2), duration: 5_000, frameCount: 5, frameRate: 1, height: 930, width: 390)
+      
+        let data = sut.serialize()
+        
+        let metaInfo = data[0]
+        let metaInfoData = metaInfo["data"] as? [String: Any]
+        
+        let recordingInfo = data[1]
+        let recordingData = recordingInfo["data"] as? [String: Any]
+        let recordingPayload = recordingData?["payload"] as? [String: Any]
+        
+        expect(metaInfo["type"] as? Int) == 4
+        expect(metaInfo["timestamp"] as? Int) == 2_000
+        expect(metaInfoData?["href"] as? String) == ""
+        expect(metaInfoData?["height"] as? Int) == 930
+        expect(metaInfoData?["width"] as? Int) == 390
+        
+        expect(recordingInfo["type"] as? Int) == 5
+        expect(recordingInfo["timestamp"] as? Int) == 2_000
+        expect(recordingData?["tag"] as? String) == "video"
+        expect(recordingPayload?["segmentId"] as? Int) == 3
+        expect(recordingPayload?["size"] as? Int) == 200
+        expect(recordingPayload?["duration"] as? Int) == 5_000
+        expect(recordingPayload?["encoding"] as? String) == "h264"
+        expect(recordingPayload?["container"] as? String) == "mp4"
+        expect(recordingPayload?["height"] as? Int) == 930
+        expect(recordingPayload?["width"] as? Int) == 390
+        expect(recordingPayload?["frameCount"] as? Int) == 5
+        expect(recordingPayload?["frameRateType"] as? String) == "constant"
+        expect(recordingPayload?["frameRate"] as? Int) == 1
+        expect(recordingPayload?["left"] as? Int) == 0
+        expect(recordingPayload?["top"] as? Int) == 0
+    }
+}
diff --git a/Tests/SentryTests/Protocol/SentryEnvelopeTests.swift b/Tests/SentryTests/Protocol/SentryEnvelopeTests.swift
index a2903c61179..d365a05283b 100644
--- a/Tests/SentryTests/Protocol/SentryEnvelopeTests.swift
+++ b/Tests/SentryTests/Protocol/SentryEnvelopeTests.swift
@@ -1,3 +1,4 @@
+import Nimble
 import SentryTestUtils
 import XCTest
 
@@ -235,6 +236,12 @@ class SentryEnvelopeTests: XCTestCase {
         XCTAssertEqual(attachment.contentType, envelopeItem.header.contentType)
     }
     
+    func testEmptyHeader() {
+        let sut = SentryEnvelopeHeader.empty()
+        expect(sut.eventId) == nil
+        expect(sut.traceContext) == nil
+    }
+    
     func testInitWithFileAttachment() {
         writeDataToFile(data: fixture.data ?? Data())
         
diff --git a/Tests/SentryTests/SentryClientTests.swift b/Tests/SentryTests/SentryClientTests.swift
index b650280d35f..3908b95e494 100644
--- a/Tests/SentryTests/SentryClientTests.swift
+++ b/Tests/SentryTests/SentryClientTests.swift
@@ -1576,6 +1576,32 @@ class SentryClientTest: XCTestCase {
         }
     }
     
+    func testCaptureReplayEvent() {
+        let sut = fixture.getSut()
+        let replayEvent = SentryReplayEvent()
+        replayEvent.segmentId = 2
+        let replayRecording = SentryReplayRecording()
+        replayRecording.segmentId = 2
+        
+        //Not a video url, but its ok for test the envelope
+        let movieUrl = Bundle(for: self.classForCoder).url(forResource: "Resources/raw", withExtension: "json")
+        
+        sut.capture(replayEvent, replayRecording: replayRecording, video: movieUrl!)
+        
+        let envelope = fixture.transport.sentEnvelopes.first
+        
+        let recordingHeader = envelope?.items[1].header as? SentryReplayEnvelopeItemHeader
+        let videoHeader = envelope?.items[2].header as? SentryReplayEnvelopeItemHeader
+                
+        expect(envelope?.items.count) == 3
+        expect(envelope?.items[2].data.count) == 120_617
+        expect(recordingHeader?.segmentId) == 2
+        expect(videoHeader?.segmentId) == 2
+        
+        expect(recordingHeader?.type) == SentryEnvelopeItemTypeReplayRecording
+        expect(videoHeader?.type) == SentryEnvelopeItemTypeReplayVideo
+    }
+    
     private func givenEventWithDebugMeta() -> Event {
         let event = Event(level: SentryLevel.fatal)
         let debugMeta = DebugMeta()
diff --git a/Tests/SentryTests/SentryTests-Bridging-Header.h b/Tests/SentryTests/SentryTests-Bridging-Header.h
index acbe3676eaa..61e518cdd08 100644
--- a/Tests/SentryTests/SentryTests-Bridging-Header.h
+++ b/Tests/SentryTests/SentryTests-Bridging-Header.h
@@ -216,6 +216,9 @@
 #import "SentryNSProcessInfoWrapper.h"
 #import "SentryPerformanceTracker+Testing.h"
 #import "SentryPropagationContext.h"
+#import "SentryReplayEnvelopeItemHeader.h"
+#import "SentryReplayEvent.h"
+#import "SentryReplayRecording.h"
 #import "SentrySampleDecision+Private.h"
 #import "SentrySpanOperations.h"
 #import "SentryTimeToDisplayTracker.h"