Best monitoring tools for Next.js apps

The best monitoring tools for Next.js apps in 2026 are Vercel Observability for built-in metrics and Speed Insights, Sentry for error tracking with native Next.js SDK support, Better Stack for uptime and incident response, Axiom for edge and serverless logs, and OpenTelemetry when you want vendor-neutral traces across App Router, Server Actions, and Route Handlers. Pick one error tracker, one log store, one uptime monitor, and a RUM layer. That's the whole stack.

Most teams overbuy. You don't need Datadog at week one. You need to see when a Server Action throws, when a Route Handler times out on Edge, and when LCP regresses on /pricing. Below is what each tool actually does for a Next.js app, where it loses to the alternatives, and how to wire it up without a week of YAML.

TL;DR comparison

Tool	Best for	Free tier	Paid starts	Native Next.js?
Vercel Observability + Speed Insights	Runtime metrics, RUM, function logs on Vercel	Yes (Hobby)	$20/mo Pro + usage	Yes (zero-config)
Sentry	Error tracking, source maps, performance traces	5k errors/mo	$26/mo Team	Yes (@sentry/nextjs)
Better Stack	Uptime, status pages, incident on-call	10 monitors	$29/mo	Yes (Vercel integration)
Axiom	High-volume logs, edge logs, analytics	500GB/mo ingest	$25/mo	Yes (Vercel log drain)
OpenTelemetry (self-hosted)	Vendor-neutral traces, custom backends	Free (you host)	Infra cost only	Yes (instrumentation hook)
Datadog	Full APM if you're already on it	14-day trial	$15/host/mo	Partial
New Relic	Full-stack monitoring with generous free tier	100GB/mo	$0.30/GB ingest	Partial

Vercel Observability + Speed Insights

If you deploy to Vercel, you already have a monitoring tool. Vercel Observability ships with every project on the Pro plan and surfaces function invocations, error rates, cold starts, cache hit ratios, ISR revalidations, and Edge Middleware throughput. The Hobby tier shows you the basics for free.

Speed Insights is the RUM (real user monitoring) layer. Add @vercel/speed-insights/next and Vercel collects Core Web Vitals (LCP, INP, CLS) from real browsers, broken down by route and device. This is the data Google actually uses to rank you, so treating it as nice-to-have is a mistake.

Where Vercel wins: zero config, accurate Edge runtime data nobody else has, native breakdown by App Router segment, and Speed Insights costs less than running PageSpeed Insights manually.

Where Vercel loses: the included log retention is short (1 day on Hobby, 1 day on Pro without enabling the paid extension), traces don't reach into your database, and you can't ship the data to a SIEM. If you self-host Next.js on Render, Fly, or AWS, Vercel Observability isn't an option at all.

Sentry for error tracking

Sentry is the default for a reason. The @sentry/nextjs SDK auto-instruments App Router, Pages Router, Route Handlers, Server Actions, Middleware, and the client. It uploads source maps during next build, so a stack trace pointing at chunk-7f3a.js:1:48592 becomes app/(dashboard)/billing/page.tsx:42. That single feature is why teams stay.

Install is one command and a wizard:

npx @sentry/wizard@latest -i nextjs

The wizard writes sentry.client.config.ts, sentry.server.config.ts, sentry.edge.config.ts, and patches next.config.js with withSentryConfig. Server Action errors get captured automatically once you wrap them, and React Server Component errors land in the same project as client-side issues.

Where Sentry wins: the best stack traces in the category, replay sessions that show the user's last 30 seconds before a crash, performance traces that span client to server to database, and a Cron Monitors product if you run scheduled jobs.

Where Sentry loses: the pricing model is event-based and gets expensive past 100k errors/mo if you have noisy validation errors. Their logs product is newer than Axiom or Better Stack and doesn't yet match them on query speed. Use Sentry for errors, not as your log store.

Better Stack for uptime and incidents

Better Stack (formerly Logtail and Better Uptime, now merged) does three jobs: synthetic uptime checks, public status pages, and on-call rotation. The Vercel integration lets you trigger an incident from a failed deployment or a Sentry alert without writing webhook glue.

For a Next.js app on Vercel, the right config is:

• One HTTPS check on / every 30 seconds from 3 regions
• One on /api/health (a route handler that pings your database)
• A status page subdomain like status.yourapp.com with subscriber emails

Where Better Stack wins: the status page is the best in the category at the price (Statuspage is 5x the cost), on-call escalation is included on the $29 plan, and the heartbeat URLs work for cron jobs running on Vercel Cron, Trigger.dev, or GitHub Actions.

Where Better Stack loses: the logs product is fine but slower than Axiom for large queries, and the APM features lag Datadog. Use it for the uptime + status page + on-call piece, then pair it with Sentry and Axiom for the rest. Our companion guide on the best monitoring tools for startups in 2026 covers the cross-framework stack in more depth.

Axiom for edge and serverless logs

Next.js generates more logs than people expect. Every Route Handler invocation, every Server Action, every Middleware run, every revalidation, every console.log you forgot to remove. Vercel's built-in log retention is 1 day. Axiom is where you send them when you actually need to search history.

Set up a Vercel log drain pointing at Axiom and every log line streams into a dataset you can query with their APL (a SQL-ish language). The pricing is ingest-based and the free tier (500 GB/mo) is honest enough that small teams never pay.

What to actually log:

• Request ID, user ID, route, status, duration on every API hit
• Webhook payloads from Stripe, Clerk, Resend (redact PII)
• LLM provider responses if you're calling OpenAI or Anthropic, with token counts and latency
• Cache hit/miss on ISR routes you care about

Where Axiom wins: the query speed on 100GB+ datasets is faster than Better Stack and a fraction of Datadog's cost. Native Vercel integration means setup is 90 seconds. Dashboards are flexible without being baroque.

Where Axiom loses: no synthetic uptime checks, no on-call, no error grouping. It's a log store, not a platform. Their alerting is functional but less polished than Datadog Monitors.

OpenTelemetry + Next.js instrumentation hooks

If you're allergic to vendor lock-in, Next.js has a first-party instrumentation hook. Create instrumentation.ts at the project root, export a register function, and Next.js runs it on cold start across Node and Edge runtimes.

// instrumentation.ts
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    await import('./instrumentation.node');
  }
}

In instrumentation.node.ts, configure the OpenTelemetry Node SDK with an OTLP exporter pointed at any backend: Honeycomb, Grafana Tempo, SigNoz, Jaeger, Datadog, New Relic, anywhere that speaks OTLP. The @vercel/otel package is a one-line wrapper that handles the common case if you don't want to write the SDK config yourself.

Where OTel wins: vendor-neutral. If you change backends in 12 months, the instrumentation stays the same. The data model (traces, metrics, logs with shared trace IDs) is the right abstraction for distributed systems.

Where OTel loses: you're operating the pipeline. The "free" backends (Tempo, SigNoz) require infrastructure. The hosted backends (Honeycomb, Grafana Cloud) cost real money at scale. For a 3-engineer startup shipping weekly, Sentry + Axiom is a faster path; OTel becomes a fit when you have a platform team.

Datadog and New Relic (the all-in-one option)

If you're already on Datadog or New Relic at the company level, both work for Next.js with caveats. Datadog's RUM SDK ships browser and Edge support, the APM tracer auto-instruments Node, and the Logs product handles Vercel drains. New Relic's free tier (100 GB/mo ingest, one user) is generous enough to handle small Next.js workloads end to end.

The downside is integration depth. Sentry knows what a Server Action is; Datadog sees an opaque function. Speed Insights knows which App Router segment shipped a bad LCP; Datadog RUM sees a URL. For pure Next.js work, the focused tools win on signal-to-noise. For mixed stacks (Next.js frontend, Go backend, Postgres, Kafka), the all-in-one tools win on correlation.

Server Action error tracking specifically

This is the one Next.js-specific failure mode worth calling out. Server Actions throw on the server but the error surfaces in the client. Without instrumentation, the user sees a generic "something went wrong" and you see nothing. Three options:

1. Sentry: the SDK wraps Server Actions automatically once you import the right helpers. Errors land in your Sentry project with the action name and arguments.
2. Manual try/catch + log: wrap each action, log to Axiom with { action, userId, error }, return a typed error object to the client. More work, no vendor.
3. Next-safe-action or zsa: these libraries already include error handling and let you plug in any logger. Pairs well with either Sentry or Axiom.

The wrong answer is shipping unwrapped Server Actions to production. Whatever monitoring stack you pick, this is the first instrumentation you wire up.

Picking a stack: three working defaults

For a Next.js solo founder or 2-engineer team on Vercel:

• Vercel Speed Insights for RUM (free on Hobby, $20/mo Pro adds Observability)
• Sentry Team plan, $26/mo
• Better Stack $29/mo for uptime + status page
• Total: ~$75/mo, ~30 min to wire up

For a Series A team self-hosting Next.js on Render or AWS:

• Sentry Business plan
• Axiom for logs (free tier likely enough)
• Better Stack for uptime
• OpenTelemetry to Grafana Cloud for traces
• Total: ~$150-300/mo, half a day to wire up

For an enterprise team already on Datadog:

• Datadog for everything except errors
• Sentry for errors and source maps (you can ship Sentry data to Datadog if needed)
• Total: whatever your Datadog bill already is + $26/mo Sentry

What to do next

Audit what you have first. Most Next.js apps we see at Cadence have Sentry installed but not configured for Server Actions, Speed Insights ignored, and zero log retention. Fixing those three takes an afternoon and is worth more than adding a fourth tool.

If you want a second pair of eyes, every engineer on Cadence is AI-native (vetted on Cursor, Claude Code, and Copilot before they unlock bookings) and a mid-tier engineer at $1,000/week can have your monitoring stack honest and on-call-ready inside a week. Worth pairing with our breakdowns on LaunchDarkly vs Statsig vs Vercel feature flags if you're also evaluating runtime control planes, and the best feature flag services for startups in 2026 for the wider category view.

If your monitoring stack hasn't been touched since launch, book a 48-hour trial with a Cadence mid-tier engineer. Two days, no cost, and you'll know whether Sentry, Speed Insights, and Axiom are actually catching the failures that matter. Audit your tooling at /tools/ship-or-skip.

FAQ

What's the best free monitoring tool for Next.js?

Vercel Speed Insights and Vercel Observability on the Hobby plan, paired with Sentry's free tier (5k errors/mo) and Axiom's free tier (500 GB/mo ingest). That combination covers RUM, errors, and logs at $0/mo for a side project. Add Better Stack's free tier (10 monitors) for uptime.

Do I need Datadog if I use Vercel?

Probably not. Vercel Observability plus Sentry plus Axiom covers everything Datadog does for a Next.js app, at 10-20% of the cost. Datadog earns its price when you have multiple services in multiple languages on multiple clouds. A Vercel-only Next.js app rarely qualifies.

How do I monitor Server Actions?

Use Sentry's @sentry/nextjs SDK, which auto-instruments Server Actions, or wrap each action manually with try/catch and log to Axiom. Whatever you pick, do not ship unwrapped Server Actions to production. Errors thrown server-side become invisible to the user-facing app without instrumentation.

Can I use OpenTelemetry with Next.js?

Yes. Next.js ships a first-party instrumentation.ts hook that runs on cold start in both Node and Edge runtimes. Use @vercel/otel for a one-line setup or wire the OTel Node SDK yourself and point it at Honeycomb, Grafana Tempo, SigNoz, or any OTLP backend.

How much should monitoring cost for a Next.js startup?

Budget $50-150/mo at pre-seed and seed stage. Vercel Speed Insights ($20/mo as part of Pro), Sentry Team ($26/mo), and Better Stack ($29/mo) cover most teams under 100k MAU. Logs via Axiom usually stay in the free tier until you cross 500 GB/mo of ingest. The right take is also covered in our best monitoring tools for startups in 2026 roundup if you're not Next.js-specific.

What's the difference between Sentry and Vercel Observability?

Sentry is an error tracker with source-mapped stack traces, session replay, and performance traces. Vercel Observability is infrastructure metrics: function invocations, cold starts, cache hit rates, Edge Middleware throughput. They overlap on performance but solve different problems. Most teams run both.