Skip to content
Vigie

Observability for embeddable widgets

Your widget is live on 340 customer sites.How many is it broken on right now?

Vigie watches your widget from your customers' sites, not from yours. Which customer, which version, which page, since which hour — before the customer emails you.

A 1.8 KB gzip loader, loaded async. No URLs to enter: the inventory discovers itself.

Customer fleet

last hour window

  • 331healthy
  • 6broken
  • 3never heard from
  • app.northwind.examplev2.14.011:20
  • shop.bluefig.examplev2.14.009:05
  • portal.lumen-co.examplev2.13.402:41
Every square is a customer domain. The six orange squares are the reason this product exists: their loader fired and their render never arrived.

The problem

A blocked widget cannot report its own failure.

Your code runs on somebody else's machine. A CSP tightened on a Tuesday evening, a blocking extension, a redesign that removes the container, a CMS that rewrites the script tag: the widget never starts. It throws no exception, because there is no code in memory to throw one. Your telemetry stays green. Your customer's page has a hole in it.

  • Your server logs

    See nothing. The failure is in a browser, on a domain that is not yours.

  • Your error tracker

    Sees nothing. No error was thrown: nothing executed.

  • Your support inbox

    Sees everything, last. The ticket arrives days after the breakage, and sometimes never.

Absence is the signal. And absence cannot send itself.

The model

Two signals, three states, no guessing.

The beacon loads in two stages. The loader fires before your widget; the reporter confirms the render completed. The gap between the two carries all the information.

Loader
fired
Render
confirmed

Verdict

Healthy

The widget loaded and it painted. You get volume and render p95, by domain and by version.

Loader
fired
Render
never arrived

Verdict

Broken

The loader started, the render never came. You know which customer, which version, which page, since which hour. This is the alert the product is bought for.

Loader
silence
Render
silence

Verdict

Never heard from

Either the page was not visited, or everything is blocked upstream. Vigie settles it with the domain's history — never on a single hourly window.

Before the first alert

Week one raises no alerts.

It builds the baseline. Without seven days of history, "silent" and "not visited" are indistinguishable, and alerting on that confusion would cost you your trust in a week. A domain Vigie has never heard from is never shown as healthy: it is shown as never heard from, and the dashboard says so in plain words.

The inventory

You enter no URLs.

You probably cannot list the domains your widget runs on. Customers install it, move it to a subdomain, resell it white-label, leave it on a staging page. Vigie does not need the list: every execution declares it.

  1. You serve the loader

    From your own CDN, inside the snippet your customers already paste. 1.8 KB gzip, async, no dependencies.

  2. Domains announce themselves

    Every origin that executes your code shows up in the fleet, with its version, within minutes. Including the ones you had forgotten.

  3. The baseline forms

    After seven days of history per domain, silence becomes readable and alerting turns on.

The snippet your customers paste

<script src="https://cdn.your-company.example/vigie-loader.js"
        data-vigie-key="pk_live_8f3c…"
        data-vigie-version="2.14.0" async></script>

Then, inside your widget, one line the moment it has painted: markRendered(). The reporter finds the loader in the page, adopts its counters, and exactly one request leaves per hour.

Widget in an iframe? The loader sits in the parent page and hands the customer origin to the reporter over a handshake: inside the frame, location is your own domain and the referrer cannot be trusted.

In the product

Six things the dashboard gives you.

What it is not

Vigie replaces none of the tools you already run.

The honest comparison

You already have error telemetry. It is good.

Any serious vendor already runs Sentry or its equivalent, and we are not going to pretend otherwise. Here is exactly where the line falls.

The questionAn error trackerVigie
My widget just threw an exceptionYes, with the stack and breadcrumbsYes, but aggregated per customer domain
My widget never started on this siteNothing. No code in memory, so no errorBroken state, customer named, start hour
How many of my customers am I broken on?A global error rate, with no customer denominatorA list of domains, each with its history
Which customers have never been heard from?Not a question it can representSettled by history, once the baseline exists

The data contract

One request an hour, and this is the whole of it.

Vigie runs on the pages of your customers' visitors, people who have never heard of us. That is why this request body is the shortest sales argument the product has: you can paste the tag on a customer's site without opening a file with their DPO.

Everything one window sends

