# Session Replay

Get to the root cause of an issue faster by watching replays of real user sessions with best-in-class privacy controls. Understand when, where, and how an error is impacting your website or mobile app without having to repro it yourself, talk to a customer, or expose sensitive data.

[ Try Sentry for Free ](https://sentry.io/signup/) [ Get a Demo ](https://sentry.io/demo/)

## Visual Debugging for Developers

### Debug with visual context

Navigate your application’s console output, network calls, and even watch reproductions of user actions. Get the insights and context that matters, right inside Sentry.

[ Read the Docs ](https://docs.sentry.io/product/session-replay/)

### Protect your users' privacy

Lock down your debugging experience without sacrificing user privacy with a range of privacy controls to ensure no sensitive user information leaves your users device.

[ Learn More ](https://docs.sentry.io/product/session-replay/protecting-user-privacy/)

### Fix mobile issues without the guesswork

Maintain a 5 star mobile app experience by getting device-level insight into a given user session including battery level, device orientation, and connectivity.

[ Read the Docs ](https://docs.sentry.io/product/explore/session-replay/mobile/)

## How Sentry helps

[ ### Private by Default Sessions prioritize user privacy.  ](https://docs.sentry.io/security-legal-pii/scrubbing/protecting-user-privacy/)[ ### Associated Errors and Performance Link replays to error and performance issues. ](https://docs.sentry.io/product/insights/)[ ### Hydration Error Diff Tool (EA) Pinpoint hydration errors through session replays. ](https://docs.sentry.io/product/issues/issue-details/replay-issues/hydration-error/)[ ### Rage & Dead Click Detection Identify unresponsive elements users engage with. ](https://docs.sentry.io/product/issues/issue-details/replay-issues/rage-clicks/)[ ### User Feedback Collect direct user feedback on issues.  ](https://docs.sentry.io/product/user-feedback/)

Session Replay has been instrumental in helping us resolve hydration errors. With Replay, we can visually see the jankiness of the page and pinpoint which components were impacted, saving us hours of manual debugging.

Laszlo Gaal

Fullstack JavaScript Engineer,

Lablab.ai

I have been using Session Replay in a few of my company's apps and it is a really great feature! Not only has it helped me and my team to be more efficient on resolving very oddly-specific issues and things related to UI, but also has helped me spot issues with non-error sessions as well.

John Victor

Fullstack Software Developer,

Jornadayu

## 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.

JavaScriptAngularAstroCapacitorElectronEmberGatsbyNext.jsReactRemixSvelteSveltekitVueReact NativeAndroidiOSFlutter

## 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:

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    // 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

Copied!Click to Copy

    # 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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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 Replay integration is already included with the Sentry Astro SDK.

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) 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:

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/guides/astro/manual-setup/#manual-sdk-initialization) for the client side (`sentry.client.config.js`), add the Sentry `Replay` integration:

Copied!Click to Copy

    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:

Copied!Click to Copy

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

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

## Set Up

Copied!Click to Copy

    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

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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

Copied!Click to Copy

    # 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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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,
        }),
      ],
    });

## Install

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

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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 Replay integration is already included with the Sentry SDK. We recommend installing the SDK through our installation wizard:

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

On your client-side NextJS app, add:

Copied!Click to Copy

    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.

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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:

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/guides/remix/usage/).

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

On your client-side Remix app, add:

Copied!Click to Copy

    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.

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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:

Copied!Click to Copy

    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](https://kit.svelte.dev/docs/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](https://docs.sentry.io/platforms/javascript/guides/sveltekit/usage/).

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

On your client-side SvelteKit app, add:

Copied!Click to Copy

    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.

Copied!Click to Copy

    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](https://docs.sentry.io/platforms/javascript/session-replay/configuration/) for more details.

Copied!Click to Copy

    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,
        }),
      ],
    });

## Install

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

Copied!Click to Copy

    npm install @sentry/react-native --save

## Set Up

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

Copied!Click to Copy

    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 easiest way to update through the Sentry Android Gradle plugin to your app module's `build.gradle` file.

Copied!Click to Copy

    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:

Copied!Click to Copy

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

## Set Up

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

Copied!Click to Copy

    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 easiest way to update through the Sentry iOS CocoaPods file.

Copied!Click to Copy

    .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.

Copied!Click to Copy

    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
    })

## 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:

Copied!Click to Copy

    dependencies:
      sentry_flutter: ^8.9.0

## Install

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

Copied!Click to Copy

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

That's it. Check out our [documentation](https://sentry.io/platforms) to ensure you have the latest instructions.

