Skip to main content
Before launch. The install snippet, with the real host and your site token, is in your dashboard once you have an account: when we pick yours for the beta, or when Vero opens to everyone. The examples below use placeholders.

Quick start

Drop the script anywhere, head or body. defer is recommended. Replace YOUR_TOKEN with your site token from Dashboard → Settings → Install. With an AI editor such as Cursor or Claude Code, copy the prompt from your framework's guide in the dashboard: it adds the script and passes the visit to your checkout.

HTML
<script defer src="https://[your-vero-host]/t.js?s=YOUR_TOKEN"></script>

That's it: pageviews fire automatically. UTMs, referrer, language, timezone, and screen width are captured. No cookies and no localStorage.

Prefer explicit attributes? Use data-site-id and data-endpoint instead of query params:

HTML
<script defer src="https://[your-vero-host]/t.js" data-site-id="YOUR_TOKEN"></script>

Tracker modules

Core is ~1.2 KB gz. Modules opt-in per site; enable from Dashboard → Settings → Install. Full bundle (all 9) is 2.7 KB gz, inside the 2.8 KB budget. leave is the only module with dependencies: it auto-enables scroll + engagement.

ModuleSizeWhat it does
spa222 BPatches History API to track pushState, replaceState and popstate. Enables zero-config navigation tracking in Next.js, React Router, Vue Router, and SvelteKit.
scroll254 BTracks max scroll depth (0–100%) reached per page.
engagement242 BCounts time only while the tab is visible. Powers "time on page".
outbound403 BAuto-detects external + mailto: + tel:. No manual tagging.
downloads357 BPDF, zip, docs and media. By href extension or a download attribute.
leave270 BFinal event on page unload with scroll depth + session duration. Auto-enables scroll + engagement.
vitals587 BCaptures LCP, CLS, INP, FCP, and TTFB via the Web Vitals + Performance APIs.
experiments248 BRecords A/B exposures from edge-applied variants, so each variant is measured against its goal event: exposures, conversions, conversion rate, lift and significance. Exposures are recorded on Pro.
checkout319 BOn a click on a Stripe Payment Link (buy.stripe.com) it adds client_reference_id with the session id; on a Lemon Squeezy checkout link, checkout[custom][vero]. The rest of the link stays as it was, a value the page already set is never replaced, and it sends no event. A checkout on your own domain is not recognized: add the parameter yourself with window.vero.session().

Custom events

The public API is two functions: window.vero.track(name, props?), and window.vero.session(), which returns the session id to send with a sale. Props must be JSON-serializable and stay under 4 KB. Vero drops any property whose value contains an email address (the event is still stored) and reports it in the X-Vero-Props-Dropped response header; even so, never send emails or user ids.

JavaScript
window.vero.track('signup')

window.vero.track('upgrade_click', {
plan: 'pro',
trigger: 'banner',
})

window.vero.track('video_play', {
video_id: 'demo',
position_pct: 0,
})

Step-by-step guide: how to track custom events

The tracker queues events and flushes via navigator.sendBeacon (with fetch keepalive fallback). Events from bots, DNT, and Global Privacy Control browsers are dropped client-side.

Custom events power Goals: point a goal at an event name in Dashboard → Goals and you get its conversion rate and the revenue behind it, per traffic source.

SPA navigation

Enable the spa module in Dashboard → Settings → Install. It patches the History API at load and emits a pageview on every pushState, replaceState and popstate. Not on hash changes: an in-page anchor is not a new pageview. Zero code in your app.

Works out of the box with Next.js App / Pages Router, React Router, Vue Router, SvelteKit, Astro view transitions, and anything else that uses the History API.

Revenue tracking

Connect your payment provider with one paste and each sale arrives with the visit that brought it, and so with its source, UTM and referrer. Stripe, Lemon Squeezy and Paddle post sales straight to Vero. If you run your own checkout, the ingest endpoint further down is the alternative. On Paddle, you pass the visit id yourself as customData.vero when you open the checkout: the recipe is in Revenue webhooks.

