Independent pricing guide. Not affiliated with Sentry (Functional Software, Inc.).

Sentry Pricing: Event-Based Billing Means a Single Bug Can Blow Through Your Monthly Quota

Updated 30 March 2026

Developer plan is free for 5K events. Team costs $26/month for 50K events. Business costs $80/month for 100K events. The pricing seems simple until a bug affecting 10% of users generates 300,000 events in a day. Here is how to predict your real usage and avoid overages.

Developer

Free

5K events/mo

5K events/mo

MOST POPULAR

Team

$$26

/month

50K events/mo

Business

$$80

/month

100K events/mo

Enterprise

Custom

Contact sales

Custom

Sentry Plans and Features

All plans include all SDK support, error tracking, and stack traces. Tiers differ in event volume, retention, and team features.

Developer

Free

5K events/mo

1 user

30-day retention

  • Error tracking
  • Stack traces
  • Breadcrumbs
  • Release tracking
  • All SDK support
  • Basic alerts

Personal projects and early-stage startups with minimal error volume

Popular

Team

$$26/mo

50K events/mo

Unlimited

90-day retention

  • Everything in Developer
  • Unlimited team members
  • Crash-free session monitoring
  • Performance monitoring
  • Advanced search
  • Custom alerts

Growing apps with 1K-10K DAU needing team access and performance monitoring

Business

$$80/mo

100K events/mo

Unlimited

90-day retention

  • Everything in Team
  • Advanced data scrubbing
  • Custom dashboards
  • SSO/SAML
  • Session replay
  • Release health monitoring

Production apps with 10K+ DAU needing advanced security and data controls

Enterprise

Custom

Custom

Unlimited

Unlimited retention

  • Everything in Business
  • Dedicated support
  • SLA guarantees
  • Priority event processing
  • Custom retention
  • Account management

Large organizations with compliance requirements and high event volumes

Event Volume Pricing Beyond Included Quota

When you exceed your included events, Sentry charges per additional event. The overage rates incentivize fixing bugs: fewer errors mean lower costs.

$0.00025

Per error event (overage)

100K extra errors = $25

$0.000025

Per transaction event (overage)

1M extra transactions = $25

Example: 500K error events/month on Team plan

Base cost (50K events included)$26.00
Overage: 450K events x $0.00025$112.50
Total monthly cost$138.50

What Counts as an Event

Error Events

$0.00025/event (overage)

Unhandled exceptions and errors you explicitly capture with Sentry.captureException() or Sentry.captureMessage(). These are the highest-cost events. A single unhandled exception in production can generate thousands of error events per hour if it affects many users.

Transaction Events

$0.000025/event (overage)

Performance monitoring spans that track request timing, database queries, and API calls. Transaction events are 10x cheaper than error events. At a 20% sample rate, a 100K DAU app generates approximately 1.2M transaction events/month.

Replay Events

Separate quota

Session replays that record user interactions before and after an error. Available on Business plan and above. Replays help reproduce bugs by showing exactly what the user was doing. Replay events have their own quota separate from error and transaction events.

Attachment Events

Separate quota

Minidumps, screenshots, and other binary attachments sent with error events. Used primarily for native applications (iOS, Android, desktop). Attachments have file size limits and their own storage quota.

Sentry Event Volume and Cost Estimator

Predict your event volume from DAU and error rate to choose the right plan before signing up.

Sentry recommends 10-20% for production. 100% captures everything but costs more.

Event Volume Estimate

200

error events/day

6,000

error events/month

120,000

transaction events/month (20% sample rate)

Recommended Plan

Team ($26/mo)

Base cost$26/mo
Transaction overages$0.50/mo
Total estimated cost$26.50/mo

Datadog APM Comparison

Datadog APM for similar scale (~2 hosts): approximately $30/month for APM only. Sentry at $26.50/month is cheaper for error tracking. Many teams use both: Sentry for error tracking and Datadog for infrastructure monitoring.

Estimates based on DAU, error rate, and session volume. Actual event volume depends on application error handling, SDK configuration, and usage patterns. Sentry's pricing can change; verify current rates on sentry.io.

Managing Event Volume

Set transaction sample rates to 10-20%

80-90% reduction in transaction events

Instead of capturing every transaction, sample 10 to 20% in production. This reduces performance monitoring event volume by 80 to 90% while still providing statistically meaningful data. A 20% sample rate on 100K daily transactions gives you 20K representative samples, which is sufficient for identifying slow endpoints and p95 latency issues.

Use inbound data filters

10-30% reduction depending on app type

Sentry's server-side inbound data filters drop known irrelevant errors before they count against your quota. Filter out: browser extension errors (common in web apps), localhost/development errors that accidentally reach production, known bot and crawler user agents, and legacy browser errors (IE11, old Safari) that you cannot fix.

Configure rate limiting

