GlitchTip vs Honeybadger: A Hands-On Error Tracking Comparison for 2026

Stanley Ulili
Updated on November 20, 2026

My third release added one new bug: a payment gateway failure that put the charge amount in its message. GlitchTip filed it as seven issues, one for every amount. Honeybadger filed it as one. Everything else in this comparison follows from that difference in how the two tools decide what counts as the same error.

They look alike on paper. Both are small, independent error trackers for teams that find Sentry or Datadog too much, both cover the browser and the server in one project, and both bundle uptime monitoring into the price. GlitchTip is an open-source tracker built to receive events from Sentry's SDKs, with logs and route-level timing drawn from one pool of events, and you can host it yourself for nothing.

Honeybadger goes its own way. Honeybadger is a hosted error tracker with its own SDKs, and each of its flat-priced plans folds in Insights, its log and event store, plus uptime monitoring, cron check-ins and hosted status pages.

Both tools watched one broken bookstore, storefront and API, through three releases. The sections cover setup, capture, the error page, source maps, grouping, releases, the slow release, logs, uptime and alerts, AI and price.

GlitchTip vs Honeybadger: Results at a glance

Every verdict comes from one Express API and one Vite storefront set up from each vendor's own guide. Grouping rules written from day one, or another language, could shift a few.

Area Better in my test Why
Setup Honeybadger, narrowly One package and key; GlitchTip's Performance page stays blank on Sentry SDK 11 by default
Error capture Tie Both caught every planted failure, the rejection included
Debugging a server error Mixed GlitchTip shows the code; Honeybadger shows the request, the user and the deploy
Source maps Tie Both mapped the wishlist crash after a scripted upload
Error grouping Honeybadger One payment bug stayed one group; GlitchTip made seven
Releases and regressions Honeybadger, narrowly Named the deploy that revived the coupon bug, and clears its list at each deploy
The slow release Mixed GlitchTip timed routes; Honeybadger tied the slowdown to 1.2.0 through logs
Logs and querying Honeybadger Insights with BadgerQL; GlitchTip keeps a plain list
Uptime and alerts Not compared Both include uptime checks; neither was tested
AI-assisted debugging Not compared Both hand errors to your own assistant
Price GlitchTip for volume $15 buys 100,000 events and self-hosting is free; Honeybadger's free tier is larger

How I tested GlitchTip and Honeybadger

My test subject, monitoring-lab, is a deliberately fragile bookstore. An Express API stores data in SQLite and calls a mock price service that fails on cue, a report job runs each minute, and a Vite storefront routes by hash. Each tool plugs into one browser adapter and one server adapter, so both saw the same failures.

What fails:

  • Storefront: clicking the wishlist reads a property of null, order tracking leaves a promise rejection unhandled, and some fetches come back 404, 500 or 502.
  • API: checkout throws on an unrecognised coupon, a book page throws when the ID doesn't exist, out-of-stock items are reported as handled errors, and the price service replies 503.
  • Async: an unawaited recommendations promise rejects, and the report job fails on some runs.

Scripted shoppers alice and bob drive headless Chromium, and carol calls the API without a browser.

The releases

Version What it checks
1.0.0 First data, source maps and the error page
1.1.0 A bug marked fixed comes back unchanged
1.2.0 The checkout book lookup takes seconds, and about a fifth of card charges fail

That last release hides two problems in one request, and only one of them throws.

SDKs and coverage

Platform GlitchTip Honeybadger
API @sentry/node 11.8.0 @honeybadger-io/js 6.17.0, server build
Storefront @sentry/browser 11.8.0 @honeybadger-io/js 6.17.0, browser build
Plan Hosted GlitchTip, Free plan 30-day trial
  • GlitchTip's free cap: the run went past the 1,000-event allowance to 1,097, so the final performance numbers could be missing some data.
  • Environments: the API ran as "development" while the storefront ran as "production", and Honeybadger applies several settings per environment.
  • Not tested: uptime checks, since neither vendor could reach my private host, plus alert delivery and the two AI hand-offs.