Stripe in one paste

  1. In Vero, on the Connect your sales screen: copy the Stripe URL. It carries your site token, so connect a Stripe account to one site only: Stripe sends every sale of the account to each destination, and every site that connects it would count them all.
  2. In Stripe, Developers → Webhooks: add a destination with the latest API version, that URL and the four events below. checkout.session.async_payment_succeeded only fires for delayed payment methods such as SEPA Direct Debit: without it, those sales do not count.
  3. Paste the destination's signing secret (whsec_…) in Vero.
  4. Turn on the tracker's checkout module. On a click on a Payment Link it adds client_reference_id with the session id, so the sale arrives with its visit.
URL for Stripe
https://[your-vero-host]/api/revenue/stripe/YOUR_SITE_TOKEN
Stripe events
checkout.session.completed
checkout.session.async_payment_succeeded
invoice.paid
charge.refunded

What is stored: what was charged, without tax, in minor units and in the payment's currency. On a Checkout Session, amount_total minus total_details.amount_tax; on an invoice, amount_paid in proportion to total_excluding_tax. A sale is keyed by its invoice, or by its PaymentIntent when it has none, so a Checkout Session and its first invoice are one sale and a redelivered event counts once.

Attribution: the session comes from client_reference_id, from metadata.vero on the Checkout Session, or from vero in the subscription's metadata (subscription_data.metadata.vero), which every invoice of that subscription carries: that is the recipe for free trials. A free trial started from a Payment Link (a checkout with no_payment_required) is remembered with its customer, so the first paid invoice inherits its visit even without subscription_data.metadata.vero; that key is still the recipe that covers every case. A client_reference_id that names no visit of the site is ignored. An invoice without a session inherits the source of the customer's first attributed payment, so renewals keep their source; when the checkout of a new subscription names a visit, that visit wins, whichever event arrives first. Creating the Checkout Session yourself? Send window.vero.session() from the page and set it as client_reference_id.

Refunds: charge.refunded comes off the sale it reverses, found by PaymentIntent, by invoice or, for an invoice stored without its PaymentIntent, by the customer, the amount and the date of the charge, and in the same proportion without tax, so a partial refund subtracts only its part. A refund that arrives before its sale is acknowledged with held: unknown_sale, kept, and subtracted as soon as the sale arrives; if the sale never arrives, it does not count.

Security and testing: Vero checks the Stripe-Signature header with HMAC-SHA256 over timestamp.payload, accepts any of the v1 signatures (Stripe sends two while it rolls a secret) and refuses a timestamp more than 5 minutes off. An event with livemode: false is acknowledged with ignored: test_mode and not counted; a test-mode refund of a sale Vero stored does count. A test-mode destination has its own signing secret: paste the live one when you are done.

Your own checkout: the ingest endpoint

Send each sale from your server to the ingest endpoint, with the session id of the visit. With the Stripe webhook connected, do not send the same Stripe sales here too: they would count twice.

From your server, in bash
curl -X POST https://[your-vero-host]/api/revenue \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_INGEST_SECRET' \
-d '{
  "session_id": "ses_abc123",
  "amount": 2900,
  "currency": "eur",
  "provider_event_id": "pi_3OxAbc...",
  "customer_id": "cus_xyz",
  "livemode": true,
  "metadata": { "plan": "pro_1m" }
}'

Fields: amount in minor units (cents), a whole number, and without tax, as the webhooks store it: 29.99 or a negative amount is refused with a 400, and 0 is ignored, not stored. provider_event_id (your charge or invoice id) is required: it makes ingest idempotent so a retry never double-counts. session_id is optional but required for attribution. Read it with window.vero.session() in the browser and carry it through your checkout. provider is optional: a sale sent without one is stored as your own checkout.

The endpoint is idempotent on provider_event_id: retries are safe. Set livemode from the payment's mode. A sale with livemode: false is acknowledged with ignored: test_mode and not counted. Neither is a refund with livemode: false, unless its original_event_id is a sale Vero already stored. From a Lemon Squeezy handler, send livemode: !meta.test_mode.

Refunds go to POST /api/refund, with the same ingest secret.

A refund, in bash
curl -X POST https://[your-vero-host]/api/refund \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer YOUR_INGEST_SECRET' \
-d '{
  "amount": 2900,
  "currency": "eur",
  "provider_event_id": "re_3OxAbc...",
  "original_event_id": "pi_3OxAbc...",
  "customer_id": "cus_xyz"
}'

