Sentry logo

Sentry Review (2026)

Excellent error tracking that keeps appearing in LLM observability roundups where it does not belong. Its AI product, Seer, is a code-debugging agent billed per contributor - not an LLM tracing or evaluation platform.

Researched

Rating

2.0

Starting Price

$26/mo

Free Plan

Yes

SDKs & Frameworks

4

Deployment

3

Best For

Error tracking and front-end debugging, which it does superbly. It is not the right tool for observing or evaluating LLM applications, and should be paired with one rather than substituted for one.

Last Updated:

10 Things You Should Know About Sentry

  1. 1 The free Developer plan covers 5,000 errors per month and 1 user
  2. 2 Team starts at $26/month for 50,000 errors; Business is $80/month
  3. 3 Seer costs $40 per active contributor per month, billed separately from the pay-as-you-go budget
  4. 4 An active contributor is anyone making two or more pull requests to a Seer-enabled repository within a billing cycle
  5. 5 Errors are the most expensive unit, followed by session replays, then transactions
  6. 6 Enabling all event types without filtering can raise costs 3-5x versus error-only monitoring
  7. 7 Reserved capacity can be pre-purchased at a 20% discount versus pay-as-you-go

Pros & Cons

Pros

  • Genuinely best-in-class at what it actually does - error tracking with excellent stack traces and grouping
  • Session replay is outstanding for reproducing user-facing failures
  • Enormous SDK coverage and mature source-control integrations
  • Reserved capacity at a 20% discount gives real cost control if your volume is predictable
  • Self-hosting exists and is open source

Cons

  • Not an LLM observability platform - it does not do prompt and completion capture, token accounting, model comparison or evaluation the way this category means
  • Seer is a code debugging agent, not agent observability, and the naming causes genuine confusion
  • Seer's per-active-contributor billing is an unusual meter - anyone opening 2+ PRs to an enabled repo in a cycle counts
  • Enabling all event types without filtering can push costs 3-5x above error-only monitoring
  • Errors are the most expensive unit, then session replays, then transactions - easy to misjudge

Features

Best-in-class error and exception tracking with full stack traces
Session replay for reproducing front-end failures
Performance monitoring and distributed tracing
Seer, an AI debugging agent that proposes fixes for code errors
Release health and regression detection for application errors
Very broad SDK coverage across languages and frameworks

Why this page exists

Sentry keeps turning up in LLM observability roundups. It should not, and the single most useful thing we can tell you is why.

Sentry is an error tracking and performance monitoring platform. It is very good at that - arguably best in class. It captures exceptions with excellent stack traces and grouping, records session replays that let you watch a user hit a bug, and does distributed tracing and release health across more than a hundred platform SDKs.

It is not an LLM observability platform. It does not capture prompts and completions, account for tokens, attribute cost per model, or evaluate output quality. Its trace model is built around requests and exceptions, not conversations and agent loops.

The distinction matters because of the failure mode LLM applications actually have. If your LLM application throws an exception, Sentry will tell you in exquisite detail. If your LLM application returns a confident, well-formed, completely wrong answer, Sentry sees nothing - because from the application’s point of view, nothing went wrong. That gap is the entire reason this category exists.

The Seer confusion

The reason Sentry gets miscategorised is Seer, its AI product. Roundup authors see “AI” and file it under AI observability.

Seer is an AI debugging agent for your code. It examines errors Sentry captured and proposes fixes. It is a developer productivity tool.

It is not agent observability. It does not observe your agents - it is an agent that observes your errors. Those two things sound almost identical and are entirely different purchases.

Seer’s pricing is also unusual enough to flag: $40 per active contributor per month, where an active contributor is anyone making two or more pull requests to a Seer-enabled repository within a billing cycle. It is billed separately from the pay-as-you-go budget.

That meter tracks development activity, not traffic. A busy sprint with many contributors touching an enabled repo costs more than a quiet one regardless of what your application is doing. Perfectly rational for a developer tool; disorienting if you are used to usage-based observability pricing and are trying to slot it into the same spreadsheet.

Pricing

PlanPriceErrors/mo
Developer (Free)$05,000, 1 user
Team$26/mo50,000
Business$80/mo50,000 + advanced features
EnterpriseCustomCustom
Seer add-on$40/active contributor/moSeparate from PAYG budget

The cost trap here is well documented and worth knowing even though it has nothing to do with LLMs: the units are not equally priced. Errors are the most expensive, then session replays, then transactions. Teams that enable every event type without filtering can see costs rise three to five times versus error-only monitoring. Overages apply across errors, spans, replays, logs, metrics, profiling, monitors and Seer.

If your volume is predictable, reserved capacity at a 20% discount versus pay-as-you-go is the most effective control.

The right way to use it

Run both. This is not a compromise, it is the correct architecture.

  • Sentry tells you the application crashed, where in the stack, and what the user was doing.
  • Langfuse, Logfire or similar tells you what the model was asked, what it answered, what it cost, and whether the answer was any good.

Neither substitutes for the other. Most teams shipping LLM features inside a real application need both, and the mistake is assuming one covers the other’s territory because both are called “observability.”

About the rating

We rate 2 here, and that is a statement about category fit rather than product quality.

This site scores tools for LLM evaluation and observability. On that axis, Sentry does not do the job. On a site about error tracking it would score very highly and deserve to.

