Stream structured logs from browsers, Node.js APIs, Python workers, Go services — anything that can POST JSON. Search, filter, tail in real time, and click any log line to jump to the user session that produced it.
Console.log, console.warn, console.error from the browser. Pino, Winston, Bunyan, structlog, zap, anything from the backend. Same query syntax across both.
Search by free text, by JSON field (level=error AND service=api), by time range, or by session/user ID. Sub-second over millions of lines.
Every log line carries a sessionId. Click to watch the session replay; jump from a backend error to the frontend session that triggered the API call.
Logs are the oldest debugging tool we have. Modern log management tools — Logtail, Datadog Logs, Papertrail — make ingestion and search easy, but they treat frontend and backend as separate problems. The browser's console.log goes to one tool (Sentry, LogRocket), the server's structured log goes to another (Datadog, Logtail), and you stitch them together manually using request IDs.
Nevision does the stitching automatically. The browser recorder injects a x-nevision-session header on every fetch/XHR. Your backend reads that header and includes it on every log line. Now backend logs are searchable by sessionId — and from any backend log, you can jump straight to the user session, the error, the replay.
Every log line is JSON, with at minimum: timestamp, level, message. You can attach arbitrary fields (service, region, userId, requestId, traceId) and search them with a Lucene-like syntax: level:error AND service:api.
Volume-based, no per-host or per-user fees. Each tier includes a generous monthly GB allotment; usage above the cap is billed via Stripe metered usage at a per-GB rate that decreases as you scale up:
The dashboard shows your real-time GB used, hourly traffic for the last 24 hours, daily traffic for the last 30 days, and an end-of-period forecast — so the bill never surprises you. Free accounts hard-block at the cap; paid accounts keep ingesting and overage shows up as a separate line on the next invoice.
The recorder hooks console.log/warn/error/info. Every call is captured with timestamp, source location, and the current sessionId.
Stream from Node.js, Python, Go, anything. POST raw JSON to the logs endpoint with your API key — no SDK or transport package required.
Live-tail incoming logs with filters applied. Click any line to see the session, the error, or the related backend request trace.
| Feature | Nevision | Logtail | Datadog Logs | Papertrail |
|---|---|---|---|---|
| Free GB/month | 500 MB | 1 GB | — | 100 MB |
| Paid plan starts at | $12/mo + 5 GB | $0.25/GB | $0.10/GB | $7/mo (1 GB) |
| Overage rate (lowest paid tier) | $0.30/GB | $0.25/GB | $0.10/GB | $10/mo per +1GB |
| Frontend log capture (warn + error) | — | Manual SDK | — | |
| Backend log ingest | ||||
| Linked to session replay | — | — | — | |
| Linked to error tracking | — | — | — | |
| Live dashboard widget (hourly + daily) | — | |||
| Self-host | — | — | — | — |
Comparison based on publicly listed pricing and features as of April 2026.
Direct transports for Pino (Node.js), Winston (Node.js), Bunyan (Node.js), and structlog (Python). For everything else, POST JSON to /v1/logs — every modern logging library has a custom-transport hook.
Yes. Free text search across the message field, structured search across any JSON field, time-range scoped. Powered by an inverted index, sub-second on millions of lines.
We store logs as you send them — we don't auto-mask. If you log sensitive data (emails, tokens), you should redact at the source before sending. We can sign DPAs on paid plans for compliance use cases.
S3 export is supported on Business plans (continuous archive to your bucket). BigQuery and Snowflake exports are on the roadmap.
By GB ingested per month. Free: 500 MB hard cap (no overage). Lite ($12/mo): 5 GB included, $0.30/GB after. Pro ($39/mo): 25 GB included, $0.20/GB after. Business ($99/mo): 200 GB included, $0.10/GB after. Overage is billed via Stripe metered usage and appears as a separate line on your next invoice. The dashboard widget shows real-time traffic + projected end-of-period usage so the bill never surprises you.
Only console.warn and console.error are captured client-side — never console.log, console.info, or console.debug, by design. This bounds bandwidth and reduces accidental PII leakage. Frontend log capture is opt-in: you enable it per-site under Settings → Tracking features.
POST a JSON batch to https://api.nevision.app/v1/logs with Authorization: Bearer <your sk_* server key>. The server key is shown on the site's Install page. Backend logs accept all levels (debug/info/warn/error/fatal) — there's no client-side filtering since you control what your server emits.
Free accounts: log ingestion is paused until the next billing period (or until you upgrade). Paid accounts: ingestion continues and overage GB are tracked atomically; an hourly cron pushes them to Stripe metered usage so your invoice reflects exactly what you sent. The recorder also stops emitting frontend logs to avoid wasting your customers' bandwidth on requests that would just be billed.
Yes — the dashboard live-tails matching logs as they arrive. Filters compose: tail only level:error from service:api in the last 5 minutes, refreshes automatically.