VetoVetoDocs
Getting Started

Quickstart – sell to an agent in 5 minutes

The fastest path to a store an AI agent can buy from – sign in to the hosted dashboard, add one product, set your wallet, publish, and watch a throwaway agent buy it on the sandbox. No code required; an API path for developers is right below.

Veto is a hosted platform – think "Stripe for AI agents." You set your store up once on the dashboard, and Veto handles how each agent discovers your products, pays you, and settles the money into your own wallet. The fastest way to a working store is entirely no-code, so that's the path we lead with. Developers who'd rather script it get the same steps as API calls right after.

The fast path – the dashboard (no code)

Open https://merchants.veto-ai.com and click through it. This takes about five minutes and never touches a terminal.

Sign in

Go to https://merchants.veto-ai.com and sign in with a magic link (we email you a one-click link – no password).

Create your store

Give it a name, a slug, and your storefront domain. That's the resource an agent discovers and buys from.

Add one product

A name and a price is enough. Prices are exact – Veto quotes agents the same amount, to the cent, that you type here.

Set your receiving wallet

Paste your own wallet address on Base (Coinbase's low-fee network), paid in USDC (the dollar-pegged stablecoin). Use base-sepolia while you're building – that's the sandbox (testnet, no real money) – and base when you're ready for real money. Veto is non-custodial: settled funds land in your wallet, never Veto's.

Publish

Click Publish. Your store is now discoverable and buyable by agents.

Now put it in front of an agent. You have two options:

  • Connect your domain – add one DNS record (a CNAME) so your store's agent-checkout anchor resolves under your own brand (e.g. shop.acme.example).
  • Or just hand an agent your checkout link – no DNS needed. The hosted link works as-is.

The full click-by-click walkthrough – receiving, publish, connecting your domain, and watching a real agent pay over x402 – is in Set up Veto end-to-end (hosted).

See it work – a sandbox test purchase

You don't need a real buyer to prove your store works. From the dashboard Overview, click the Test agent button. A throwaway AI agent discovers your store and buys your product on the sandbox rail – no wallet, no real money – and you get back a real, signed receipt, exactly the shape a live sale produces. It's the whole discover → pay → receipt arc, safe to run as many times as you like.

Sandbox purchases run on the mock facilitator: the full acceptance gate runs and a genuine signed receipt is issued, but no funds move. Flipping to real money is just switching your wallet chain to base and using a live key – nothing about the flow changes. More in Test mode.

The API path (for developers)

Prefer to script it? Every dashboard action is a plain REST call against the hosted platform at https://merchants.veto-ai.com. Grab an API key from Dashboard → Developers – a veto_test_… key for the sandbox (no real money) or a veto_live_… key for real money – and send it as a Bearer token. Prices are always exact decimal strings (e.g. "5.00"), never floats, so money stays exact end to end.

Here's the same three steps – create store → add product → publish – in the language you already use:

API="https://merchants.veto-ai.com"
KEY="veto_test_..."   # veto_live_... for real money

# 1) Create your store → returns { "id": "mrch_..." }
curl -X POST "$API/v1/merchants" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "slug": "acme",
    "name": "Acme Corp",
    "domain": "shop.acme.example",
    "receiving": {
      "x402": {
        "chain": "base-sepolia",
        "address": "0x1111111111111111111111111111111111111111",
        "asset": "USDC"
      }
    }
  }'

# 2) Add a product (use the id from step 1)
curl -X POST "$API/v1/catalog?merchant_id=mrch_..." \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sku": "rpt-001",
    "name": "Market Report",
    "description": "Q3 market intelligence.",
    "price": { "amount": "5.00", "currency": "USD" },
    "available": true
  }'

# 3) Publish – activates the config and rebuilds the discovery manifest
curl -X POST "$API/v1/publish?merchant_id=mrch_..." \
  -H "Authorization: Bearer $KEY"
quickstart.mjs
const API = "https://merchants.veto-ai.com";
const KEY = process.env.VETO_API_KEY; // veto_test_... or veto_live_...

const headers = {
  Authorization: `Bearer ${KEY}`,
  "Content-Type": "application/json",
};

// 1) Create your store
const merchant = await fetch(`${API}/v1/merchants`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    slug: "acme",
    name: "Acme Corp",
    domain: "shop.acme.example",
    receiving: {
      x402: {
        chain: "base-sepolia", // "base" for real money
        address: "0x1111111111111111111111111111111111111111",
        asset: "USDC",
      },
    },
  }),
}).then((r) => r.json());

const merchantId = merchant.id; // mrch_...

// 2) Add a product
await fetch(`${API}/v1/catalog?merchant_id=${merchantId}`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    sku: "rpt-001",
    name: "Market Report",
    description: "Q3 market intelligence.",
    price: { amount: "5.00", currency: "USD" }, // exact decimal string
    available: true,
  }),
});

// 3) Publish
await fetch(`${API}/v1/publish?merchant_id=${merchantId}`, {
  method: "POST",
  headers,
});

console.log("Published:", merchantId);
quickstart.py
import os
import requests

API = "https://merchants.veto-ai.com"
KEY = os.environ["VETO_API_KEY"]  # veto_test_... or veto_live_...
headers = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}

# 1) Create your store
merchant = requests.post(
    f"{API}/v1/merchants",
    headers=headers,
    json={
        "slug": "acme",
        "name": "Acme Corp",
        "domain": "shop.acme.example",
        "receiving": {
            "x402": {
                "chain": "base-sepolia",  # "base" for real money
                "address": "0x1111111111111111111111111111111111111111",
                "asset": "USDC",
            }
        },
    },
).json()

merchant_id = merchant["id"]  # mrch_...

# 2) Add a product
requests.post(
    f"{API}/v1/catalog",
    params={"merchant_id": merchant_id},
    headers=headers,
    json={
        "sku": "rpt-001",
        "name": "Market Report",
        "description": "Q3 market intelligence.",
        "price": {"amount": "5.00", "currency": "USD"},  # exact decimal string
        "available": True,
    },
)

# 3) Publish
requests.post(f"{API}/v1/publish", params={"merchant_id": merchant_id}, headers=headers)

print("Published:", merchant_id)

A veto_test_ key makes a test store on base-sepolia (no real value); a veto_live_ key makes a live store – set chain to base and use your real address. The full sequence – the receiving step broken out, dry-run validation, and connecting your domain – is in Set up Veto end-to-end (hosted), and every endpoint is in the REST API reference.

Or tell your coding agent (MCP)

In Cursor or Claude Code, you don't have to write any of the above yourself – point your agent at the @veto-protocol/mcp-merchant MCP server and describe your shop in plain English. It calls these same endpoints for you.

What happens after you publish

Your store is now live and self-describing. An AI agent discovers it at a single manifest URL, pays you USDC over x402, and you deliver the goods – triggered by a signed webhook on every sale. That whole arc is walked through in How Veto works – discover, pay, deliver.


Prefer to run the checkout on your own servers instead of the hosted platform? That's the advanced self-host path – the @veto-protocol/checkout SDK, the veto CLI, and the create-checkout scaffold – covered in the SDK reference. Most merchants should use the hosted path above.