We would rather say that plainly than give it a flattering score that misleads someone comparing it against Langfuse or Logfire in a shortlist.

Should you use it?

Use Sentry if you need error tracking, exception monitoring and session replay. It is excellent and you should probably already have it.

Don’t use Sentry if you are looking for LLM observability. Nothing here does that job.

Bottom line: a great product in the wrong category. Buy it for your application errors, pair it with a real LLM observability tool, and ignore the roundups that list them as alternatives to each other.


Pricing verified against published sources on 31 July 2026, with the caveat that Sentry’s quotas and overage rates change frequently and many public figures are editorial estimates. We could not identify a dedicated LLM tracing or evaluation product from Sentry; if one has shipped since our review, this page will be out of date. This is a researched directory entry - we have not instrumented this platform with our reference application.

Pricing Plans

Developer (Free)

$0

  • 5,000 errors per month
  • 1 user
  • Core error tracking
Most Popular

Team

$26/mo

  • 50,000 errors per month
  • The cheapest business-usable tier
  • Overages on errors, spans, replays, logs and more

Business

$80/mo

  • 50,000 errors per month
  • Advanced features
  • Reserved capacity available at 20% off pay-as-you-go

Seer (AI add-on)

$40 per active contributor/mo

  • Code debugging agent, not LLM observability
  • Active contributor means 2+ PRs to a Seer-enabled repo in a billing cycle
  • Billed separately from the pay-as-you-go budget

SDKs & Frameworks

Python JavaScript / TypeScript Java, Go, Ruby, PHP, .NET and many more 100+ platform SDKs

Deployment

Cloud SaaS Self-hosted (open source, functional but unsupported at scale) Deep source-control and issue-tracker integrations

Eval Methods

None for LLM output quality No LLM-as-judge, datasets or regression testing

Category Fit

Error tracking and APM, not LLM observability

Our Verdict

We are including Sentry because it keeps appearing in LLM observability comparisons, and the most useful thing we can tell you is that it does not belong in them. Sentry is an outstanding error tracking and performance monitoring product. What it is not is an LLM observability platform. It does not do prompt and completion capture, token accounting, per-model cost attribution or output-quality evaluation in the way this category means those terms. The confusion comes from Seer, Sentry's AI product, which roundups see and file as AI observability. Seer is a code debugging agent - it looks at your errors and proposes fixes - billed at $40 per active contributor per month, where an active contributor is anyone opening two or more pull requests to a Seer-enabled repository in a billing cycle. That is a developer productivity tool, not agent observability. Run Sentry for your application errors, absolutely. Run something else for your LLM calls.

Similar Tools

Frequently Asked Questions

Is Sentry an LLM observability tool?

No, and this is the main reason this page exists. Sentry does error tracking, performance monitoring and session replay, and it is excellent at all three. It does not provide the things this category means by LLM observability - prompt and completion capture, token accounting, per-model cost attribution, trace views built around conversations and agent loops, or output-quality evaluation. If your LLM application throws an exception, Sentry will tell you about it beautifully. If your LLM application returns a confident, well-formed, completely wrong answer, Sentry will not notice anything happened, because from the application's perspective nothing did.

What is Seer, then?

An AI debugging agent for your code. It examines errors Sentry has captured and proposes fixes. It is a developer productivity tool, and it is the reason Sentry ends up in AI tooling roundups written by people pattern-matching on the word AI. It is not agent observability - it does not observe your agents, it is an agent that observes your errors. Worth being precise about, because the two things sound similar and are completely different purchases.

How does Seer's pricing work?

It is metered in an unusual way. Seer costs $40 per active contributor per month, where an active contributor is defined as anyone making two or more pull requests to a Seer-enabled repository within a billing cycle. It is billed separately from your pay-as-you-go budget. The consequence worth modelling is that your bill tracks development activity rather than traffic or error volume - a busy sprint with many contributors touching an enabled repo costs more than a quiet one, regardless of what your application is doing. That is a rational meter for a developer tool and an unfamiliar one if you are used to usage-based observability pricing.

What makes Sentry bills grow unexpectedly?

Enabling every event type without filtering. Pricing is structured around plan tier, event volume and seats, and the units are not equally priced - errors are the most expensive, followed by session replays, then transactions. Teams that switch on all event types without filtering can see costs rise three to five times versus error-only monitoring. Overages apply across errors, spans, replays, logs, metrics, profiling, monitors and Seer usage. If your volume is predictable, reserved capacity pre-purchased at a 20% discount is the most effective lever.

Should I use Sentry alongside an LLM observability tool?

Yes, and that is the right architecture rather than a compromise. They answer different questions. Sentry tells you your application crashed, where in the stack, and what the user was doing. Langfuse or Logfire tell you what your model was asked, what it answered, what it cost and whether the answer was any good. Neither substitutes for the other. Most teams shipping LLM features in a real application need both, and the mistake is assuming one covers the other's ground.

Why rate it 2 if it is a good product?

Because this site rates tools for LLM evaluation and observability, and that is the axis being scored. Sentry is genuinely excellent at error tracking and would rate very highly on a site about error tracking. Scored as an LLM observability platform - which is the category it keeps being listed in - it does not do the job, and a high rating here would mislead someone comparing it against Langfuse or Logfire. The rating reflects category fit, not product quality.