Real User Monitoring (RUM)

Not all bugs crash. Some just make people quit, and you’re left staring at green dashboards, wondering what went wrong. Sentry’s Real User Monitoring shows what actually happens, revealing what backend metrics miss: session-level insights, slow pages, rage clicks — all directly tied to real users and the code-level issues behind the pain.

Try Sentry For Free Get a Demo

Tolerated by 4 million developers

  • GitHub
  • Disney
  • Atlassian
  • Linear
  • Vercel
  • Cloudflare
  • Slack
  • Metronome
  • Autodesk
  • Microsoft
  • Instacart
  • Lyft
  • Bolt
  • Monday
  • Cursor
  • Anthropic
  • Factory AI
  • Sentry
  • Baseten
  • Runlayer
  • Convex

From rage click to root cause

Follow the trace to the point of failure

Knowing a session broke is one thing. Knowing why, and how to fix it, is another. Sentry ties frontend behavior to backend traces and context, so you’re not guessing based on vague complaints or dashboards.

With Real User Monitoring, you get:

  • Session Replay that captures clicks, scrolls, rage-taps, and navigation, linked to stack traces and spans

  • Trace-level visibility into slow scripts, failed API calls, rendering issues, and more — right from the user’s browser

  • Impact-first prioritization, so you can focus on the sessions affecting the most users, not just the loudest alerts

Watch what the user saw. See what broke. Fix what matters.

Learn about Tracing

Monitor your Web Vitals

Measure what matters, then fix it fast

Web Vitals impact everything from SEO to user experience and revenue. But knowing a page is slow isn’t enough, you need to know why. Sentry connects frontend metrics with backend traces and code-level profiling to show exactly what’s causing the lag.

With Web Vitals Monitoring, you get:

  • Key metrics like LCP, INP, CLS, FCP, and TTFB, tracked in real time and rolled into a single score

  • Trace waterfalls and replays that reveal which calls, assets, or user actions are behind the slowdown

  • Code profiling that highlights the specific function or line of code causing the issue

From metric to root cause, Sentry gives you the full picture.

Learn more about Web Vitals

See what users experience

Full visibility into real user behavior

Get real-time visibility into your app’s performance, user behavior, and privacy — all in one place.

With Real User Monitoring, you’ll get:

  • Instant alerts for slow pages, error spikes, and downtime, with smart routing and anomaly detection to keep noise low

  • Full session replays that show every user click, scroll, and rage‑tap alongside stack traces and spans — no guesswork

  • Privacy by default, with sensitive data like passwords and credit cards stripped on the server and masking tools you can control

The result: clear context, real impact, and zero oversharing, all without switching tools.

Full visibility into real user behavior
Traditional RUM

Black‑Box Metrics: You’re staring at waterfall charts and percentile graphs that tell you something is slow, but not why‑or which user flows are paying the price.

Context Vacuum: RUM dashboards sit in their own silo, so you’re forced to juggle separate tools for errors, traces, and logs—good luck matching a Core Web Vital spike to the deploy that caused it.

Privacy Panic: Instrumenting the browser feels risky; masking, scrubbing, and compliance settings live in a different console (or worse, a legal doc), so teams ship half‑baked configs—or none at all.

Single‑Page‑App Blind Spots: Traditional RUM still thinks every navigation is a full page load, so route changes, lazy‑loaded bundles, and long tasks hide in plain sight.

Developer Disengagement: The performance team cares, the business team cares, but the people who can actually fix the code? They’re busy because the RUM tool speaks in metrics, not stack traces.

RUM with Sentry

Full Visibility into Performance: Web Vitals, custom spans, and error events land in one place—right next to the exact release, commit, and line of code. Move directly from symptom to fix without tab‑surfing.

Session‑Aware Debugging: Jump straight from a 400 ms INP outlier to a Session Replay of the actual click path, console logs, and network chatter that caused it. No more “can you record your screen?”.

Privacy Built‑In: Field‑level scrubbing, domain‑level blocking, and one‑click GDPR/CCPA modes ship with the SDK, so legal sleeps well and you still get the diagnostics you need.

Instrumentation built for SPAs: Route changes, virtual pages, and long tasks are auto‑captured, so modern frameworks (React, Vue, Next, Remix—you name it) finally get monitoring that understands them.

Developer‑First UX: Clean UI, GitHub‑linked stack traces, and IDE‑ready deep links mean the folks writing code actually use the tool—turning “somebody should fix this” into “PR #457 closes it.”

Getting started with Sentry is simple

