✦ Pushka — 250,000 signals a month, free. No card. Start free →
Pushka by Favect — observability, unified

One console,
not four.

Pushka collects your errors, logs, traces, uptime checks, sessions and metrics, joins them on one trace id, and wires the result to alerts, on-call and a public status page.

No card. The free plan doesn’t expire.
pushka · productionLIVE
Uptime
99.98%
p95 latency
242ms
Events / min
1.24k
Open errors
3
Uptime check · us-east ✓now
GET /api/checkout → 200now
Session replay capturednow
Cron heartbeat receivednow
.NETNode.jsBrowser JSSentry SDKs

Native SDKs for .NET · Node.js · the browser — one wire contract, no runtime dependencies, PII scrubbing on by default. Already on Sentry? Change one URL.

Why Pushka

Stop stitching four tools together

An error tracker, a log tool, an uptime checker and a metrics dashboard — each with its own bill, its own login and its own idea of what a request is. Pushka is one console that agrees with itself.

One trace id, everywhere

The SDKs stamp a single trace id on everything they send. The browser error, the Node span that caused it and the .NET log line underneath arrive already joined — no more matching timestamps across four tabs.

Change one URL to try it

Pushka speaks the Sentry protocol. If your app already runs a Sentry SDK, point its DSN at Pushka and your errors start arriving — no re-instrumentation, no migration project.

A free tier, not a countdown

250,000 signals a month on one shared allowance — errors, logs, spans, metrics, sessions and checks all draw from the same pool. No card, no expiry. Go over and Pushka sheds the spike instead of billing you.

How it works

An incident, start to finish

The order things actually happen in — and which part of the console does the work.

  1. T+00:00

    The signal arrives

    The SDK sends the exception with its stack, the breadcrumbs before it, the release it shipped in and the user it happened to. Minified frames are symbolicated against the source map you uploaded on deploy — you get a file and a line, not a bundle offset.

    • issues
    • logs
    • events
    • source maps
    • sessions
  2. T+00:20

    The rule fires — once

    Rules watch error volume, custom metric thresholds, uptime checks and the health of your outbound dependencies. Deduplication is claimed atomically, so two console replicas can never page you twice for the same thing.

    • alerts
    • monitors
    • custom metrics
    • dependencies
  3. T+00:22

    Somebody gets paged

    The rotation knows who is awake. The escalation policy knows what happens if they aren't: step two after five minutes, a different channel, a different person. Acknowledging stops the chain.

    • on-call
    • escalation
    • notifications
    • mobile app
  4. T+02:40

    You find the cause

    The trace shows where the three seconds went. The replay shows the click that started it. The map shows which countries it reached. The release view shows the issue first appeared in 1.9.3.

    • traces
    • replays
    • where
    • service map
    • releases
  5. T+04:12

    Customers already know

    The status page moved when the monitor did, and subscribers were notified. The error budget was debited against your SLA. The incident timeline is your postmortem draft.

    • status pages
    • sla
    • reports
    • change log
AI agents

Read production from your editor

Pushka ships an MCP server, so Claude Code, Cursor, Codex or Windsurf can query your issues, stacks, logs and traces while it writes the fix. It reads through a scoped API key — the agent can look at production; it cannot change it.

  • list_projectswhich projects this key can read
  • search_issueswhat is broken, using the console's search syntax
  • get_issuethe exception, the symbolicated stack, the breadcrumbs, the trace id
  • get_logsthe lines around it, already filtered to the trace
claude mcp add pushka \
  -e PUSHKA_API_KEY=pk_live_… \
  -- npx -y @pushkadotdev/mcp
claude codeprojects:read
which unresolved issues in checkout hit the most users this week?
pushka.search_issues
PSH-482 TimeoutException: pool exhausted 41 users, 214 events
PSH-461 NullReference in ReceiptRenderer 6 users, 9 events
what does the stack say for PSH-482?
pushka.get_issue
Npgsql.PoolManager.RentAsync
Checkout/OrderService.cs:214
trace 4f9c2b…a17, slowest span db.query 2.91s
fix it and open a pr
reading OrderService.cs …
raised the pool ceiling to 60, added a wait-time metric
opened PR #214
Setup

