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.
<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:
<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.
| Module | Size | What it does |
|---|---|---|
spa | 222 B | Patches History API to track pushState, replaceState and popstate. Enables zero-config navigation tracking in Next.js, React Router, Vue Router, and SvelteKit. |
scroll | 254 B | Tracks max scroll depth (0–100%) reached per page. |
engagement | 242 B | Counts time only while the tab is visible. Powers "time on page". |
outbound | 403 B | Auto-detects external + mailto: + tel:. No manual tagging. |
downloads | 357 B | PDF, zip, docs and media. By href extension or a download attribute. |
leave | 270 B | Final event on page unload with scroll depth + session duration. Auto-enables scroll + engagement. |
vitals | 587 B | Captures LCP, CLS, INP, FCP, and TTFB via the Web Vitals + Performance APIs. |
experiments | 248 B | Records 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. |
checkout | 319 B | On 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.
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
- 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.
- In Stripe, Developers → Webhooks: add a destination with the latest API version, that URL and the four events below.
checkout.session.async_payment_succeededonly fires for delayed payment methods such as SEPA Direct Debit: without it, those sales do not count. - Paste the destination's signing secret (
whsec_…) in Vero. - Turn on the tracker's
checkoutmodule. On a click on a Payment Link it addsclient_reference_idwith the session id, so the sale arrives with its visit.
https://[your-vero-host]/api/revenue/stripe/YOUR_SITE_TOKEN
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.
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.
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.
| Provider | Endpoint | Signature header |
|---|---|---|
| Stripe | POST /api/revenue/stripe/SITE_TOKEN | stripe-signature |
| Lemon Squeezy | POST /api/revenue/lemonsqueezy?s=SITE_TOKEN | x-signature |
| Paddle | POST /api/revenue/paddle?s=SITE_TOKEN | paddle-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.
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).
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.
{
"type": "revenue.recorded",
"data": {
"site_id": "site_id",
"amount": 4900,
"currency": "USD",
"provider": "stripe",
"customer_id": "cus_123",
"session_id": "visit id",
"timestamp": 1760000000000
}
}| Field | Type | What it does |
|---|---|---|
type | string | revenue.recorded for a sale, revenue.refunded for a refund. |
data.site_id | string | The site the sale belongs to. |
data.amount | integer | In the currency's minor unit (cents), without tax. Negative on a refund. |
data.currency | string | The currency of the payment. |
data.provider | string | Where the sale came from, for example the provider that sent it. |
data.customer_id | string | null | The customer id, when the provider or your call gave one. |
data.session_id | string | null | The visit the sale is attributed to, null when it has none. |
data.timestamp | integer | When 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.
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.
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.
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- 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"}' || truelabel 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.
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:
| Endpoint | Returns |
|---|---|
GET /api/v1/stats | Visitors, pageviews, sessions, top pages / referrers / countries. |
GET /api/v1/revenue | Revenue, 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/attribution | Revenue 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/goals | Conversion goals and their rates. |
GET /api/v1/vanity | Traffic sources that sent visitors but earned no revenue in the period, with their visitor counts. |
GET /api/v1/cohorts | Revenue 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/realtime | Visitors on the site right now and their top pages; window_seconds says how far back presence was read. |
GET /api/v1/anomalies | Detected 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:
| Endpoint | Limit |
|---|---|
GET /t.js | 600 / min |
POST /api/collect | 200 / min |
POST /api/events | 200 / min |
POST /api/revenue, /api/refund | 240 / 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:
{ "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.
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 mcp add --transport http vero https://mcp.getvero.dev/mcpThen 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 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.
https://mcp.getvero.dev/mcpIn 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.
{
"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.
https://mcp.getvero.dev/mcpIn 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.
{
"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.
{
"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.
{
"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.
{
"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 mcp add vero --url https://mcp.getvero.dev/mcpcodex mcp login veroYour 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.
[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.
{
"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.
{
"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.
{
"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'andnavigator.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.