amount is what was refunded, positive and in minor units; Vero stores it as negative revenue, so revenue drops. provider_event_id is required and makes the call idempotent. It is the refund's own id, never the sale's: a refund sent under its sale's id is refused with a 400. To net it against the sale's source, Vero finds the sale by session_id; without one, by original_event_id (the provider_event_id you sent with the sale); failing that, by the latest sale of that customer_id.

Revenue webhooks

Stripe, Lemon Squeezy and Paddle post sales straight to Vero, zero code on your side. Every path dedupes on provider_event_id, so a provider retry never double-counts.

ProviderEndpointSignature header
StripePOST /api/revenue/stripe/SITE_TOKENstripe-signature
Lemon SqueezyPOST /api/revenue/lemonsqueezy?s=SITE_TOKENx-signature
PaddlePOST /api/revenue/paddle?s=SITE_TOKENpaddle-signature

Each site has its own signing secret per provider (Dashboard → Settings → Connect revenue), stored encrypted. Paste the endpoint URL and that secret into the provider's webhook settings; Vero verifies every request with HMAC SHA-256 before touching the database. Stripe and Paddle signatures older than 300 seconds are rejected, so a captured request can't be replayed later.

Webhook URLs
https://[your-vero-host]/api/revenue/stripe/YOUR_SITE_TOKEN
https://[your-vero-host]/api/revenue/lemonsqueezy?s=YOUR_SITE_TOKEN
https://[your-vero-host]/api/revenue/paddle?s=YOUR_SITE_TOKEN

Handled events: Stripe's, from the previous section; order_created, order_refunded, subscription_payment_success and subscription_payment_refunded (Lemon Squeezy); transaction.completed, adjustment.created and adjustment.updated (Paddle). Subscribe to those in the provider. A Lemon Squeezy subscription renewal is a sale; its first payment is not counted twice, because order_created already stored it. Anything else is acknowledged and ignored.

One definition of revenue: what was charged, without tax, less refunds, before fees, the same for all three providers. On Lemon Squeezy, total minus tax; on Paddle, grand_total minus grand_total_tax. A refund is stored as a negative amount of what was actually refunded, in the same proportion without tax, so a partial refund subtracts only its part; a Paddle refund counts once Paddle approves it. A sale that charged nothing is not stored.

Attribution: the visit travels in the checkout's custom data. The checkout module adds checkout[custom][vero] to Lemon Squeezy checkout links and Vero reads it from meta.custom_data.vero. With Paddle.js, pass customData: { vero: window.vero.session() } when you open the checkout and Vero reads it from data.custom_data.vero. A sale without a session inherits the source of the customer's first attributed payment, and a refund comes off the source of the sale it reverses.

A test-mode payment (Stripe with livemode: false, Lemon Squeezy with test_mode, or a Paddle sandbox transaction) is acknowledged with ignored: test_mode and not counted, so a test purchase proves the connection without adding to revenue. Vero tells a Paddle sandbox webhook apart by the IP addresses Paddle sends it from. If ingest fails, Vero answers 5xx so the provider retries instead of dropping the sale. Revenue webhooks work on every plan: Hobby stores every sale and sees the total, and the breakdown by source is Pro.

Edge / no-script tracking

Track pageviews with zero client JavaScript, from edge middleware (Vercel/Next, Cloudflare, Netlify) or your server. Unblockable by ad-blockers, works with JS disabled. Authenticated with your ingest secret; forward the visitor's IP, UA, and country so the visitor hash is computed from the real visitor (the IP is hashed and discarded, never stored).

middleware.ts (Vercel / Next)
import { NextResponse, type NextRequest, type NextFetchEvent } from 'next/server';

const UTM_KEYS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content'];

export function middleware(req: NextRequest, event: NextFetchEvent) {
const url = req.nextUrl;
if (req.method === 'GET' && (req.headers.get('accept') || '').includes('text/html')) {
  event.waitUntil(fetch('https://[your-vero-host]/api/collect', {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      authorization: `Bearer ${process.env.VERO_INGEST_SECRET}`,
      'x-vero-ip': (req.headers.get('x-forwarded-for') || '').split(',')[0].trim(),
      'x-vero-ua': req.headers.get('user-agent') || '',
      'x-vero-country': req.headers.get('x-vercel-ip-country') || '',
    },
    body: JSON.stringify({
      type: 'pageview', site_id: process.env.VERO_SITE_TOKEN, path: url.pathname,
      referrer: req.headers.get('referer') || '',
      ...Object.fromEntries(UTM_KEYS.map((k) => [k, url.searchParams.get(k) || undefined])),
    }),
  }).catch(() => {}));
}
return NextResponse.next();
}

