AppSignal vs Raygun: A Hands-On Error Tracking Comparison for 2026

Stanley Ulili
Updated on November 16, 2026

The second release of my test app quietly reintroduced a bug I'd closed, and its 1.2.0 release made checkout more than 2,000 times slower. Raygun handled the first one best: its deployment page listed the returning bug under Regressions with no extra work. AppSignal handled the second: a table on the checkout route showed the mean jump from 2 ms to 4.59 s on the deploy that caused it.

Each tool's best release view answered a different question, and that shapes this whole comparison. AppSignal is an APM platform for small teams, with errors, traces, slow queries, logs, host metrics, uptime and cron monitoring in one app, priced by request volume with no overage charges. Its Node.js package includes the agent and runs on OpenTelemetry.

Raygun sells three products separately: Crash Reporting, Real User Monitoring and APM. Its crash reporter has the stronger release workflow of the two, and its RUM measures page speed and Core Web Vitals for every visit.

Both tools watched my storefront and my API through all three releases, so the sections below compare them directly. One exception: Raygun's APM ran on 1.0.0 only, because installing it broke Raygun's own crash reporting, which I'll cover under performance.

You'll find them weighed on setup, capture, source maps, debugging, real user monitoring, grouping, releases, performance, logs and metrics, infrastructure, alerts, AI and pricing.

AppSignal vs Raygun: Results at a glance

I followed each vendor's own instructions on a single Express API with a Vite front end, using trial accounts for both. A CommonJS app or a paid Raygun plan would make setup smoother for each.

Area Better in my test Why
Setup AppSignal One app for both tiers; Raygun needs an application per tier and a queued browser loader
Error capture AppSignal, narrowly Both missed the unhandled rejection; AppSignal kept both tiers in one list
Source maps AppSignal API upload with the push key; Raygun's API needs a paid token
Debugging an error AppSignal Detailed browser breadcrumbs and Time Detective; neither showed server code
Real user monitoring Raygun Page loads, Core Web Vitals and sessions; AppSignal keeps vitals as raw metrics
Error grouping AppSignal One group per bug through 1.2.0; Raygun split by amounts and URLs
Releases and regressions Raygun Version-aware fixes, with a deployment page listing what came back
Performance AppSignal Per-deploy means and spans found the slow query; Raygun's APM broke its errors
Logs and metrics AppSignal Logs, custom metrics and dashboards; Raygun has neither
Hosts, uptime and cron AppSignal only Host metrics and heartbeats tested; Raygun offers none
Alerts Not compared No notifier was connected in either
AI-assisted debugging Not compared Both offer an MCP server; neither was tested
Price AppSignal A free plan and $279 a year for both tiers; Raygun starts at $40 a month for errors alone

How I tested AppSignal and Raygun

The app is monitoring-lab, a bookstore with deliberate faults. Shoppers use a Vite front end, orders go through an Express service writing to SQLite, a dummy pricing endpoint fails on cue, and a reporting job runs every sixty seconds. Each tool connects through one browser adapter and one server adapter, and nothing else in the app changes.

The planted failures:

  • Storefront: the wishlist click crashes, order tracking leaves a rejection unhandled, and some API requests come back 404, 500 or 502.
  • API: checkout dies on a bogus coupon, a book page dies on a missing book, sold-out stock raises a handled error, prices return 503, and the recommendations promise rejects with nothing to catch it.
  • Job: occasional failed report runs.

alice and bob shop in headless Chromium, and carol calls the API directly.

The releases

Version Purpose
1.0.0 Install, errors from both tiers, maps, first traces
1.1.0 The coupon crash marked fixed, then deployed again unchanged
1.2.0 A slow lookup at checkout plus a payment bug on one charge in five

1.2.0 tests whether a tool can show you a slowdown and a new error from the same deploy.

SDKs and test limitations

