vlayer logovlayer
Getting started

Tracking verification progress

Every verification leaves a trail of telemetry events — the extension being installed, the consent screen being shown, notarization starting and finishing, your webhook being called. getTelemetryEvents returns that trail for one of your verifications, so you can see exactly how far a user got and where they dropped off.

Fetch the events

import { Vouch } from "@getvouch/sdk";

const vouch = new Vouch({
  customerId: "1be03be8-5014-413c-835a-feddf4020da2",
  apiKey: "your-api-key",
});

const { events } = await vouch.getTelemetryEvents({
  requestId: "8f14e45f-ceea-4a26-9c3f-1d0f4a3f9b21",
});

for (const event of events) {
  console.log(event.timestamp, event.eventType, event.origin);
}

The requestId is the one returned by getDataSourceUrl or getWidgetUrl.

Calling the API directly

The SDK method wraps a single HTTP call, so a backend in any language can fetch the same timeline without the JS SDK:

curl https://app.getvouch.io/api/proof-request/8f14e45f-ceea-4a26-9c3f-1d0f4a3f9b21/telemetry-events \
  -H "Authorization: Bearer your-api-key"

GET /api/proof-request/{requestId}/telemetry-events authenticates with your API key as a bearer token and returns the same { events } body described below.

You can only read your own verifications

The API key you construct Vouch with scopes every call. Asking for a requestId that belongs to a different customer fails with 404 Not Found — indistinguishable from an id that was never issued, so the endpoint cannot be used to probe for other customers' verifications. There is no account-wide listing endpoint.

Response shape

getTelemetryEvents resolves to { events }, ordered oldest first:

{
  "events": [
    {
      "eventType": "PROOF_REQUEST_CREATED",
      "timestamp": "2026-07-22T09:01:12.443Z",
      "origin": "Server",
      "metadata": { "datasourceId": "e37a1a02-3b6e-4f38-9f6d-2b1a5c7d9e00" }
    },
    {
      "eventType": "CONSENT_DISPLAYED",
      "timestamp": "2026-07-22T09:01:31.902Z",
      "origin": "Desktop",
      "metadata": {
        "datasourceId": "e37a1a02-3b6e-4f38-9f6d-2b1a5c7d9e00",
        "geolocation": { "country": "PL", "city": "Warsaw" }
      }
    },
    {
      "eventType": "NOTARIZATION_FINISHED",
      "timestamp": "2026-07-22T09:02:41.008Z",
      "origin": "Desktop",
      "metadata": {
        "datasourceId": "e37a1a02-3b6e-4f38-9f6d-2b1a5c7d9e00"
      }
    }
  ]
}

eventType

What happened. The full set is listed in Event types below, and is exported as the TelemetryEventType union so your editor will autocomplete it:

import type { TelemetryEventType } from "@getvouch/sdk";

New event types are added over time. Switch on the ones you care about and ignore the rest rather than matching exhaustively, so a new event never breaks your integration.

timestamp

ISO 8601 UTC string recording when the event was captured.

origin

Which side emitted the event — "Desktop", "Android", "iOS", "Server", or "Unknown". Useful for telling a desktop-extension run apart from a mobile-app run.

metadata

Extra details attached to the event. Which keys are present depends on eventType, and every one of them is optional — a widget-created verification, for example, emits its first events before a data source has been chosen, so even datasourceId is absent there. Treat the whole object as optional and read keys defensively rather than assuming any one exists.

Only these keys are ever returned:

KeyOn which events
datasourceIdAny event recorded once the data source is known
widgetIdPROOF_REQUEST_CREATED_WITH_WIDGET, PROOF_REQUEST_DS_UPDATED
webhookUrlWEBHOOK_SUCCESS, WEBHOOK_FAILED
webhookResponseErrorWEBHOOK_FAILED
geolocationClient-emitted events, limited to country and city

Everything else your end user's device reports — their IP address and coordinates, user agent, device model and OS, session identifiers, and the URL of the page they were on — is held back and never leaves Vouch through this API.