Prevents surprise overage charges

Set per-key rate limits to prevent a single bug from consuming your entire monthly quota. For example, limit each SDK key to 1,000 events per hour. If a deployment introduces a bug affecting 50% of users, rate limiting caps the damage to 1,000 events/hour instead of potentially millions. You still see the bug and its frequency, but without the runaway costs.

Use beforeSend hooks

Variable, depends on filtering rules

The Sentry SDK supports a beforeSend callback that runs before each event is sent to Sentry. Use this to conditionally drop events client-side: filter out known issues you have accepted, drop events from specific user segments (internal testing users), and redact sensitive data before transmission. This reduces both event volume and data privacy risk.

Fix high-frequency bugs quickly

Directly proportional to bug frequency

The most effective cost management strategy is simply fixing bugs. A single unhandled exception in a hot code path can generate 10,000+ events per day. Fixing it eliminates those events permanently. Sentry's issue grouping shows which bugs produce the most events, making it easy to prioritize fixes by cost impact.

Sentry vs Datadog vs New Relic

Different pricing models for different monitoring needs.

FeatureSentryDatadogNew Relic
Pricing modelEvent-based ($0-$80/mo base)Host-based ($15+/host/mo APM)Data-based (100GB/mo free)
Free tier5K events/mo, 1 user14-day trial only100GB/mo data, 1 full user
Error tracking depthPurpose-built (excellent)Good (part of APM suite)Good (part of Errors Inbox)
Stack tracesBest-in-class with source mapsGoodGood
Infrastructure monitoringNoComprehensiveComprehensive
Log managementNoYes ($0.10/GB)Yes (included in data tier)
Session replayBusiness planRUM product ($1.50/1K sessions)Browser monitoring
Best forPure error trackingFull-stack observabilityAll-in-one with generous free tier

Frequently Asked Questions

Is the Sentry free plan enough for production apps?
For small projects with under 5,000 error events per month (roughly apps with under 1,000 DAU and good error handling), the Developer plan is functional for production. You get error tracking, stack traces, breadcrumbs, and release tracking. The 1-user limit means only you can access the dashboard, which works for solo developers. For any app with real traffic or a team, you will outgrow it within months.
Can I self-host Sentry to avoid costs?
Yes. Sentry is open source and can be self-hosted. Self-hosting eliminates per-event costs but introduces infrastructure costs (server, storage, maintenance) and operational overhead. A typical self-hosted Sentry instance requires 4 to 8 GB RAM, 20+ GB storage (grows with event volume), and regular maintenance (upgrades, backups, scaling). For teams with DevOps capacity, self-hosting makes sense above 500K events/month. Below that, the cloud service is usually cheaper than the operational overhead.
What counts as an event in Sentry?
Sentry counts four types of events: error events (unhandled exceptions and explicitly captured errors), transaction events (performance monitoring spans), replay events (session replays), and attachment events (minidumps, screenshots). Error events are the most expensive per event. Transaction events cost approximately 10x less per event than errors. Each type consumes a separate quota. Performance monitoring transactions are the highest volume for most apps.
How can I reduce my Sentry event volume?
Five strategies: (1) set transaction sample rates to 10-20% instead of 100%, which reduces performance monitoring events by 80-90%, (2) use Sentry's inbound data filters to drop known irrelevant errors (browser extension errors, bot traffic, etc.), (3) configure rate limiting to prevent a single bug from consuming your entire monthly quota, (4) use beforeSend hooks in the SDK to conditionally drop events client-side, and (5) resolve high-frequency issues quickly to stop repeat event generation.
What SDKs does Sentry support?
Sentry supports every major language and framework: JavaScript (React, Vue, Angular, Next.js, Node.js), Python (Django, Flask, FastAPI), Ruby (Rails), Java (Spring), Go, PHP (Laravel), .NET, Rust, Swift (iOS), Kotlin (Android), Flutter, React Native, and more. The SDKs handle error capture, breadcrumbs, context enrichment, and source map upload automatically. Installation typically takes 5 to 15 minutes.
Is Sentry GDPR compliant?
Yes. Sentry offers data processing agreements (DPA), data residency options (US and EU), PII scrubbing tools (both server-side and client-side), and the ability to delete user data on request. Sentry's Advanced Data Scrubbing (Business plan) automatically removes sensitive data patterns before storage. For teams subject to GDPR or CCPA, the Business plan's advanced data scrubbing features are important.
What happens if I exceed my monthly event quota?
When you exceed your included events, Sentry charges per additional event: approximately $0.00025 per error event and $0.000025 per transaction event. You can set spending caps to prevent unexpected overages. You can also configure rate limiting to drop events once a certain daily or hourly threshold is reached. Without a spending cap, a single widespread bug can generate significant overage charges.
Sentry vs DatadogSentry vs New RelicFree Plan Guide