Platform AppSignal Raygun
Browser @appsignal/browser 1.0.0-beta.9 raygun4js 3.1.4 with RUM
Node.js server @appsignal/nodejs 3.9.4 raygun 2.2.10
Tracing Built in, on OpenTelemetry Separate agent with raygun-apm 2.3.0, first release only
Plan Trial 14-day trial
  • Separate runs: Raygun ran on October 23 and AppSignal on October 27, with the same traffic script. Counts don't line up between them.
  • AppSignal's browser SDK is a beta, listed under Labs.
  • Host and cron monitoring were tested for AppSignal on a Linux server afterwards. Raygun has no equivalent.
  • Not tested: uptime checks, alert delivery and either tool's MCP server.

Terms in each tool

Idea AppSignal Raygun
Grouped errors Error incident Error group
One occurrence Sample Instance
Fixed Closed Resolved, optionally in a version
Release Revision, which creates a deploy setVersion, plus deployments
Browser and server One app, two namespaces Two applications
Request timing Traces and actions APM traces, RUM XHR timings

Setup and onboarding

You install each from npm, once per tier. AppSignal's wizard didn't fit my ESM app, and Raygun's structure added steps throughout.

AppSignal: A wizard for CommonJS

AppSignal's onboarding picks a language, then a framework, then walks you through an appsignal.cjs file:

AppSignal onboarding with the appsignal.cjs file

The wizard starts the app with node --require, which only works for CommonJS. My app uses ES modules, so the adapter had to register OpenTelemetry's import hook itself before Express would be traced. My first attempt failed with "Uh-oh! No data received", which was a placeholder key in my own .env, and the page pointed me at the log file and a diagnose command. With the right key, data arrived within a minute.

Setting revision in the config created a deploy automatically, with no separate deploy call. The browser SDK reported both tiers into the same app under separate namespaces.

Raygun: An application per tier

Raygun's model is an application for each piece of your system, with products added one by one:

Raygun create application form with notification defaults

My storefront and API became two applications with separate keys and separate error lists. I couldn't leave onboarding until an event arrived, so I fired a bad-coupon request at the API. In the browser, raygun4js from npm reads its settings at the page's load event, so imported later from a module it never started. I copied the CDN snippet's queue and imported the library after load.

Worth turning on: in AppSignal on an ESM app, confirm Express spans appear in your first trace, since the wizard's --require path won't trace them. In Raygun, keep the version string identical across your applications, since each one tracks its own deployments and regressions.

Setup comparison

Capability AppSignal Raygun
Both tiers in one app ✔: namespaces ✘: an application each
ESM support in the wizard ✘: --require only Not an issue
Browser SDK from npm ✔: worked Needed a queued loader
Deploys from the version ✔: automatic ✘: created separately
First-data diagnostics ✔: log and CLI pointers Waits on step three

Verdict: AppSignal. One app with automatic deploys covered both tiers once the ESM hook was in. Raygun's two-application model adds work at setup and every step after it.

Error capture

Both tools received both tiers, and both missed the same failure.

AppSignal: One list, grouped by class and route

AppSignal's errors list held both namespaces, with "In selection" and "Total" counts on each row:

AppSignal errors list after the first run

Browser ApiErrors split by route template, so /orders and /books/:id failures get separate rows. The browser SDK also reports failed fetches as HTTPError, next to the app's own ApiError, so one failed call can count twice. The recommendations rejection never arrived. It only showed up in AppSignal's logs, because my app logs it.

Raygun: Two lists, one split by URL

The API's application had five error groups, and the storefront's had eight, in a separate list:

Raygun browser error groups split by URL

One failed book load became four groups, one per book ID in the message. The recommendations rejection was missing here too.

Error capture comparison

Capability AppSignal Raygun
Browser crashes ✔: captured ✔: captured
API crashes ✔: captured ✔: captured
Unhandled rejection with an app listener ✘: missed ✘: missed
Report job ✔: captured ✔: captured
Both tiers in one list ✔: by namespace ✘: two applications
Failed fetches Reported twice Once, split by URL

Verdict: AppSignal, narrowly. Both missed the same rejection. AppSignal's single list grouped browser failures by route, which is easier to read than four rows for one bug.

Source maps

My storefront ran on localhost, so both tools needed uploads.

AppSignal: An API call per file

