Error monitoring

Errors, traces and releases, from the Sentry SDK you already use.

Point your Sentry SDK at Guidely for issues, tracing, release health, cron and uptime monitors, user feedback and alerts, next to the replays and analytics of the same users and your own Grafana, Prometheus, Tempo and Loki.

Works with Sentry SDKs

Keep your Sentry SDK. Change one line.

Swap the DSN for one from Settings → Sentry SDKs, and errors, traces, release health, cron check-ins and user feedback arrive in Guidely.

  • Every Sentry SDK

    Browser, mobile and server SDKs send to the same envelope endpoint, and older SDKs to /store/. Nothing else in your code changes.

  • sentry-cli works too

    Upload source maps and debug files and create releases from CI with sentry-cli, pointed at Guidely with four environment variables.

  • Filters and scrubbing

    Inbound filters drop the events you don't want before they count, and data scrubbing removes sensitive fields on the server.

  • Keys you control

    Several DSNs per project, allowed browser origins, a rate limit per key, and revoking a key stops it at once.

  • Limits SDKs understand

    When a product's allowance or billing limit is used up, Guidely answers with the rate-limit headers Sentry SDKs already respect.

  • Or use Guidely's SDKs

    Guidely's own web and mobile SDKs report errors and crashes too, with ProGuard and dSYM symbolication for mobile apps.

import * as Sentry from "@sentry/browser";

Sentry.init({
  // The one line that changes: a DSN from Guidely.
  dsn: "https://<key>@<your Guidely host>/<id>",
  // The rest of your options stay as they are.
});
# sentry-cli: source maps, debug files and releases
SENTRY_URL=https://<your Guidely host>/
SENTRY_ORG=<workspace slug>
SENTRY_PROJECT=<project slug>
SENTRY_AUTH_TOKEN=gly_sk_…

Errors & issues

Every error grouped, with what caused it.

Errors become issues with readable stack traces, the users and releases they touched, the replay of the moment it broke and what the user told you about it.

Issues you can work through

Search and filter by any tag, assign issues to a person or a team, merge duplicates, and route new ones with ownership rules. Fingerprint rules decide what groups together.

Readable stack traces

Source maps from sentry-cli or your bundler plugin, and ProGuard mappings and dSYMs for mobile, so frames show your original code.

The replay behind the error

Recordings from Guidely's session replay or Sentry's Session Replay are linked to the errors that happened in them, so you can watch what led up to it.

What the user said

Bug reports from the Sentry feedback widget, the crash-report dialog or Guidely's Report a bug dialog arrive with the issue they're about, next to the user's details and their replay.

AI issue analysis

Turn it on for a project, then ask for a summary, root cause or suggested fix on any issue. AI reads the stack trace, breadcrumbs and user reports, with secrets scrubbed, and writes it up for you to check. HIPAA workspaces use only their own Anthropic key.

Ask your assistant about an error

Guidely's MCP server lets Claude, Cursor or ChatGPT list errors, open one with its stack trace and resolve it when you say so, without leaving your editor.

Performance & tracing

See where the time goes.

Turn on tracing in the Sentry SDK you already have, and every transaction arrives as a trace you can open, with web vitals for your pages.

  • Traces and spans

    Page loads, navigations, requests and database queries as a waterfall, following a request from the browser to your backend.

  • Web vitals from real users

    Largest Contentful Paint, Interaction to Next Paint and Cumulative Layout Shift for each page, from the people using it.

  • Performance issues

    Problems found in traces open as issues, with the same search, assignment and alerts as errors.

  • Errors in their trace

    Jump from an error to the trace it happened in to see the slow query or failed request around it.

Your Grafana, Prometheus, Tempo, Loki

See your backend next to every error.

Connect your own Grafana, or Prometheus, Tempo and Loki directly. Guidely queries them live when a page opens, and nothing is copied into Guidely.

  • On every error

    The request's backend trace from Tempo, the log lines that mention it from Loki, and your metrics with the error marked.

  • In every trace

    The browser's spans and your backend's spans in one waterfall, with the trace's logs underneath.

  • Behind every replay

    The backend requests and log lines behind what the user saw. Click one to jump the recording to that moment.

  • Around releases and incidents

    Request rate, errors and latency before and after each deploy, and what your backend was doing while a monitor was down or an alert fired.

  • For AI too

    AI issue analysis reads the trace and logs, and Claude, ChatGPT or Cursor can query them through Guidely's MCP server.

Public or private, your choice

Point Guidely at a public URL, like Grafana Cloud, or run the Guidely relay in your AWS, GCP or Kubernetes. The relay only connects out over HTTPS, keeps your credentials in your cloud, and runs read-only queries.

Read-only by design

Guidely only calls the query endpoints of Grafana, Prometheus, Tempo and Loki, and the relay checks the same list. Credentials for direct connections are encrypted, and who can see backend data is a permission you control per member.

  • Query endpoints only

    No writes, deletes or admin APIs

  • Nothing stored

    Answers go straight to your screen

  • Your credentials

    Kept by the relay in your cloud

  • Your labels

    Map each environment to your selectors