Terms in each tool

Idea GlitchTip Honeybadger
Grouped errors Issue Error
One occurrence Event Notice
Fixed for a version Resolve in next release Resolved, reopened by new notices
Release release from the SDK revision, plus reported deploys
Logs Logs Insights

Setup and onboarding

Both put the storefront and the API in one project. Each had one setting you'd miss without being told.

GlitchTip: Sentry's snippet, and one missing line

GlitchTip makes you pick a plan, then wants a team before its project form will save. Its connect page is Sentry's Node.js code with your DSN in place:

GlitchTip connect page with the Sentry SDK snippet

Errors flowed from the first request. Performance didn't, because version 11 of Sentry's SDK streams spans and GlitchTip only reads transactions:

GlitchTip Performance page reporting no transactions

The page doesn't say why it's empty. One line, missing from the connect page, fixed it:

src/monitoring/adapters/glitchtip.js
Sentry.init({
  dsn: process.env.GLITCHTIP_DSN,
  release: '<your_release>',
  tracesSampleRate: 1.0,
});

Honeybadger: One package, one key, one switch

Honeybadger's package carries a browser build and a server build that share a project key. In Express, its request middleware goes ahead of the routes and its error middleware behind them:

src/monitoring/adapters/honeybadger.js
import Honeybadger from '@honeybadger-io/js';

Honeybadger.configure({
  apiKey: process.env.HONEYBADGER_API_KEY,
  environment: process.env.NODE_ENV,
  revision: '<your_release>',
insights: { enabled: true },
});

Honeybadger discards anything from a "development" environment unless reportData is on, and its setup page warns you about it. One side effect: the late recommendations rejection reached Express through Honeybadger's middleware once the response was already sent, which produced a headers-already-sent line in my logs, though the app kept running.

Worth turning on: in GlitchTip with Sentry SDK 11, add traceLifecycle: 'static' or Performance stays empty. In Honeybadger, report a deploy for every environment you run, because resolve on deploy works per environment.

Setup comparison

Step GlitchTip Honeybadger
Browser and API together ✔: one project ✔: one project, one key
SDK Sentry's, with your DSN Its own, one package
Required before a project Choosing a plan, creating a team No extra steps
Hidden setting traceLifecycle: 'static' for performance reportData for development
Side effects None seen A headers-already-sent log line

Verdict: Honeybadger, narrowly. One package and one key covered both tiers, and its catch is announced on the setup page. GlitchTip's catch is silent, though it only touches performance.

Error capture

Both received the same failures from both tiers, and neither missed one.

GlitchTip: Everything, in 24 issues

One traffic run left GlitchTip with 24 issues:

GlitchTip issues list after the first run

All planted failures are in it, with 6 events on the unawaited promise. The list runs longer than my bug count for grouping reasons covered below. No badge separates handled errors from crashes.

Honeybadger: Everything, in eight groups

Honeybadger's list after the same kind of run:

Honeybadger errors list with both tiers

85 notices in eight groups, each row with its environment, a sparkline, an assignee picker and a resolve toggle. The rejection and the report job are both there. All the storefront's failed API calls share one row, which matters later.

Capture comparison

Test GlitchTip Honeybadger
Browser crash ✔: received ✔: received
API crashes ✔: received ✔: received
Handled errors ✔: received ✔: received
Unawaited rejection ✔: own issue ✔: own group
Report job ✔: received ✔: received
Assignee on each row ✘: not offered ✔: picker

Verdict: Tie. Each tool caught everything I planted on both tiers. Honeybadger's list was shorter, for reasons the grouping section explains.

Debugging a server error

The coupon crash, in each tool.

GlitchTip: The code around the throw

GlitchTip printed the failing lines straight from the SDK's event:

GlitchTip server error with source lines around line 150

Lines 145 to 155 are on the page, comment and all, with no repository connected. The breadcrumbs were less useful: of 13 on this error, only two came from the failing checkout, and the rest were startup messages and report-job output.

Honeybadger: The request, the user and the deploy

Honeybadger's server error carries the request in its context and params:

Honeybadger context and request params

Params hold the JSON body with the bad coupon, context names carol with a button to email her, and the summary line names deploy 1.0.0. Its breadcrumbs were mostly scoped to the request. The backend frame gave a file and line and no code.

Server debugging comparison

Capability GlitchTip Honeybadger
Source lines ✔: from the SDK ✘: frame only
Request body ✘: not shown ✔: params
Affected user ✔: on the event ✔: with an email button
Deploy on the error ✘: no ✔: in the summary
Request-scoped breadcrumbs ✘: mixed with other work ✔: mostly scoped

Verdict: Mixed. GlitchTip shows the line that broke, and Honeybadger shows the input that broke it. Pick by which one your team reaches for first.

Source maps

Since my storefront sat on a private host, I uploaded the maps to each tool myself.

GlitchTip: Debug IDs

I ran sentry-cli to stamp debug IDs into the bundles and push the maps, and GlitchTip paired them without any URL configuration. The wishlist crash pointed at ../../src/pages.js line 122 on the first try.

Honeybadger: An API call per revision

Honeybadger takes maps over an HTTP endpoint authenticated by the project key, and the trial allows it:

 
curl https://api.honeybadger.io/v1/source_maps \
  -F api_key="$HONEYBADGER_API_KEY" -F revision=1.0.0 \
  -F minified_url="http://localhost:5173/assets/index.js" \
-F minified_file=@web/dist/assets/index.js

Once uploaded, the wishlist backtrace listed the original files:

Honeybadger browser backtrace after source maps

The top frames point into src/ with code around them, kept per revision.

Capability GlitchTip Honeybadger
Upload method sentry-cli with debug IDs API call with the project key
Matched by Debug ID Revision and minified URL
Scriptable on the free tier or trial ✔: yes ✔: yes

Verdict: Tie. Both mapped the crash from a script. GlitchTip's debug IDs spare you the URL, and Honeybadger keeps maps per release.

Error grouping

1.2.0's new payment error put the charge amount in its message, the hardest test in this comparison.

GlitchTip: One issue per amount

GlitchTip groups by message text, so every amount opened a new issue:

GlitchTip payment gateway error split into one issue per amount

Seven issues, from 35.99 USD to 84 USD, each holding a single event. Report-job failures broke apart by run number too. Older bugs, at least, kept growing in their original issues through the 1.2.0 code change.

Honeybadger: One group by class and frame

Honeybadger groups by the exception's class and its first stack frame, so the amount didn't matter:

Honeybadger payment error as one group

Every charge landed in one group, and sold-out errors stayed together across books. The same rule went wrong in the browser, where my app throws every failed request from one helper:

Honeybadger ApiError group holding four different failures

Four unrelated API failures share one ApiError group, because they share a class and a throw site.

Grouping comparison

Test GlitchTip Honeybadger
Grouping key Message text Class and top frame
New payment error in 1.2.0 ✘: 7 issues ✔: 1 group
Report job runs ✘: one issue per run ✔: one group
Browser failures from one helper ✔: separate issues ✘: merged
Manual fix Merge by hand ✔: Merge

Verdict: Honeybadger. It kept every server bug in one group through all three releases. Give each kind of browser failure its own error class, or that single ApiError row will hide different problems.

GlitchTip split the payment bug by amount, and Honeybadger merged unrelated browser failures. Better Stack, using the same Sentry SDK GlitchTip does, kept the payment bug as one group:

Better Stack single payment error group with source

Ten exceptions with ten amounts share it, with the code around the throw underneath. Other errors kept their own rows.

Get one group per bug

Releases and regressions

Before 1.1.0, I resolved the coupon bug in both tools, then shipped it again.

Honeybadger: Reopened, with the deploy named

Honeybadger's resolve toggle promises an alert if the error returns. Two minutes into 1.1.0, it was open again:

Honeybadger coupon error reopened after deploy 1.1.0

The error page said "after deploy 1.1.0", pointing straight at the release responsible. In the list, though, the row looked like any other open error, and History recorded nothing about it reopening.