AppSignal accepts maps through its API with the push key and the revision:

 
curl -X POST \
  -F "name[]=http://localhost:5173/assets/index.js" \
-F "file=@web/dist/assets/index.js.map" \
"https://appsignal.com/api/sourcemaps?push_api_key=$APPSIGNAL_PUSH_API_KEY&app_name=monitoring-lab&environment=development"

The wishlist crash then showed src/pages.js at line 122, with the code around it:

AppSignal browser error with source code

An "Application backtrace" toggle hides library frames.

Raygun: Hand-labeled uploads on the trial

To script uploads, Raygun asks for a Personal Access Token, and trial accounts can't make one. On the trial, you upload files in the JS Source Map Center and type a full URL for each one:

Raygun Source Map Center with unlabeled files

Bundle names change with each build, so the labeling repeats every release, and two labels swapped during my test. After fixing the labels, the Re-process this error for Source Maps button corrected errors that had already arrived.

Source map comparison

Capability AppSignal Raygun
Scripted upload ✔: push key ✘: paid token
Tied to a release ✔: revision By file URL
Fixes earlier errors Not tested ✔: Re-process button
Server source lines ✘: file:// frames not parsed ✘: not shown

Verdict: AppSignal. A scripted upload with a key you already have fits into any build. On a paid Raygun plan, the token would close most of this gap.

Debugging an error

Neither tool showed server code. The rest of each error page differs.

AppSignal: Detailed browser crumbs, thin server frames

AppSignal's browser SDK records breadcrumbs automatically: network calls with status and duration, clicks with the button's label and coordinates, hash navigation, and the error itself:

AppSignal browser breadcrumbs with click and error

button "Add to wishlist" comes right before the crash. On the server, the coupon error carries the request body and the shopper as tags, but its backtrace has a parse warning on the app frame:

AppSignal backend backtrace with a parse warning

AppSignal couldn't read the ESM file:// frame, so it showed no code. The Node SDK has no breadcrumbs API, so my server breadcrumbs went in as custom data and display as JSON. Time Detective makes up for some of it: from any error, it opens a one-minute snapshot of errors, performance, alerts, hosts and logs around that moment.

Raygun: Request data and scoped breadcrumbs

Raygun's server error shows file and line with no code:

Raygun server stack trace without code

Its HTTP tab holds the request body, and its breadcrumbs belong to the request: POST /checkout, "checkout started", "book found". In the browser it logs clicks, route changes and XHR calls without any setup, and a Customers view gathers one person's sessions and errors.

Debugging comparison

Capability AppSignal Raygun
Server source lines ✘: parse warning ✘: not shown
Request body ✔: payload ✔: HTTP tab
Server breadcrumbs Custom data as JSON ✔: native, per request
Browser breadcrumbs ✔: clicks with labels, fetch timing ✔: clicks, XHR
Snapshot around the error ✔: Time Detective ✘: not offered
User history Tags ✔: Customers page
Browser error to server error ✘: not joined ✘: separate applications

Verdict: AppSignal. Its browser crumbs and Time Detective gave more context per error. Raygun's native server breadcrumbs and Customers page are better than AppSignal's equivalents, so this one is close.

AppSignal never joined a browser error to its backend trace, and Raygun keeps the two tiers in separate applications. Better Stack put one storefront request on both sides into a single trace in my test:

Better Stack timeline with browser and server spans

The browser contributed 30 spans and the API 7, all under one trace ID. From a failed checkout you can step straight into the server exception.

Debug errors across browser and API

Real user monitoring

Raygun sells RUM as a product. AppSignal's browser SDK collects Web Vitals and leaves the presentation to you.

Raygun: Pages, vitals and sessions

Raygun RUM's performance tab charts load time, FCP, LCP, CLS, INP and more across every visit:

Raygun RUM performance overview