Event types

Not every verification produces every event — which ones you see depends on the device, the data source, and how far the user got. Events marked → status are the ones that move the verification's status.

Desktop

Emitted by the browser and the Vouch Verifier extension while the user is on desktop.

EventWhat it means
DESKTOP_UNSUPPORTED_BROWSERThe user's desktop browser cannot run the extension, so the flow could not start.
INSTALL_EXTENSIONThe user was prompted to install the Vouch Verifier extension.
EXTENSION_INSTALLEDThe extension was detected as installed.
EXTENSION_OPENThe extension was opened and took over the flow.
QR_CODEThe QR code was shown so the user could continue on their phone.
SDK_STARTINGA mobile app opened the flow through an embedded Vouch SDK.

Mobile web

Emitted by a mobile browser, before any app takes over.

EventWhat it means
MOBILE_UNSUPPORTED_BROWSERThe user's mobile browser cannot run the flow.
COPY_URLThe user copied the verification URL, usually to paste into another browser.

Mobile app

Emitted by the Vouch Verifier mobile app.

EventWhat it means
APP_OPENEDThe Vouch Verifier app was opened.
REDIRECTThe app opened the site being verified — the user lands on that site's sign-in page.
USER_INSTRUCTIONAn instruction was shown telling the user what to do on the target site — for example "Log in to your account".
SUCCESS_MOBILE_REDIRECTThe user finished on mobile and was redirected back.
SUCCESS_MOBILE_TO_DESKTOPThe user started on desktop, finished on mobile, and the handoff completed.
SUCCESS_ADD_CLAIMThe resulting claim was added successfully.

Processing

Emitted while the extension or app is on the target site, capturing the data to notarize.

EventWhat it means
PROCESSING_NEW_PAGE→ status A page loaded on the site being verified. The first one is usually that site's sign-in page; each navigation after it — submitting the login form, landing on the account page — emits another.
REQUEST_MATCHEDA network request matching the data source's rules was captured — the moment the data being verified was actually observed.
PROCESSING_LOGA diagnostic log line. Emitted repeatedly; usually noise unless you are debugging.
PROCESSING_TIMEOUT→ status Processing ran too long and gave up.
UPLOAD_STARTEDUpload of captured data began.
UPLOAD_FINISHEDUpload of captured data completed.
UPLOAD_ERROR→ status Upload failed.
OVERLAY_SHOWNThe Vouch overlay appeared over the target site.
OVERLAY_HIDDENThe overlay was dismissed.
APP_WENT_TO_BACKGROUNDThe user switched away from the app mid-flow.
APP_WENT_TO_FOREGROUNDThe user came back to the app.
USER_NAVIGATED_AWAYThe user navigated away from the page that was proving.
PROVING_TAB_CLOSEDThe tab that was proving was closed before finishing.

Notarization

Emitted from both desktop and mobile as the proof is generated.

EventWhat it means
CONSENT_DISPLAYEDThe consent screen was shown — the page listing what will be shared, displayed before the extension or app takes over.
NOTARIZATION_STARTED→ status Notarization began.
NOTARIZATION_PENDINGA progress heartbeat while notarization runs. Each heartbeat replaces the previous one, so a timeline holds at most one — and it disappears once NOTARIZATION_FINISHED or NOTARIZATION_ERROR lands.
NOTARIZATION_FINISHEDNotarization finished on the client.
NOTARIZATION_ERROR→ status Notarization failed. The user can retry.

Server

Emitted by Vouch's backend.

EventWhat it means
PROOF_REQUEST_CREATEDThe verification was created from a data source.
PROOF_REQUEST_CREATED_WITH_WIDGETThe verification was created from a widget.
PROOF_REQUEST_DS_UPDATEDA data source was selected for a widget-created verification.
WEBPROOF_POSTED→ status The finished web proof reached Vouch. This is the event that marks a verification successful.
WEBHOOK_SUCCESSYour webhook accepted the delivery.
WEBHOOK_FAILED→ status Your webhook could not be reached. The proof is fine; delivery is not.
NOTARIZATION_MODE_OVERRIDDENThe notarization mode was overridden for this verification.