Ahead of 1.2.0, I turned on resolve-on-deploy, which clears the whole project at every deploy:

Honeybadger errors list after the 1.2.0 deploy

Deploying the API cleared only its own errors; browser errors stayed open until I reported a "production" deploy too. Everything that recurred then reopened, giving a per-release list of what's still broken.

GlitchTip: Reopened, with a release page of files

GlitchTip has "Resolve in next release", and the bug duly came back:

GlitchTip coupon error back to Unresolved on 1.1.0

The issue reads "Unresolved" and its newest event is tagged 1.1.0, with no label or history entry. Its release page lists the uploaded files and nothing about errors, so finding 1.2.0's new bugs meant sorting by first seen.

Release comparison

Capability GlitchTip Honeybadger
Resolve for a future version ✔: next release ✘: plain resolve
Returning bug reopened ✔: yes ✔: yes
Reopen shown in the list ✘: no ✘: no
Release named on the error Tag on the event ✔: "after deploy" in the summary
Deploys recorded From the SDK release ✔: Deployments list
Clear all errors on deploy ✘: not offered ✔: per environment

Verdict: Honeybadger, narrowly. Both brought the bug back. Honeybadger also told me which deploy did it and gives each release a fresh list, while GlitchTip's release page says nothing about errors.

Both tools reopened the coupon bug without marking its row. Better Stack labelled it when 1.1.0 arrived:

Better Stack list with the coupon bug marked Reoccurred

The coupon row alone turned red with "Reoccurred", taken from the SDK's release value. A failed fix stands out in the list itself.

See which fixes didn't hold

The slow release

1.2.0 made checkout take seconds without throwing. Each tool caught a different half of that.

GlitchTip: Route averages across all releases

Once traceLifecycle was static, GlitchTip listed routes sorted by mean duration:

GlitchTip transaction groups after 1.2.0

Checkout's mean climbed to 752.27 ms, a blend of three releases with no filter to isolate 1.2.0. Route pages show a span breakdown but no single requests to open.

Honeybadger: A breadcrumb gap and a query

Honeybadger measures no request times, but the payment error's breadcrumbs carry relative timestamps:

Honeybadger payment error breadcrumbs with relative times

Roughly 2.4 seconds separate "checkout started" from "book found", and that gap is the slow lookup. Next, a BadgerQL query tallied my app's warnings by revision:

 
filter level::str == "warn" | stats count() as count by message::str, revision::str

Its result tied both problems to one release:

Honeybadger Insights warnings by revision

44 slow-query warnings and 36 payment retries, all on 1.2.0. That only works because my app logs those warnings.

Capability GlitchTip Honeybadger
Request timing ✔: average per route ✘: not offered
Single request detail ✘: no trace view Breadcrumb offsets
Split by release ✘: no filter ✔: BadgerQL on revision
Works without app logging ✔: yes ✘: no

Verdict: Mixed. GlitchTip measured the slowdown without knowing when it started. Honeybadger knew when, but only because my app wrote it down.

GlitchTip averaged three releases together, and Honeybadger relied on warnings my code happened to log. Better Stack traced one failing 1.2.0 checkout directly:

Better Stack spans for the slow 1.2.0 checkout

Inside that 2.19 s request, the book lookup accounts for 1.53 s and the charge the gateway turned down for another 660 ms. Both problems are measured on the request that failed.

Open the slow request itself

Logs and querying

Both tools store logs. Only one lets you query them.

GlitchTip: A list with filters

After the first run, GlitchTip held 233 log lines:

GlitchTip Logs with level and service filters

Rows show time, level and message, and you can search text or filter by level and service. Lines open nothing further, and no error links to its logs.

Honeybadger: Insights and BadgerQL

Honeybadger's Insights view collects logs, notices, console output and custom events into a single stream:

Honeybadger Insights event stream

Any of it can be filtered and aggregated with BadgerQL; summing my metric events gave me revenue and order totals for checkout. Turning on console capture while my adapter also shipped log events doubled every line, so pick one path.

