Overview

Sentry is a platform designed for real-time error monitoring and performance observation across the full application stack. It provides developers with tools to identify, triage, and resolve issues ranging from front-end JavaScript errors to back-end server exceptions. The platform collects error data, including stack traces, contextual information, and user details, to facilitate debugging and understanding the impact of defects on users. Sentry supports a wide array of programming languages, frameworks, and mobile platforms through its Software Development Kits (SDKs), enabling integration into diverse development environments.

Developers use Sentry to gain visibility into the health and stability of their applications. Beyond basic error logging, Sentry's capabilities extend to performance monitoring, which tracks various metrics like transaction durations and page load times to pinpoint bottlenecks. Its release health features allow teams to monitor the stability of new code deployments, detect regressions, and understand the impact of releases on user sessions. The platform is designed to integrate into existing development workflows, offering features like alerting, issue assignment, and integrations with version control systems and communication tools.

Sentry addresses the challenges of debugging in production environments by providing actionable insights without requiring direct access to production servers. For instance, when a JavaScript error occurs in a web application, Sentry can capture the error, the user's browser details, and the steps leading up to the error, helping front-end developers reproduce and fix the issue. Similarly, for server-side applications, it can capture exceptions, database query performance, and memory usage spikes. This comprehensive approach to monitoring helps teams maintain application reliability and improve the user experience by proactively addressing issues before they escalate.

The platform is suitable for individual developers, small teams, and large enterprises, offering various pricing tiers that scale with usage. Its compliance certifications, including SOC 2 Type II and GDPR, position it for use in regulated industries. While its primary focus is on error and performance monitoring, Sentry also offers features such as session replay to visualize user interactions leading to an error, and code coverage analysis to assess test effectiveness. This broad feature set aims to provide a unified view of application health, from code deployment through user interaction.

Key features

  • Real-time Error Monitoring: Captures and aggregates application errors across various platforms and languages as they occur, providing immediate notification and detailed context for debugging.
  • Performance Monitoring: Tracks critical performance metrics, including transaction durations, page load times, and database query speeds, to identify and resolve performance bottlenecks.
  • Release Health: Monitors the health of new code deployments, tracks crash-free user rates, and identifies regressions or spikes in errors after a release.
  • Session Replay: Reconstructs user sessions to visualize the steps a user took leading up to an error, offering visual context for debugging.
  • Code Coverage: Integrates with testing workflows to provide insights into which parts of the codebase are covered by tests, helping improve test suite effectiveness.
  • Alerting & Notifications: Configurable alerts based on error rates, performance thresholds, or new issues, delivered via email, Slack, PagerDuty, and other channels.
  • Detailed Error Context: Provides comprehensive information for each error, including full stack traces, local variables, device and browser information, and user context.
  • Issue Tracking & Management: Organizes errors into actionable issues, allows for assignment to team members, and tracks resolution status.
  • Customizable Dashboards: Offers flexible dashboards to visualize application health, error trends, and performance metrics tailored to specific team needs.

Pricing

Sentry offers a free developer tier and tiered paid plans with varying levels of error events, transactions, and session replays. Custom enterprise pricing is available for organizations with specific needs.

Plan Errors/Month Transactions/Month Sessions/Month Starting Price (as of 2026-05-07)
Developer (Free) 5,000 10,000 100 $0
Team 50,000 100,000 1,000 $26/month
Business 100,000 200,000 2,000 $80/month
Enterprise Custom Custom Custom Contact for pricing

For detailed pricing information and current offerings, refer to the Sentry pricing page.

Common integrations

Alternatives

  • Datadog: Offers a broad observability platform including infrastructure monitoring, APM, log management, and security monitoring.
  • New Relic: Provides an all-in-one observability platform for APM, infrastructure, logs, and user experience monitoring.
  • Rollbar: Focuses on error monitoring and real-time error tracking with support for multiple languages and frameworks.

Getting started

To get started with Sentry in a Node.js application, you typically install the Sentry SDK and initialize it in your application. This example demonstrates basic error capture.

// Install Sentry SDK for Node.js
// npm install @sentry/node @sentry/integrations

const Sentry = require('@sentry/node');
const { Integrations } = require('@sentry/tracing');

Sentry.init({
  dsn: "YOUR_SENTRY_DSN_HERE",
  integrations: [
    // Enable HTTP calls tracing
    new Integrations.Http({
      tracing: true,
    }),
    // Enable Express.js middleware for tracing and error handling
    // If using Express, install @sentry/integrations/express
    // new Integrations.Express({ app: require('express')() }),
  ],
  // Set tracesSampleRate to 1.0 to capture 100% of transactions for performance monitoring.
  // In production, you might want to use a lower sample rate.
  tracesSampleRate: 1.0,
});

// Example of capturing an error
function divide(a, b) {
  if (b === 0) {
    throw new Error("Cannot divide by zero!");
  }
  return a / b;
}

try {
  divide(10, 0);
} catch (error) {
  Sentry.captureException(error);
  console.error("Error captured by Sentry!");
}

// Or, for unhandled promise rejections or uncaught exceptions,
// Sentry will automatically capture them after initialization.

console.log("Sentry initialized and example error might be sent.");

Replace "YOUR_SENTRY_DSN_HERE" with your actual DSN obtained from your Sentry project settings. For more detailed instructions and platform-specific guides, refer to the Sentry Node.js documentation.