Video verification

Only present on video verifications.

EventWhat it means
RECORDING_UPLOADED→ status The recording was uploaded and is being reviewed.
VIDEO_VERIFICATION_APPROVED→ status The recording was accepted.
VIDEO_VERIFICATION_REJECTED→ status The recording was rejected.

Limits

A timeline is capped at the 1000 most recent events. Long proving sessions emit progress events continuously, so if a run exceeds the cap the oldest events are dropped and the newest — the ones that explain where it ended up — are kept.

Interpreting a timeline

The shape of a successful run

A desktop extension run that completes looks like this — mobile runs swap the extension events for the APP_OPENED / REDIRECT ones, and first-time users get INSTALL_EXTENSION / EXTENSION_INSTALLED before step 3:

  1. PROOF_REQUEST_CREATED — the verification was issued.
  2. CONSENT_DISPLAYED — the user opened the link and saw what will be shared.
  3. EXTENSION_OPEN — the extension took over.
  4. PROCESSING_NEW_PAGE (repeated) — the user signs in and navigates the target site.
  5. REQUEST_MATCHED — the data being verified was captured.
  6. NOTARIZATION_STARTEDNOTARIZATION_FINISHED — the proof was generated.
  7. WEBPROOF_POSTED — the proof reached Vouch; the verification is successful.
  8. WEBHOOK_SUCCESS — your webhook received the result.

A struggling timeline is this sequence cut short — whatever milestone is missing is the stage the user never reached.

Where did the user stop?

For a single stuck or abandoned verification, find the last event and read it against this table:

Timeline ends atWhat it means
Server events only (PROOF_REQUEST_CREATED, …)The verification link was never opened.
INSTALL_EXTENSIONThe install prompt was shown, but the extension was never installed.
QR_CODEThe QR code was shown but never scanned.
CONSENT_DISPLAYEDThe user saw what would be shared and went no further.
EXTENSION_OPEN, APP_OPENED, REDIRECT, USER_INSTRUCTIONThe flow reached the site being verified, but the user stopped at or before its sign-in page.
PROCESSING_NEW_PAGE, REQUEST_MATCHEDThe user was signed in and moving through the site when the trail stops.
NOTARIZATION_PENDINGProof generation was interrupted — the tab or app closed mid-proof.
NOTARIZATION_ERRORProof generation failed and the user did not retry.
WEBPROOF_POSTED, WEBHOOK_SUCCESSThe verification succeeded end to end.
WEBHOOK_FAILEDThe verification succeeded, but delivering it to your webhook did not.

When the trail just stops, the events immediately before the end record how the user left: USER_NAVIGATED_AWAY, PROVING_TAB_CLOSED, and APP_WENT_TO_BACKGROUND.

Measuring drop-off

To see where users are lost across many verifications rather than one, count how many timelines reach each of these milestones:

  1. PROOF_REQUEST_CREATED — the verification was issued.
  2. CONSENT_DISPLAYED — the user opened the verification link.
  3. First PROCESSING_NEW_PAGE — the user reached the site being verified.
  4. NOTARIZATION_STARTED — the data was captured and proof generation began.
  5. WEBPROOF_POSTED — the verification succeeded.

Each gap points at a different problem: losses between 2 and 3 are consent refusals or install/handoff friction, losses between 3 and 4 are users failing to sign in or find their data on the target site, and losses between 4 and 5 are technical failures — check those timelines for NOTARIZATION_ERROR, UPLOAD_ERROR, and PROCESSING_TIMEOUT.

Telemetry is for observability, not for deciding whether a verification succeeded. To act on a result, use the webhook payload and verify it — telemetry events are not cryptographically signed.