We support every technology (except the ones we don't).
Get started with just a few lines of code.

Install

The Replay integration is already included in your browser or framework SDK NPM packages. If you're using CDN bundles instead of NPM packages, you need to load the Replay integration CDN bundle in addition to your browser bundle:

npm install --save @sentry/browser

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 for more details.

// import Sentry from your framework SDK (e.g. @sentry/react) instead of @sentry/browser
import * as Sentry from "@sentry/browser";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

# Angular 12 and newer:
npm install --save @sentry/angular-ivy

# Angular 10 and 11:
npm install --save @sentry/angular

Angular Version Compatibility

Because of the way Angular libraries are compiled, you need to use a specific version of the Sentry SDK for each corresponding version of Angular as shown below:

Angular Version Recommended Sentry SDK
12 and newer @sentry/angular-ivy
10, 11 @sentry/angular

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 for more details.

import * as Sentry from "@sentry/angular-ivy";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The easiest way to update through the Sentry Android Gradle plugin to your app module's build.gradle file.

plugins {
  id("com.android.application")
  id("io.sentry.android.gradle") version "4.14.1"
}

If you have the SDK installed without the Sentry Gradle Plugin, you can update the version directly in the build.gradle through:

dependencies {
    implementation("io.sentry:sentry-android:7.20.0")
}

Set Up

To set up the integration, add the following to your Sentry initialization.

SentryAndroid.init(context) { options ->
  options.dsn = "https://examplePublicKey@o0.ingest.sentry.io/0"
  options.isDebug = true

  options.sessionReplay.onErrorSampleRate = 1.0
  options.sessionReplay.sessionSampleRate = 0.1
}

Install

The Replay integration is already included with the Sentry Astro SDK.

npx astro add @sentry/astro

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 for more details.

Session replay is enabled by default if you use the SDK configuration in your astro.config.mjs file.

You can customize Replay sample rates like so:

import { defineConfig } from "astro/config";
import sentry from "@sentry/astro";

export default defineConfig({
  integrations: [
    sentry({
      dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
      replaysSessionSampleRate: 0.2, // defaults to 0.1
      replaysOnErrorSampleRate: 1.0, // defaults to 1.0
    }),
  ],
});

If you have a custom SDK configuration file for the client side (sentry.client.config.js), add the Sentry Replay integration:

import * as sentry from "@sentry/astro";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
  integrations: [Sentry.replayIntegration()],
});

Install

Install the Sentry Capacitor SDK alongside the corresponding Sentry SDK for the framework you're using, such as React in this example:

# npm
npm install --save @sentry/capacitor @sentry/vue

# yarn
yarn add @sentry/capacitor @sentry/vue

Set Up

import * as Sentry from "@sentry/capacitor";
import { Replay } from "@sentry/replay";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // This sets the sample rate at 10%. You may want this to be 100% while
  // in development, then 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: [
    replayIntegration({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

npm install --save @sentry/electron

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 for more details.

import * as Sentry from "@sentry/electron/renderer";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

# ember-cli
ember install @sentry/ember

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 for more details.

import * as Sentry from "@sentry/ember";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Prerequisites

Make sure your Sentry Flutter SDK version is at least 8.9.0, which is required for Session Replay. You can update your pubspec.yaml to the matching version:

dependencies:
  sentry_flutter: ^8.9.0

Install

To set up the integration, add the following to your Sentry initialization:

await SentryFlutter.init((options) {
  ...
  options.experimental.replay.sessionSampleRate = 1.0;
  options.experimental.replay.onErrorSampleRate = 1.0;
});

Install

The Replay integration is already included with the Gatsby SDK package.

npm install --save @sentry/gatsby

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 for more details.

import * as Sentry from "@sentry/gatsby";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The easiest way to update through the Sentry iOS CocoaPods file.

.package(url: "https://github.com/getsentry/sentry-cocoa", from: "8.43.0"),

Set Up

To set up the integration, add the following to your Sentry initialization.

SentrySDK.start(configureOptions: { options in
  options.dsn = "https://examplePublicKey@o0.ingest.sentry.io/0"
  options.debug = true

  options.sessionReplay.onErrorSampleRate = 1.0
  options.sessionReplay.sessionSampleRate = 0.1
})

Install

The Replay integration is already included with the Sentry SDK. We recommend installing the SDK through our installation wizard:

npx @sentry/wizard@latest -i nextjs

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 for more details.

On your client-side NextJS app, add:

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

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The Replay integration is already included with the React SDK package.

npm install --save @sentry/react

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 for more details.

import * as Sentry from "@sentry/react";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The Replay integration is already included with the Sentry SDK. We recommend installing the SDK through our installation wizard:

npm install @sentry/react-native --save

Set Up

To set up the integration, add the following to your Sentry initialization.

import * as Sentry from "@sentry/react-native";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
  integrations: [Sentry.mobileReplayIntegration()],
});