Capability GlitchTip Honeybadger
Log storage ✔: from the Sentry SDK ✔: Insights
Query language ✘: search and filters only ✔: BadgerQL
Custom metrics ✘: not offered ✔: events with stats
Logs linked to errors ✘: no ✔: notices in the same stream

Verdict: Honeybadger. BadgerQL turned logs into answers, as the slow release showed. GlitchTip's list is somewhere to look, not something to ask.

GlitchTip's logs stand apart from errors, and Honeybadger's need a query to reach a request. Better Stack narrowed the logs to one failing 1.2.0 checkout by trace ID:

Better Stack Live tail filtered to one failing checkout

Only that request's lines remain, the slow-query warning right beside the failure. Those logs stay searchable afterwards.

Read the logs behind an error

Uptime and alerts

Both tools bundle uptime monitoring into the price, which few error trackers do. I didn't test either: the checks run from the vendor's side and couldn't reach my app, and I connected no alert channel.

  • GlitchTip: each uptime check spends events from the pool your errors and logs share.
  • Honeybadger: every plan, the free one included, has uptime monitors, cron check-ins and status pages, and resolving an error promises an alert if it returns.
Capability GlitchTip Honeybadger
Uptime checks Included, not tested ✔: every plan, not tested
Cron check-ins ✘: not found ✔: every plan
Status pages ✘: not found ✔: every plan
Alert on a returning bug Not tested Promised on resolve, not tested

Verdict: Not compared. Nothing was delivered. On paper, Honeybadger adds cron check-ins and status pages that GlitchTip doesn't list.

AI-assisted debugging

Neither tool runs an assistant in the product, and I didn't test their hand-offs.

  • GlitchTip: next to the raw JSON link, "copy for AI" puts the whole event on your clipboard.
  • Honeybadger: Copy for LLM puts an error's details on your clipboard.
Capability GlitchTip Honeybadger
Assistant in the product ✘: not offered ✘: not offered
Copy to your own assistant "copy for AI" Copy for LLM
Cost Free Free

Verdict: Not compared. Both leave AI to whatever assistant your team already uses.

GlitchTip and Honeybadger both stop at the clipboard. Better Stack's AI SRE worked through release 1.2.0 inside the product, with no repository connected:

Better Stack AI SRE answer on release 1.2.0

It traced the slowdown to checkout's book query and reported that 10 of the 48 charges had failed, all on 1.2.0. The whole investigation cost $0.49 and ran for about four minutes.

Let AI SRE investigate a release

Pricing

GlitchTip bills one shared pool that errors, transactions, logs and uptime checks all spend. Honeybadger charges a flat fee per tier of error volume, Insights and uptime bundled in.

Prices below come from GlitchTip's page as of November 4, 2026, and Honeybadger's as of November 13, so check them again before you buy.

Free plans and trials

Starting out GlitchTip Honeybadger
Free plan ✔: 1,000 events a month ✔: 5,000 errors a month
Free retention 30 days 15 days
Free users Not limited on the page 1
Free extras Logs and uptime, sharing the pool One uptime monitor and 50 MB of Insights per day
Trial Not needed 30 days, no card
Self-hosting ✔: open source ✘: hosted only

GlitchTip's free pool empties fast once performance data counts against it:

GlitchTip usage at 110% of the free limit

By the end it read 110% under a warning banner, yet GlitchTip went on accepting events.

Entry-level paid plans

Paid tier GlitchTip Small Honeybadger Team Honeybadger Business
Monthly $15 $26 $80
Yearly Not listed $286 a year $880 a year
Volume 100,000 events 50,000 errors 50,000 errors
Retention 90 days 90 days 180 days
Users Not limited on the page Unlimited Unlimited
Uptime From the event pool 5 monitors every 2 minutes 5 monitors every minute

Higher GlitchTip tiers cost $50 for 500,000 events and $250 for 3 million each month, and a spend cap governs on-demand overage starting at $0.17 per thousand.

Comparing the actual cost

