Compare

Nohmo vs Sentry

Flat-price error monitoring — with the product analytics Sentry leaves out.

Sentry is the best-known error monitoring tool for good reason: it is mature, it supports almost every language, and its tracing and replay products are genuinely strong. If you need distributed tracing or a full APM, this page will end by telling you to use Sentry.

But two things frustrate small teams. The first is billing: the $26/month headline covers errors only, and spans, replays, logs, cron monitors, uptime checks and profiling are each metered separately — so the bill moves in ways that are hard to predict. The second is scope: a stack trace tells you what broke, never what it cost. Sentry has no funnels, no retention and no attribution, so the question "did this bug lose us signups?" cannot be answered inside it.

Nohmo captures the same class of errors — JavaScript exceptions, unhandled rejections, failed requests, native iOS and Android crashes — and puts them next to the product analytics, at one flat price. Below is Sentry's real pricing, an honest account of where Sentry wins, and how to migrate.

Nohmo vs Sentry, feature by feature

Feature comparison: Nohmo versus Sentry
CapabilitynohmoSentry
JavaScript error & native crash monitoring
Included
Included
Bugs ranked by estimated revenue lost
Included
Not included
Silent failures — dead clicks, void form submits, empty 200s
Included
Not included
Product analytics — events, funnels & retention
Included
Not included
Session journey leading up to the error
Included
Partial
UTM traffic & conversion attribution
Included
Not included
Mobile install attribution
Included
Not included
Flat price, no per-event metering
Included
Not included
Distributed tracing / APM
Not included
Included
Session replay video
Not included
Included
Source map & dSYM symbolication
Not included
Included
Backend language SDKs (Python, Go, Ruby, PHP…)
Not included
Included
Self-hosted deployment
Not included
Included
IncludedPartial / add-onNot included

What Sentry actually costs

Quoted from sentry.io/pricing, checked July 2026. Verify before deciding — vendors change pricing.

PlanPriceIncluded
Developer$05k errors · 5M spans · 50 replays · 5GB logs · 1 seat
Team$26/mo billed annually50k errors · 5M spans · 50 replays · 5GB logs
Business$80/mo billed annually50k errors · 5M spans · 50 replays, plus advanced quotas
EnterpriseCustomNegotiated volume and support

Metered separately

This is where the bill moves. Each of these is its own line item on top of the plan price.

MeterIncludedBeyond that
Errors50k on Team~$0.00025–0.000315 per event
Session replays50~$0.00375 per replay
Logs5 GB+$0.50 / GB
Cron monitors1+$0.78 / monitor
Uptime monitors1+$1.00 / alert
UI profiling—+$0.25 / hour
Continuous profiling—+$0.0315 / hour

Worked examples

80k errors a month, nothing else enabled

Sentry: ≈ $36/mo — $26 base plus ~30k events of overage

Nohmo: $49/mo — and that includes the analytics you would otherwise buy separately

Errors, plus analytics from a second vendor

Sentry: Sentry Team + an analytics plan — two bills, two SDKs, two dashboards

Nohmo: $49/mo — one bill, one SDK

Replays switched on across a busy month

Sentry: Replays meter separately at ~$0.00375 each beyond the 50 included

Nohmo: No replay product — see the honest limitations below

Nohmo: $49/mo flat per project — errors and analytics together, no per-event metering.

Which one should you pick?

Choose Sentry if…

  • •You need distributed tracing or APM across backend services.
  • •You need session replay video, not an event-level journey.
  • •You need error tracking in a language Nohmo does not ship an SDK for — Python, Go, Ruby, PHP, Java and so on.
  • •Readable minified or mobile stack traces are essential today, and you cannot wait for symbolication.
  • •You need on-premise or self-hosted deployment.

Choose Nohmo if…

  • •You want to know what a bug cost, not just that it happened — Nohmo ranks errors by estimated revenue lost.
  • •You are paying for an error tool and an analytics tool and would rather pay once.
  • •You want a predictable bill that does not move with event volume.
  • •You ship web and React Native from one team and want a single SDK for both.
  • •You care about the failures that never throw — dead clicks, forms that submit into the void, 200s with an empty body. Sentry cannot see any of them, because nothing raised.

Where Nohmo falls short today

  • •Stack traces are raw and unsymbolicated today. Sentry resolves minified JavaScript through source maps and mobile crashes through dSYM/ProGuard; Nohmo does not yet, so mobile traces are less readable. Symbolication is on the roadmap.
  • •No session replay. Nohmo reconstructs a journey from events — the pages, screens, clicks and taps in order — not a video of the screen.
  • •No distributed tracing or APM. There is nothing equivalent to Sentry Performance for spans across services.
  • •Native crash capture covers uncaught JVM exceptions on Android and Objective-C exceptions plus Swift/signal crashes on iOS. It does not cover Android NDK/C++ crashes or ANRs.
  • •Nohmo's SDKs are JavaScript, React, Next.js and React Native. Sentry supports dozens of languages and backend runtimes; if you need Python, Go, Ruby or PHP error tracking, Nohmo has no answer.

