# Uptime monitoring for developers

> Know when your site goes down before your users do. Sentry monitors your URLs every minute and links outages to traces so you can fix them fast.

**URL:** https://sentry.io/product/uptime-monitoring/

---

Know when your site goes down before your users do. Sentry runs automated checks every minute, alerts your team through Slack or email, and links outages to distributed traces so you can debug without switching tools.

## Features

### Manage your site reliability effortlessly

Sentry runs HTTP checks on your URLs every minute and catches everything from DNS failures to application errors. An issue only opens after three consecutive failures, so you get real signal rather than noise from transient blips. Check intervals are configurable from one minute to one hour.

### Full visibility into system health

When a check fails, Sentry surfaces the related traces and errors alongside it. You get a timeline view, the HTTP response details, and a direct path to the spans that were active at the time. Uptime spans are free and do not count against your quota.

### Configure alerts to match your infrastructure

Configure uptime checks for any URL with control over the HTTP method, request headers, body, and expected response codes. You can validate JSON response properties and set failure thresholds to match your service's behavior. When something fails, Sentry notifies your team through Slack, email, or your on-call tool.

## More Features

- **Automated checks**: Sentry checks any URL you configure every minute, testing the full request path from DNS resolution to application response. — [Learn more](https://docs.sentry.io/product/monitors-and-alerts/monitors/uptime-monitoring/)

- **Distributed tracing**: Failed checks link directly to related distributed traces so you can see what broke and why without jumping between tools. — [Learn more](https://docs.sentry.io/product/issues/issue-details/uptime-issues/)

- **Geo-distributed checks**: Checks run from multiple geographic regions. Sentry waits for failures across locations before opening an issue, filtering out regional network noise. — [Learn more](https://docs.sentry.io/product/monitors-and-alerts/monitors/uptime-monitoring/)

- **Configurable thresholds**: Set how many consecutive failures open an issue and how many successes close it. Tune the sensitivity to match your service's normal behavior. — [Learn more](https://docs.sentry.io/product/monitors-and-alerts/monitors/uptime-monitoring/)

- **Instant alerts**: Route downtime notifications to Slack, email, or your on-call tool so the right people are paged when it matters. — [Learn more](https://docs.sentry.io/product/monitors-and-alerts/alerts/)

## FAQ

**What features are available with Uptime Monitoring?**

Automated health checks: Monitors URLs every minute and alerts on failures including non-200 status codes, timeouts, and DNS issues.

Auto-configuration: Detects and monitors the most common hostname in your error data if you do not set one up manually.

Customizable alerts: Set alerts for specific URLs with full control over the HTTP method, headers, and request body.

Uptime issues: An issue is created when downtime is detected and automatically resolved when the service returns to a healthy state.

Tracing integration: Links uptime failures to distributed traces for faster debugging.

Check history: Review past uptime checks to track performance trends over time.

**How much does Uptime Monitoring cost?**

One monitor is included in all Sentry plans. Additional monitors are $1/monitor/month. To add more, increase your pay-as-you-go volume in subscription settings or learn more in [the docs](https://docs.sentry.io/pricing/).

**What's the difference between uptime monitoring and a status page?**

Uptime monitoring checks whether your services are actually up, automatically, from the outside. A status page communicates the state of your services to your customers. Monitoring detects the problem; the status page tells people about it.

Most teams use both. Uptime monitoring fires an alert when something goes down, and the status page gets updated to keep users informed while the team works on a fix.

**How does uptime monitoring work?**

Sentry sends HTTP requests to your URLs at a set interval from multiple geographic locations. If the response does not match your expected criteria — wrong status code, timeout, or DNS failure — Sentry records a failure. After a configurable number of consecutive failures, an issue is created and your team gets alerted. When the service recovers, the issue resolves automatically.

Because checks run from multiple regions, a single bad network hop in one location does not trigger a false alarm.

**How do I reduce false positive alerts?**

The main levers are consecutive failure thresholds and geographic distribution. Sentry only opens an issue after a configurable number of consecutive failures (the default is three), so a single bad request does not page your team. Checks also run from multiple geographic locations, so a regional network blip does not count as downtime.

You can tune both the failure tolerance (how many failures trigger an alert) and the recovery tolerance (how many successes close it) to match your service's normal behavior.

**How do you set up Uptime Monitoring?**

Uptime Monitoring is [automatically configured](https://docs.sentry.io/product/monitors-and-alerts/monitors/uptime-monitoring/automatic-detection/) for the most frequently encountered hostname in your error data, so your most critical URL is monitored from day one.

You can also [create uptime monitoring alerts](https://docs.sentry.io/product/monitors-and-alerts/alerts/) for any URL. They are fully customizable with request details including the HTTP method, headers, and body.

## Of course we have more content

- [Uptime Monitoring documentation](https://docs.sentry.io/product/monitors-and-alerts/monitors/uptime-monitoring/): Everything you need to set up and configure Uptime Monitoring, from automatic detection to custom alert rules and response validation.

- [Cancel the (issue) noise](https://blog.sentry.io/cancel-the-issue-noise/): Alert fatigue is real. Learn how Sentry's noise-reduction improvements help you focus on the issues that actually need your attention.

- [Everyone needs to know how to trace](https://blog.sentry.io/everyone-needs-to-know-how-to-trace/): Tracing gives you visibility into what your code is doing across services. Learn the basics and how to get started with distributed tracing in Sentry.

- [Downtime happens, fix it faster](https://blog.sentry.io/downtime-happens-fix-it-faster-uptime-monitoring-now-in-open-beta/): A closer look at how Sentry's Uptime Monitoring works, including automated HTTP checks, tracing integration, and the issue lifecycle from detection to resolution.

- [Distributed tracing 101 for full stack developers](https://blog.sentry.io/distributed-tracing-101-for-full-stack-developers/): Spans, traces, and how they connect operations across services. A practical introduction to distributed tracing using OpenTelemetry and Sentry.

- [Top 3 issue alert tips to stop noisy notifications](https://blog.sentry.io/top-3-issue-alert-tips-to-stop-noisy-notifications/): Three ways to configure alerts so you only get paged when it matters, including prioritizing new issues, routing to the right people, and filtering by severity.

## Use Cases

- [Route OTel traces to Sentry](https://sentry.io/cookbook/route-opentelemetry-traces-to-sentry/)

## Testimonials

> Sentry's high-quality tooling helps Disney+ maintain high-quality service to its tens of millions of global subscribers.

> — Andrew Hay, Disney+

> Think about our 150+ developers and multiply that by the number of issues we see across our services and clients - it's insane the amount of developer time we've saved.

> — Roni Avidov, Monday.com

## Quick Start

### Python

Install the Sentry Python SDK with pip

```bash
pip install sentry-sdk
```

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

```python
import sentry_sdk

sentry_sdk.init(
  dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
  send_default_pii=True,
  # Set traces_sample_rate to 1.0 to capture 100%
  # of transactions for tracing.
  traces_sample_rate=1.0,
  #Enable logs to be sent to Sentry
  enable_logs=True,
  # To collect profiles for all profile sessions,
  # set profile_session_sample_rate to 1.0.
  profile_session_sample_rate=1.0,
  # Profiles will be automatically collected while
  # there is an active span.
  profile_lifecycle="trace",
)
```

### JavaScript

Install the Sentry JavaScript SDK with npm

```bash
npm install @sentry/browser --save
```

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

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

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  tracesSampleRate: 1.0,
  // Set tracePropagationTargets to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

### React

Run the command for your preferred package manager to add the Sentry SDK to your application:

```bash
npm install @sentry/react --save
```

To import and initialize Sentry, create a file in your project's root directory, for example, `instrument.js`, and add the following code:

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

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/react/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
  tracePropagationTargets: [/^//, /^https://yourserver.io/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    // If you're using react router, use the integration for your react router version instead.
    // Learn more at
    // https://docs.sentry.io/platforms/javascript/guides/react/features/react-router/
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

Initialize Sentry as early as possible in your application. We recommend putting the import of your initialization code as the first import in your app's entry point:

```javascript
// 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 />);
```

To make sure Sentry captures all your app's errors, configure error handling based on your React version. 
 For React versions 19 and up:  

```javascript
import { createRoot } from "react-dom/client";
import * as Sentry from '@sentry/react';

const container = document.getElementById("app");
const root = createRoot(container, {
  // Callback called when an error is thrown and not caught by an ErrorBoundary.
  onUncaughtError: Sentry.reactErrorHandler((error, errorInfo) => {
    console.warn('Uncaught error', error, errorInfo.componentStack);
  }),
  // Callback called when React catches an error in an ErrorBoundary.
  onCaughtError: Sentry.reactErrorHandler(),
  // Callback called when React automatically recovers from errors.
  onRecoverableError: Sentry.reactErrorHandler(),
});
root.render();
```

For React versions 18 and below, use the ErrorBoundary component to automatically send errors from specific component trees to Sentry and provide a fallback UI:

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

<Sentry.ErrorBoundary fallback={<p>An error has occurred</p>}>
  <Example />
</Sentry.ErrorBoundary>;
```

### Next.js

To install Sentry using the installation wizard, run thrun the following command and step through the prompts:

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

For manual installation run the following command and use the following configurations:

```bash
npm install @sentry/nextjs --save
```

Extend your app's default Next.js options by adding code with `withSentryConfig` into your `next.config.(js|mjs)` file:

```javascript
const { withSentryConfig } = require("@sentry/nextjs");
const nextConfig = {
  // Your existing Next.js configuration
};
// Make sure adding Sentry options is the last code to run before exporting
module.exports = withSentryConfig(nextConfig, {
  org: "example-org",
  project: "example-project",
  // Only print logs for uploading source maps in CI
  // Set to `true` to suppress logs
  silent: !process.env.CI,
  // Automatically tree-shake Sentry logger statements to reduce bundle size
  disableLogger: true,
});
```

#### Client-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
});

// This export will instrument router navigations, and is only relevant if you enable tracing.
// `captureRouterTransitionStart` is available from SDK version 9.12.0 onwards
export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
```

#### Server-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
});
```

#### Register Sentry Server-Side SDK Initialization

Create a Next.js Instrumentation file named `instrumentation.(js|ts)` in your project root or inside the `src` folder if you have one. Import your server and edge configurations, making sure that the imports point to your specific files:

```javascript
export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    await import("./sentry.server.config");
  }
  if (process.env.NEXT_RUNTIME === "edge") {
    await import("./sentry.edge.config");
  }
}
```

### Go

Grab the Sentry Go SDK:

```bash
go get "github.com/getsentry/sentry-go"
```

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

```text
err := sentry.Init(sentry.ClientOptions{
  Dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Enable printing of SDK debug messages.
  // Useful when getting started or trying to figure something out.
  Debug: true,
  // Adds request headers and IP for users,
  // visit: https://docs.sentry.io/platforms/go/data-management/data-collected/ for more info
  SendDefaultPII: true,
  EnableTracing: true,
  // Set TracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  TracesSampleRate: 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)
```

### Ruby

Add the sentry-ruby gem to your Gemfile:

```ruby
gem "sentry-ruby"
```

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

```ruby
require 'sentry-ruby'

Sentry.init do |config|
  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'

  # get breadcrumbs from logs
  config.breadcrumbs_logger = [:sentry_logger, :http_logger]

  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/ruby/data-management/data-collected/ for more info
  config.send_default_pii = true
  # enable tracing
  # we recommend adjusting this value in production
  config.traces_sample_rate = 1.0
  # Enable logs to be sent to Sentry
  config.enable_logs = true
  # enable profiling
  # this is relative to traces_sample_rate
  config.profiles_sample_rate = 1.0
end
```

### PHP

Install the Sentry SDK using Composer:

```bash
composer require sentry/sentry
```

To use Profiling, you'll also need to install the Excimer extension via PECL:

```bash
pecl install excimer
```

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

```php
\Sentry\init([
  'dsn' => 'https://examplePublicKey@o0.ingest.sentry.io/0',
  // Add request headers, cookies and IP address,
  // see https://docs.sentry.io/platforms/php/data-management/data-collected/ for more info
  'send_default_pii' => true,
  // Specify a fixed sample rate
  'traces_sample_rate' => 1.0,
  // Enable logs to be sent to Sentry
  'enable_logs' => true,
  // Set a sampling rate for profiling - this is relative to traces_sample_rate
  'profiles_sample_rate' => 1.0,
]);
```

### .NET

Install the NuGet package to add the Sentry dependency:

```shell
dotnet add package Sentry -v 5.16.2
```

To use Profiling, you'll also need to install the Sentry.Profiling package:

```shell
dotnet add package Sentry.Profiling -v 5.16.2
```

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

```csharp
SentrySdk.Init(options =>
{
    options.Dsn = "https://examplePublicKey@o0.ingest.sentry.io/0";
    options.Debug = true;
    // Adds request URL and headers, IP and name for users, etc.
    options.SendDefaultPii = true;
    // A fixed sample rate of 1.0 - 100% of all transactions are getting sent
    options.TracesSampleRate = 1.0f;
    // A sample rate for profiling - this is relative to TracesSampleRate
    options.ProfilesSampleRate = 1.0f;
});
```

---

*Source: [sentry.io/product/uptime-monitoring/](https://sentry.io/product/uptime-monitoring/)*