For a team with few errors, Honeybadger's free plan is the better start, at five times GlitchTip's volume, though for one user and 15 days. Once you pay, GlitchTip's $15 buys twice Honeybadger Team's volume for $11 less, and its pool also covers logs and route timing.

The units aren't the same. GlitchTip counts transactions and logs against the pool, so an app with tracing on uses it up faster than its error count suggests. Honeybadger counts only errors. For a rival with an even lower entry price, see our GlitchTip vs Rollbar comparison.

Verdict: GlitchTip for volume. It costs less per event and nothing if you host it. Honeybadger's free plan and flat bundle suit a small team that wants uptime and status pages in one bill.

Full feature comparison

Feature GlitchTip Honeybadger
SDKs Sentry's Its own
Browser and server together ✔: one project ✔: one project, one key
Unawaited rejection ✔: caught ✔: caught
Server source lines ✔: from the SDK ✘: frame only
Server request body ✘: not shown ✔: params
Source maps ✔: debug IDs ✔: API per revision
Grouping Message text Class and top frame
New payment error in 1.2.0 ✘: 7 issues ✔: 1 group
Returning bug reopened ✔: yes ✔: yes
Deploy named on the error ✘: no ✔: yes
Resolve all at a deploy ✘: not offered ✔: per environment
Request timing Per-route means, unfiltered by release ✘: not offered
Logs Plain list with search ✔: Insights with BadgerQL
Uptime checks Included ✔: every plan
Cron check-ins and status pages ✘: not found ✔: every plan
AI "copy for AI" Copy for LLM
Free plan 1,000 events 5,000 errors
Run it yourself ✔: open source ✘: SaaS only

Which should you choose?

Neither tool is bloated or pushy about upsells. The question is whether you'd rather own the tool or own a tidy error list.

Choose GlitchTip if you want Sentry compatibility and control

  • You want the failing line on the error page. It printed server code from the SDK payload alone, no repo linked.
  • Your volume is growing. 100,000 events for $15, with logs and route timing in the same pool.
  • You'd like to self-host or switch later. It's open source, and moving is a DSN change.

The cost: a new issue for every value in a message, mixed server breadcrumbs, a release page that lists files, and an empty Performance page on Sentry SDK 11 until you add traceLifecycle. To see it next to the platform it borrows SDKs from, read our Sentry vs GlitchTip comparison.

Choose Honeybadger if you want a clean list and a bundle

  • You want one row per server bug. Its class-and-frame grouping held through all three releases.
  • You review deploys. A returning error names its deploy, and resolve-on-deploy wipes the slate per release.
  • You want logs, uptime, cron and status pages on one bill. Insights and the monitoring extras are in every plan.

The cost: no request timing, no server code on frames, and one browser group that can swallow different API failures unless you give them their own classes. If real user monitoring matters too, our Raygun vs Honeybadger comparison covers that matchup.

FAQ

Can GlitchTip use the latest Sentry SDK?

Yes, for errors and logs. For performance, add traceLifecycle: 'static', because SDK 11 streams spans and GlitchTip reads only transactions.

Does Honeybadger group errors by message?

No. It groups by exception class and first stack frame, so values in a message don't split an error. Different failures thrown from one helper can share a group, though.

Do both include uptime monitoring?

Yes. GlitchTip's checks spend events from the shared pool, while every Honeybadger plan ships with uptime monitors, cron check-ins and status pages. Neither was tested here.

Which is cheaper?

Honeybadger to start, with 5,000 free errors a month. GlitchTip once you pay: $15 for 100,000 events against $26 for Honeybadger Team's 50,000 errors, or nothing if you self-host.

Final thoughts

These two caught exactly the same failures, so the choice comes down to what each does with them. GlitchTip shows you more of the code and charges you less, and its message-based grouping turned one bug into seven on the release that mattered. Honeybadger shows you more of the request and the deploy, and kept that bug in one row.

If you can live with merging issues by hand, GlitchTip's price and open source are hard to beat. If you'd rather trust the list without tending it, Honeybadger earns its higher bill. On a bad release, the cheaper tool is the one that doesn't make you count the same bug seven times.