---
title: "Session Replay"
description: "Learn how to enable Session Replay in your app if it is not already set up."
url: https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/
---

# Set Up Session Replay for Next.js

If you have any questions, feedback or would like to report a bug, please open a [GitHub issue](https://github.com/getsentry/sentry/issues/new?assignees=\&labels=\&template=bug.yml) with a link to a relevant replay or, if possible, a publicly accessible URL to the page you're attempting to record a replay of.

[Session Replay](https://docs.sentry.io/product/session-replay.md) helps you get to the root cause of an error or latency issue faster by providing you with a video-like reproduction of what was happening in the user's browser before, during, and after the issue. You can rewind and replay your application's DOM state and see key user interactions, like mouse clicks, scrolls, network requests, and console entries, in a single combined UI inspired by your browser's DevTools.

By default, Sentry's Session Replay SDK masks all DOM text content, images, and user input, giving you heightened confidence that no sensitive data will leave the browser. To learn more, see [Session Replay Privacy](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md).

You can also use Session Replay to record user interactions with your application that do not result in an error. This is helpful for understanding the user's experience and for debugging issues that are not related to errors, like performance issues.

In this page, learn how to [set up Session Replay](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#set-up) and best practices for [configuring its sampling rates](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#sampling).

## [Prerequisites](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#prerequisites)

Session Replay requires your SDK to be version `7.27.0` or higher. If you're on an older version, please check the [migration document](https://github.com/getsentry/sentry-javascript/blob/master/MIGRATION.md).

Session Replay requires Node 12+, and browsers newer than IE11.

## [Install](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#install)

Session Replay is included with `@sentry/nextjs`. If you haven't installed Sentry yet, run the wizard:

```bash
npx @sentry/wizard@latest -i nextjs
```

If you already have Sentry installed, skip to [Set Up](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#set-up) below.

## [Set Up](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#set-up)

To set up the integration, add the following to your Sentry initialization. There are several options you can pass to the integration constructor. See the [configuration documentation](https://docs.sentry.io/platforms/javascript/session-replay/configuration.md) for more details.

These are starting values, not a recommendation for your application. The rest of this page is about how to tune them to get the replays that matter to you.

Session Replay only runs in the browser, so you only need to configure it in `instrumentation-client.ts`. The server (`sentry.server.config.ts`) and edge (`sentry.edge.config.ts`) entry points run in Node.js and Edge runtimes where Replay is not available.

#### [Add Replay Integration](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#add-replay-integration)

Add `replayIntegration()` to your client initialization and configure the sample rates.

**Testing tip:** Set `replaysSessionSampleRate: 1.0` during development to capture all sessions.

```typescript
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",

  // This sets the sample rate to be 10%. You may want this to be 100% while
  // in development and sample at a lower rate in production
  replaysSessionSampleRate: 0.1,

  // If the entire session is not sampled, use the below sample rate to sample
  // sessions when an error occurs.
  replaysOnErrorSampleRate: 1.0,

  integrations: [Sentry.replayIntegration()],
});
```

#### [Privacy Options](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#privacy-options)

By default, Replay masks all text and blocks media. Customize privacy settings based on your needs.

See [Session Replay Privacy](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md) for all options.

```typescript
Sentry.replayIntegration({
  // Text masking (default: true)
  maskAllText: true,

  // Block images/videos (default: true)
  blockAllMedia: true,

  // Mask specific inputs
  maskAllInputs: true,
}),
```

### [PII & Privacy Considerations](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#pii--privacy-considerations)

Personally identifiable information (PII) and privacy are important considerations when enabling Session Replay. There are multiple ways in which Sentry helps you avoid collecting PII, including:

* [Masking](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md#masking), which replaces text content with something else (the default behavior being to replace each character with a `*`).
* Making [network request and response bodies](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md#network-request-and-response-bodies-and-headers) opt-in, to avoid capturing endpoints that may contain PII.

For static websites without sensitive data, you can opt out of the default masking and blocking settings.

#### [Lazy-Loading Replay](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#lazy-loading-replay)

Load Replay only when needed instead of at startup. Useful for reducing initial bundle size.

```typescript
// Don't add replayIntegration to init
Sentry.init({
  integrations: [],
});

// Later, when you want to start recording:
import("@sentry/nextjs").then((lazyLoadedSentry) => {
  Sentry.addIntegration(lazyLoadedSentry.replayIntegration());
});
```

### [Canvas Recording](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#canvas-recording)

There is currently no PII scrubbing in canvas recordings!

#### [Enable Canvas Recording](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#enable-canvas-recording)

Add `replayCanvasIntegration()` to record HTML canvas elements. This is opt-in and tree-shaken from your bundle if not used.

```javascript
import * as Sentry from "@sentry/nextjs";

Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,

  integrations: [
    // Keep the Replay integration as before
    Sentry.replayIntegration(),

    // The following is all you need to enable canvas recording with Replay
    Sentry.replayCanvasIntegration(),
  ],
});
```

#### [3D and WebGL Canvases](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#3d-and-webgl-canvases)

For 3D/WebGL canvases, the integration needs `preserveDrawingBuffer` to export images, which can affect performance. To avoid this, enable manual snapshotting and call `snapshot()` inside your paint loop.

Call `snapshot()` in the same execution loop as draw commands to avoid capturing empty buffers.

```javascript
// Step 1: Enable manual snapshotting
Sentry.replayCanvasIntegration({
  enableManualSnapshot: true,
});

// Step 2: Call snapshot in your paint loop
function paint() {
  const canvasRef = document.querySelector("#my-canvas");
  Sentry.getClient()
    ?.getIntegrationByName("ReplayCanvas")
    ?.snapshot(canvasRef);
}
```

#### [WebGPU Canvases](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#webgpu-canvases)

WebGPU canvas textures expire after the current task completes. Use `skipRequestAnimationFrame: true` to capture immediately after rendering.

```javascript
// Step 1: Enable manual snapshotting
Sentry.replayCanvasIntegration({
  enableManualSnapshot: true,
});

// Step 2: Snapshot immediately after rendering
function paint() {
  const canvasRef = document.querySelector("#my-canvas");
  const canvasIntegration =
    Sentry.getClient()?.getIntegrationByName("ReplayCanvas");

  // ... your WebGPU rendering commands ...

  // Capture immediately - required for WebGPU
  canvasIntegration?.snapshot(canvasRef, {
    skipRequestAnimationFrame: true,
  });
}
```

### [Content Security Policy (CSP)](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#content-security-policy-csp)

#### [Configure CSP for Replay](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#configure-csp-for-replay)

Session Replay uses a WebWorker for compression off the main UI thread. Add these CSP entries to allow workers to load.

Safari versions ≤ 15.4 also need `child-src`.

```text
worker-src 'self' blob:
child-src 'self' blob:
```

If you're unable to update your CSP policy to allow inline web workers, you can also [use a custom compression worker](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/configuration.md#using-a-custom-compression-worker) instead.

### [Linking](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#linking)

Replays stay connected to the errors and traces from the same session, so you can move from what the user saw to the data around it.

#### [Error Linking](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#error-linking)

Errors that happen while a replay is running are linked to that replay. Open the replay from the issue, or open the related issue from [Replay Details](https://docs.sentry.io/product/session-replay/replay-details.md). The error count on Replay Details can be lower than the number of errors captured when the replay was rate-limited, deleted by someone in your organization, or not saved because of a network error.

#### [Trace Linking](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#trace-linking)

When [tracing](https://docs.sentry.io/platforms/javascript/guides/nextjs/tracing.md) is enabled, traces appear in the replay timeline. Select a span to open the trace and see the network request, database queries, and API calls behind that moment. From a trace, open the replay to see what the user was doing. See [Replay Linking](https://docs.sentry.io/platforms/javascript/guides/nextjs/tracing.md#replay-linking).

## [Sampling](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#sampling)

Sampling controls how much of your traffic results in a Session Replay. There are two rates, and they do different jobs.

| Option                     | What it records                                               | The question it answers                                                              |
| -------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
| `replaysOnErrorSampleRate` | Only when an error occurs, including the 60 seconds before it | "Something broke. What was the user doing?"                                          |
| `replaysSessionSampleRate` | Complete sessions from the start, error or not                | "What are users experiencing?" or "What's going wrong that isn't throwing an error?" |

A replay session starts when the SDK first loads. It stays open across pageloads, refreshes, and navigations in the same tab and on the same domain. A fully recorded session pauses after 5 minutes without a click, text input, or navigation, and resumes on the same session if the user does one of those again. The session ends after 15 minutes without one, after 60 minutes, or when the tab closes. That definition is not the same as a Google Analytics session. One person can produce several replay sessions in a day, so don't substitute analytics session counts for these numbers.

Most applications want a high error rate (`replaysOnErrorSampleRate`) and a low session rate (`replaysSessionSampleRate`), but every case is different. Sampling rates in your code represent percentages, so `1.0` = 100%, `0.1` = 10% and so on.

### [What Are You Trying to Answer?](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#what-are-you-trying-to-answer)

Session Replay has two sample rates, and most setups use both:

* `replaysOnErrorSampleRate` answers "what happened around this error?". The SDK holds the last 60 seconds of each session in memory and only uploads it if an error happens. You pay only for sessions that hit an error, so you can usually set this high (often 1.0). The replay attaches to the issue, so you can see what the user did to trigger the error and whether they noticed it, worked around it, or gave up.

* `replaysSessionSampleRate` answers "what are users running into that never throws an error?". Sessions it picks are recorded and uploaded in full, whether or not anything goes wrong, so every percent adds directly to your replay usage.

The SDK checks the session rate first. Any session it doesn't pick falls back to the error rate, so each session uses one rate or the other.

Rule of thumb: keep the error rate high. Reach for session recording only for problems an error won't tell you about. The sections below cover how to aim it, depending on what you know in advance.

### [Recording on Errors](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#recording-on-errors)

To record a replay when an error is thrown, use `replaysOnErrorSampleRate`. The replay attaches to the issue, so you can watch what the user did in the minute before the error was thrown. It answers:

* What did the user do to trigger this?
* Did this error hurt anyone? Watching the session tells you whether the user noticed, worked around it, or gave up, which is often what decides priority.

Recording on errors gives you context for problems you already know about, because the error told you. The three situations below cover finding problems that don't come attached to an error.

### [When You Know Where to Look](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#when-you-know-where-to-look)

You care about a specific route, a feature behind a flag, a release you shipped this week, or the checkout funnel. This is the most common case and the easiest one to configure well.

Leave the global rates alone and switch matching sessions to full recording, using `replay.flush()` if the session is buffering or `replay.start()` if no replay is running.

See [Examples of Custom Sampling](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/understanding-sessions.md#examples-of-custom-sampling) for recording by URL, feature flag, or user segment.

Nothing expires a raised rate for you, so decide up front how it comes back down. The cleanest way is to tie the increase to the thing you're watching: condition it on the feature flag or the release version, and it falls away when they do.

### [When You Know Who to Look At](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#when-you-know-who-to-look-at)

A customer reported a problem and you want their session. If the complaint arrives days later, either you were already recording that person or you weren't. A sampling rate only helps here at `1.0`, and that's expensive. `replay.flush()` only has the previous 60 seconds to send if `replaysOnErrorSampleRate` is above 0.

Two things that work better:

* **Capture at the moment they tell you.** Sentry's [User Feedback widget](https://docs.sentry.io/product/user-feedback.md#user-feedback-widget) sends a replay when a user opens the feedback widget or submits feedback. This requires `replaysOnErrorSampleRate` to be above 0, which keeps a buffer of the session in memory so the replay includes what happened before the widget opened (up to 60 seconds). If it's 0, the feedback arrives without that context. You can do the same from your own support widget by calling `replay.flush()`, which uploads the buffered session and gives you a replay ID to attach to the ticket. The same requirement applies with an error rate of 0, `flush()` only records from the moment it's called.
* **Record the users most likely to contact you.** Set a higher rate for logged-in users, paying accounts, or enterprise customers. This covers your support cases at a fraction of what raising the rate for all traffic would cost.

Either way, call [`setUser`](https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/apis.md#setUser) so you can find the session once you have it.

### [When You Don't Know Either: Broad Observability](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#when-you-dont-know-either-broad-observability)

Targeted and on-error sampling only catch problems you can predict. To find the ones you can't, like rage clicks or a broken flow on a page you weren't watching, set a small baseline with `replaysSessionSampleRate`. This is the one case where a flat, global percentage makes sense.

Sentry captures [Rage clicks, dead clicks, and hydration error issues](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/issue-types.md) from replay data. Rage and dead clicks don't throw errors, so only session-sampled replays (replaysSessionSampleRate) capture them, both as rage clicks. Hydration errors are also sent as regular errors, but by default an inbound filter drops those and Sentry creates the issue from the replay instead, which gives you the visual and HTML diff tools. Rage click and hydration issues are grouped by problem type and URL, so even a low session sample rate will surface recurring problems.

This is also a good use case for using the [Session Replay Explorer](https://sentry.io/orgredirect/organizations/:orgslug/explore/replays/?project=:projectId) to discover potential problems you might not have otherwise known about.

### [Setting Your Rates](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#setting-your-rates)

Set the error rate and the session rate separately.

#### [Your Error Rate](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#your-error-rate)

**Keep `replaysOnErrorSampleRate` at `1.0`, but tune your error noise first.**

At `1.0`, every session that hits any error is recorded. A single noisy error on a popular route can consume a lot of replays that all look the same.

Before lowering the rate, reduce which errors you record:

* `ignoreErrors` for third-party scripts, browser extension noise, and benign quirks.
* `beforeErrorSampling` to skip errors you've already triaged, already have replays for, or don't intend to fix.

```javascript
Sentry.replayIntegration({
  beforeErrorSampling: (event) => {
    const message = event.exception?.values?.[0]?.value ?? "";
    // We already have plenty of replays for this one
    return !message.includes(
      "NetworkError when attempting to fetch resource",
    );
  },
});
```

`beforeErrorSampling` only runs in [buffer mode](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/understanding-sessions.md#buffer-mode). If a session was already selected by `replaysSessionSampleRate`, it records regardless.

Lower `replaysOnErrorSampleRate` below `1.0` only if you can't bring the noise down. Reducing sampling uniformly across errors can also sample away the rare one you most wanted to see.

#### [Your General Session Rate](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#your-general-session-rate)

How much you need depends on how much your sessions differ from each other. Session replays show you experiences you didn't know to look for. If every session resembles every other one, a smaller number will tell you what you need to know. If they vary a lot, you need more to have a reasonable chance of catching the unusual one.

**Record more when sessions differ:** a large or highly interactive surface area, layouts that vary per user, long multi-step sessions, a product changing quickly, or a feature that just launched.

**Record less when sessions look alike:** a handful of templated page types, short visits, a stable UI that hasn't changed in months, mostly static content. For example, a documentation site doesn't need much.

### [What a Given Rate Covers](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#what-a-given-rate-covers)

You can't predict how often a problem will happen before it happens, so this isn't a way to choose a rate. It is useful after the fact, when you want to understand why a replay you expected isn't there, or to sanity-check what your current rate is likely to catch.

The chance of catching at least one occurrence of something is:

**P(caught at least once) = 1 - (1 - r)^n**

*where r = your sample rate and n = the number of times it happened*

| Times it occurred | `0.01` | `0.05` | `0.1` | `0.25` |
| ----------------- | ------ | ------ | ----- | ------ |
| 1                 | 1%     | 5%     | 10%   | 25%    |
| 10                | 10%    | 40%    | 65%   | 94%    |
| 50                | 39%    | 92%    | 99%   | 100%   |
| 100               | 63%    | 99%    | 100%  | 100%   |
| 500               | 99%    | 100%   | 100%  | 100%   |

*Assumes the problem threw no error. Anything that throws is covered by `replaysOnErrorSampleRate` instead.*

**Read the top row closely.** If you need one specific session, raising your rate won't get it. Record that route or that user deliberately, or capture it manually.

### [Checking the Cost](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#checking-the-cost)

Once you know roughly what your use cases need, check what it costs before you deploy. Work in this direction rather than the reverse: a rate derived from a budget alone can land below what your use cases need, and then the money is spent without buying you the answer.

You'll need three numbers: sessions per day, roughly what share of those sessions hit an error, and your available replay quota. The first two are in your Sentry project; the quota is under your subscription settings.

Error-triggered replays are mostly out of your hands: if `replaysOnErrorSampleRate` is `1.0`, your error volume sets that number. Calculate it first, then add what your session rate will produce.

```text
sessions per day with an error × replaysOnErrorSampleRate × 30 days = error-triggered replays per month

sessions per day × replaysSessionSampleRate × 30 days = session-sampled replays per month
```

If the total is more than your quota, you have three options: raise the quota, narrow your session sampling to specific routes or users, or reduce your error volume. Dropping your session rate to whatever fits may be tempting, but it can leave you paying for replays that no longer answer your question.

If you don't have your traffic numbers yet, start low and leave a comment saying the rate is provisional. Over-recording costs money quietly, while under-recording shows up the first time someone goes looking for a replay and it isn't there. Either way, work out the expected monthly volume before you deploy rather than after.

One other consideration: recording is work in your user's browser or device, and mutation-heavy pages feel it most. See [Mutation Limits](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/configuration.md#mutation-limits).

### [Worked Example](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#worked-example)

An app with 8,000 sessions per day, about 3% of which hit an error, and a budget of 10,000 replays per month:

* Sessions with an error: 8,000 × 0.03 = 240 per day
* Error-triggered replays: 240 × 30 = 7,200 per month at `replaysOnErrorSampleRate: 1.0`
* At the `0.1` starting value, `replaysSessionSampleRate` adds 8,000 × 0.1 × 30 = 24,000 per month
* Total: 31,200 replays per month, about three times the budget

Error-triggered replays alone take 72% of this budget. Now you decide: if broad observability is all you need from session sampling, `0.01` brings the total to 9,600 and fits. If you need to watch checkout closely, keep the global rate low and record that route instead. If you need both, the budget is too small and the answer is to raise it.

### [Things to Avoid](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#things-to-avoid)

* Don't ship `replaysSessionSampleRate: 1.0` to production. It's the right setting while you're testing locally and almost never right once you're live.
* Don't guess at numbers you can look up. Sessions per day and error rate are both in your Sentry project. A sample rate derived from a guess is usually off by enough to matter. If you can't get them, ask someone who can rather than estimating.
* Setting both rates to `0` turns replay off completely. If you're using a low baseline plus targeted recording, you still need a baseline above `0`, or you need to call `replay.start()` or `replay.startBuffering()` manually.
* Write down when a temporary rate increase should come back down. Rates raised to investigate an issue or watch a release tend to stay raised. Put the date or the release in a comment next to the value.
* Don't filter on error message text in `beforeErrorSampling` if your app is localized. Match on error type, or on a tag you set yourself, so the filter doesn't silently stop working in other languages.

### [Adjusting Over Time](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#adjusting-over-time)

**Raise your session rate** when you're investigating a specific issue, or shortly after a release when you want to watch a launch closely. Scope the increase to the route or flag you care about where you can.

**Lower it** when you're hitting your replay quota before the end of the month, replays are piling up unreviewed, or your application is stable and you're seeing the same few flows repeatedly. Also lower it once whatever prompted you to raise it has shipped and settled. Revisit after launches, redesigns, and significant changes in traffic.

## [Verify](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#verify)

While you're testing, we recommend that you set `replaysSessionSampleRate` to `1.0`. This ensures that every user session will be sent to Sentry.

Once testing is complete, **we recommend lowering this value in production**. We still recommend keeping `replaysOnErrorSampleRate` set to `1.0`.

## [Related Features](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#related-features)

* [Tracing](https://docs.sentry.io/platforms/javascript/guides/nextjs/tracing.md) — Traces on the Replay timeline show the requests behind a session and where they failed or slowed down.
* [Logs](https://docs.sentry.io/platforms/javascript/guides/nextjs/logs.md) — Logs emitted during a replay session are automatically linked for easy navigation.

## [Replay Next Steps](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay.md#replay-next-steps)

* #### [Configuration](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/configuration.md)

  Learn about the general Session Replay configuration fields.

* #### [Privacy](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md)

  Configuring Session Replay to maintain user and data privacy.

* #### [Replay Issues](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/issue-types.md)

  Learn about the Issue types that Session Replay can detect.

* #### [Understanding Sessions](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/understanding-sessions.md)

  Learn about customizing sessions with the Session Replay SDK.

* #### [Session Replay Troubleshooting](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/troubleshooting.md)

  Troubleshooting Session Replay-specific Issues

## Pages in this section

- [Configuration](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/configuration.md)
- [Privacy](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/privacy.md)
- [Replay Issues](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/issue-types.md)
- [Understanding Sessions](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/understanding-sessions.md)
- [Troubleshooting](https://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/troubleshooting.md)