Virtual pages and XHR calls get their own tables with counts and timings, and each session is a timeline of pages with load times and errors. Routes like /books/3 collapse into /books/*, so one slow book page hides in the average.

AppSignal: Vitals as metrics

AppSignal's browser SDK sends CLS, FCP, INP, LCP and TTFB as metrics:

AppSignal web vital metrics in the picker

There's no Web Vitals page. You build a dashboard chart for each, and the page_url and app_version tags let you split them per page and release.

RUM comparison

Capability AppSignal Raygun
Core Web Vitals collected ✔: as metrics ✔: charted
Built-in vitals page ✘: build your own ✔: performance tab
Page and XHR tables ✘: not offered ✔: with counts and timing
Session timelines ✘: not offered ✔: per user
Split by release ✔: app_version tag ✔: Compare, page loads only

Verdict: Raygun. It turns browser timings into pages you can read on day one. AppSignal collects the same numbers and asks you to chart them.

Error grouping

1.2.0 changed the async path through checkout, which tests whether a tool keeps old bugs in their rows and gives a new bug just one.

AppSignal: Class plus action

AppSignal groups by error class and the action, which is the route. The new payment error arrived as one incident, and old bugs stayed in their rows:

AppSignal errors list on 1.2.0

The payment error's "In selection" equals its "Total", the only sign it's new. It has no badge and sits fourth, sorted by last seen. One fix was mine: handled errors sent outside a request lost their route, until my adapter used setError inside requests.

Raygun: Message text in the group

Raygun's Node grouping included the message. The payment error split by charge amount:

Raygun 1.2.0 errors list with payment errors split

Charges of 44 USD and 35.5 USD failed identically yet got their own rows. The release also duplicated the coupon crash and the out-of-stock error into fresh groups beside the originals.

Grouping comparison

Behavior AppSignal Raygun
Groups by Class and route Message and stack
New payment bug ✔: one incident ✘: one group per amount
Old bugs in 1.2.0 ✔: same rows ✘: new duplicate groups
Browser API failures By route By URL
New-error signal In selection equals Total Deployment's New errors tab

Verdict: AppSignal. It kept one row per bug through the release that changed timing. Raygun's list after 1.2.0 needed cleanup before it told the truth.

Releases and regressions

Before 1.1.0, I closed the coupon crash in AppSignal and resolved it in Raygun. Then it shipped again.

AppSignal: Reopened by notification rules

An incident in AppSignal can be Open, Work in progress or Closed, and a notification firing will reopen a closed one. With alerting on the coupon error left at "First in deploy", the new revision woke it up:

AppSignal coupon error reopened on 1.1.0

It's Open again with a 1.1.0 sample, while the page still says it first occurred in 1.0.0. The Logbook recorded my close and nothing about the reopen. The errors list's default "Most recent revisions" filter shows only errors seen in the latest release, with per-release counts, which works as a rough regression view. The Deploys page lists errors and errors per hour per revision, without a detail page.

Raygun: Resolved in the next version

Raygun offers Resolve in next version, which keeps the error resolved for 1.0.0 and reactivates it in anything newer:

Raygun Resolve in next version dialog

A checkbox, on by default, discards further events until a newer version arrives. Deployments on the trial are entered by hand. Filling every field gave me a server error, and a second attempt with just the version saved. Once traffic arrived, the deployment flagged the bug:

Raygun 1.1.0 deployment with one regression

Its Regressions tab contains exactly one entry, the coupon crash, which logs "Error reoccurred" in its activity. In the main list, it's just another Active row.

Release comparison

Capability AppSignal Raygun
Fix tied to a version ✘: not offered ✔: next version or a named one
Returning bug reopened ✔: by notification rule ✔: in a newer version
Reopen recorded ✘: not in the Logbook ✔: "Error reoccurred"
Regressions per release Recent-revisions filter ✔: Regressions tab
Deploys ✔: automatic from the revision Manual or API
Label in the list ✘: none ✘: none

Verdict: Raygun. Version-aware resolving and a Regressions tab answer "did my fix hold" without searching. AppSignal reopened the bug but left no record of why.

AppSignal reopened the coupon bug with no record of it, and Raygun named it on a deployment page while the list row stayed plain. Better Stack's list labeled the returning bug when I shipped 1.1.0:

Better Stack errors list with Reoccurred label

Only the coupon row turned red with "Reoccurred". You catch it in the list you already triage from.

See regressions the moment they return

Performance monitoring

This is where the two diverged most. AppSignal's tracing comes in the same package as its errors, and Raygun's needs a separate agent.

AppSignal: The deploy that slowed checkout

The checkout action's summary has a table called Performance in the last deploys:

AppSignal performance per deploy for checkout

Average checkout time held at 2 ms for two releases, then hit 4.59 s with the third. A successful checkout trace from that release explained it:

AppSignal slow checkout trace on 1.2.0

SELECT book for checkout took 3.06 s and the payment span 3.3 s. The Slow queries page re-ranked itself too, putting that SELECT at 67.6% of query impact. Outgoing HTTP calls were instrumented automatically, so the slow price service showed up under slow API requests with no code.

Two gaps: a checkout that failed with the new payment error kept only its root span, so the error's own trace couldn't explain its three seconds. And an anomaly trigger I set for the web namespace's mean above 1 s didn't fire, because fast requests kept the namespace mean below it. Triggers can't target one action.

Raygun: RUM called it faster, and APM broke errors

Crash Reporting has no timing. RUM's release comparison for 1.1.0 against 1.2.0 said this:

Raygun RUM comparison calling 1.2.0 faster

It rated 1.2.0 "34.8% faster" by median load time. The comparison only covers whole page loads, and those were unaffected. The slow checkout call isn't part of that comparison.

Raygun APM, tested on 1.0.0, runs as a separate agent beside the raygun-apm package. Its traces showed Node internals and idle time with no app functions, and SQLite isn't supported. Worse, the package swaps out global.Error on install, and from then on the crash reporter delivered built-in JavaScript errors with an empty message and stack, titled "Unknown error":

Raygun errors arriving as Unknown error after APM was installed

Both TypeError crashes collapsed into that single row until I uninstalled it. Setting RAYGUN_APM_CRASH_REPORTING_INTEGRATION=false is the documented way around it.

Performance comparison

Capability AppSignal Raygun
Server spans ✔: in the same package ✔: separate agent
App code and queries in traces ✔: Express, SQLite, fetch ✘: Node internals only
Latency by deploy ✔: per action RUM page loads only
Slow query ranking ✔: by impact ✘: SQLite unsupported
Spans on errored traces ✘: root span only Not tested
Side effects None found Broke crash reporting

Verdict: AppSignal. It found the slow query and the deploy behind it from one table. Raygun's release comparison crowned the bad release, and its APM damaged its own error reports.

AppSignal's failing checkout kept only its root span, and Raygun's APM couldn't see SQLite at all. In Better Stack, the 1.2.0 payment error came with its child spans:

Better Stack spans on the failing 1.2.0 checkout

Within 2.19 s, the book lookup ran 1.53 s and the rejected charge 660 ms. The failed request explains its own time, with no need to find a successful one to compare.

Keep spans on every failed request

Logs and metrics

AppSignal includes both. Raygun includes neither.

AppSignal: Logging, metrics and Time Detective

Appsignal.logger() sent my app's logs with severity, host and attributes, plus live tailing:

AppSignal logs viewer

From any line you can jump to its surrounding context, open Time Detective, or turn it into a metric. Custom metrics such as checkout revenue appear only after you build a dashboard chart, which took about ten clicks each, and tag combinations are enforced in the picker.

Raygun: Only what's on the error

Beyond the breadcrumbs and custom fields attached to errors, Raygun stores no logs and has no metrics.

Logs and metrics comparison

Capability AppSignal Raygun
Log storage and search ✔: with live tail ✘: not offered
Logs linked to errors ✔: show in context ✘: not offered
Custom metrics ✔: dashboards ✘: not offered
Snapshot across signals ✔: Time Detective ✘: not offered

Verdict: AppSignal. It stores logs and metrics beside the errors. With Raygun, both need another product.

Hosts, uptime and cron jobs

This section is AppSignal alone, because Raygun has no host, uptime or cron monitoring.

Host metrics on a real server

After I moved the app to an Ubuntu box, CPU, memory and disk figures showed up without any setting, because the agent gathers them on Linux:

AppSignal host metrics list

Load average, memory and disk sit in the list, and the host page charts CPU, memory, swap, disk I/O and network with deploy markers. A host usage view compares request performance per host.

Heartbeat monitoring

appsignal-run wraps a process and sends heartbeats. Once I created a heartbeat monitor with a matching name, it showed the app running:

AppSignal heartbeat monitor running

When I stopped the app, the monitor turned red with "Missed" about two minutes later. The monitor has to exist before the wrapper's heartbeats count, and the CLI doesn't warn you. Uptime checks are included too, though they can't reach localhost, so I didn't test them.

Capability AppSignal Raygun
Host metrics ✔: automatic on Linux ✘: not offered
Cron and heartbeat monitors ✔: tested ✘: not offered
Uptime checks Included, not tested ✘: not offered

Verdict: AppSignal only. If you'd otherwise buy a separate tool for servers and scheduled jobs, AppSignal covers them.

Alerts

Neither tool had a notifier connected, so nothing was delivered.

AppSignal's anomaly detection offers triggers for error rate, error count, throughput, slow actions, host metrics and custom metrics, per namespace. My slow-actions trigger didn't fire on 1.2.0, as described above. Errors carry an alerting setting per incident, such as "First in deploy".

Each new Raygun application emails you about new errors from the start, plus daily and weekly digests.

Capability AppSignal Raygun
On by default Per-error alerting setting ✔: new error email
Performance triggers ✔: per namespace Not tested
Host and metric triggers ✔: offered ✘: not offered
Fired on 1.2.0 in my test ✘: no Not configured

Verdict: Not compared. On paper, AppSignal has more triggers. Mine missed the regression, because triggers average a whole namespace.

AI-assisted debugging

AppSignal lists an MCP server and a CLI under its Intelligence features. Raygun has a remote MCP server for assistants like Claude Code and Cursor. Neither has an assistant inside the app, and I tested neither server.

Capability AppSignal Raygun
Assistant in the product ✘: none seen ✘: none
MCP server ✔: listed, not tested ✔: remote, not tested

Verdict: Not compared. Both leave AI to the assistant you bring.

AppSignal and Raygun both stop at an MCP server for your own assistant. Better Stack's AI SRE runs the investigation itself, and it answered the 1.2.0 question in my test:

Better Stack AI SRE on release 1.2.0

It attributed the slowdown to checkout's query and counted ten failures among 48 charges on 1.2.0, in roughly four minutes for $0.49, and the same agent is reachable over MCP from your editor.

Investigate releases with AI SRE

Pricing

AppSignal charges by monthly requests, with every feature on every plan and no overage charges. Raygun prices Crash Reporting, RUM and APM separately, each by volume.

Prices below come from both vendors' pages on November 16, 2026, and may have moved since.

Free plans and trials

At signup AppSignal Raygun
Free plan ✔: 30,000 requests a month ✘: none
Free logs 1 GB Not applicable
Free retention 5 days Not applicable
Users Unlimited Unlimited on paid plans
Trial 30 days on paid plans, no card 14 days on every plan

Entry-level paid plans

Cheapest tiers AppSignal Raygun Crash Reporting Raygun RUM Raygun APM
Billed yearly $279 a year $40 a month $80 a month $80 a month
Billed monthly Not listed $60 $120 $120
Volume 250,000 requests 100,000 errors 100,000 sessions 100,000 traces
Past the quota Free; plan reviewed after 30 days A tenth of a cent per error Two tenths of a cent per session Two tenths of a cent per trace
Includes Errors, traces, logs, hosts, uptime Errors Page speed and sessions Server traces

AppSignal's add-ons include long-term log storage and HIPAA compliance at $89 a month each.

Comparing the actual cost

AppSignal's entry plan, about $23 a month billed yearly, covers errors, tracing, logs, host metrics and uptime for 250,000 requests. Raygun's error tracking alone costs $40 a month yearly, and matching AppSignal's coverage with RUM and APM brings it to $200.

The meters differ too. AppSignal counts requests, not errors, and never bills overages, so a noisy release costs nothing extra. Raygun counts errors, and its discard option on resolved errors exists partly to save quota. For Raygun against another bundled plan, see our Raygun vs Honeybadger comparison.

Verdict: AppSignal. It covers more for less. Raygun's RUM is worth its price only if page speed is something you report on.

Full feature comparison

Feature AppSignal Raygun
Both tiers in one app ✔: namespaces ✘: two applications
Unhandled rejection with an app listener ✘: missed ✘: missed
Source map upload on a trial ✔: push key ✘: manual only
Browser breadcrumbs ✔: detailed ✔: automatic
Server breadcrumbs Custom data ✔: native
Server source lines ✘: ESM frames not parsed ✘: not shown
Grouping through 1.2.0 ✔: one row per bug ✘: split by amount, duplicates
Resolve in next version ✘: not offered ✔: with discard
Regressions per release Recent-revisions filter ✔: Regressions tab
Automatic deploys ✔: from the revision ✘: created separately
Server tracing ✔: built in APM agent, broke crash reporting
Latency per deploy ✔: per action ✘: page loads only
Slow queries ✔: ranked ✘: not offered
Real user monitoring Vitals as metrics ✔: full product
Logs and metrics ✔: included ✘: not offered
Host, uptime and cron ✔: included ✘: not offered
AI MCP server MCP server
Free plan ✔: 30,000 requests ✘: trial only

Which should you choose?

AppSignal is the broader platform at a lower price. Raygun is stronger on two specific jobs: release reviews and front-end performance.

Choose AppSignal if you want one tool for the whole backend

  • You care why a release got slower. Per-deploy means and slow-query rankings pointed at the query in two clicks.
  • You'd rather not run more tools. Logs, metrics, host monitoring, heartbeats and uptime are in the same plan.
  • You want predictable bills. No overages, and a free plan for small apps.

The trade-offs: an ESM setup the wizard doesn't cover, no server code on ESM frames, a beta browser SDK, triggers that average a whole namespace, and errored traces without their child spans. Our Sentry vs AppSignal comparison sets it against a tool with deeper error features, and our AppSignal vs Honeybadger comparison against a cheaper error tracker.

Choose Raygun if releases and page speed are what you report on

  • You review every deploy. Resolve in next version and a Regressions tab show which fixes held.
  • Front-end speed is a product metric. RUM tracks load times and Core Web Vitals for every visit.
  • You want error tracking you can buy on its own. Crash Reporting stands alone without the other two products.

The trade-offs: separate applications per tier, grouping that splits on message values, manual source maps on the trial, an APM agent that can break crash reporting, and no logs or host monitoring. Our Sentry vs Raygun comparison puts Raygun beside a platform with fuller tracing.

FAQ

Does AppSignal support ES modules on Node.js?

Yes, but the onboarding wizard only shows the CommonJS --require path. For an ESM app, register OpenTelemetry's import hook before your server loads, then check that Express spans appear in your first trace.

Can I use Raygun APM and Crash Reporting in the same Node.js app?

Only after changing one environment variable. Installing raygun-apm made built-in errors arrive empty in my test, and RAYGUN_APM_CRASH_REPORTING_INTEGRATION=false disables the integration responsible.

Does AppSignal have real user monitoring?

Its browser SDK collects Core Web Vitals as metrics you can chart on a dashboard, split by page and release. It has no RUM pages or session timelines like Raygun's.

Which is cheaper?

AppSignal. A free tier covers 30,000 requests monthly, and $279 a year buys a paid plan with tracing, logs and hosts. Raygun skips the free tier, and Crash Reporting alone costs $40 monthly on annual billing.

Final thoughts

AppSignal won more sections here, and it did so by covering the server deeply: traces that found the slow query, logs, metrics, hosts and cron jobs, all from one package. Raygun's two wins were the ones its products are built around, a release workflow that names regressions and RUM that measures every page.

The decision is whether your hardest questions are about releases or about the backend. If your team reviews every deploy and reports on page speed, Raygun answers those questions better. If you need to know why the API got slow and what the server was doing at the time, AppSignal answers them for less money.

And if you do pick Raygun's APM for Node.js, turn off its crash reporting bridge before you install it.