export const config = { matcher: ['/((?!_next|api|.*\\..*).*)'] };

Set VERO_SITE_TOKEN and VERO_INGEST_SECRET (Dashboard → Settings: the token in the install snippet, the secret under Connect your sales). Cloudflare Worker and Netlify Edge snippets are in the setup page. From a plain backend there is nothing to install: send the same POST with fetch. POST /api/revenue and POST /api/refund take the same ingest secret; POST /api/events takes an API key with write access (below).

Which to use. The script gives you rich browser signals (scroll, engagement, Web Vitals, SPA). Edge middleware gives you automatic, whole-site, unblockable pageviews with zero dependency. The server API covers custom events, revenue and refunds from any backend, the most reliable path for money. For pageviews, pick one per site: the script always sends its own pageview and Vero does not deduplicate, so running both on the same pages counts each load twice. Choose edge for counts ad blockers can't stop, the script for browser signals and the session that ties a sale to its visit. The server API works alongside either one.

Outbound revenue webhook

Vero can send you every sale too. With an outbound webhook, each sale or refund Vero stores for a site is POSTed to a URL of yours (your CRM, Zapier, Make or your own server), with the visit it came from. One webhook per site, on every plan.

Where to set it up: Dashboard → Site settings → Sales → Revenue webhook. Paste the endpoint URL and press Save webhook. The URL must be https on a public domain name, not an IP or a local host. Vero generates the signing secret the first time you save and shows it there, to owners and admins only. Changing the URL keeps the secret. There is no rotate button: remove the webhook and add it again to get a new one.

The request. Vero makes a POST to your URL with Content-Type: application/json and an X-Vero-Signature header, and the body is JSON. type is revenue.recorded for a sale and revenue.refunded when the amount is negative.

JSON
{
  "type": "revenue.recorded",
  "data": {
    "site_id": "site_id",
    "amount": 4900,
    "currency": "USD",
    "provider": "stripe",
    "customer_id": "cus_123",
    "session_id": "visit id",
    "timestamp": 1760000000000
  }
}
FieldTypeWhat it does
typestringrevenue.recorded for a sale, revenue.refunded for a refund.
data.site_idstringThe site the sale belongs to.
data.amountintegerIn the currency's minor unit (cents), without tax. Negative on a refund.
data.currencystringThe currency of the payment.
data.providerstringWhere the sale came from, for example the provider that sent it.
data.customer_idstring | nullThe customer id, when the provider or your call gave one.
data.session_idstring | nullThe visit the sale is attributed to, null when it has none.
data.timestampintegerWhen the sale happened, in milliseconds since the epoch.

Only a new sale is sent. A repeated provider event is not stored again and fires nothing, and neither does a test-mode or zero-amount payment, because it is not stored. The body has no event id: if your endpoint has to be idempotent, build the key from the fields above.

Verify the signature. X-Vero-Signature is the HMAC SHA-256, hex-encoded, of the body exactly as it arrived, with your full signing secret (the one starting with whsec_) as the key. Compute it over the raw body, before parsing the JSON, and compare in constant time.

Node.js
import { createHmac, timingSafeEqual } from 'node:crypto';

export const isFromVero = (rawBody, signature, secret) => {
  const expected = createHmac('sha256', secret).update(rawBody).digest('hex');
  const a = Buffer.from(expected);
  const b = Buffer.from(signature ?? '');
  return a.length === b.length && timingSafeEqual(a, b);
};

The signature carries no timestamp, so it does not protect against a replay of the same request.

When it fails. Vero waits up to 5 seconds and counts a delivery as good only on a 2xx response. It does not follow redirects, so a 3xx counts as a failure, like an error, a timeout or a URL that no longer passes the https and public-domain check. A failed delivery goes into a queue and is retried on the hourly pass: the first time an hour later, and after each new failure waiting one hour longer than the last (2, 3, 4, 5). Each retry sends the same body, signed with the secret you have at that moment. That makes 6 attempts in all. After the sixth failure the delivery is dropped and is not resent on its own. A failing endpoint never delays or affects how the sale is recorded.