POST /api/ingest/v1/rollup

{
  "k": "pk_live_8f3c…",
  "o": "https://booking.kestrel.example",
  "u": "/rooms/deluxe",
  "v": "2.14.0",
  "t": "2026-09-23T14:00:00Z",
  "l": 1284,
  "r": 1279,
  "e": 0,
  "b": 5,
  "m": 1281,
  "p95": 38,
  "d": "x"
}
k
Your ingest key. Public by design: it writes, and it reads nothing.
o
The customer origin. Scheme, host, port — never a path.
u
The most seen path that hour, query string stripped, 120 characters at most.
v
Your widget version, as the snippet declares it.
t
The window, aligned to the round hour, in UTC.
l
Loaders that fired.
r
Renders that completed.
e
JavaScript errors counted.
b
Blocks detected: a CSP, or an extension.
m
Pages where your container was present at all — the denominator of the render rate.
p95
Render time at the 95th percentile, in whole milliseconds.
d
How the render was proven: asserted by your widget, or observed by the loader.

Pricing

By the number of monitored customer domains.

Not by event volume. You know how many customers you have; nobody knows their event count in advance, and nobody enjoys a bill that tracks somebody else's traffic.

Watch

A first widget in production, a fleet you could still list by hand.

199 €/ month

Monitored customer domains
Up to 100 customer domains
History window
30 days of history
  • All three states, per domain and per version
  • Email alerts that name the customer
  • 2 ingest keys
Get started
Most chosen

Fleet

The fleet outgrew what support can hold in its head, and versions now coexist.

349 €/ month

Monitored customer domains
Up to 500 customer domains
History window
90 days of history
  • Everything in Watch
  • Outbound webhooks and threshold alerts
  • Side-by-side version comparison
  • 10 ingest keys
Get started

Atlas

Several widgets, several white labels, a team that lives in the dashboard.

499 €/ month

Monitored customer domains
Up to 2,000 customer domains
History window
13 months of history
  • Everything in Fleet
  • Multiple widgets on one account
  • Hourly window export
  • Unlimited ingest keys
Get started

Excl. VAT, billed monthly, no commitment.

In every plan

  • Self-discovering domain inventory
  • 1.8 KB gzip loader served from your own CDN
  • Anonymous ingest, always answering 204
  • No cookies, no visitor identifiers
  • Ingest key rotation and revocation

Beyond 2,000 domains

Write to us with your domain count and the versions you have in circulation. You get a price back, not a qualification form.

Email us

Questions

What people ask before they sign.

How heavy is the loader on my customer's page?

4.0 KB minified, 1.8 KB gzip, loaded async with no dependencies. The reporter, which lives inside your widget, is 6.5 KB gzip. Neither adds a blocking request: traffic leaves once an hour, aggregated.

What data leaves my customer's site?

The origin, the page path truncated to 120 characters with the query string stripped, your widget version, the hour rounded to the hour, and counters: loads, renders, errors, blocks, p95. No cookies, no visitor identifier, no page content, nothing a user typed.

What happens if my ingest key leaks?

The ingest API answers 204 to every request, valid or not, so it never confirms that a key exists. A stolen key lets somebody push noise into your account; it reads nothing at all. Keys are revoked and replaced from the dashboard.

When does my first alert arrive?

Not in the first week, and that is deliberate. It takes seven days of history per domain to tell "silent" from "not visited". During that period the dashboard shows the baseline being built, and a domain never heard from is never painted green.

My widget ships white-label. Does this work?

That is the normal case. Vigie groups by origin, not by customer name: you map origins onto your accounts afterwards. A widget served in an iframe works too, through the handshake between the parent page loader and the reporter.

Does this replace my error tracker?

No, and it is not meant to. Keep it for exceptions, stacks and breadcrumbs. Vigie answers a question that tool cannot ask: how many of my customers is my widget not running on at all.

What if my customers block the ingest domain?

Then the domain goes silent, and Vigie says so instead of painting it green. That is precisely why "never heard from" exists as a state separate from "healthy".

How many of your customers, right now?

Serve the loader in the snippet your customers already paste. The first domains appear within the hour; the baseline is ready in seven days.

No commitment. No qualification call.

  • 331healthy
  • 6broken
  • 3never heard from