Instrument one service this afternoon

Install the SDK, paste your project DSN, deploy. Errors, logs and request spans start arriving in the console already correlated — and PII scrubbing is on before you configure anything.

No runtime dependencies
$ npm i @pushkadotdev/browser
import Pushka from "@pushkadotdev/browser";

Pushka.init({
  dsn: "https://api.pushka.dev/api/v1/envelope?project_key=pk_live_…",
  environment: "production",
  release: "web@1.9.4",
});

Pushka.setUser({ id: "u_88213" });
Pushka.logger.info("checkout started", { cartId: "c_99", items: 3 });
What’s in the console

Eighteen modules. One login.

Turn off the ones you don’t use — for the whole organization, or for one person.

IssuesError tracking with grouping you can override, merge and unmerge.
LogsLog explorer with a histogram, a brush and follow mode.
TracesDistributed traces, span waterfalls and performance stats.
Service mapOrganization topology derived from the spans themselves.
WhereCountry resolution and the affected-users map — IP scrubbed after.
SessionsSession health, crash-free rates and release adoption.
ReplaysDOM replay of a user session around the error.
ReleasesRelease tracking, regressions and adoption.
Custom metricsCounters, gauges and distributions with dimensions.
MonitorsMulti-region uptime checks with keyword and JSON assertions.
AlertsRules over errors, metrics, uptime and dependency health.
On-callRotations, overrides and who is on call right now.
EscalationMulti-step escalation with acknowledgement.
SLAUptime objectives, error budgets and SLA reports.
Status pagesPublic status pages, custom domain, subscriber notifications.
Source mapsSymbolicated stack frames for minified bundles.
MCP serverAgent access to your telemetry from Claude Code, Cursor or Codex.
AI observabilitygen_ai spans: model latency, token cost and tool calls.
0
Modules, one console
0K
Free signals every month
0
Trace id across every surface
$0
Card needed to start
Pricing

One allowance. Every signal.

Retention you can read off the plan, and paid plans start with a 14-day trial — no card.

Yearly is ten months — two are free.

Free

$0forever

Everything a solo developer needs to watch one project. No card, no expiry.

Start free
Signals / month
250,000
Retention
7 days
Projects
1
Uptime monitors
3
Check interval
5 min
Session replays
—
On-call + escalation
—
Agent access (MCP)
—

Includes logs, traces, the service map, sessions, releases, custom metrics, source maps and the audit trail.

Business

$129/ month

Higher volume, longer retention, the change log, AI observability and SMS/voice.

Start 14-day trial
Signals / month
50,000,000
Retention
90 days
Projects
Unlimited
Uptime monitors
100
Check interval
30s
Session replays
5,000 / month
On-call + escalation
Included
Agent access (MCP)
Included

Adds AI/LLM observability, the customer-facing change log, SMS and voice alerts, and a status page on your own domain.

Enterprise

$499/ month

Negotiated volume and retention, SSO/SCIM, white-label status pages.

Talk to us
Signals / month
Negotiated
Retention
365 days
Projects
Unlimited
Uptime monitors
Unlimited
Check interval
10s
Session replays
Unlimited
On-call + escalation
Included
Agent access (MCP)
Included

Adds SAML SSO, SCIM provisioning, audit export, white-label status pages and priority support.

A signal is one error, log line, span, metric point, session or uptime check. They share a single allowance, so there aren’t six separate meters to forecast. Go over it and Pushka sheds the spike and tells you — rather than billing you for it.

Pushka mobile

The pager in your pocket.

A companion app for iOS and Android: incidents, monitors, issues and on-call — with push notifications that deep-link straight to the problem, and acknowledge in one tap.

Start with one service.

Instrument something this afternoon and you’ll know about the next incident before your customers do. The free plan doesn’t expire.