What does not exist: a test button and a delivery log in the dashboard. To check your endpoint, make a real sale and see whether it arrives (a payment the provider marks as test is not stored, so nothing is sent). Deliveries are not guaranteed to arrive in order.

Server API

Send custom events from your backend with an API key that has write access (Account → API keys: pick Read and send events when you create it). Use it for what happens on your server: cron jobs, background workers, a webhook you receive. The event's visitor hash comes from your server's IP and UA, not a visitor's: it shows up in top events, but it belongs to no visit, so it has no traffic source and does not count as a goal conversion. To tie it to the visitor, fire it in the browser with window.vero.track(), or send it through the edge ingest above (type: "custom" with event_name) forwarding their IP and UA.

Bash
curl -X POST https://[your-vero-host]/api/events \
-H 'Authorization: Bearer vk_...' \
-H 'Content-Type: application/json' \
-d '{
  "type": "custom",
  "path": "/checkout/complete",
  "event_name": "purchase_completed",
  "props": { "plan": "pro_1m", "trial": false }
}'

The site is inferred from the API key. type is usually custom; use pageview only if you have a real reason to. A read-only key gets 403 with insufficient_scope and the event is not stored.

Deploys from CI

Mark each deploy on your charts, so a jump or a drop lines up with the release behind it. Send one request from your pipeline once the deploy finishes, with the same ingest secret the edge ingest uses. It is a Pro feature: on Hobby the request answers 403.

Bash
curl -fsS -X POST https://[your-vero-host]/api/annotations \
-H "Authorization: Bearer $VERO_INGEST_SECRET" \
-H 'Content-Type: application/json' \
-d '{"label": "Deploy v1.4.2", "source": "manual", "url": "https://github.com/acme/web/releases/tag/v1.4.2"}' || true
.github/workflows/deploy.yml
- name: Mark the deploy in Vero
  if: success()
  run: |
    curl -fsS -X POST https://[your-vero-host]/api/annotations \
      -H "Authorization: Bearer ${{ secrets.VERO_INGEST_SECRET }}" \
      -H 'Content-Type: application/json' \
      -d '{"label": "Deploy ${{ github.sha }}", "source": "github"}' || true

label is required (one line, up to 200 characters). source is manual, github, vercel, netlify or cloudflare; url is optional and must be https. On Vercel, add it to the end of the Build Command with $VERCEL_GIT_COMMIT_SHA in the label, only when $VERCEL_ENV is production. The || true keeps a network hiccup from failing your deploy.

Read API

Pull aggregates into your own dashboards, BI tools, or weekly reports. Any API key works, read-only or with write access; Pro plan required.

Bash
curl https://[your-vero-host]/api/v1/stats?period=7d \
-H 'Authorization: Bearer vk_...'

Returns totals (pageviews / visitors / sessions), top_pages, top_referrers, and top_countries. Each referrer carries referrer, the stored value, and label, how it reads: android-app://com.linkedin.android/ arrives as LinkedIn (Android). Periods: today, 7d, 30d, 90d, or custom from / to.

A sale with no visit on record, such as one whose checkout carried no session, counts toward the total without a source: /api/v1/revenue and /api/v1/attribution return it once, in unattributed_cents, never as (direct). (direct) is a visit with no UTM tag and no referrer from another site. Each platform is one source: facebook.com, l.facebook.com and m.facebook.com arrive as facebook; x.com, twitter.com and t.co as x. Each row also carries label, how it reads: Direct, X, Facebook.

Each campaign arrives as { campaign, label, revenue_cents }, under by_campaign on /api/v1/revenue and campaigns on /api/v1/attribution. The campaign is the utm_campaign of the first touch of the visit that brought the sale, the same rule as the source; refunds are subtracted. A visit with no utm_campaign is (none). Ten campaigns at most. Until 18 October 2026 these names were direct, none and other, without parentheses, and collided with real tags of that name.

All read endpoints take the same auth and period parameters:

EndpointReturns
GET /api/v1/statsVisitors, pageviews, sessions, top pages / referrers / countries.
GET /api/v1/revenueRevenue, revenue by traffic source (by_source) and revenue by UTM campaign (by_campaign), in the site's primary currency (amounts are not summed across currencies). Sales with no visit on record count toward the total without a source or campaign, in unattributed_cents.
GET /api/v1/attributionRevenue per UTM source (sources) and per UTM campaign (campaigns) of the visit that earned it, with total_cents, currency and unattributed_cents. Each list shows the top ten; the rest add up in a final row named (other), so either list plus unattributed_cents adds up to the total.
GET /api/v1/goalsConversion goals and their rates.
GET /api/v1/vanityTraffic sources that sent visitors but earned no revenue in the period, with their visitor counts.
GET /api/v1/cohortsRevenue cohorts: paying customers grouped by the week of their first payment, with what each cohort paid in every later week, refunds subtracted. Defaults to 30d.
GET /api/v1/realtimeVisitors on the site right now and their top pages; window_seconds says how far back presence was read.
GET /api/v1/anomaliesDetected traffic and revenue spikes and drops.

Auth is Authorization: Bearer with a Pro API key. Limit: 60 requests per minute per IP; the full error contract is in Rate limits & errors.

Rate limits & errors

Public endpoints are limited per IP over a fixed 60-second window:

EndpointLimit
GET /t.js600 / min
POST /api/collect200 / min
POST /api/events200 / min
POST /api/revenue, /api/refund240 / min
POST /api/revenue/lemonsqueezy, /paddle, /stripe/…240 / min
GET /api/v1/*60 / min

Over the limit you get 429 plus a Retry-After header (seconds until reset). Every error, on every endpoint, is the same one-field JSON shape:

JSON
{ "error": "Rate limit exceeded" }

Status codes are boring on purpose: 400 invalid payload, 401 missing or bad key or signature, 403 the plan doesn't include the feature (or insufficient_scope: the key lacks the scope the endpoint needs), 404 unknown token, 413 body over 64 KB (webhooks), 429 rate limited. A 5xx is worth retrying; a 4xx is not.

MCP server

The Vero MCP server lets Claude, Cursor and any Model Context Protocol client read your analytics (ChatGPT too, depending on your ChatGPT plan), so you can ask your AI agent about your traffic and revenue while you work. It is hosted, with no server to run, and part of Pro. It only reads: it cannot send events or change anything.

Tools
  • vero_list_sites(): the sites the connection can read, and which one is the default.
  • vero_get_stats(period?, site?): visitors, pageviews, top pages, referrers, countries.
  • vero_get_revenue(period?, site?): total revenue and revenue by source.
  • vero_get_attribution(period?, site?): revenue by source, plus the revenue with no visit on record.
  • vero_get_goals(period?, site?): conversion goals and their rates.
  • vero_get_cohorts(period?, site?): revenue cohorts by week of first payment.
  • vero_get_realtime(site?): who is on the site right now.
  • vero_get_anomalies(site?): recent traffic and revenue spikes and drops.

Give your client the server URL. It opens Vero in your browser: you sign in (with your two-step code if you use one), pick a site and allow read-only access. Tick the box and it also reads every other site you see, in every workspace. There is no key to copy. The connection lasts while you use it and expires after 90 days unused; you revoke it from «Connect your AI» in the dashboard. If your client cannot sign in with OAuth, send a read-only API key as a bearer header to the same URL; when you create it in «Connect your AI» you can let it read all your sites too.

Claude Code

Run this in your terminal.

Claude Code
claude mcp add --transport http vero https://mcp.getvero.dev/mcp

Then type /mcp in Claude Code, pick vero and sign in.

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Run this in your terminal.

Claude Code
claude mcp add --transport http vero https://mcp.getvero.dev/mcp \
  --header "Authorization: Bearer vk_your_key"

Replace vk_your_key with the read-only key you create in the dashboard.

Claude

Paste this URL into your client.

Claude
https://mcp.getvero.dev/mcp

In Claude, open Connectors in Settings, add a custom connector and paste this URL. It works on claude.ai and in Claude Desktop.

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Add this to claude_desktop_config.json.

claude_desktop_config.json
{
  "mcpServers": {
    "vero": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.getvero.dev/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer vk_your_key"
      }
    }
  }
}

With a key, Claude Desktop connects through the mcp-remote bridge, which needs Node.js.

Replace vk_your_key with the read-only key you create in the dashboard.

ChatGPT

Paste this URL into your client.

ChatGPT
https://mcp.getvero.dev/mcp

In ChatGPT, add a custom MCP server and paste this URL. Whether you can depends on your ChatGPT plan and workspace settings.

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Cursor

Add this to ~/.cursor/mcp.json.

~/.cursor/mcp.json
{
  "mcpServers": {
    "vero": {
      "url": "https://mcp.getvero.dev/mcp"
    }
  }
}

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Add this to ~/.cursor/mcp.json.

~/.cursor/mcp.json
{
  "mcpServers": {
    "vero": {
      "url": "https://mcp.getvero.dev/mcp",
      "headers": {
        "Authorization": "Bearer vk_your_key"
      }
    }
  }
}

Replace vk_your_key with the read-only key you create in the dashboard.

VS Code

Add this to .vscode/mcp.json.

.vscode/mcp.json
{
  "servers": {
    "vero": {
      "type": "http",
      "url": "https://mcp.getvero.dev/mcp"
    }
  }
}

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Add this to .vscode/mcp.json.

.vscode/mcp.json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "vero-key",
      "description": "Vero API key",
      "password": true
    }
  ],
  "servers": {
    "vero": {
      "type": "http",
      "url": "https://mcp.getvero.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${input:vero-key}"
      }
    }
  }
}

VS Code asks for the key the first time and stores it for you, so it is never written in the file.

Codex

Run this in your terminal.

Codex
codex mcp add vero --url https://mcp.getvero.dev/mcp
codex mcp login vero

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Add this to ~/.codex/config.toml.

~/.codex/config.toml
[mcp_servers.vero]
url = "https://mcp.getvero.dev/mcp"
bearer_token_env_var = "VERO_API_KEY"

Codex reads the key from an environment variable. Set it with the line below.

export VERO_API_KEY="vk_your_key"

Replace vk_your_key with the read-only key you create in the dashboard.

Windsurf

Add this to mcp_config.json.

mcp_config.json
{
  "mcpServers": {
    "vero": {
      "serverUrl": "https://mcp.getvero.dev/mcp",
      "headers": {
        "Authorization": "Bearer vk_your_key"
      }
    }
  }
}

Open the file from Cascade, with its "Open MCP config file" action.

Replace vk_your_key with the read-only key you create in the dashboard.

This client connects with a read-only API key.

Other client

Add this to your client's MCP configuration.

Other client
{
  "mcpServers": {
    "vero": {
      "url": "https://mcp.getvero.dev/mcp"
    }
  }
}

An MCP client that signs in with OAuth needs only this URL. One that can only send a bearer header uses the API key.

Your client opens Vero in your browser. Sign in, pick a site and allow read-only access. You can also let it read every other site you see. There is no key to copy.

Use an API key instead

Add this to your client's MCP configuration.

Other client
{
  "mcpServers": {
    "vero": {
      "url": "https://mcp.getvero.dev/mcp",
      "headers": {
        "Authorization": "Bearer vk_your_key"
      }
    }
  }
}

Replace vk_your_key with the read-only key you create in the dashboard.

Each client's snippet, and what the server does not do, is on the MCP server page.

period is one of today, 7d, 30d, 90d (default 7d; 30d for cohorts).

site is a domain or an id from vero_list_sites. Without it, each tool reads the site the connection was set up for. The REST API still reads the key's own site only.

Privacy & consent

Vero writes nothing to the visitor's device, stores nothing that identifies anyone and uses the IP only in memory, to compute a hash with a daily salt. What that means for your consent setup is your legal team's call; /transparency lists every field the tracker sends.

  • No cookies and no localStorage.
  • Visitor identity is a daily-rotating SHA-256(IP + UA + day + site + secret salt), scoped to each site. The raw IP is never stored.
  • Honors navigator.doNotTrack === '1' and navigator.globalPrivacyControl: those visitors are not tracked at all.
  • Bot user-agents (crawlers, headless browsers, navigator.webdriver) are skipped client-side and re-verified on ingest.
  • Hobby retention 30 days, Pro 2 years. Deleting the account deletes its data at once. Only the nightly backups hold the deleted rows until they expire, at most 30 days.

Need help?

New to Vero? The guides walk through install, events, and revenue step by step. Stuck on integration or hit a bug? Email hello@getvero.dev and we'll get back to you.

Hand-picked beta, waitlist open

Ask for a place in the beta.

Anyone can join the list. The accounts we pick get Pro free for the whole beta.

By joining you agree to receive launch updates and accept our Privacy Policy.

See the demo