Install

The Replay integration is already included with the Sentry SDK. We recommend installing the SDK through our installation wizard:

npx @sentry/wizard@latest -i remix

The wizard will prompt you to log in to Sentry. It will then automatically do the following steps for you:

  • create two files in the root directory of your project, entry.client.tsx and entry.server.tsx (if they don't already exist).
  • add the default Sentry.init() for the client in entry.client.tsx and the server in entry.server.tsx.
  • create .sentryclirc with an auth token to upload source maps (this file is automatically added to .gitignore).
  • adjust your build script in package.json to automatically upload source maps to Sentry when you build your application.
  • add an example page to your app to verify your Sentry setup

After the wizard setup is completed, the SDK will automatically capture unhandled errors, and monitor performance. You can also manually capture errors.

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 for more details.

On your client-side Remix app, add:

import * as Sentry from "@sentry/remix";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The Replay integration is already included with the Svelte SDK package.

npm install --save @sentry/svelte

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 for more details.

import * as Sentry from "@sentry/svelte";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The Replay integration is already included with the Sentry SDK. We recommend installing the SDK by running our installation wizard in the root directory of your project:

npx @sentry/wizard@latest -i sveltekit

The wizard will prompt you to log in to Sentry. It will then automatically do the following steps for you:

  • create or update SvelteKit files with the default Sentry configuration:
    • hooks.(client|server).js to initialize the SDK and instrument SvelteKit's hooks
    • vite.config.js to add source maps upload and auto-instrumentation via Vite plugins.
  • create a .sentryclirc file with an auth token to upload source maps (this file is automatically added to .gitignore)
  • add an example page to your app to verify your Sentry setup

After the wizard setup is completed, the SDK will automatically capture unhandled errors, and monitor performance. You can also manually capture errors.

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 for more details.

On your client-side SvelteKit app, add:

import * as Sentry from "@sentry/sveltekit";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

Install

The Replay integration is already included with the Vue SDK package.

npm install --save @sentry/vue

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 for more details.

import * as Sentry from "@sentry/vue";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",

  // 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({
      // Additional SDK configuration goes in here, for example:
      maskAllText: true,
      blockAllMedia: true,
    }),
  ],
});

That's it. Check out our documentation to ensure you have the latest instructions.

Create a Sentry Account See All Platforms
"We’re shipping six to seven times a day across more than 100 teams, keeping up this pace with the visibility we had was nearly impossible before moving to Sentry SaaS."
Coveo
Since adopting Sentry, Coveo has seen...
2x

release pace without risking undetected issues in production

50%

decrease in debugging time

250

projects migrated to Sentry in <2 months

read more

More RUM content

Debug errors faster while protecting user privacy with Session Replay

Debug errors faster while protecting user privacy with Session Replay

Debug errors faster while protecting user privacy with Session Replay. See how Tilled uses Session Replay for faster debugging, and how Sentry helps t...
Debugging e-commerce performance issues with Session Replay

Debugging e-commerce performance issues with Session Replay

Session Replay shows you how customers experience your e-commerce site when things go wrong, from performance hiccups to checkout failures. In this st...
Smarter Tools and Best Practices for Mobile Debugging: A Hands-On Workshop

Smarter Tools and Best Practices for Mobile Debugging: A Hands-On Workshop
Session Replay: Debug Faster without the Guesswork

Session Replay: Debug Faster without the Guesswork

Get full visibility into user errors to see exactly what went wrong and when with Session Replay.
Debugging weird stack traces with Session Replay

Debugging weird stack traces with Session Replay

Sometimes errors aren't always easy to understand, the stack trace doesn't give a lot of info. You can see through breadcrumbs that something went wro...
Monitoring & Debugging a Checkout Flow in Flask & React

Monitoring & Debugging a Checkout Flow in Flask & React

When your checkout flow breaks, customers disappear faster than most ‘cutting-edge’ JS metaframeworks. Let's walk through how we instrumented, monitor...
Debuggability Explained - Monitoring & Observability in Your Workflow

Debuggability Explained - Monitoring & Observability in Your Workflow

Monitoring & debugging are critical in every developer's workflow. Learn more about debuggability and the differences between observability vs. monito...