How it works

Releases, crons & uptime

Know what a release changed, and what stopped running.

Release health shows whether a version made things better or worse. Monitors tell you when a scheduled job or an endpoint goes quiet.

Releases and release health

Crash-free sessions and users and adoption for each release, with its commits from GitHub. Suspect commits point at the change most likely behind a new issue, and you can open a GitHub issue from it.

Cron and uptime monitors

Cron monitors expect a check-in on schedule and open an issue when a job is missed, fails or runs too long. Uptime monitors check your URLs every 1 to 60 minutes from one region, and tell you when one goes down or its TLS certificate is about to expire.

Alerts

Hear about it where you already work.

Send alerts to the tools your on-call team uses, and let each person choose the emails and Slack messages they get.

  • Email
  • Slack
  • PagerDuty
  • Opsgenie
  • Microsoft Teams
  • Discord
  • Webhooks
  • Linear & Jira tickets
  • Issue alerts

    Rules for when an issue is new, comes back, escalates or happens often, filtered by environment, tag, level or release.

  • Metric alerts

    A warning and a critical threshold on a number you care about, like error count, latency or crash-free sessions, with a message when it recovers.

  • Weekly reports

    A Monday summary of new and frequent issues and how each project did, for each teammate who turns it on.

The Guidely Slack app

Triage without leaving Slack.

  • Resolve, ignore and assign from Slack

    Alerts posted by the Guidely app carry buttons, and the message updates in place with who did what.

  • Your alerts as direct messages

    Each person turns on Slack DMs for the alerts, assignments and reports they want, per project.

  • Link previews and /guidely

    Guidely links pasted in Slack get a short preview, and /guidely issue looks one up without leaving the channel.

Buttons act as the Guidely member with the same confirmed email, with that member's permissions. They're off in workspaces that require two-step verification or single sign-on, where alerts post with links only. Incoming webhooks work too.

Connect Slack

Switching from Sentry

Bring your setup. Pay for what you send.

Import what you've configured in Sentry, change the DSN, and compare the prices product by product with Sentry's Team plan.

  • Import from Sentry

    Match your Sentry projects to Guidely ones and bring their alert rules (turned off until you're ready), cron monitors and releases. Members arrive as invite suggestions for you to send.

  • One project at a time

    Each project has its own DSN, so you can move one app, check it, and move the rest when you're ready.

  • No plan fee

    Pay as you go starts at $0 a month. Each product has a free allowance and a billing limit you set, and only what you send beyond the allowance is billed.

Prices per product

Guidely pay as you go, from December 2026, compared with Sentry's Team plan, pay as you go, per product per month
Per monthGuidely, pay as you gofrom December 2026Sentry Team plan
Plan fee$0$29 billed monthly
Error trackingSentry: Errors10K errors freethen $0.00025 / errordown to $0.00008 / error over 1M errors50K errors includedthen $0.0003625 / errordown to $0.00015 / error over 20M errors
Performance tracingSentry: Spans (tracing)10M spans free5M spans on the Free planthen $0.0000014 / spandown to $0.000001 / span over 1B spans5M spans includedthen $0.000002 / spandown to $0.0000018 / span over 100M spans
Session replaySentry: Session replays5K recordings freethen $0.0028 / recordingdown to $0.0015 / recording over 200K recordings50 recordings includedthen $0.00375 / recordingdown to $0.002453 / recording over 4.5M recordings
AttachmentsSentry: Attachments2 GB freethen $0.20 / GBdown to $0.15 / GB over 1 TB1 GB includedthen $0.3125 / GB
Cron & uptime monitorsSentry: Cron and uptime monitors5 monitors freethen $0.50 / monitordown to $0.40 / monitor over 100 monitors1 cron and 1 uptime monitor includedthen $0.78 / cron monitorand $1.00 / uptime monitor

Example monthly bills

  • A small app

    • 25K errors
    • 2M spans
    • 500 recordings
    • 0.5 GB
    • 2 monitors
    Guidely
    $3.75
    Sentry Team, estimated
    $31.47
  • A growing product

    • 250K errors
    • 50M spans
    • 10K recordings
    • 5 GB
    • 10 monitors
    Guidely
    $113.60
    Sentry Team, estimated
    $214.59
  • At scale

    • 2M errors
    • 500M spans
    • 100K recordings
    • 50 GB
    • 50 monitors
    Guidely
    $1,075
    Sentry Team, estimated
    $1,736

Sentry Team plan, pay as you go, from docs.sentry.io/pricing checked Nov 8, 2026. Sentry estimates are the $29 monthly plan fee plus usage beyond what the plan includes, with every monitor priced as a cron monitor. Sentry's reserved volume and annual billing cost less. Guidely prices and bills are pay as you go from December 2026, before any billing limit; until then errors and session replays are billed at the earlier rates. Prices in USD, before tax.

Help every user find their way.

Install once. Ship your first tour today, and watch how people use it tomorrow.

Error monitoring for Sentry SDKs · Guidely