Marketing Mode
Want to connect with the folks building Sentry? Join us on Discord. ➔

Code breaks, fix it faster

Application monitoring software considered 
"not bad" by millions of developers.

Developer first. Always.

Illustration of a terminal-style window showing the command npm install @sentry/browser on a dark purple background.

Monitor in five lines

Drop in the SDK. No agents to install. No performance surprises.

A section labeled "Root Cause" with code insight stating: "The code attempts to check if $quantities," highlighting a probable bug in the application logic.

Automatically root-cause any issue

Catch critical issues before you merge and fix them when they hit prod with Seer, our debugging agent and code reviewer.

Code snippet with a console warning message and a Sentry UI section showing a bug in detectOperationType() linked to initial-build, with options for detailed analysis and a suggested fix.

Break production less

Predict and prevent the errors that matter most before they even make it to production with AI code review.

Chat-style interface showing "Sentry agent connected" and a user named "codydearkland" asking, "@Sentry can i get some help?"

Stay in the flow

From GitHub, Slack, Jira, and Linear to coding agents with Sentry's MCP server, Sentry brings full context to every fix from dev to prod.

Everything’s connected

Yeah, other tools exist. But errors, logs, replays, spans, profiles, and metrics — all connected by the same trace? That’s kind of our thing.

Go from Issue → Context → Fix.

Debugging needs context—
with or without AI

Seer, our AI debugger, uses Sentry context – logs, commits, traces, stack trace - so you can stop guessing and it can fix issues for you.

Loved by developers worldwide

quote mark
We wouldn’t have scaled without Sentry. Most of our incidents are hardware-related—and we debug them all inside Sentry

Nova DasSarma

Systems Lead at Anthropic

quote mark
Sentry’s high-quality tooling helps Disney+ maintain high-quality service to its tens of millions of global subscribers.

Andrew Hay

Director at Disney Streaming Services at Disney+

quote mark
The signal we get from Sentry is the most reliable indicator of software issues and is used throughout Instacart because it can be easily configured for each service regardless of the language or framework.

Igor Dobrovitski

Infrastructure Software Engineer at Instacart

Left Installation Instructions Image Mobile

Get started in minutes

Five lines of code. That's it. No complex setup, no performance hits, no waiting around.

See -- it's really just one command.

Copied!
npx @sentry/wizard@latest -i nextjs

Get started with just one line of code:

Copied!
npx @sentry/wizard@latest -i angular

Just run this command to sign up for and install Sentry.

Copied!
brew install getsentry/tools/sentry-wizard && sentry-wizard -i android

Signup and install Sentry with just one line of code:

Copied!
brew install getsentry/tools/sentry-wizard && sentry-wizard -i ios

Sign-up and install Sentry with just one line of code:

Copied!
npx @sentry/wizard@latest -i flutter

Install Sentry with one line of code:

Copied!
npx @sentry/wizard@latest -i reactNative

Add the Sentry dependency to your .NET MAUI application:

Copied!
dotnet add package Sentry.Maui -v 5.11.1

Grab the Sentry Python SDK:

Copied!
pip install --upgrade sentry-sdk

Configure your DSN:

Copied!
import sentry_sdk
sentry_sdk.init(
 "https://<key>@sentry.io/<project>",
 # Set traces_sample_rate to 1.0 to capture 100%
 # of transactions for Tracing.
 # We recommend adjusting this value in production.
 enable_tracing=True,
 traces_sample_rate=1.0,
)

Grab the Sentry Node SDK:

Copied!
npm install @sentry/node

Configure your SDK:

Copied!
const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>' });

Grab the Sentry React SDK:

Copied!
npm install @sentry/react

We recommend putting the Sentry initialization code into its own file and including that file as the first import in your application entry point as shown in the example below:

Copied!
import { useEffect } from "react";
import * as Sentry from "@sentry/react";
Sentry.init({
 dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
 integrations: [
 ],
 // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
 tracePropagationTargets: [/^\//, /^https:\/\/yourserver\.io\/api/],
});

Include the Sentry initialization file as the first import statement:

Copied!
// Sentry initialization should be imported first!
import "./instrument";
import App from "./App";
import { createRoot } from "react-dom/client";
const container = document.getElementById("app");
const root = createRoot(container);
root.render(<App />);

Install the NuGet package to add the Sentry dependency:

Copied!
dotnet add package Sentry

Initialize the SDK as early as possible, like in the Main method in Program.cs/Program.fs:

Copied!
using (SentrySdk.Init(o => {
 // Tells which project in Sentry to send events to:
 o.Dsn = "https://<key>@sentry.io/<project>";
 // When configuring for the first time, to see what the SDK is doing:
 o.Debug = true;
 // Set TracesSampleRate to 1.0 to capture 100% of transactions for Tracing.
 // We recommend adjusting this value in production.
 o.TracesSampleRate = 1.0; }))
{
 // App code goes here - Disposing will flush events out
}

Grab the Sentry Go SDK:

Copied!
go get "github.com/getsentry/sentry-go"

Configuration should happen as early as possible in your application's lifecycle:

Copied!
package main
import (
	"log"
	"time"
	"github.com/getsentry/sentry-go"
)
func main() {
	err := sentry.Init(sentry.ClientOptions{
		Dsn: "https://<key>@sentry.io/<project>",
 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
		}),
	})
	if err != nil {
		log.Fatalf("sentry.Init: %s", err)
	}
	// Flush buffered events before the program terminates.
	// Set the timeout to the maximum duration the program can afford to wait.
	defer sentry.Flush(2 * time.Second)
}

To integrate Sentry into your Xcode project, specify it in your Podfile, then run pod install:

Copied!
platform :ios, '9.0'
use_frameworks! # This is important
target 'YourApp' do
 pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '<VERSION>'
end

Initialize the SDK as soon as possible in your application lifecycle, such as in your AppDelegate application:didFinishLaunchingWithOptions method:

Copied!
import Sentry // Make sure you import Sentry
func application(_ application: UIApplication,
 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
 SentrySDK.start { options in
 options.dsn = "https://<key>@sentry.io/<project>"
 options.debug = true // Enabled debug when first installing is always helpful
 // Example uniform sample rate: capture 100% of transactions for Tracing
 options.tracesSampleRate = 1.0
 }
 return true
}

Add the sentry-ruby gem to your Gemfile:

Copied!
gem "sentry-ruby"

Configure your DSN:

Copied!
Sentry.init do |config|
 config.dsn = 'https://<key>@sentry.io/<project>'
 # 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

Install the sentry/sentry package with Composer:

Copied!
composer require sentry/sentry

To capture all errors, even the one during the startup of your application, you should initialize the Sentry PHP SDK as soon as possible.

Copied!
\Sentry\init(['dsn' => 'https://<key>@sentry.io/<project>',
 // 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
 }, ]);

Install the sentry/sentry-laravel package with Composer:

Copied!
composer require sentry/sentry-laravel

Add Sentry reporting to bootstrap/app.php:

Copied!
<?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:

Copied!
// 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:

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

Add the Sentry dependency:

Copied!
dotnet add package Sentry.AspNetCore

Configure Sentry in appsettings.json.

Copied!
"Sentry": {
 "Dsn": "https://examplePublicKey@o0.ingest.sentry.io/0",
 "Debug": true,
},

Then add the SDK by simply calling UseSentry:

Copied!
public static IHostBuilder CreateHostBuilder(string[] args) =>
 Host.CreateDefaultBuilder(args)
 .ConfigureWebHostDefaults(webBuilder =>
 {
 // Add the following line:
 webBuilder.UseSentry();
 });

Grab the Sentry Java SDK:

Copied!
<dependency>
 <groupId>io.sentry</groupId>
 <artifactId>sentry-spring-boot-starter</artifactId>
 <version><VERSION></version>
</dependency>

Configure your DSN in application.properties:

Copied!
sentry.dsn=https://<key>@sentry.io/<project>
# 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

Grab the Sentry Vue SDK:

Copied!
npm install @sentry/vue

Configure your DSN:

Copied!
import { createApp } from "vue";
import * as Sentry from "@sentry/vue";
const app = createApp({
 // ...
});
Sentry.init({
 app,
 dsn: "https://<key>@sentry.io/<project>"",
 // 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/],
});
app.mount("#app");

To use the SDK, initialize Sentry in your Solid entry point index.jsx before you render your Solid app:

Copied!
// index.jsx / index.tsx
import * as Sentry from "@sentry/solid";
import { useBeforeLeave, useLocation } from "@solidjs/router";
import { render } from "solid-js/web";
import App from "./app";
// Initialize the Sentry SDK here 
Sentry.init({
 dsn: "__DSN__",
 integrations: [Sentry.browserTracingIntegration()],
 // Performance Monitoring
 tracesSampleRate: 1.0, // Capture 100% of the transactions
 // Set 'tracePropagationTargets' to control for which URLs trace propagation should be enabled
 tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
});
const app = document.getElementById("app");
if (!app) throw new Error("No #app element found in the DOM.");
render(() => <App />, app)

To use the SDK, initialize Sentry in your Svelte entry point main.js before you bootstrap your Svelte app:

Copied!
// main.js / main.ts
import App from "./App.svelte";
import * as Sentry from "@sentry/svelte";
import { BrowserTracing } from "@sentry/tracing";
// Initialize the Sentry SDK here
Sentry.init({
 dsn: "__DSN__",
 release: "my-project-name@2.3.12",
 integrations: [new BrowserTracing()],
 // 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/],
});
// Then bootstrap your Svelte app
const app = new App({
 target: document.getElementById("app"),
});
export default app;

Just run this command to install and register Sentry's Astro integration.

Copied!
npx astro add @sentry/astro

And add your DSN and project config to your astro.config.mjs file:

Copied!
import { defineConfig } from "astro/config";
import sentry from "@sentry/astro";
export default defineConfig({
 integrations: [
 sentry({
 dsn: "__DSN__",
 sourceMapsUploadOptions: {
 project: "your-project-slug",
 authToken: process.env.SENTRY_AUTH_TOKEN,
 },
 tracesSampleRate: 1.0,
 }),
 ],
});

Grab the Sentry JavaScript SDK:

Copied!
<script src="https://browser.sentry-cdn.com/<VERSION>/bundle.min.js"></script>

Configure your DSN:

Copied!
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>',
 // 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/],
});
Left Installation Instructions ImageRight Installation Instructions Image

Built to be secure, Designed to not get in your way

Security and compliance aren't just checkboxes—they're built into how we run Sentry. We use industry-standard tech and practices to keep your data safe, and we stay out of your way while doing it.

Get monthly product updates
from our newsletter

By filling out this form, you agree to ourprivacy policy . This form is protected by reCAPTCHA and Google'sPrivacy PolicyandTerms of Serviceapply.
 [画像:Cartoon showing the Sentry logo as a distressed character watching one person stuck in a smartphone and another diving headfirst into a retro computer—illustrating developers getting lost in debugging chaos.]
[画像:Cartoon showing the Sentry logo as a distressed character watching one person stuck in a smartphone and another diving headfirst into a retro computer—illustrating developers getting lost in debugging chaos.]

Fix It

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