[ Create a Sentry Account ](https://sentry.io/signup/) [ See All Platforms ](https://sentry.io/platforms)

Session Replay supports all browser-based applications. This includes static websites, single-page-applications and also server-side-rendered, that includes frameworks such as: [Django](https://docs.sentry.io/platforms/python/integrations/django/), [Spring](https://docs.sentry.io/platforms/java/guides/spring-boot/), [ASP.NET](https://dotnet.microsoft.com/en-us/apps/aspnet), [Laravel](https://docs.sentry.io/platforms/php/guides/laravel/), [Express](https://docs.sentry.io/platforms/javascript/guides/express/) and [Rails](https://docs.sentry.io/platforms/ruby/guides/rails/).

This also include mobile frameworks such as: [React Native](https://docs.sentry.io/platforms/react-native/session-replay/), [Android](https://docs.sentry.io/platforms/android/session-replay/), [iOS](https://docs.sentry.io/platforms/apple/guides/ios/session-replay/), and [Flutter](https://docs.sentry.io/platforms/dart/guides/flutter/session-replay/).

## FAQs

What is Session Replay

Sentry’s Session Replay provides a video-like reproduction of user interactions on a web or mobile app, giving developers the details they need to resolve errors and performance issues faster. All user interactions - including page visits, mouse movements, clicks, and scrolls - are captured, helping developers connect the dots between a known issue and how a user experienced it in the UI.

Which platforms does Session Replay support?

Session Replay is available for web-based and mobile applications. It supports all web applications whether it’s static or dynamic, server-side rendered or single-page applications.

It is built to work with `@sentry/browser`, and our browser framework SDKs:

  * [Vanilla JavaScript](http://docs.sentry.io/platforms/javascript/session-replay/)

  * [Angular](http://docs.sentry.io/platforms/javascript/guides/angular/session-replay/)

  * [Capacitor](http://docs.sentry.io/platforms/javascript/guides/capacitor/session-replay/)

  * [Electron](http://docs.sentry.io/platforms/javascript/guides/electron/session-replay/)

  * [Ember](http://docs.sentry.io/platforms/javascript/guides/ember/session-replay/)

  * [Gatsby](http://docs.sentry.io/platforms/javascript/guides/gatsby/session-replay/)

  * [Next.js](http://docs.sentry.io/platforms/javascript/guides/nextjs/session-replay/)

  * [React](http://docs.sentry.io/platforms/javascript/guides/react/session-replay/)

  * [Remix](http://docs.sentry.io/platforms/javascript/guides/remix/session-replay/)

  * [Solid](http://docs.sentry.io/platforms/javascript/guides/solid/session-replay/)

  * [Svelte](http://docs.sentry.io/platforms/javascript/guides/svelte/session-replay/)

  * [Vue](http://docs.sentry.io/platforms/javascript/guides/vue/session-replay/) This means _Session Replay is supported on server-side rendered Web applications_ such as Express, Laravel, Rails, Django, [ASP.NET](http://asp.net/), Spring Boot and others. We recommend creating a separate project in Sentry to track frontend errors from your backend. And adding Session Replay to your frontend via npm, or [using the loader](https://docs.sentry.io/platforms/javascript/install/loader/).

Session Replay for mobile supports the following SDKs:

  * [iOS](https://docs.sentry.io/platforms/apple/guides/ios/session-replay/)

  * [Android](https://docs.sentry.io/platforms/android/session-replay/)

  * [React Native](https://docs.sentry.io/platforms/react-native/session-replay/)

  * [Flutter](https://docs.sentry.io/platforms/flutter/session-replay/)

What is the performance ovehead of Session Replay?

Session Replay has minimal impact on the performance on your web application. We employ standard optimizations such as data compression, which is performed in a web worker outside of the browser’s UI thread in such a way that minimizes impact on your application. You can measure the overhead of Session Replay on your application without deploying to production by following [these instructions](https://sentry.engineering/blog/measuring-session-replay-overhead).

Is Session Replay easy to set up?

You will be able to set up Session Replay with only a few lines of code. Your existing `@sentry/browser` basic setup + DSN can be used for configuration.

How do you protect user data?

We offer a range of privacy controls to ensure that no sensitive user information leaves the browser. By default, our privacy configuration is very aggressive and masks all text and images, but you can – for example – choose to just mask user input text. More on that can be found in our [documentation](https://docs.sentry.io/product/session-replay/protecting-user-privacy/). We also provide server-side scrubbing to additionally filter on the server in case anything slips by. Additionally, we offer a self-serve deletion capability of individual replays in the UI. Session Replay adheres to the same security standards and is subject to the same compliance requirements as all of our software. Please see our [Security page](https://sentry.io/security/) for further details.

How much does Session Replay cost?

Please check out our [pricing page](https://sentry.io/pricing/) for details.

[ Read more on our FAQs page ](https://sentry.zendesk.com/hc/en-us/articles/23699186513947-Session-Replay-FAQ)

## Of course we have more content

[ ### Common NextJS errors Whether it’s on the client or server, errors are bound to happen. Checkout how to solve some of the most common Next.js errors. ](https://blog.sentry.io/common-errors-in-next-js-and-how-to-resolve-them/)

[ ### Debugging context Understand the conditions of each error by viewing the associated release, environment, tags and more. ](https://sentry.io/features/context/)

[ ### Reproduce Errors Without User Feedback Sentry Breadcrumbs show you the events your app and users took prior to an error. View events like user interactions, API calls, network requests befo... ](https://sentry.io/features/breadcrumbs/)

## Get monthly product updates from Sentry

Sign up for our newsletter.

And yes, it really is monthly. Ok, maybe the occasional twice a month, but for sure not like one of those daily ones that you just tune out after a while.

Your Email:

I want to receive the monthly newsletter and other updates from Sentry. You may unsubscribe at any time.

By filling out this form, you agree to our [privacy policy](https://sentry.io/privacy/). This form is protected by reCAPTCHA and Google's [Privacy Policy](https://policies.google.com/privacy) and [Terms of Service](https://policies.google.com/terms) apply.

Subscribe

## Fix It

Get started with the only application monitoring platform that empowers developers to fix application problems without compromising on velocity.

[ Try Sentry for Free ](https://sentry.io/signup/) [ Get a Demo ](https://sentry.io/demo/)


# Distributed tracing — full context for every query, crash, and API call

Not sure why that API’s slow? Or where that crash came from? With connected context—from the first user action through every service, system, and line of code—Sentry's distributed tracing gets you to the fix fast, without digging through five different tools.

[ Try Sentry for Free ](https://sentry.io/signup/) [ Get a Demo ](https://sentry.io/demo/)

### [Upcoming workshop] Debugging with Seer: Getting Started & Full Demo

Sentry’s debugging agent, Seer, is here. Join our upcoming Seer workshop series to learn how debug faster by using Seer throughout your entire workflow— from your IDE to PRs and production. RSVP for our first session on February 24th.

[ RSVP ](https://sentry.io/resources/seer-workshop-series/)

## Debug with Tracing

### What’s making this database query slow?

A single bad query can bring your app to a crawl and send your DB bill into the stratosphere—but finding it in a sea of `EXPLAIN` commands is tough. Jump straight to the query causing delays with Tracing and Insights.

[ Read the docs ](https://docs.sentry.io/product/insights/backend/queries/)

### Which API calls are causing unexpected slowdowns?

Your app usually loads fine, but some actions lag—and you’re not sure why.

  * See which API calls are slow, whether it's an overloaded endpoint or a sluggish third-party service with Trace Explorer.

  * When spikes happen, pinpoint the exact transaction, user, environment, or repo to fix it fast.

[ Learn More ](https://docs.sentry.io/product/explore/trace-explorer/)

### What’s causing the checkout UI to lag?

A user taps “Place Order,” but instead of an instant confirmation, they’re stuck waiting.

  * The problem? A checkout process that fires multiple requests, but one API call is dragging.

  * Break down the entire flow, see exactly which request is slowing things down, and fix it before it costs you conversions with trace explorer

[ Trace Explorer Docs ](https://docs.sentry.io/product/explore/trace-explorer/)

### What’s triggering ‘LoadFailed’ in my app?

A missing module or failed request can break your app, leaving you chasing vague LoadFailed errors with no clear cause.

  * Instead of digging through network logs, use Sentry’s Tracing to pinpoint the issue.

  * Whether it’s a 404 on a missing file, a CORS rejection, or Webpack failing to resolve a module, see exactly what led to the failure and fix it fast.

## More questions answered

[ ### How can I catch slowdowns before users do? Set metric alerts on latency, error rate, or throughput for key spans like _payment.stripe.charge_. For dynamic patterns, use anomaly alerts to detect spikes or regressions without thresholds. Then jump into trace waterfalls to find the exact cause. ](https://docs.sentry.io/product/alerts/#metric-alerts-for-errors--performance)[ ### Why is this endpoint slower after the last deploy? Sentry surfaces performance issues like N+1 queries, slow database calls, and uncompressed assets. Each issue includes example traces, spans, and stack traces to show where time is spent. Quickly identify root causes—whether it’s inefficient code, blocking I/O, or frontend bottlenecks. ](https://docs.sentry.io/product/issues/issue-details/performance-issues/)[ ### Is this database call getting slower over time? Use span metrics to track latency, throughput, and failure rate for specific operations like db.query.user_by_id. Analyze trends over time, broken down by service, operation, or environment. Use filters to investigate performance regressions and set alerts on critical spans. ](https://docs.sentry.io/product/explore/trace-explorer/#span-metrics)[ ### How to debug errors in background jobs? With Sentry tracing, background jobs are part of the full request flow—so you can see what triggered them, how long they ran, and where they failed. Spans show job timing, retries, and related service calls. When a job errors, trace context connects it to user actions or upstream issues ](https://www.youtube.com/watch?v=wb4Km8pCZRY&list=PLOwEowqdeNMpTNukOGxv37NHuQ1Ju7a-a&index=4)[ ### What’s causing errors in my agent runs? Monitor and debug AI agents like OpenAI and Vercel with full visibility into how they interact with your app. See prompt flows, model responses, and tool calls. Catch failures in tools, malformed outputs, or high token usage. Link issues to triggering frontend/backend requests to understand impact. ](https://docs.sentry.io/product/insights/ai/agents/)

Monitoring a production environment is always a challenge, with regular deployments, third party integrations, and the cloud resources we depend on - the number of issues that can fire from any one system increases the complexity of figuring out which service or team owns what.

Roni Avidov

Front End Technical Lead,

Monday.com

[ Read MoreMonday.com testimonial ](https://sentry.io/customers/monday-dot-com/)

If our app is slow, users won't wait—they'll just leave. Using Sentry to debug and monitor performance is a key factor to our success in keeping users in our app and engaged.

Vaidas Zlotkus

Director of Engineering,

Flo Health

[ Read MoreFlo Health testimonial ](https://sentry.io/customers/flo/)

## 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.

Next.jsAndroidAngularASP.NET CoreAstroiOS.NETGoJavaScriptLaravelPHPPythonReactRubySpring BootSvelteVue

Copied!Click to Copy

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

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

      // We recommend adjusting this value in production, or using `tracesSampler`
      // for finer control
      tracesSampleRate: 1.0,
    });

Copied!Click to Copy

    import io.sentry.android.core.SentryAndroid;

    SentryAndroid.init(this, options -> {
      options.setDsn("https://examplePublicKey@o0.ingest.sentry.io/0");
      // To set a uniform sample rate
      options.setTracesSampleRate(1.0);
      // OR if you prefer, determine traces sample rate based on the sampling context
      options.setTracesSampler(
          context -> {
            // return a number between 0 and 1 or null (to fallback to configured value)
          });
    });

Copied!Click to Copy

    // If you're using one of our framework SDK packages, like `@sentry/react`,
    // substitute its name for `@sentry/browser` here
    import * as Sentry from '@sentry/browser';

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

      // This enables automatic instrumentation (highly recommended),
      // but is not necessary for purely manual usage
      // If you only want to use custom instrumentation:
      // * Remove the `BrowserTracing` integration
      // * add `Sentry.addTracingExtensions()` above your Sentry.init() call
      integrations: [Sentry.browserTracingIntegration()],

      // We recommend adjusting this value in production, or using tracesSampler
      // for finer control
      tracesSampleRate: 1.0,

      // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
      tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
    });

Copied!Click to Copy

    using Sentry;

    // Add this to the SDK initialization callback
    // Example uniform sample rate: capture 100% of transactions
    options.TracesSampleRate = 1.0;

Either set `tracesSampleRate` in your `astro.config.mjs` file or in `sentry.(client|server).init.js`:

Copied!Click to Copy

    /* astro.config.mjs */

    import {defineConfig} from 'astro/config';
    import sentryAstro from '@sentry/astro';

    export default defineConfig({
      integrations: [
        sentryAstro({
          dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',
          tracesSampleRate: 1.0,
        }),
      ],
    });

Copied!Click to Copy

    /* sentry.(client|server).init.js */

    import * as Sentry from '@sentry/astro';

    Sentry.init({
      dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',
      tracesSampleRate: 1.0,
    });

Copied!Click to Copy

    import Sentry

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

        // Example uniform sample rate: capture 100% of transactions
        // In Production you will probably want a smaller number such as 0.5 for 50%
        options.tracesSampleRate = 1.0

        // OR if you prefer, determine traces sample rate based on the
        // sampling context
        options.tracesSampler = { context in
             // Don't miss any transactions for VIP users
            if context?["vip"] as? Bool == true {
                return 1.0
            } else {
                return 0.25 // 25% for everything else

Copied!Click to Copy

    using Sentry;

    // Add this to the SDK initialization callback
    // Example uniform sample rate: capture 100% of transactions
    options.TracesSampleRate = 1.0;

Copied!Click to Copy

    func main() {
        err := sentry.Init(sentry.ClientOptions{
            // ...

            EnableTracing: true,
            // Specify a fixed sample rate:
            // We recommend adjusting this value in production
            TracesSampleRate: 1.0,
            // Or provide a custom sample rate:
            TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 {
                // As an example, this does not send some
                // transactions to Sentry based on their name.
                if ctx.Span.Name == "GET /health" {
                    return 0.0

                return 1.0
            }),
        })

Copied!Click to Copy

    // If you're using one of our framework SDK packages, like `@sentry/react`,
    // substitute its name for `@sentry/browser` here
    import * as Sentry from '@sentry/browser';

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

      // This enables automatic instrumentation (highly recommended),
      // but is not necessary for purely manual usage
      // If you only want to use custom instrumentation:
      // * Remove the `BrowserTracing` integration
      // * add `Sentry.addTracingExtensions()` above your Sentry.init() call
      integrations: [Sentry.browserTracingIntegration()],

      // We recommend adjusting this value in production, or using tracesSampler
      // for finer control
      tracesSampleRate: 1.0,

      // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
      tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
    });

Copied!Click to Copy

    /* config/sentry.php */

    // Specify a fixed sample rate:
    'traces_sample_rate' => 0.2,
    // Or provide a custom sampler:
    'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
        // return a number between 0 and 1
    },

Copied!Click to Copy

    \Sentry\init([
        'dsn' => 'https://examplePublicKey@o0.ingest.sentry.io/0',
        // Specify a fixed sample rate:
        'traces_sample_rate' => 0.2,
        // Or provide a custom sampler:
        'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
            // return a number between 0 and 1
        },
    ]);

Copied!Click to Copy

    import sentry_sdk

    sentry_sdk.init(
        dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
        enable_tracing=True,
    )

Copied!Click to Copy

    import {createBrowserRouter} from 'react-router-dom';
    import * as Sentry from '@sentry/react';

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

      // This enables automatic instrumentation (highly recommended)
      // If you only want to use custom instrumentation:
      // * Remove the `BrowserTracing` integration
      // * add `Sentry.addTracingExtensions()` above your Sentry.init() call
      integrations: [
        Sentry.browserTracingIntegration(),
        // Or, if you are using react router, use the appropriate integration
        // See docs for support for different versions of react router
        // https://docs.sentry.io/platforms/javascript/guides/react/configuration/integrations/react-router/
        Sentry.reactRouterV6BrowserTracingIntegration({
          useEffect: React.useEffect,
          useLocation,
          useNavigationType,
          createRoutesFromChildren,
          matchRoutes,
        }),
      ],

      // For finer control of sent transactions you can adjust this value, or
      // use tracesSampler
      tracesSampleRate: 1.0,

      // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
      tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
    });

Copied!Click to Copy

    Sentry.init do |config|
      #...

      # Set a uniform sample rate between 0.0 and 1.0
      # We recommend adjusting the value in production:
      config.traces_sample_rate = 1.0

      # or control sampling dynamically
      config.traces_sampler = lambda do |sampling_context|
        # sampling_context[:transaction_context] contains the information about the transaction
        # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
        true # return value can be a boolean or a float between 0.0 and 1.0
      end
    end

Configure sample rate in `application.properties` or `application.yml` file:

Copied!Click to Copy

    # Set traces_sample_rate to 1.0 to capture 100%
    # of transactions for performance monitoring.
    # We recommend adjusting this value in production.
    sentry.traces-sample-rate=1.0

Or through providing a bean of type `SentryOptions#TracesSamplerCallback`:

Copied!Click to Copy

    import io.sentry.SentryOptions.TracesSamplerCallback;
    import io.sentry.SamplingContext;
    import org.springframework.stereotype.Component;

    @Component
    class CustomTracesSamplerCallback implements TracesSamplerCallback {
      @Override
      public Double sample(SamplingContext context) {
        CustomSamplingContext customSamplingContext = context.getCustomSamplingContext();
        if (customSamplingContext != null) {
          HttpServletRequest request = (HttpServletRequest) customSamplingContext.get("request");
          // return a number between 0 and 1 or null (to fallback to configured value)
        } else {
          // return a number between 0 and 1 or null (to fallback to configured value)

Copied!Click to Copy

    // If you're using one of our framework SDK packages, like `@sentry/react`,
    // substitute its name for `@sentry/browser` here
    import * as Sentry from '@sentry/browser';

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

      // This enables automatic instrumentation (highly recommended),
      // but is not necessary for purely manual usage
      // If you only want to use custom instrumentation:
      // * Remove the `BrowserTracing` integration
      // * add `Sentry.addTracingExtensions()` above your Sentry.init() call
      integrations: [Sentry.browserTracingIntegration()],

      // We recommend adjusting this value in production, or using tracesSampler
      // for finer control
      tracesSampleRate: 1.0,

      // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
      tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
    });

Copied!Click to Copy

    import Vue from 'vue';
    import * as Sentry from '@sentry/vue';

    Sentry.init({
      // Passing in `Vue` is optional, if you do not pass it `window.Vue` must be present.
      Vue: Vue,
      dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',

      // This enables automatic instrumentation (highly recommended),
      // but is not necessary for purely manual usage
      // If you only want to use custom instrumentation:
      // * Remove the `BrowserTracing` integration
      // * add `Sentry.addTracingExtensions()` above your Sentry.init() call
      integrations: [Sentry.browserTracingIntegration()],

      // We recommend adjusting this value in production, or using tracesSampler
      // for finer control
      tracesSampleRate: 1.0,
      // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
      tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
    });

That's it. Check out our [documentation](https://sentry.io/platforms) to ensure you have the latest instructions.

[ Create a Sentry Account ](https://sentry.io/signup/) [ See All Platforms ](https://sentry.io/platforms)

## Distributed tracing FAQs

What is Tracing?

Tracing provides a connected view of related errors and transactions by capturing interactions among your software systems. With Tracing, Sentry tracks your software performance and displays the impact of errors across multiple systems.

What languages and platforms is Tracing currently available for?

Tracing is available for all languages and platforms that Sentry supports. [See the full list here](https://sentry.io/platforms/).

How much does Tracing cost?

To enable Tracing capabilities you need to purchase spans. See docs for [pricing details](https://docs.sentry.io/pricing/).

How can I use Tracing?

To use Tracing, you will first need a Sentry account. If you don’t have a Sentry account, you can [create one here](https://sentry.io/signup/). Then, follow the [instructions in our docs](https://docs.sentry.io/platform-redirect/?next=/tracing/) to use Tracing.

Can I use OTel with Sentry Tracing?

Yes, you can configure your OpenTelemetry SDK to send traces and spans to Sentry. [Learn more](https://docs.sentry.io/platforms/go/guides/echo/performance/instrumentation/opentelemetry/#install).

## Of course there’s more to distributed tracing

[ ### The Best Way to Debug Slow Web Pages Tools like Page Speed Insights and Google Lighthouse are great for providing advice for front end performance issues. But what these tools can’t do, i... ](https://www.youtube.com/watch?v=v6wJgQRhY10)

[ ### Debugging Errors Faster with Distributed Tracing Learn what distributed tracing is, how it works, and how it can help you make sense of your complex microservices architectures. ](https://sentry.io/resources/debugging-errors-faster-with-distributed-tracing/)

[ ### Distributed Tracing | Debugging your Next.js applications with Sentry In this video you’ll learn how to view traces in Sentry and implement them in your Next.js application. ](https://www.youtube.com/watch?v=L1cJgs5RZK0&list=PLOwEowqdeNMqf3dArAE-Mo4rVR7T2Vanr&index=6&t=3s)

[ ### Tracing for the Frontend to the Backend Join Dustin Bailey as he shows how developers can trace those pesky performance issues to poor-performing API calls & slow database queries across all... ](https://www.youtube.com/watch?v=GSW7zJ9qFXM)

[ ### Tracing docs Learn more about the tracing features Sentry offers to help you track your software performance across multiple systems. ](https://docs.sentry.io/concepts/key-terms/tracing/)

## Get monthly product updates from Sentry

Sign up for our newsletter.

And yes, it really is monthly. Ok, maybe the occasional twice a month, but for sure not like one of those daily ones that you just tune out after a while.

Your Email:

I want to receive the monthly newsletter and other updates from Sentry. You may unsubscribe at any time.

By filling out this form, you agree to our [privacy policy](https://sentry.io/privacy/). This form is protected by reCAPTCHA and Google's [Privacy Policy](https://policies.google.com/privacy) and [Terms of Service](https://policies.google.com/terms) apply.

Subscribe

## Fix It

Get started with the only application monitoring platform that empowers developers to fix application problems without compromising on velocity.

[ Try Sentry for Free ](https://sentry.io/signup/) [ Get a Demo ](https://sentry.io/demo/)


# GitHub + Sentry Integration

Bring more debugging context into Sentry and your GitHub workflow.

[ See the docs  ](https://docs.sentry.io/product/integrations/github/)

### Augment errors with commit data

Automatically track releases in Sentry and link commits to a release. If something breaks after the deploy, Sentry will tell you which commit caused the error and the developer that can help fix it.

You can resolve errors efficiently by including `fixes ISSUE_ID` in your commit message.

### See unhandled issues in your PR

Fix issues with the context of your source code. When you open a pull request in GitHub, Sentry will comment and inform you if there are any unhandled issues being caused by the functions you are modifying in your pull request.

After integrating GitHub, enable [Stack Trace Linking](https://docs.sentry.io/product/integrations/source-code-mgmt/github/#stack-trace-linking) to have Sentry comment on your pull requests.

### Save time triaging issues

Spend less time managing the queue. Automatically assign Sentry Issues and route alerts to teams and individuals by uploading your existing [GitHub CODEOWNERS file](https://docs.sentry.io/product/integrations/source-code-mgmt/github/#code-owners).

### Connect Sentry Issues to merged PRs

Know if a merged pull request is causing issues. Sentry will comment on merged pull requests that are causing Sentry Issues.

### Link to GitHub Issues

Get alerted whenever a deploy introduces an error and dive into triaging, assigning, reproducing, and fixing the problem with all the information you need to kick off your workflow with confidence.

Enable [SSO in GitHub Organizations](https://docs.sentry.io/learn/sso/) or enable the GitHub plugin in project settings and link GitHub issues right from the Sentry issue page.

## Is your data secure?
You better believe it.

Just look at all the high-quality security
features all accounts get, regardless of plan.

  * Two-Factor Auth
  * Single Sign-On support
  * Organization audit log
  * SOC 2 Type II and ISO 27001 certified
  * HIPAA attestation

[ Learn more about Security  ](https://sentry.io/security/)

  * PII data scrubbing
  * SSL encryption
  * Data Processing Addendum (includes latest EU SCCs)
  * Privacy Shield certified

[ Learn more about Privacy  ](https://sentry.io/privacy/)

## All errors, one place

Use Sentry to collect and process errors from clients and connected projects. We support all major platforms.

[ Android ](https://sentry.io/for/android/)

[ Apple ](https://sentry.io/for/ios/)

[ Django ](https://sentry.io/for/django/)

[ Dot Net ](https://sentry.io/for/dot-net/)

[ Go ](https://sentry.io/for/go/)

[ JavaScript ](https://sentry.io/for/javascript/)

[ Laravel ](https://sentry.io/for/laravel/)

[ PHP ](https://sentry.io/for/php/)

[ Python ](https://sentry.io/for/python/)

[ Flutter ](https://sentry.io/for/flutter/)

[ React ](https://sentry.io/for/react/)

[ Ruby ](https://sentry.io/for/ruby/)

[ GitHub ](https://sentry.io/integrations/github/)

[ Gitlab ](https://sentry.io/integrations/gitlab/)

[ Jira ](https://sentry.io/integrations/jira/)

[ Rookout ](https://sentry.io/integrations/rookout/)

[ Shortcut ](https://sentry.io/integrations/shortcut/)

[ Bitbucket ](https://sentry.io/integrations/bitbucket/)

[ Datadog ](https://sentry.io/integrations/datadog/)

[ Heroku ](https://sentry.io/integrations/heroku/)

[ Slack ](https://sentry.io/integrations/slack/)

[ PagerDuty ](https://sentry.io/integrations/pagerduty/)

[ Segment ](https://sentry.io/integrations/segment/)

[ Trello ](https://sentry.io/integrations/trello/)

## A better experience for your users. An easier life for your developers.

[ Try Sentry for free  ](https://sentry.io/signup/) [ Request a demo  ](https://sentry.io/demo/)


# Jira + Sentry Integration

Connect errors from Sentry with your Jira issues.

[ See the docs  ](https://docs.sentry.io/organization/integrations/issue-tracking/jira/)

### Automatically Create Jira Tickets

Define Issue Alerts based on issue impact, tags, or several other conditions and automatically create Jira tickets in the project and backlog of the team that can fix the problem.

### Sync issues between Jira and Sentry

Sync comments, assignees and status updates for issues in Sentry to Jira, to minimize duplication. When you delegate an issue to an assignee or update a status on Jira, the updates will also populate in Sentry. When you resolve an issue in Sentry, it will automatically update in Jira.

Note: Two way sync is available for everyone on the Team plan and above

[ Get the plugin ](https://marketplace.atlassian.com/apps/1219432/sentry-for-jira)

## Is your data secure?
You better believe it.

Just look at all the high-quality security
features all accounts get, regardless of plan.

  * Two-Factor Auth
  * Single Sign-On support
  * Organization audit log
  * SOC 2 Type II and ISO 27001 certified
  * HIPAA attestation

[ Learn more about Security  ](https://sentry.io/security/)

  * PII data scrubbing
  * SSL encryption
  * Data Processing Addendum (includes latest EU SCCs)
  * Privacy Shield certified

[ Learn more about Privacy  ](https://sentry.io/privacy/)

## All errors, one place

Use Sentry to collect and process errors from clients and connected projects. We support all major platforms.

[ Android ](https://sentry.io/for/android/)

[ Apple ](https://sentry.io/for/ios/)

[ Django ](https://sentry.io/for/django/)

[ Dot Net ](https://sentry.io/for/dot-net/)

[ Go ](https://sentry.io/for/go/)

[ JavaScript ](https://sentry.io/for/javascript/)

[ Laravel ](https://sentry.io/for/laravel/)

[ PHP ](https://sentry.io/for/php/)

[ Python ](https://sentry.io/for/python/)

[ Flutter ](https://sentry.io/for/flutter/)

[ React ](https://sentry.io/for/react/)

[ Ruby ](https://sentry.io/for/ruby/)

[ GitHub ](https://sentry.io/integrations/github/)

[ Gitlab ](https://sentry.io/integrations/gitlab/)

[ Jira ](https://sentry.io/integrations/jira/)

[ Rookout ](https://sentry.io/integrations/rookout/)

[ Shortcut ](https://sentry.io/integrations/shortcut/)

[ Bitbucket ](https://sentry.io/integrations/bitbucket/)

[ Datadog ](https://sentry.io/integrations/datadog/)

[ Heroku ](https://sentry.io/integrations/heroku/)

[ Slack ](https://sentry.io/integrations/slack/)

[ PagerDuty ](https://sentry.io/integrations/pagerduty/)

[ Segment ](https://sentry.io/integrations/segment/)

[ Trello ](https://sentry.io/integrations/trello/)

## A better experience for your users. An easier life for your developers.

[ Try Sentry for free  ](https://sentry.io/signup/) [ Request a demo  ](https://sentry.io/demo/)


# Let's help you fix your code faster

We'll show you how to cut alert noise, find the real issue faster, and use AI to debug in production (and in review).

  * See how Sentry connects errors, logs, replays, and tracing together
  * Use that context to catch issues in PRs, explain what broke in production, and fix what you missed
  * Discuss pricing options that fit teams your size
  * Review the security + compliance checkboxes
  * Set a rollout plan that doesn't take months

**Trusted by 4M developers** at **150K+ organizations**.

### Request a demo

First Name

Last Name

Email Address

Job Title:

Company Name

How can we help?Select...DemoEnterprise quoteBilling supportTechnical supportPartnershipEDU/Non-profit/Student Plans Legal requirementsOther

Additional context:

Have a support question? [Contact Support.](https://sentry.zendesk.com/hc/en-us)

By filling out this form, you agree to our [privacy policy](https://sentry.io/privacy/). You may unsubscribe at any time. This form is protected by reCAPTCHA and Google's [Privacy Policy](https://policies.google.com/privacy) and [Terms of Service](https://policies.google.com/terms) apply.

Submit

Sentry helps us get visibility into complex distributed systems and close the loop on broken jobs—giving developers everything they need to debug, in one place.

Nova

Systems Lead,

Anthropic

Sentry gives us exactly what we need — straight to the point, fast, and accurate. It’s saved us hours per feature, and that translates to the bottom line.

Marc Maceira Zayas

President,

Honra


# AI and LLM Observability

Agents, LLMs, vector stores, custom logic—visibility can’t stop at the model call.

Get the context you need to debug failures, optimize performance, and keep AI features reliable.

[Try Sentry For Free](https://sentry.io/signup/)[Get a Demo](https://sentry.io/demo/)

### works with

[Vercel AI](https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/integrations/vercelai/)[OpenAI Agents](https://docs.sentry.io/platforms/python/integrations/openai-agents/)[Node.js](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/vercelai/)[Next.js](https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/integrations/vercelai/)[SvelteKit](https://docs.sentry.io/platforms/javascript/guides/sveltekit/configuration/integrations/vercelai/)[Nuxt](https://docs.sentry.io/platforms/javascript/guides/nuxt/configuration/integrations/vercelai/)[Astro](https://docs.sentry.io/platforms/javascript/guides/astro/configuration/integrations/vercelai/)[Remix](https://docs.sentry.io/platforms/javascript/guides/remix/configuration/integrations/vercelai/)[SolidStart](https://docs.sentry.io/platforms/javascript/guides/solidstart/configuration/integrations/vercelai/)[Express](https://docs.sentry.io/platforms/javascript/guides/express/configuration/integrations/vercelai/)[Fastify](https://docs.sentry.io/platforms/javascript/guides/fastify/configuration/integrations/vercelai/)[NestJS](https://docs.sentry.io/platforms/javascript/guides/nestjs/configuration/integrations/vercelai/)[Hapi](https://docs.sentry.io/platforms/javascript/guides/hapi/configuration/integrations/vercelai/)[Koa](https://docs.sentry.io/platforms/javascript/guides/koa/configuration/integrations/vercelai/)[Connect](https://docs.sentry.io/platforms/javascript/guides/connect/configuration/integrations/vercelai/)[Hono](https://docs.sentry.io/platforms/javascript/guides/hono/configuration/integrations/vercelai/)[Bun](https://docs.sentry.io/platforms/javascript/guides/bun/configuration/integrations/vercelai/)[AWS Lambda](https://docs.sentry.io/platforms/javascript/guides/aws-lambda/configuration/integrations/vercelai/)[Azure Functions](https://docs.sentry.io/platforms/javascript/guides/azure-functions/configuration/integrations/vercelai/)[Google Cloud Functions](https://docs.sentry.io/platforms/javascript/guides/gcp-functions/configuration/integrations/vercelai/)[Electron](https://docs.sentry.io/platforms/javascript/guides/electron/configuration/integrations/vercelai/)

Tolerated by 4 million developers

Anthropic logo

Cursor logo

Github logo

Vercel logo

Microsoft logo

CoveoDark logo

BoltLogo logo

FactoryAi logo

Anthropic logo

Cursor logo

Github logo

Vercel logo

Microsoft logo

CoveoDark logo

BoltLogo logo

FactoryAi logo

one dashboard

Track Model Costs & Tokens

Monitor tool execution

Deep Trace Analysis

## Full LLM Observability

### See everything on one pane of glass

Track all agent runs, error rates, LLM calls, tokens used, and tool executions. Monitor traffic patterns and duration metrics across your AI-powered features.

[See Docs](https://docs.sentry.io/product/insights/ai/agents/dashboard/)

## Track Model Costs & Tokens

### Monitor spending across models.

Compare costs across different models. See token usage breakdown by model, track input vs output tokens, and identify expensive operations.

[See Docs](https://docs.sentry.io/product/insights/ai/agents/dashboard/#models-tab)

## Monitor tool execution

### Track agent tool calls and errors.

See which tools your agents call, their error rates, average duration, and P95 latency. Identify slow or failing tool executions before they impact users.

[Learn About Tracing](https://docs.sentry.io/product/insights/ai/agents/dashboard/#tools-tab)

## Deep Trace Analysis

### Debug with full context.

Dive into individual requests with full prompt and response context. See AI spans with agent invocations, tool executions, token counts, costs, and timing.

[Learn More](https://docs.sentry.io/product/insights/ai/agents/)

## 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.

Python (OpenAI Agents)JavaScript (Vercel AI)See All Platforms

Install `sentry-sdk` from PyPI:

Click to Copy

Click to Copy

    pip install "sentry-sdk"

Add `OpenAIAgentsIntegration()` to your `integrations` list:

Click to Copy

Click to Copy

    import sentry_sdk
    from sentry_sdk.integrations.openai_agents import OpenAIAgentsIntegration

    sentry_sdk.init(
        # Configure your DSN
        dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
        # Add data like inputs and responses to/from LLMs and tools;
        # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
        send_default_pii=True,
        integrations=[
            OpenAIAgentsIntegration(),
        ],
    )

That's it. Check out our [documentation](https://docs.sentry.io/platforms/python/integrations/openai-agents/) to ensure you have the latest instructions.

[Create a Sentry Account](https://sentry.io/signup/)[See All Platforms](https://sentry.io/platforms/)

"Sentry played a significant role in helping us develop [Claude] Sonnet"

Since adopting Sentry, Anthropic has seen:

10-15%

increase in developer productivity

600+

engineers rely on Sentry to ship code

20-30%

faster incident resolution

[read more](https://sentry.io/customers/anthropic/)

## Fix what's broken with LLM Observability

Get started with the only LLM observability platform that gives developers tools to fix application problems without compromising on velocity.

[Try Sentry For Free](https://sentry.io/signup/)[Get a Demo](https://sentry.io/demo/)


# Platforms

Track errors and performance issues in every language, framework, and library.

  * [.NET](https://sentry.io/for/dot-net/)
    * [.NET MAUI](https://sentry.io/for/dotnet-maui/)
    * [ASP.NET](https://sentry.io/for/aspnet/)
    * [ASP.NET Core](https://sentry.io/for/aspnetcore/)
    * [C#](https://sentry.io/for/csharp/)

  * [Android](https://sentry.io/for/android/)
    * Supports NDK, ANR and more.

  * [Cocoa](https://sentry.io/for/cocoa/)
    * [iOS](https://sentry.io/for/ios/)
    * [macOS](https://sentry.io/for/macos/)
    * [Objective-C](https://sentry.io/for/objc/)
    * [Swift](https://sentry.io/for/swift/)
    * [tvOS](https://sentry.io/for/tvos/)

  * [Dart](https://sentry.io/for/dart/)
    * [Flutter](https://sentry.io/for/flutter/)

  * [Elixir](https://sentry.io/for/elixir/)
    * Client available via Hex.

  * [Go](https://sentry.io/for/go/)
    * Integration with the native `net/http` module.

  * [Godot](https://sentry.io/for/godot/)

  * [Java](https://sentry.io/for/java/)
    * [Log4j 2](https://sentry.io/for/log4j2/)
    * [Logback](https://sentry.io/for/logback/)
    * [Spring](https://sentry.io/for/spring/)
    * [Spring Boot](https://sentry.io/for/spring-boot/)

  * [JavaScript](https://sentry.io/for/javascript/)
    * [Angular](https://sentry.io/for/angular/)
    * [Astro](https://sentry.io/for/astro/)
    * [Backbone](https://sentry.io/for/backbone/)
    * [Electron](https://sentry.io/for/electron/)
    * [Ember](https://sentry.io/for/ember/)
    * [Next.js redesign](https://sentry.io/for/nextjs/)
    * [Nuxt](https://sentry.io/for/nuxt/)
    * [React](https://sentry.io/for/react/)
    * [Remix](https://sentry.io/for/remix/)
    * [Solid](https://sentry.io/for/solid/)
    * [Svelte](https://sentry.io/for/svelte/)
    * [SvelteKit](https://sentry.io/for/sveltekit/)
    * [Vue](https://sentry.io/for/vue/)

  * [Kotlin](https://sentry.io/for/kotlin/)
    * Client available on Maven Central.

  * [Minidumps](https://sentry.io/for/minidumps/)
    * [Breakpad](https://sentry.io/for/breakpad/)
    * [Crashpad](https://sentry.io/for/crashpad/)

  * [Native](https://sentry.io/for/native/)
    * [C](https://sentry.io/for/c/)
    * [C++](https://sentry.io/for/c-plus-plus/)

  * [Node](https://sentry.io/for/node/)
    * [AWS Lambda Node](https://sentry.io/for/node-aws-lambda/)
    * [Cloud Functions for Firebase](https://sentry.io/for/node-firebase-functions/)
    * [Google Cloud Functions Node](https://sentry.io/for/node-google-cloud-functions/)
    * [Microsoft Azure Node](https://sentry.io/for/node-azure/)
    * [Remix](https://sentry.io/for/remix/)

  * [OpenTelemetry](https://sentry.io/for/opentelemetry/)

  * [Perl](https://sentry.io/for/perl/)
    * Client available on CPAN.

  * [PHP](https://sentry.io/for/php/)
    * [Laravel](https://sentry.io/for/laravel/)
    * [Symfony](https://sentry.io/for/symfony/)

  * [Python](https://sentry.io/for/python/)
    * [AWS Lambda Python](https://sentry.io/for/python-aws-lambda/)
    * [Bottle](https://sentry.io/for/bottle/)
    * [Celery](https://sentry.io/for/celery/)
    * [Django](https://sentry.io/for/django/)
    * [FastAPI](https://sentry.io/for/fastapi/)
    * [Flask](https://sentry.io/for/flask/)
    * [Google Cloud Functions Python](https://sentry.io/for/python-google-cloud-functions/)
    * [Pyramid](https://sentry.io/for/pyramid/)
    * [RQ](https://sentry.io/for/rq/)
    * [Starlette](https://sentry.io/for/starlette/)
    * [Tornado](https://sentry.io/for/tornado/)

  * [React Native](https://sentry.io/for/react-native/)

  * [Ruby](https://sentry.io/for/ruby/)
    * [Rails](https://sentry.io/for/rails/)
    * [Sidekiq](https://sentry.io/for/sidekiq/)
    * [Sinatra](https://sentry.io/for/sinatra/)

  * [Rust](https://sentry.io/for/rust/)
    * Integrations with `tokio-rs/tracing`, `axum` and Actix Web.``

  * [Scala](https://sentry.io/for/scala/)
    * Client available on Maven Central.

  * [Serverless](https://sentry.io/for/serverless/)
    * [AWS Lambda](https://sentry.io/for/aws-lambda/)
    * [Google Cloud Functions](https://sentry.io/for/google-cloud-functions/)
    * [Microsoft Azure](https://sentry.io/for/azure/)

  * [Unity](https://sentry.io/for/unity/)

  * [Unreal Engine](https://sentry.io/for/unrealengine/)


# Laravel Error and Performance Monitoring

Actionable insights to resolve Laravel performance bottlenecks and errors. Improve your monitoring workflow with a full view of releases so you can mark Laravel errors as resolved and prioritize live issues.

[Try Sentry For Free](https://sentry.io/signup/)[Request a Demo](https://sentry.io/demo/)

## Getting Started is Simple

Install the `sentry/sentry-laravel` package with Composer:

Click to Copy

Click to Copy

    composer require sentry/sentry-laravel

Add Sentry reporting to `bootstrap/app.php`:

Click to Copy

Click to Copy

    <?php

    use Illuminate\Foundation\Application;
    use Illuminate\Foundation\Configuration\Exceptions;
    use Illuminate\Foundation\Configuration\Middleware;
    use Sentry\Laravel\Integration;

    return Application::configure(basePath: dirname(__DIR__))
        ->withRouting(
            web: __DIR__.'/../routes/web.php',
            commands: __DIR__.'/../routes/console.php',
            health: '/up',
        )
        ->withMiddleware(function (Middleware $middleware) {
        })
        ->withExceptions(function (Exceptions $exceptions) {
            Integration::handles($exceptions);
        })->create();

Enable Sentry Tracing in `config/sentry.php`:

Click to Copy

Click to Copy

    // Specify a fixed sample rate:
    'traces_sample_rate' => 0.2,
    // Or provide a custom sampler:
    'traces_sampler' => function (SentryTracingSamplingContext $context): float {
        // return a number between 0 and 1
    },

Run this `Artisan` command to configure the Sentry DSN:

Click to Copy

Click to Copy

    php artisan sentry:publish --dsn=<paste-your-DSN-here>

Check our [documentation](https://docs.sentry.io/platforms/php/guides/laravel/) for the latest instructions.

[See all platforms](https://sentry.io/platforms/)

### More than 150K Organizations Trust Sentry with Their Application Monitoring

Github logo

Atlassian logo

Disney logo

Cloudflare logo

Microsoft logo

Lush logo

### Laravel Performance Monitoring

Quickly identify performance issues and view full end-to-end distributed trace to see the exact, poor-performing API call and surface any related errors.

### Laravel Error Monitoring with Complete Stack Traces

See local variables in the stack for prod errors, just like in your dev environment. Explore the full source code context with frame to function data. Filter and group Laravel exceptions intuitively to eliminate noise.

### Fill In the Blanks About Laravel Errors

Expose the important events that led to each Laravel exception: network requests, SQL queries, debug logs, post errors. Learn in which version a bug first appeared, merge duplicates, and know if things regress in a future release.

### Set up Sentry through Forge

If you're using Laravel's Forge platform to provision and deploy your PHP application, creating your Sentry account is as simple as a few clicks. As a preferred debugging platform for Laravel, you can set up your Sentry organization [through Forge](https://forge.laravel.com/docs/integrations/sentry/).

Sentry gives us a good overview of any possible issues that were caused by a release, and the ability to fix them before they become real problems.”

### See the Full Picture of Any Laravel Exception

Aggregate errors by factors like request details, user ID, and app version to see what’s new, a priority, or a trend.

Assign custom key-value tags to reproduce the error environment specific to your application, business, and users.

Find answers to key questions: Was it a code error or usage exception? In which app release did the Laravel bug occur?

## FAQs

Does Sentry show stack trace arguments in my issues?

Yes, please see our [docs](https://docs.sentry.io/platforms/php/guides/laravel/troubleshooting/) for more details.

Does Sentry offer Profiling for Laravel?

Profiling for PHP is supported with Sentry Laravel SDK version 3.3.0 and above. Please [see the docs](https://docs.sentry.io/platforms/php/guides/laravel/profiling/) for more details.

What automatic performance monitoring does Sentry offer for my Laravel application?

The Laravel SDK automatically instruments your application to capture transactions and adds spans for the following features:

  * Views
  * Queue jobs
  * Caches
  * Notifications
  * Database queries
  * Redis operations
  * Laravel HTTP Client requests
  * GraphQL operations (when using Lighthouse)
  * Folio page based routes
  * Livewire components

Please see our Laravel SDK [documentation](https://docs.sentry.io/platforms/php/guides/laravel/performance/instrumentation/automatic-instrumentation/) for more details.

Which PHP versions does the Laravel SDK support?

Sentry's Laravel SDK supports PHP 7.2 and up.

Which Laravel Version does Sentry support?

Sentry supports 8.x, 9.x and 10.x as well as Laravel Lumen 8.x, 9.x and 10.x. Older versions of the SDK support Laravel from version 4.x.

Please see our [Laravel SDK docs](https://docs.sentry.io/platforms/php/guides/laravel/) for more information.

Does Sentry support Scheduled Tasks monitoring?

Yes, Sentry supports Scheduled Tasks monitoring in Laravel with [Sentry Crons](https://docs.sentry.io/platforms/php/guides/laravel/crons/).

What frontend languages does Sentry support?

Sentry supports every major frontend language, framework, and library. You can browse each of them [here](https://sentry.io/platforms/).

How much does Sentry cost?

You can get started for free. Pricing depends on the number of monthly events, transactions, and attachments that you send Sentry. For more details, visit our [pricing page](https://sentry.io/pricing/).

How does Sentry impact the performance of my app?

Sentry doesn’t impact a web site’s performance.

If you look at the configuration options for when you initialize Sentry in your code, you’ll see there’s nothing regarding minimizing its impact on your app’s performance. This is because our team of SDK engineers already developed Sentry with this in mind.

Sentry is a listener/handler for errors that asynchronously sends out the error/event to Sentry.io. This is non-blocking. The error/event only goes out if this is an error.

Global handlers have almost no impact as well, as they are native APIs provided by the browsers.

What is the difference between Sentry and traditional logging?

Traditional logging provides you with a trail of events. Some of those events are errors, but many times they’re simply informational. Sentry is fundamentally different because we focus on exceptions, or in other words, we capture application crashes. We discuss in more detail [here](https://sentry.io/vs/logging/) and on our [blog.](https://blog.sentry.io/lets-get-ready-to-monitor)

## Supporting Resources

[How Slow Is SlowRead](https://blog.sentry.io/how-slow-is-slow/)

[How Cloudflare Uses SentryRead](https://sentry.io/customers/cloudflare/)

## Resolve Laravel errors with max efficiency, not max effort

[Try Sentry For Free](https://sentry.io/signup/)[Request a Demo](https://sentry.io/demo/)