An Everframe report is a single typed, signed document: a screenshot, the trail of actions that led to the bug, console and network state, device context, and a replay — delivered to your tools or our dashboard.
The report format is identical on every platform, so your triage prompts, your integrations and your receiver code are written once and never change when you add a platform.
Choose your SDK
| SDK | Covers |
|---|---|
| React | React web apps — a provider and a hook |
| Web | Every other web app — Vue, Svelte, Angular, Astro, or plain HTML |
| React Native | iOS, Android, tvOS, and web through the React SDK. Using Expo? See Expo |
| Flutter | Android, iOS, and web with masked Flutter screenshots and image replay |
| Kotlin Multiplatform | Shared Kotlin reporting on Android, iOS, and web |
| iOS | iPhone, iPad and Apple TV, native Swift |
| Android | Phones, tablets, Android TV and Fire TV, native Kotlin |
| Roku | Roku channels in BrightScript and SceneGraph — crash and error reporting only |
| Vega OS | Amazon Vega OS apps in React Native for Vega — a preview that reports JavaScript errors only |
Flutter and KMP browser targets use the Web SDK for
reporter UI and delivery while their own renderers supply masked screenshots
and replay. React Native’s browser entry re-exports @everframe/react.
The Roku and Vega OS SDKs report crashes and errors on their own. They have no in-app reporter, screenshot, or replay, so the pages about those exist for the other SDKs only.
Each SDK’s section is self-contained — install, configuration, and every capture feature documented for that platform only, so nothing on the page is about somebody else’s runtime.
React or Web? They share one capture core and produce the identical
envelope, so this is not a feature trade: use React if your app is React, and
Web for anything else. The difference is the binding — a provider, a hook, a
<Sensitive> wrapper and an identity prop on React, a plain init() handle on
Web. Capture is the same.
Writing a receiver?
You do not need an SDK for that. The server-side contract is one shared set of pages:
- The envelope — the exact schema of a report
- Ingest API — where reports are submitted
- Webhooks — signed delivery, retries, and who filed the report
- Symbols & source maps — tag builds, upload private artifacts, and diagnose mapping
- Error triage & releases — mapped grouping, fixed releases, and regression alerts
- Try on device — upload a runnable build from CI and reproduce reports on a live device
- Quick capture on real devices — link a test phone or TV, then file a draft with one shake or remote gesture
- Errors & limits — every cap and code in one place
How it works
- Capture. A user reports a bug from inside your app, a teammate shakes a linked test device, or an uncaught error files one on its own. The SDK assembles a screenshot, the breadcrumb trail, console and network state, and device metadata.
- Package. Everything becomes one typed envelope,
protocol version
1.0. - Ingest. The SDK posts it to the ingest API, authenticated with your SDK key.
- Deliver. Everframe fans the report out as a signed webhook to every receiver you have configured — your own tools, or the dashboard.
Retention, and what you own
Everframe is a pass-through pipe. Report artifacts are served only for your plan’s retention window — 14 days to unlimited, depending on plan — and are permanently erased a further 14 days after that window ends.
On the Free plan, attachments are also withheld while an organisation is over its install limit. Withheld is reversible: nothing is deleted, and the artifacts return when the org is back within its limit. Sustained overuse is different: on every plan, an organisation over its limit for two complete months has ingestion suspended until it upgrades or finishes a month within the limit — see Errors & limits.
You own the data and choose where it goes. See Data & retention.