diff --git a/docs/event-sending.md b/docs/event-sending.md
index 06077e807ed3..f014e1f2f94e 100644
--- a/docs/event-sending.md
+++ b/docs/event-sending.md
@@ -77,8 +77,8 @@ This document gives an outline for how event sending works, and which which plac
 ## Replay (WIP)
 
 * `replay.sendReplayRequest()`
-  * `createPayload()`
-  * `getReplayEvent()`
+  * `createRecordingData()`
+  * `prepareReplayEvent()`
     * `client._prepareEvent()` (see baseclient)
       * `baseclient._applyClientOptions()`
       * `baseclient._applyIntegrationsMetadata()`
diff --git a/packages/replay/.eslintrc.js b/packages/replay/.eslintrc.js
index 9df1f4dffa5f..cd80e893576c 100644
--- a/packages/replay/.eslintrc.js
+++ b/packages/replay/.eslintrc.js
@@ -25,10 +25,8 @@ module.exports = {
       rules: {
         // TODO (high-prio): Re-enable this after migration
         '@typescript-eslint/explicit-member-accessibility': 'off',
-        // TODO (high-prio): Re-enable this after migration
+        // Since we target only es6 here, we can leave this off
         '@sentry-internal/sdk/no-async-await': 'off',
-        // TODO (medium-prio): Re-enable this after migration
-        'jsdoc/require-jsdoc': 'off',
       },
     },
     {
diff --git a/packages/replay/src/coreHandlers/breadcrumbHandler.ts b/packages/replay/src/coreHandlers/breadcrumbHandler.ts
index fe0504b0230f..f790e28db3c1 100644
--- a/packages/replay/src/coreHandlers/breadcrumbHandler.ts
+++ b/packages/replay/src/coreHandlers/breadcrumbHandler.ts
@@ -4,6 +4,9 @@ import type { InstrumentationTypeBreadcrumb } from '../types';
 import { DomHandlerData, handleDom } from './handleDom';
 import { handleScope } from './handleScope';
 
+/**
+ * An event handler to react to breadcrumbs.
+ */
 export function breadcrumbHandler(type: InstrumentationTypeBreadcrumb, handlerData: unknown): Breadcrumb | null {
   if (type === 'scope') {
     return handleScope(handlerData as Scope);
diff --git a/packages/replay/src/coreHandlers/handleDom.ts b/packages/replay/src/coreHandlers/handleDom.ts
index 412bbb6cefd9..976adf7761c7 100644
--- a/packages/replay/src/coreHandlers/handleDom.ts
+++ b/packages/replay/src/coreHandlers/handleDom.ts
@@ -9,6 +9,9 @@ export interface DomHandlerData {
   event: Node | { target: Node };
 }
 
+/**
+ * An event handler to react to DOM events.
+ */
 export function handleDom(handlerData: DomHandlerData): Breadcrumb | null {
   // Taken from https://github.com/getsentry/sentry-javascript/blob/master/packages/browser/src/integrations/breadcrumbs.ts#L112
   let target;
diff --git a/packages/replay/src/coreHandlers/handleFetch.ts b/packages/replay/src/coreHandlers/handleFetch.ts
index 961a18b638d6..290a58d4531d 100644
--- a/packages/replay/src/coreHandlers/handleFetch.ts
+++ b/packages/replay/src/coreHandlers/handleFetch.ts
@@ -1,5 +1,4 @@
-import type { ReplayPerformanceEntry } from '../createPerformanceEntry';
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, ReplayPerformanceEntry } from '../types';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 import { shouldFilterRequest } from '../util/shouldFilterRequest';
 
diff --git a/packages/replay/src/coreHandlers/handleHistory.ts b/packages/replay/src/coreHandlers/handleHistory.ts
index f806d2d3c75b..4732c0118831 100644
--- a/packages/replay/src/coreHandlers/handleHistory.ts
+++ b/packages/replay/src/coreHandlers/handleHistory.ts
@@ -1,5 +1,4 @@
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, ReplayPerformanceEntry } from '../types';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 
 interface HistoryHandlerData {
diff --git a/packages/replay/src/coreHandlers/handleScope.ts b/packages/replay/src/coreHandlers/handleScope.ts
index 41cc4a6d4e02..429fc9d9a3bb 100644
--- a/packages/replay/src/coreHandlers/handleScope.ts
+++ b/packages/replay/src/coreHandlers/handleScope.ts
@@ -4,6 +4,9 @@ import { createBreadcrumb } from '../util/createBreadcrumb';
 
 let _LAST_BREADCRUMB: null | Breadcrumb = null;
 
+/**
+ * An event handler to handle scope changes.
+ */
 export function handleScope(scope: Scope): Breadcrumb | null {
   const newBreadcrumb = scope.getLastBreadcrumb();
 
diff --git a/packages/replay/src/coreHandlers/handleXhr.ts b/packages/replay/src/coreHandlers/handleXhr.ts
index a225345afe2f..883201d825e9 100644
--- a/packages/replay/src/coreHandlers/handleXhr.ts
+++ b/packages/replay/src/coreHandlers/handleXhr.ts
@@ -1,5 +1,4 @@
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, ReplayPerformanceEntry } from '../types';
 import { createPerformanceSpans } from '../util/createPerformanceSpans';
 import { shouldFilterRequest } from '../util/shouldFilterRequest';
 
diff --git a/packages/replay/src/createPerformanceEntry.ts b/packages/replay/src/createPerformanceEntry.ts
index c4fb293429dd..e502e4d96247 100644
--- a/packages/replay/src/createPerformanceEntry.ts
+++ b/packages/replay/src/createPerformanceEntry.ts
@@ -2,40 +2,12 @@ import { browserPerformanceTimeOrigin } from '@sentry/utils';
 import { record } from 'rrweb';
 
 import { WINDOW } from './constants';
-import type { AllPerformanceEntry, PerformanceNavigationTiming, PerformancePaintTiming } from './types';
-
-export interface ReplayPerformanceEntry {
-  /**
-   * One of these types https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType
-   */
-  type: string;
-
-  /**
-   * A more specific description of the performance entry
-   */
-  name: string;
-
-  /**
-   * The start timestamp in seconds
-   */
-  start: number;
-
-  /**
-   * The end timestamp in seconds
-   */
-  end: number;
-
-  /**
-   * Additional unstructured data to be included
-   */
-  data?: Record<string, unknown>;
-}
-
-interface MemoryInfo {
-  jsHeapSizeLimit: number;
-  totalJSHeapSize: number;
-  usedJSHeapSize: number;
-}
+import type {
+  AllPerformanceEntry,
+  PerformanceNavigationTiming,
+  PerformancePaintTiming,
+  ReplayPerformanceEntry,
+} from './types';
 
 // Map entryType -> function to normalize data for event
 // @ts-ignore TODO: entry type does not fit the create* functions entry type
@@ -46,9 +18,12 @@ const ENTRY_TYPES: Record<string, (entry: AllPerformanceEntry) => null | ReplayP
   // @ts-ignore TODO: entry type does not fit the create* functions entry type
   navigation: createNavigationEntry,
   // @ts-ignore TODO: entry type does not fit the create* functions entry type
-  ['largest-contentful-paint']: createLargestContentfulPaint,
+  'largest-contentful-paint': createLargestContentfulPaint,
 };
 
+/**
+ * Create replay performance entries from the browser performance entries.
+ */
 export function createPerformanceEntries(entries: AllPerformanceEntry[]): ReplayPerformanceEntry[] {
   return entries.map(createPerformanceEntry).filter(Boolean) as ReplayPerformanceEntry[];
 }
@@ -67,9 +42,7 @@ function getAbsoluteTime(time: number): number {
   return ((browserPerformanceTimeOrigin || WINDOW.performance.timeOrigin) + time) / 1000;
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createPaintEntry(entry: PerformancePaintTiming) {
+function createPaintEntry(entry: PerformancePaintTiming): ReplayPerformanceEntry {
   const { duration, entryType, name, startTime } = entry;
 
   const start = getAbsoluteTime(startTime);
@@ -81,9 +54,7 @@ function createPaintEntry(entry: PerformancePaintTiming) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createNavigationEntry(entry: PerformanceNavigationTiming) {
+function createNavigationEntry(entry: PerformanceNavigationTiming): ReplayPerformanceEntry | null {
   // TODO: There looks to be some more interesting bits in here (domComplete, domContentLoaded)
   const { entryType, name, duration, domComplete, startTime, transferSize, type } = entry;
 
@@ -104,9 +75,7 @@ function createNavigationEntry(entry: PerformanceNavigationTiming) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createResourceEntry(entry: PerformanceResourceTiming) {
+function createResourceEntry(entry: PerformanceResourceTiming): ReplayPerformanceEntry | null {
   const { entryType, initiatorType, name, responseEnd, startTime, encodedBodySize, transferSize } = entry;
 
   // Core SDK handles these
@@ -126,9 +95,9 @@ function createResourceEntry(entry: PerformanceResourceTiming) {
   };
 }
 
-// TODO: type definition!
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createLargestContentfulPaint(entry: PerformanceEntry & { size: number; element: Node }) {
+function createLargestContentfulPaint(
+  entry: PerformanceEntry & { size: number; element: Node },
+): ReplayPerformanceEntry {
   const { duration, entryType, startTime, size } = entry;
 
   const start = getAbsoluteTime(startTime);
@@ -147,25 +116,3 @@ function createLargestContentfulPaint(entry: PerformanceEntry & { size: number;
     },
   };
 }
-
-type ReplayMemoryEntry = ReplayPerformanceEntry & { data: { memory: MemoryInfo } };
-
-export function createMemoryEntry(memoryEntry: MemoryInfo): ReplayMemoryEntry {
-  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;
-  // we don't want to use `getAbsoluteTime` because it adds the event time to the
-  // time origin, so we get the current timestamp instead
-  const time = new Date().getTime() / 1000;
-  return {
-    type: 'memory',
-    name: 'memory',
-    start: time,
-    end: time,
-    data: {
-      memory: {
-        jsHeapSizeLimit,
-        totalJSHeapSize,
-        usedJSHeapSize,
-      },
-    },
-  };
-}
diff --git a/packages/replay/src/eventBuffer.ts b/packages/replay/src/eventBuffer.ts
index f5fbfb2497ff..a755ab0676e8 100644
--- a/packages/replay/src/eventBuffer.ts
+++ b/packages/replay/src/eventBuffer.ts
@@ -12,6 +12,9 @@ interface CreateEventBufferParams {
   useCompression: boolean;
 }
 
+/**
+ * Create an event buffer for replays.
+ */
 export function createEventBuffer({ useCompression }: CreateEventBufferParams): EventBuffer {
   // eslint-disable-next-line no-restricted-globals
   if (useCompression && window.Worker) {
@@ -72,7 +75,10 @@ class EventBufferArray implements EventBuffer {
   }
 }
 
-// exporting for testing
+/**
+ * Event buffer that uses a web worker to compress events.
+ * Exported only for testing.
+ */
 export class EventBufferCompressionWorker implements EventBuffer {
   private _worker: null | Worker;
   private _eventBufferItemLength: number = 0;
@@ -90,12 +96,18 @@ export class EventBufferCompressionWorker implements EventBuffer {
     return this._eventBufferItemLength;
   }
 
+  /**
+   * Destroy the event buffer.
+   */
   public destroy(): void {
     __DEBUG_BUILD__ && logger.log('[Replay] Destroying compression worker');
     this._worker?.terminate();
     this._worker = null;
   }
 
+  /**
+   * Add an event to the event buffer.
+   */
   public async addEvent(event: RecordingEvent, isCheckout?: boolean): Promise<ReplayRecordingData> {
     if (isCheckout) {
       // This event is a checkout, make sure worker buffer is cleared before
@@ -110,6 +122,9 @@ export class EventBufferCompressionWorker implements EventBuffer {
     return this._sendEventToWorker(event);
   }
 
+  /**
+   * Finish the event buffer and return the compressed data.
+   */
   public finish(): Promise<Uint8Array> {
     return this._finishRequest(this._getAndIncrementId());
   }
@@ -160,6 +175,9 @@ export class EventBufferCompressionWorker implements EventBuffer {
     });
   }
 
+  /**
+   * Send the event to the worker.
+   */
   private _sendEventToWorker(event: RecordingEvent): Promise<ReplayRecordingData> {
     const promise = this._postMessage({
       id: this._getAndIncrementId(),
@@ -173,6 +191,9 @@ export class EventBufferCompressionWorker implements EventBuffer {
     return promise;
   }
 
+  /**
+   * Finish the request and return the compressed data from the worker.
+   */
   private async _finishRequest(id: number): Promise<Uint8Array> {
     const promise = this._postMessage({ id, method: 'finish', args: [] });
 
@@ -182,6 +203,7 @@ export class EventBufferCompressionWorker implements EventBuffer {
     return promise as Promise<Uint8Array>;
   }
 
+  /** Get the current ID and increment it for the next call. */
   private _getAndIncrementId(): number {
     return this._id++;
   }
diff --git a/packages/replay/src/integration.ts b/packages/replay/src/integration.ts
index d5fe1275f7bd..865472c1571c 100644
--- a/packages/replay/src/integration.ts
+++ b/packages/replay/src/integration.ts
@@ -18,6 +18,9 @@ const MEDIA_SELECTORS = 'img,image,svg,path,rect,area,video,object,picture,embed
 
 let _initialized = false;
 
+/**
+ * The main replay integration class, to be passed to `init({  integrations: [] })`.
+ */
 export class Replay implements Integration {
   /**
    * @inheritDoc
@@ -126,10 +129,12 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
     this._isInitialized = true;
   }
 
+  /** If replay has already been initialized */
   protected get _isInitialized(): boolean {
     return _initialized;
   }
 
+  /** Update _isInitialized */
   protected set _isInitialized(value: boolean) {
     _initialized = value;
   }
@@ -181,6 +186,7 @@ Sentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,
     this._replay.stop();
   }
 
+  /** Setup the integration. */
   private _setup(): void {
     // Client is not available in constructor, so we need to wait until setupOnce
     this._loadReplayOptionsFromClient();
diff --git a/packages/replay/src/replay.ts b/packages/replay/src/replay.ts
index 84465de40de5..a54a5453e689 100644
--- a/packages/replay/src/replay.ts
+++ b/packages/replay/src/replay.ts
@@ -40,14 +40,14 @@ import type {
 import { addEvent } from './util/addEvent';
 import { addMemoryEntry } from './util/addMemoryEntry';
 import { createBreadcrumb } from './util/createBreadcrumb';
-import { createPayload } from './util/createPayload';
 import { createPerformanceSpans } from './util/createPerformanceSpans';
+import { createRecordingData } from './util/createRecordingData';
 import { createReplayEnvelope } from './util/createReplayEnvelope';
 import { debounce } from './util/debounce';
-import { getReplayEvent } from './util/getReplayEvent';
 import { isExpired } from './util/isExpired';
 import { isSessionExpired } from './util/isSessionExpired';
 import { overwriteRecordDroppedEvent, restoreRecordDroppedEvent } from './util/monkeyPatchRecordDroppedEvent';
+import { prepareReplayEvent } from './util/prepareReplayEvent';
 
 /**
  * Returns true to return control to calling function, otherwise continue with normal batching
@@ -56,6 +56,9 @@ import { overwriteRecordDroppedEvent, restoreRecordDroppedEvent } from './util/m
 const BASE_RETRY_INTERVAL = 5000;
 const MAX_RETRY_COUNT = 3;
 
+/**
+ * The main replay container class, which holds all the state and methods for recording and sending replays.
+ */
 export class ReplayContainer implements ReplayContainerInterface {
   public eventBuffer: EventBuffer | null = null;
 
@@ -904,7 +907,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     includeReplayStartTimestamp,
     eventContext,
   }: SendReplay): Promise<void | TransportMakeRequestResponse> {
-    const payloadWithSequence = createPayload({
+    const recordingData = createRecordingData({
       events,
       headers: {
         segment_id,
@@ -938,7 +941,7 @@ export class ReplayContainer implements ReplayContainerInterface {
       replay_type: this.session.sampled,
     };
 
-    const replayEvent = await getReplayEvent({ scope, client, replayId, event: baseEvent });
+    const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });
 
     if (!replayEvent) {
       // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
@@ -989,7 +992,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     }
     */
 
-    const envelope = createReplayEnvelope(replayEvent, payloadWithSequence, dsn, client.getOptions().tunnel);
+    const envelope = createReplayEnvelope(replayEvent, recordingData, dsn, client.getOptions().tunnel);
 
     try {
       return await transport.send(envelope);
@@ -998,6 +1001,9 @@ export class ReplayContainer implements ReplayContainerInterface {
     }
   }
 
+  /**
+   * Reset the counter of retries for sending replays.
+   */
   resetRetries(): void {
     this._retryCount = 0;
     this._retryInterval = BASE_RETRY_INTERVAL;
diff --git a/packages/replay/src/session/saveSession.ts b/packages/replay/src/session/saveSession.ts
index a506625436f8..8f75d0ab50ed 100644
--- a/packages/replay/src/session/saveSession.ts
+++ b/packages/replay/src/session/saveSession.ts
@@ -1,6 +1,9 @@
 import { REPLAY_SESSION_KEY, WINDOW } from '../constants';
 import type { Session } from '../types';
 
+/**
+ * Save a session to session storage.
+ */
 export function saveSession(session: Session): void {
   const hasSessionStorage = 'sessionStorage' in WINDOW;
   if (!hasSessionStorage) {
diff --git a/packages/replay/src/types.ts b/packages/replay/src/types.ts
index df35aefd2c60..029bd109c31f 100644
--- a/packages/replay/src/types.ts
+++ b/packages/replay/src/types.ts
@@ -235,3 +235,30 @@ export interface ReplayContainer {
   addUpdate(cb: AddUpdateCallback): void;
   getOptions(): ReplayPluginOptions;
 }
+
+export interface ReplayPerformanceEntry {
+  /**
+   * One of these types https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType
+   */
+  type: string;
+
+  /**
+   * A more specific description of the performance entry
+   */
+  name: string;
+
+  /**
+   * The start timestamp in seconds
+   */
+  start: number;
+
+  /**
+   * The end timestamp in seconds
+   */
+  end: number;
+
+  /**
+   * Additional unstructured data to be included
+   */
+  data?: Record<string, unknown>;
+}
diff --git a/packages/replay/src/util/addMemoryEntry.ts b/packages/replay/src/util/addMemoryEntry.ts
index bac07200cd6c..0b847a25a42d 100644
--- a/packages/replay/src/util/addMemoryEntry.ts
+++ b/packages/replay/src/util/addMemoryEntry.ts
@@ -1,7 +1,15 @@
 import { WINDOW } from '../constants';
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, ReplayPerformanceEntry } from '../types';
 import { createPerformanceSpans } from './createPerformanceSpans';
 
+type ReplayMemoryEntry = ReplayPerformanceEntry & { data: { memory: MemoryInfo } };
+
+interface MemoryInfo {
+  jsHeapSizeLimit: number;
+  totalJSHeapSize: number;
+  usedJSHeapSize: number;
+}
+
 /**
  * Create a "span" for the total amount of memory being used by JS objects
  * (including v8 internal objects).
@@ -17,3 +25,23 @@ export function addMemoryEntry(replay: ReplayContainer): void {
     // Do nothing
   }
 }
+
+function createMemoryEntry(memoryEntry: MemoryInfo): ReplayMemoryEntry {
+  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;
+  // we don't want to use `getAbsoluteTime` because it adds the event time to the
+  // time origin, so we get the current timestamp instead
+  const time = new Date().getTime() / 1000;
+  return {
+    type: 'memory',
+    name: 'memory',
+    start: time,
+    end: time,
+    data: {
+      memory: {
+        jsHeapSizeLimit,
+        totalJSHeapSize,
+        usedJSHeapSize,
+      },
+    },
+  };
+}
diff --git a/packages/replay/src/util/createBreadcrumb.ts b/packages/replay/src/util/createBreadcrumb.ts
index bb1d2eb49ec1..b9f7527b0180 100644
--- a/packages/replay/src/util/createBreadcrumb.ts
+++ b/packages/replay/src/util/createBreadcrumb.ts
@@ -2,6 +2,9 @@ import type { Breadcrumb } from '@sentry/types';
 
 type RequiredProperties = 'category' | 'message';
 
+/**
+ * Create a breadcrumb for a replay.
+ */
 export function createBreadcrumb(
   breadcrumb: Pick<Breadcrumb, RequiredProperties> & Partial<Omit<Breadcrumb, RequiredProperties>>,
 ): Breadcrumb {
diff --git a/packages/replay/src/util/createPerformanceSpans.ts b/packages/replay/src/util/createPerformanceSpans.ts
index 9bb999a0faa3..f7327ff488b0 100644
--- a/packages/replay/src/util/createPerformanceSpans.ts
+++ b/packages/replay/src/util/createPerformanceSpans.ts
@@ -1,7 +1,6 @@
 import { EventType } from 'rrweb';
 
-import { ReplayPerformanceEntry } from '../createPerformanceEntry';
-import type { ReplayContainer } from '../types';
+import type { ReplayContainer, ReplayPerformanceEntry } from '../types';
 import { addEvent } from './addEvent';
 
 /**
diff --git a/packages/replay/src/util/createPayload.ts b/packages/replay/src/util/createRecordingData.ts
similarity index 90%
rename from packages/replay/src/util/createPayload.ts
rename to packages/replay/src/util/createRecordingData.ts
index b3b6615b1b40..63c1db5f6e7b 100644
--- a/packages/replay/src/util/createPayload.ts
+++ b/packages/replay/src/util/createRecordingData.ts
@@ -2,7 +2,10 @@ import { ReplayRecordingData } from '@sentry/types';
 
 import type { RecordedEvents } from '../types';
 
-export function createPayload({
+/**
+ * Create the recording data ready to be sent.
+ */
+export function createRecordingData({
   events,
   headers,
 }: {
diff --git a/packages/replay/src/util/createReplayEnvelope.ts b/packages/replay/src/util/createReplayEnvelope.ts
index 3d950e06cb29..3a052f32fdd6 100644
--- a/packages/replay/src/util/createReplayEnvelope.ts
+++ b/packages/replay/src/util/createReplayEnvelope.ts
@@ -1,6 +1,10 @@
 import { DsnComponents, ReplayEnvelope, ReplayEvent, ReplayRecordingData } from '@sentry/types';
 import { createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader } from '@sentry/utils';
 
+/**
+ * Create a replay envelope ready to be sent.
+ * This includes both the replay event, as well as the recording data.
+ */
 export function createReplayEnvelope(
   replayEvent: ReplayEvent,
   recordingData: ReplayRecordingData,
diff --git a/packages/replay/src/util/isBrowser.ts b/packages/replay/src/util/isBrowser.ts
index 3ad78dce93a5..6a64317ba3fa 100644
--- a/packages/replay/src/util/isBrowser.ts
+++ b/packages/replay/src/util/isBrowser.ts
@@ -1,5 +1,8 @@
 import { isNodeEnv } from '@sentry/utils';
 
+/**
+ * Returns true if we are in the browser.
+ */
 export function isBrowser(): boolean {
   // eslint-disable-next-line no-restricted-globals
   return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());
diff --git a/packages/replay/src/util/isRrwebError.ts b/packages/replay/src/util/isRrwebError.ts
index d9b065857062..1607f55255ef 100644
--- a/packages/replay/src/util/isRrwebError.ts
+++ b/packages/replay/src/util/isRrwebError.ts
@@ -1,5 +1,8 @@
 import { Event } from '@sentry/types';
 
+/**
+ * Returns true if we think the given event is an error originating inside of rrweb.
+ */
 export function isRrwebError(event: Event): boolean {
   if (event.type || !event.exception?.values?.length) {
     return false;
diff --git a/packages/replay/src/util/monkeyPatchRecordDroppedEvent.ts b/packages/replay/src/util/monkeyPatchRecordDroppedEvent.ts
index 76825f727e6b..70cf11faf450 100644
--- a/packages/replay/src/util/monkeyPatchRecordDroppedEvent.ts
+++ b/packages/replay/src/util/monkeyPatchRecordDroppedEvent.ts
@@ -3,6 +3,9 @@ import { Client, DataCategory, Event, EventDropReason } from '@sentry/types';
 
 let _originalRecordDroppedEvent: Client['recordDroppedEvent'] | undefined;
 
+/**
+ * Overwrite the `recordDroppedEvent` method on the client, so we can find out which events were dropped.
+ * */
 export function overwriteRecordDroppedEvent(errorIds: Set<string>): void {
   const client = getCurrentHub().getClient();
 
@@ -28,6 +31,9 @@ export function overwriteRecordDroppedEvent(errorIds: Set<string>): void {
   _originalRecordDroppedEvent = _originalCallback;
 }
 
+/**
+ * Restore the original method.
+ * */
 export function restoreRecordDroppedEvent(): void {
   const client = getCurrentHub().getClient();
 
diff --git a/packages/replay/src/util/getReplayEvent.ts b/packages/replay/src/util/prepareReplayEvent.ts
similarity index 90%
rename from packages/replay/src/util/getReplayEvent.ts
rename to packages/replay/src/util/prepareReplayEvent.ts
index 5a0cfd0ac8ff..a7e2fd6da995 100644
--- a/packages/replay/src/util/getReplayEvent.ts
+++ b/packages/replay/src/util/prepareReplayEvent.ts
@@ -1,7 +1,10 @@
 import { prepareEvent, Scope } from '@sentry/core';
 import { Client, ReplayEvent } from '@sentry/types';
 
-export async function getReplayEvent({
+/**
+ * Prepare a replay event & enrich it with the SDK metadata.
+ */
+export async function prepareReplayEvent({
   client,
   scope,
   replayId: event_id,
diff --git a/packages/replay/test/unit/util/getReplayEvent.test.ts b/packages/replay/test/unit/util/prepareReplayEvent.test.ts
similarity index 88%
rename from packages/replay/test/unit/util/getReplayEvent.test.ts
rename to packages/replay/test/unit/util/prepareReplayEvent.test.ts
index 1949b722c545..4c7785bf3735 100644
--- a/packages/replay/test/unit/util/getReplayEvent.test.ts
+++ b/packages/replay/test/unit/util/prepareReplayEvent.test.ts
@@ -3,10 +3,10 @@ import { getCurrentHub, Hub, Scope } from '@sentry/core';
 import { Client, ReplayEvent } from '@sentry/types';
 
 import { REPLAY_EVENT_NAME } from '../../../src/constants';
-import { getReplayEvent } from '../../../src/util/getReplayEvent';
+import { prepareReplayEvent } from '../../../src/util/prepareReplayEvent';
 import { getDefaultBrowserClientOptions } from '../../utils/getDefaultBrowserClientOptions';
 
-describe('getReplayEvent', () => {
+describe('prepareReplayEvent', () => {
   let hub: Hub;
   let client: Client;
   let scope: Scope;
@@ -33,12 +33,11 @@ describe('getReplayEvent', () => {
       trace_ids: ['trace-ID'],
       urls: ['https://sentry.io/'],
       replay_id: replayId,
-      event_id: replayId,
       replay_type: 'session',
       segment_id: 3,
     };
 
-    const replayEvent = await getReplayEvent({ scope, client, replayId, event });
+    const replayEvent = await prepareReplayEvent({ scope, client, replayId, event });
 
     expect(replayEvent).toEqual({
       type: 'replay_event',