Migrating from Sentry

  1. 1

    Install alongside Sentry

    Nohmo does not conflict with Sentry, so run both while you evaluate. Neither patches the other out — Nohmo wraps fetch and XHR and adds its own global handlers.

    bash
    npm install nohmo
  2. 2

    Replace the provider

    Where Sentry needs an init call plus a separate analytics SDK, Nohmo mounts once and captures errors, page views, clicks and journeys together.

    tsx
    // Before — two SDKs, two configs
    Sentry.init({ dsn: process.env.SENTRY_DSN })
    analytics.init({ writeKey: process.env.SEGMENT_KEY })
     
    // After — one provider
    import { NohmoNextProvider } from 'nohmo/next'
     
    <NohmoNextProvider
      projectId={process.env.NEXT_PUBLIC_NOHMO_PROJECT!}
      apiKey={process.env.NEXT_PUBLIC_NOHMO_KEY!}
      options={{ release: process.env.NEXT_PUBLIC_APP_VERSION }}
    >
      {children}
    </NohmoNextProvider>
  3. 3

    Map captureException to send

    Manual error reports translate one-to-one. Uncaught exceptions and unhandled rejections are captured automatically, so most captureException calls can simply be deleted.

    ts
    // Before
    Sentry.captureException(err, { tags: { checkout: 'true' } })
     
    // After
    nohmo.send('JS_ERROR', { message: err.message, stack: err.stack, checkout: true })
  4. 4

    Point your release step at Nohmo

    Replace the Sentry release step in CI so metric movements can be correlated with deploys. Idempotent on (version, platform), so re-running a pipeline is safe.

    bash
    curl -X POST https://www.nohmo.in/api/tracker/release/ \
      -H "X-API-Key: $NOHMO_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{"version":"2.4.1","platform":"web","commitSha":"'"$GIT_SHA"'"}'
  5. 5

    Add a conversion goal with a value

    This is the step Sentry has no equivalent for. Once a goal carries a monetary value, Nohmo can compare sessions that hit an error against sessions that reached the same page and did not — and price the difference.

    ts
    nohmo.trackConversion('purchase', { value: order.total })

Why teams choose Nohmo

Bugs ranked by what they cost

Nohmo compares sessions that hit an error against sessions that reached the same page and did not, then prices the conversion gap. Sentry can tell you an error fired 4,000 times; it has no conversion data, so it cannot tell you which 4,000 mattered.

The failures that never throw

A button wired to a handler that returns early, a form posting into the void, an endpoint answering 200 with an empty body. Nothing raises, so no error monitor sees any of it. Nohmo detects them behaviourally.

One SDK, one flat bill

Errors and product analytics from a single provider at $49/mo per project — instead of an error tool metered by event volume plus a separate analytics subscription.

Frequently asked questions

How much does Sentry actually cost?+

Sentry Team is $26/month billed annually and includes 50,000 errors, 5M tracing spans, 50 session replays and 5GB of logs. Business is $80/month. The important detail is that errors, spans, replays, logs, cron monitors, uptime checks and profiling are metered separately — so 80,000 errors on the Team plan runs about $36/month, and enabling replays or profiling adds further line items. Figures from sentry.io/pricing, checked July 2026.

Can Nohmo replace Sentry?+

For a web or React Native team, often yes — Nohmo captures uncaught JavaScript exceptions, unhandled promise rejections, failed fetch/XHR requests and native iOS/Android crashes. It cannot replace Sentry if you need distributed tracing, session replay video, self-hosting, or error tracking in a backend language like Python, Go or Ruby.

What does Sentry do better than Nohmo?+

Several things, and they matter. Sentry has real distributed tracing and APM; Nohmo has none. Sentry resolves minified and mobile stack traces through source maps and dSYM/ProGuard, so its traces are far more readable — Nohmo's are raw today. Sentry has session replay, dozens of language SDKs, a much larger integration catalogue, and a self-hosted option.

What does Nohmo do that Sentry cannot?+

Three things. It ranks bugs by estimated revenue lost rather than frequency. It detects silent failures — dead clicks, forms that submit into the void, successful responses with an empty body — none of which throw an exception, so none appear in any error monitor. And it includes product analytics: funnels, retention, UTM attribution and mobile install attribution.

Is Nohmo cheaper than Sentry?+

It depends on volume and on what you are comparing. Sentry Team at low error volume is cheaper than $49/month. Nohmo becomes cheaper once you factor in the analytics tool you would otherwise buy alongside it, or once event volume pushes Sentry into overage. The more useful difference is predictability: $49 flat does not move with traffic.

Can I run Nohmo and Sentry together?+

Yes. They do not conflict — Nohmo wraps fetch and XHR and adds its own global handlers without removing Sentry's. Running both during an evaluation is the sensible way to compare what each catches on your own traffic.

How do I migrate from Sentry to Nohmo?+

Install the package, replace the Sentry init with the Nohmo provider, delete most captureException calls (uncaught errors are captured automatically), and point your CI release step at Nohmo's release endpoint. Full steps with code are above.

The verdict

If you need APM, tracing, session replay video or backend-language coverage, stay on Sentry — it is better at all four and this page will not pretend otherwise. If you are a small web or React Native team paying separately for errors and analytics, want a bill that does not move with volume, and want to know which bug is actually costing you money, Nohmo replaces both tools for $49/mo flat.

Switch from Sentry in an afternoon

One npm package, one provider, and you are tracking analytics and errors — cookielessly.

No credit card required · $49/mo during early access (normally $79)

Comparison reflects our understanding of Sentry as of 2026; third-party products change — check their site for current details.