I've spent a lot of time evaluating monitoring tools for Next.js. This post is the distillation: 9 tools, ranked by how well they actually fit the shape of a Next.js application in 2026, with honest tradeoffs.
Skip to the comparison table if you just want the TL;DR. Otherwise, let's start with why Next.js monitoring is a different problem than generic web app monitoring.
Why Next.js Monitoring Is Different
Next.js combines several workloads in a single deployment: API routes, server actions, server components, middleware, and often a ton of serverless functions running on Vercel, AWS Lambda, Netlify, or Cloudflare Workers. This breaks the assumptions legacy APM tools make:
- You can't install a host-level agent on serverless platforms. The traditional Datadog-agent-on-every-host model just doesn't apply.
- Functions are short-lived. Log shipping needs to flush before the function exits, or you lose telemetry.
- Cold starts matter. First-request latency can be 10x warm-request latency and needs to be tracked separately.
- Bills scale with invocations. Monitoring overhead has a real dollar cost on serverless.
Next.js 13.4 shipped an instrumentation.ts hook to solve this, and Next.js 15 stabilized it. This hook runs once per server boot, lets monitoring SDKs attach to the runtime, and gives them access to the request lifecycle without an agent. Modern Next.js monitoring is built around this hook. Tools that don't support it are fighting uphill.
The 3 Layers You Actually Need
Before I rank anything, I need to explain the mental model I'm using. There is no "one monitoring tool to rule them all" for Next.js. Production-grade monitoring is three layers:
- External uptime checks. Pings from outside your infrastructure that answer "is my API reachable from the public internet?" Catches DNS, SSL, CDN, and platform outages, failure modes where your code never runs, so in-process monitoring can't help.
- Internal execution monitoring. Metrics from inside your Next.js process that answer "what's happening when my server handles a real request?" Catches slow database queries, latency degradation, and silent errors where the response is 200 OK but the user is waiting 8 seconds.
- Error tracking. Stack traces from exceptions that answer "what broke, and where in my code?" Catches bugs you can fix.
Every tool on this list covers one or more of these layers. The "best tool" for you depends on which layers you need and whether you want them in one tool or three.
How I Evaluated These Tools
Criteria:
- Next.js fit. Does it support
instrumentation.tsnatively? How much code does it take to install? - Pricing honesty. Is the published price what you actually pay, or does the real bill triple after a year of use?
- Which layers it covers. External pings, internal metrics, error tracking, or all three?
- Setup time. Minutes, hours, or days?
- Alerting quality. How fast does the first alert land in my hand?
The Ranking
1. Sentry: Best for error tracking
What it does well: Sentry is best in class at error tracking. Stack traces are source-mapped, errors are grouped, session replay shows you exactly what the user did before the exception fired, and the Next.js SDK integrates cleanly via instrumentation.ts. If your question is "what broke and where in my code", Sentry has no equal. Most production Next.js teams install Sentry on day one and never look back.
Where it stops: Sentry is reactive. It only sees what your code reports. If your server is unreachable, your DNS is misconfigured, your deploy is broken, or your database hangs without throwing, Sentry has nothing to capture. Performance monitoring is sample-based (default ~10%), so per-route P95 history is incomplete. No native external uptime checks (the Uptime Checks add-on is basic). No WhatsApp alerts.
Pricing: Free tier: 5,000 errors/month. Team: $26/month. Business: $80/month. Real bills stay reasonable for small teams.
Setup: 10-15 minutes with the wizard (npx @sentry/wizard@latest -i nextjs).
Best for: Every production Next.js app needs error tracking, and Sentry is the default answer. I'd install it before anything else on this list.
2. Datadog: Best for enterprise platform teams
What it does well: Datadog is the most complete observability platform that exists. APM traces, logs, metrics, synthetics, RUM, network monitoring, security, CI visibility, it does everything, at high quality, with powerful dashboards and query languages. If you have a platform team managing dozens of services across multiple clouds, Datadog is the right call.
Where it stops: Pricing. The published "from $15/host/month" is misleading because real bills are multi-product: Infrastructure ($15-23/host), APM ($31-40/host), Logs ($0.10/GB ingested + $1.27/GB indexed), Synthetics ($5/10K runs), RUM ($1.50/1K sessions), custom metrics, DBM at $70/host. A 5-developer Next.js team running 3 environments typically pays $400-1,200/month. Reddit and Hacker News are full of stories of teams getting surprised by $5K-$50K monthly bills after a year of growth. Setup on Next.js via serverless integration takes 1-5 days. No WhatsApp alerts.
Pricing: $15-40/host/month published, $400-1,200/month real for a 5-dev team, unbounded at scale.
Setup: 1-5 days depending on team experience.
Best for: Platform/SRE teams at Series B+ companies with dedicated budget for observability. Not for indie devs or pre-revenue startups.
If you're specifically weighing Datadog against a lighter-weight alternative for a Next.js app, I wrote a dedicated breakdown: Next.js vs Datadog, when Datadog is overkill and what to use instead.
3. Vercel Observability: Best for teams 100% on Vercel
What it does well: If your entire stack runs on Vercel, you already have access to Vercel's built-in Observability tab, Analytics, and Speed Insights. Zero setup, it's already enabled. Function logs, execution metrics, and basic error rates are surfaced in the dashboard you already use. Cost is bundled into your Vercel plan.
Where it stops: Vercel-only. If you ever move part of the stack off Vercel, you lose the visibility. No external uptime pings from independent probes (Vercel can't monitor Vercel objectively). Log retention is limited. Alerting is thinner than dedicated monitoring tools. No multi-region comparative metrics. If you care about "is Vercel itself down from the user's perspective", Vercel can't answer that.
Pricing: Included in Pro ($20/month) and Enterprise. Speed Insights is a separate paid add-on on higher tiers.
Setup: Zero. It's already on.
Best for: Early-stage teams on Vercel who haven't outgrown the built-ins yet. Most teams add Sentry + an external monitor as they mature.
4. New Relic: Best legacy APM with a generous free tier
What it does well: New Relic has the most generous free tier in enterprise APM, 100GB of data/month free, forever. If you fit within that envelope, you get full APM, infrastructure monitoring, logs, and synthetics at zero cost. The Node.js + Next.js integration is mature and the platform has depth built up over 15 years.
Where it stops: The UX feels like an enterprise tool from the 2010s. Setup on Next.js requires the newrelic package and some configuration dance around instrumentation.ts that's not quite as clean as Sentry. Beyond the 100GB free tier, pricing gets complicated fast. No WhatsApp alerts.
Pricing: Free tier 100GB/month (real, not a trial). Paid starts at $0.30/GB ingested above that.
Setup: 30-60 minutes.
Best for: Teams that need full APM depth but can't justify Datadog pricing. The free tier is genuinely useful.
5. AppSignal: Best dev-friendly Node/Next.js APM
What it does well: AppSignal is an underrated developer-focused APM that started in the Ruby ecosystem and has solid Node and Next.js support. Clean UX, honest pricing, real support from the team, and it handles both errors and performance monitoring in one tool. Founder-led company, not enterprise-focused, so the DX is a priority rather than an afterthought.
Where it stops: Not as deep as Datadog. No external uptime checks natively. Feature set is narrower than the enterprise APMs. Next.js support is good but not specifically built around instrumentation.ts as cleanly as Sentry.
Pricing: Free tier available. Paid starts at ~$19/month.
Setup: 15-30 minutes.
Best for: Developer-led teams that want error tracking + APM in one tool and don't need the full Datadog stack. Good alternative to Sentry if you also want performance data and don't already have Sentry installed.
6. Highlight.io: Best for session replay + errors combo
What it does well: Highlight is Sentry + LogRocket in one tool, error tracking plus session replay so you can watch exactly what the user did before the bug fired. Open source, self-hostable if you want, and they built a Next.js SDK that hooks in cleanly. For consumer-facing apps where understanding user journeys matters, the session replay angle is genuinely useful.
Where it stops: Not a full APM. No external uptime checks. Performance monitoring is lighter than the dedicated APMs. Session replay comes with privacy considerations (PII masking) that take some effort to configure correctly.
Pricing: Free tier available. Paid starts at $50/month.
Setup: 15-20 minutes.
Best for: Consumer-facing Next.js apps where you need to understand user behavior around errors. Great pairing with a separate uptime tool.
7. Better Stack: Best uptime + logs + incident management combo
What it does well: Better Stack (formerly Logtail + Better Uptime) combines uptime monitoring, log management, and incident management in one tool. Modern UI, fast alerting, Slack/Discord/Teams integrations. If you want a single vendor for status pages, incident response, and external monitoring, Better Stack does it well.
Where it stops: The "internal execution monitoring" story is weaker, it's primarily an external monitoring + log management product, not an in-process APM. No instrumentation.ts integration. No native WhatsApp alerts. Pricing scales with log volume which can get expensive fast.
Pricing: Free tier: 10 monitors. Paid from $29/month.
Setup: 10-20 minutes.
Best for: Teams that want uptime + logs + incident management bundled. If you also want real internal Next.js metrics you'll need to pair it with a separate APM.
8. UptimeRobot: Best free basic external monitoring
What it does well: UptimeRobot is dead simple and has the most generous free tier in uptime monitoring: 50 monitors at 5-minute intervals, free forever. If your question is "tell me when this URL stops responding", UptimeRobot answers it for $0. Millions of developers use it precisely because it doesn't pretend to do more than one thing.
Where it stops: External pings only. It cannot see inside your server. A route can return 200 OK and still be processing for 3 seconds because of a slow database query, UptimeRobot will report it as healthy. No internal execution metrics, no per-route P95, no error rates from real traffic. It is fundamentally a single-layer tool (external only).
Pricing: Free for 50 monitors. Paid from $8/month.
Setup: 2 minutes.
Best for: Every developer's first monitoring tool. Pair it with Sentry for a free stack that covers most basic needs, and upgrade to something more sophisticated when the "200 OK but broken" incidents start hurting.
9. OpenTelemetry + Grafana Cloud: Best DIY observability stack
What it does well: OpenTelemetry is the open standard for tracing, metrics, and logs. Grafana Cloud gives you a hosted backend at a reasonable price. Together, they form a vendor-neutral observability stack: instrument once with OTel, ship to Grafana Cloud (or self-hosted Grafana + Loki + Tempo + Mimir). Next.js 15 has solid OTel support via @vercel/otel.
Where it stops: Complexity. OTel is powerful but has a real learning curve. Setup on Next.js involves decisions about span processors, resource attributes, exporters, and runtime compatibility. Grafana dashboards are not built for you, you have to design them. If you want something that works in 5 minutes, this is not it. If you want something that you'll still be running in 5 years without vendor lock-in, this is exactly it.
Pricing: OTel is free. Grafana Cloud free tier: 10K metrics, 50GB logs, 50GB traces. Paid from $29/month.
Setup: Hours to days depending on depth.
Best for: Engineering teams with a strong observability culture who want vendor neutrality. Not for founders who want to ship the product this week.
If you're comparing a Grafana-based stack against a managed Next.js monitoring tool, I also wrote: Next.js vs Grafana, which observability approach fits your team.
Comparison Table
| # | Tool | Layer(s) | Setup | Free | Paid from | Best for |
|---|---|---|---|---|---|---|
| 1 | Sentry | Errors | 10 min | 5K errors/mo | $26/mo | Error tracking, all teams |
| 2 | Datadog | All 3 + more | 1-5 days | Trial only | $400+/mo real | Platform teams w/ budget |
| 3 | Vercel Observability | Internal (lite) | Zero | Bundled | Pro $20/mo | 100% Vercel stacks |
| 4 | New Relic | All 3 | 30-60 min | 100GB/mo | $0.30/GB | Generous free tier lovers |
| 5 | AppSignal | Errors + Perf | 15-30 min | Yes | $19/mo | Dev-friendly APM |
| 6 | Highlight.io | Errors + Replay | 15-20 min | Yes | $50/mo | Consumer apps w/ session replay |
| 7 | Better Stack | External + Logs | 10-20 min | 10 monitors | $29/mo | Uptime + logs + incidents bundle |
| 8 | UptimeRobot | External | 2 min | 50 monitors | $8/mo | Free basic pings |
| 9 | OTel + Grafana | All 3 DIY | Hours-days | Generous | $29/mo | Vendor-neutral stack |
How to Choose: A Decision Tree
This is the honest version of "which one should I pick":
- Are you pre-revenue or just starting? Install Sentry (free) + UptimeRobot (free). That's it. Don't overthink it. You can add more later.
- Are you in production with real users and your main fear is "bug in code"? Sentry is non-negotiable. Add Vercel Observability if you're 100% on Vercel, or a dedicated external monitor if not.
- Are you in production and your main fear is "my API is slow or silently broken"? You need internal execution monitoring. Options: Sentry Performance (sampled), AppSignal, or Datadog APM if you have the budget.
- Do you want uptime, logs and incident management from one vendor?Better Stack bundles them; pair it with an APM for internal metrics.
- Do you have a platform team and a real budget?Datadog. You'll pay for it but it does everything.
- Are you an engineer who values vendor neutrality above ease of setup?OpenTelemetry + Grafana Cloud. Expect a learning curve.
The Stack I'd Build for a New Next.js SaaS Today
For a new Next.js SaaS in 2026 with no existing monitoring, this is what I'd install in order:
- Day 1: Sentry (5 minutes, free). Error tracking is table stakes.
- Day 1: UptimeRobot (2 minutes, free). Basic external pings. Even a dead-simple signal is better than nothing.
- When you have paying customers: Add internal execution monitoring so you catch slow endpoints before customers complain. Options: Sentry Performance (if you want to stay on one vendor), AppSignal, or OpenTelemetry + Grafana Cloud.
- When you have a platform team or your monthly infra bill is > $5K: Consider migrating to Datadog or staying with a combined stack depending on budget.
FAQ
What is the best monitoring tool for Next.js in 2026?
There is no single answer, it depends on which failure mode you're trying to catch. Sentry is best for errors. Datadog is best for platform teams. Vercel Observability is best if you are 100% on Vercel. Most production teams end up running 2-3 tools because each one covers a different layer.
Do I need a Next.js-specific monitoring tool?
Not strictly, generic APMs work. But Next.js has the instrumentation.ts hook specifically for monitoring, and tools that were built around it (Sentry, OTel) are dramatically easier to set up than legacy agent-based APMs.
Can I build a free monitoring stack for Next.js?
Mostly. Sentry free tier (5K errors/month) + UptimeRobot free tier (50 monitors) cover errors and uptime at $0. For the third layer (internal execution monitoring), AppSignal and Grafana Cloud both have free tiers to start with. You'll outgrow the free tiers eventually, but this stack is enough to get to first paying customers.
What should I actually monitor in a Next.js app?
Three layers: external uptime (is it reachable), internal execution (P50/P95/P99 latency and error rates per route), and errors (exceptions with stack traces). Each layer catches failures the others miss.
Final Verdict
If I had to pick just one tool to install on a new Next.js app, it would be Sentry. Error tracking is the layer with the best tooling-to-value ratio and Sentry owns it.
If I had to pick two tools, it would be Sentry + UptimeRobot (both free tiers).
If I had to pick three tools for a production Next.js SaaS with paying customers, it would be Sentry (with Performance for internal latency) + UptimeRobot or Better Stack for external checks + Vercel Observability for platform-level visibility.
If money were no object and I had a platform team, Datadog.