PeekPoint reveals the real value of any variable, at any line, inside a running server – on demand, with no redeploy, no pausing, and no hosted backend. Then it captures every HTTP request and the browser state behind it, so you finally see the whole story of a request.
No. The Network tab records what crossed the wire, in one browser tab. PeekPoint shows what happened inside your backend during the request – the variables, the errors, the DB results – and correlates it with the browser state that caused it. Different layer, different problem.
In short: DevTools’ Network tab is for the frontend. PeekPoint is for the backend – plus the correlation between the two.
| Capability | Browser Network tab | PeekPoint |
|---|---|---|
| Request / response body & headers | Yes | Yes |
| Variable values inside the route handler | No | Watch any line |
| Backend thrown errors with stack + payload | Status only | Yes |
| Requests from mobile / Postman / webhooks / cron | No | Yes |
| DB query & 3rd-party API results (server-side) | No | Yes |
| Cookies / localStorage / sessionStorage / IndexedDB at request time | Separate, per-tab | Attached to the request |
| Persists across reloads & shareable with the team | No | Yes |
| Works in staging / headless / no DevTools | No | Yes |
| Network timing waterfall (DNS/TCP/TTFB) | Yes | No (by design) |
Everything runs locally. No agent server, no cloud, no account. Just npm install and a localhost dashboard.
Set a logpoint on a file + line with variable names. Hit your endpoint – see the real values within ~1s. It uses a V8 logpoint that captures and returns false, so your app never pauses.
One Express middleware records query, params, body, headers, responseBody, status, duration and thrown errors – for every request, from any client.
The client SDK attaches cookies, localStorage, sessionStorage and an IndexedDB summary to the matching backend request – the full front-to-back picture in one card.
Type roughly what you want to watch; optional Gemini integration maps it to the real in-scope expression (total → cart.total), auto-applying when confident, asking when not.
The bridge binds to 127.0.0.1 only. Sensitive keys (passwords, tokens, auth, cookies) are redacted in-process before any value leaves your app.
Captures are stored in the browser via IndexedDB and a server-side ring buffer, so nothing disappears on refresh. One click to clear everything.
Watch your .ts source directly – PeekPoint resolves source maps to the compiled line, so you reason in the code you actually wrote.
No --inspect, no open debug port. Add one import (or --import peekpoint/register), run npx peekpoint, and you’re live.
When a watch fires during a request, it’s attached right onto that request’s card – no flipping between tabs to connect the dots.
Request, response, the variable that caused the bug, and the browser state behind it – together.
Three terminals, three tiny additions. There genuinely isn’t much to configure – that’s the point.
Add the package to your Node/Express server (the MERN backend – not the React app).
npm install peekpoint
Pick one. The --import form is recommended for ESM apps (it loads before your code).
# Loads PeekPoint before your app, then runs it normally node --import peekpoint/register ./server.js # Pass the shared token + port via env PEEKPOINT_TOKEN=devtoken node --import peekpoint/register ./server.js
import { init } from "peekpoint"; init({ token: process.env.PEEKPOINT_TOKEN, port: 9999 }); // ...the rest of your server
import { init, expressMiddleware, expressErrorMiddleware } from "peekpoint"; app.use(express.json()); app.use(expressMiddleware()); // after body parser → captures every request // ...your routes... app.use(expressErrorMiddleware()); // last → captures thrown errors
In a separate terminal. It prints a localhost URL with your token – open it, set a watch, hit your API.
npx peekpoint --token devtoken # → Dashboard: http://127.0.0.1:9999/?t=devtoken
One line in your React/Vue/vanilla app correlates cookies & storage with each backend request.
import { initPeekpointClient } from "peekpoint/client"; initPeekpointClient({ token: "devtoken" }); // same token as the bridge
The token just needs to match between your app, the client SDK, and npx peekpoint. Pick any string for dev.
Six situations where every other tool runs out of road. These are the moments PeekPoint was built for.
PainPager is screaming. 8% of users see TypeError: Cannot read property 'amount' of undefined. You can’t reproduce it locally. Adding a single console.log means a 12-minute deploy. Every refresh of your status page is another lost cart, another support ticket, another bad tweet.
PeekPointFrom your laptop, set a watch on the failing line. The next user who triggers the bug hands you their full cart, session, and the exact undefined property within seconds. Ship the one-line fix in 4 minutes – not 90 – with traffic still flowing.
PainStripe is firing duplicate charge.refunded events. Your idempotency check has a bug. There is no browser, no DevTools, no React app – webhooks come from Stripe’s servers and hit yours directly. Your logs show 200 OK. Meanwhile your CFO is asking why the refund total doubled this week.
PeekPointOne line of expressMiddleware() captures every inbound webhook – full payload, headers, response body, and error stack. The next misbehaving event reveals the exact field that slipped past your check. Bug fixed before another refund goes out.
PainYour largest account – 40% of ARR – is on a renewal call with their CTO. Their dashboard shows the wrong revenue numbers. Only their tenant. Only sometimes. You cannot add console.log mid-call. You cannot deploy. You cannot ask the CTO to “try again in 30 minutes.” The silence is unbearable.
PeekPointMid-call, you set a watch on the aggregation pipeline. They click. You see the multi-tenant query returned tenantId = "default" instead of theirs. They watch you find and fix it live. The contract gets signed an hour later.
PainYour iOS app is crashing for 14% of users on the new onboarding flow. Crashlytics says API returned 422 – Invalid format. The iOS team swears the payload is correct. You cannot open Chrome DevTools on a phone. Your only option: add backend logging, redeploy, then wait three days for App Store review and hope it reproduces.
PeekPointAuto-capture runs server-side, so it does not care that the caller is iOS. The very next failing 422 shows you the actual JSON the device sent – a date as MM/DD/YYYY instead of ISO. Validator updated in 5 minutes. No App Store dance.
PainAt 1,200 req/s your inventory service occasionally oversells the last item. You cannot reproduce locally. Load tests miss it. Adding console.log changes the timing and the bug disappears – the classic Heisenbug. Engineering leadership wants an answer by morning, and you are out of ideas.
PeekPointV8 logpoints capture values without pausing or perturbing the timing the way log statements do. Within an hour of real production traffic you have two captured requests with overlapping timestamps, both reading stock = 1. You see the race instead of chasing its shadow.
PainYour enterprise customer’s CISO sends a SOC 2 follow-up. Your logs have request paths and status codes. They do not have the response payloads. Your DB backups are nightly, not per-request. You are about to type the answer no one wants to send: “We don’t retain that data.” The deal stalls.
PeekPointCapture history persists in a queryable stream you can leave running on staging or production. Filter by route + user. Show the exact response body you returned that day. Auditor closes the ticket. Deal closes too.
Ships fully built (ESM + CJS + types) with the dashboard bundled inside – no post-install scripts, no separate downloads.
The core runtime inspector for your Node process.
init() – attach the in-process inspectorexpressMiddleware() – auto-capture requestsexpressErrorMiddleware() – capture errorsFor ESM apps where imports hoist above your code.
node --import peekpoint/register app.jsPEEKPOINT_TOKEN / PEEKPOINT_PORTTiny front-end hook for state correlation.
initPeekpointClient() – one linefetch + XMLHttpRequestA localhost-only relay that serves the bundled dashboard and connects your agents and browser – no cloud, no account.
A polished React UI with live captures, watch management, AI mapping, search & filters, IndexedDB persistence and a one-click clear – shipped inside the package.
Hand-authored types for every entry point. Works seamlessly in both ESM and CommonJS projects, Node 18+.
Install PeekPoint, set a watch, hit your endpoint – and watch the real values appear. It’s the debugger MERN never had.