Agentic payments, x402

Post-quantum private payments for agents, cross-chain, built on STRK20.

Your agent sees the price, pays per call, and gets what it asked for. No sign-up, no API key.

On sale, mainnet. Real funds.

The x402 market watch

0.10 USDCper call on Base, or 1.7 STRK on Starknet, or 0.10 USDC on Solana

The x402 market report, sold per call to your agent.

npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/intel

The first run reads the price and pays nothing.

How it works

One call, three steps

  1. The price. Your agent asks for the resource. The answer is HTTP 402 Payment Required, with the price.
  2. The payment. It pays that price from its own key, on Base or on Starknet.
  3. The receipt. It gets what it asked for, and the payment leaves a receipt.
A terminal. An agent asks for a resource, the answer is HTTP 402 Payment Required, the agent pays, and the screen shows paid.
Pricing

Pay per call, from your own key

Settled on Base, on Solana and on Starknet. Every price below is per call, on mainnet, and your agent reads it in the HTTP 402 before anything is paid.

On sale

The x402 market watch

The x402 market report, sold per call to your agent.

  • Starknet
  • Base
  • Solana

The price is read before you pay. No sign-up, no API key, a receipt anyone can check.

How to buy it

On Starknet

1.7 STRKper call

npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-mainnet/v1/intel

On Base

0.10 USDCper call

npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/intel

On Solana

0.10 USDCper call

PAY_MCP_SVM_KEYPAIR_PATH=~/.config/solana/id.json PAY_MCP_SVM_RPC_URL=<your Solana node> npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-solana-mainnet/v1/intel

Ways to pay

  • Pay in STRKStarknet
  • Pay in USDC from Starknet, to a merchant on BaseStarknet, 0.10 USDC
  • Pay in USDCBase
  • Pay in USDCSolana

On sale

Monthly BTC signal

A BTC signal, sold per call to your agent.

  • Base
  • Solana
  • Starknet

The price is read before you pay. No sign-up, no API key.

Not financial advice.

How to buy it

On Base

0.05 USDCper call

npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/observations/monthly-v1

On Solana

0.05 USDCper call

PAY_MCP_SVM_KEYPAIR_PATH=~/.config/solana/id.json PAY_MCP_SVM_RPC_URL=<your Solana node> npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-solana-mainnet/v1/observations/monthly-v1

On Starknet

1 STRKper call

npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-mainnet/v1/observations/monthly-v1

Ways to pay

  • Pay in USDCBase
  • Pay in USDCSolana
  • Pay in STRKStarknet

What it adds up to

The x402 market watch on Base, at 0.10 USDC per call.

  • 1 call0.10 USDC
  • 100 calls10 USDC
  • 1,000 calls100 USDC

One command. A Base key.

npx -y @vauban-pay/mcp buy key new --network base

First time on Base: buy key new --network base makes your key and prints the address to fund with USDC. Then buy <url>, then the same line with --consent.

You only need USDC on Base (network fees are included in the price): no Starknet account, no node.

On Solana, buy pays from your own keypair and asks your own Solana node for a recent blockhash: the two variables before its command. You need USDC on Solana; network fees are included in the price.

Try it, demo endpoints

Real payments on mainnet, to see the whole flow before your agent buys.

  • Starknet0.5 STRK

    A real mainnet payment, at the price you read before you pay. No sign-up, no API key, a receipt anyone can check.

    • Pay in STRK
    • Pay in USDC from Starknet, to a merchant on Base0.10 USDC
    npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-mainnet/v1/quote
  • Base0.01 USDC

    A real mainnet payment, at the price you read before you pay. No sign-up, no API key, a receipt anyone can check.

    • Pay in USDC
    npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/quote
  • Ethereum1 USDC

    A real mainnet payment, at the price you read before you pay. No sign-up, no API key.

    • Pay in USDC

    https://pay.vauban.tech/x402-ethereum-mainnet/v1/quote

    Pay it with your own x402 client.

The first run of a command reads the price and pays nothing. Run it again with --consent <token>, the token printed by the first run, and it pays exactly that. On Starknet. You need a deployed Starknet account holding STRK. Fund the address buy key newprints; buy key deploy --rpc <node> prints its fee cap and a token; --consent <token> deploys under it.buy contacts no Starknet node unless you name one, with --rpc <url> or STARKNET_RPC_URL; there is no default node. Setup in the package README. Without --private, buy pays the standard option only; the other options, and Ethereum, are not paid by buy (see Terms and notes).

Receipt

Check your receipt

A public payment to our offers on Base, or in STRK on Starknet, leaves a receipt, a public record on Starknet. Check one on the Apodix explorer: it shows what is proven, and what is not.

Sell

Sell to agents. Vauban Pay settles.

Your API answers 402 with the price. Agents pay in USDC. Vauban Pay settles each payment, pays the network fee from your credit, and keeps a cut set at creation: the greater of 2% and twice the factory's fixed settlement cost divided by your price floor (refused above 50%). With the floor of 250000 used below (USDC units, six decimals), the cut is 2%. Live on Base with real USDC, and on Base Sepolia with test money: the steps are the same.

Your server talks to Vauban Pay through the standard x402 library: new HTTPFacilitatorClient({ url }) from @x402/core, with one of the two URLs below. You need Foundry's cast, Node.js 18 or later, and a little ETH on your key on the network you pick (on Base Sepolia, from a faucet listed at docs.base.org/get-started/get-funds). The commands below use the public Base nodes; on Base, your own node is better.

curl -L https://foundry.paradigm.xyz | bash
~/.foundry/bin/foundryup
export PATH="$PATH:$HOME/.foundry/bin"
  1. Pick the network. Paste one of the two blocks in the shell you use for the steps below.
    # Base, real USDC
    export NETWORK=eip155:8453 RPC=https://mainnet.base.org
    export FACILITATOR=https://pay.vauban.tech/x402-tiers-base-mainnet
    export FACTORY=0xbc221E37429E9E65Ae5f925336f8660db2993F65 FEE_PAYER=0xCaE9a2E69F3EB1943d8DA19E33Ae1D1aFB8f9E52
    # Base Sepolia, test money
    export NETWORK=eip155:84532 RPC=https://sepolia.base.org
    export FACILITATOR=https://demo.pay.vauban.tech/x402-tiers-base-sepolia
    export FACTORY=0xe5158E431983271C4d983eDFD67e3012c5c0afA8 FEE_PAYER=0xe75d938C31650c6eC9c164C47777198Cc3721F3b
  2. Your key. This makes it in ~/.foundry/keystores/seller, asks a password, and prints its address. Send your ETH there.
    mkdir -p ~/.foundry/keystores
    cast wallet new ~/.foundry/keystores seller
  3. Your payout contract. Create it on the factory with your price floor, in USDC units (six decimals). It is yours: it receives every payment and splits it. It is the payTo of your offer.
    cast send $FACTORY "creer(uint256)" 250000 --rpc-url $RPC --account seller
    Its address is in the receipt cast prints, under logs: the second topic of the factory's log, last 40 hex digits. Keep it as PAYOUT. To read it again later:
    cast receipt <transactionHash> logs --rpc-url $RPC
    export PAYOUT=0x…
  4. Register it. One request, no account. The answer is 201 with "statut":"inscrit".
    curl -X POST $FACILITATOR/vendeurs/v1/inscription -H 'content-type: application/json' -d "{\"repartiteur\":\"$PAYOUT\"}"
  5. Credit the network fees, on your own. Send ETH from the address that created the contract to the fee payer. Each settlement debits one provision from your credit. A transfer below one provision is refused by name, and ETH sent to the fee payer is not returned. Your level is served at $FACILITATOR/vendeurs/v1/credit/<your address>.
    cast send $FEE_PAYER --value 0.0003ether --rpc-url $RPC --account seller
    Then post that transaction once the network reports its block as safe (too early, the route says so and you retry). One credit per seller, shared by all your payout contracts; when it runs out, settlements are refused by name.
    curl -X POST $FACILITATOR/vendeurs/v1/credit -H 'content-type: application/json' -d '{"vendeur":"0x…","tx":"0x…"}'
  6. Answer 402, let Vauban Pay settle. Your server returns an x402 v2 offer with payTo set to your contract, and hands each payment to the standard client, which verifies it, then settles it. It serves the resource only on a settlement that names a transaction. A complete server:
    // seller.mjs. Once: npm i @x402/core@2.25.0 ; then: node seller.mjs (Node.js 18 or later)
    // Reads NETWORK, FACILITATOR and PAYOUT (your payout contract) from the environment of step 1.
    import { createServer } from "node:http";
    import { HTTPFacilitatorClient } from "@x402/core/server";
    import { SettleError } from "@x402/core/types";
    const { NETWORK, FACILITATOR, PAYOUT } = process.env;
    const USDC = {
      "eip155:8453": { asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", name: "USD Coin" }, // Base
      "eip155:84532": { asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e", name: "USDC" }, // Base Sepolia
    }[NETWORK];
    if (!USDC || !FACILITATOR || !/^0x[0-9a-fA-F]{40}$/.test(PAYOUT ?? "")) throw new Error("set NETWORK, FACILITATOR and PAYOUT");
    // The standard x402 client: it calls /verify and /settle on this URL.
    const facilitator = new HTTPFacilitatorClient({ url: FACILITATOR, timeoutMs: 120_000 });
    const offer = {
      scheme: "exact", network: NETWORK,
      amount: "250000", // your price in USDC units, at least your floor
      asset: USDC.asset, payTo: PAYOUT,
      maxTimeoutSeconds: 120, extra: { name: USDC.name, version: "2" },
    };
    const required = { x402Version: 2, accepts: [offer],
      resource: { url: "http://127.0.0.1:8402/resource", mimeType: "application/json" } };
    const b64 = (v) => Buffer.from(JSON.stringify(v)).toString("base64");
    // A refusal names its reason and no transaction: the agent then knows nothing was paid.
    const refuse = (res, reason) => {
      const r = { success: false, errorReason: reason, transaction: "", network: NETWORK };
      res.writeHead(402, { "PAYMENT-REQUIRED": b64(required), "PAYMENT-RESPONSE": b64(r) });
      res.end(JSON.stringify(r));
    };
    createServer(async (req, res) => {
      const sig = req.headers["payment-signature"];
      if (!sig) { res.writeHead(402, { "PAYMENT-REQUIRED": b64(required) }); return res.end(JSON.stringify(required)); }
      let payload, v;
      try { payload = JSON.parse(Buffer.from(sig, "base64").toString()); } catch { return refuse(res, "invalid_payload"); }
      try {
        v = await facilitator.verify(payload, offer);
      } catch (e) {
        // Verify moves no money: the facilitator could not conclude, the agent may try again later.
        res.writeHead(502); return res.end(JSON.stringify({ error: String(e) }));
      }
      if (v.isValid !== true) return refuse(res, v.invalidReason ?? "verify_refused");
      try {
        const s = await facilitator.settle(payload, offer);
        if (s.success === true && s.transaction) {
          res.writeHead(200, { "content-type": "application/json", "PAYMENT-RESPONSE": b64(s) });
          return res.end(JSON.stringify({ hello: "paid", transaction: s.transaction }));
        }
        if (s.success === false && !s.transaction) return refuse(res, s.errorReason ?? "settle_refused");
        res.writeHead(502); res.end(JSON.stringify({ ...s, doNotPayAgain: true })); // a transaction may exist
      } catch (e) {
        // A named refusal without a transaction moved nothing. A 502 or any other error may come after the payment
        // was sent: never ask to pay again.
        if (e instanceof SettleError && e.statusCode !== 502 && !e.transaction) return refuse(res, e.errorReason ?? "settle_refused");
        res.writeHead(502); res.end(JSON.stringify({ error: String(e), doNotPayAgain: true }));
      }
    }).listen(8402, "127.0.0.1");
  7. Pay it as an agent would. Standard x402 clients pay you without any Vauban code. With ours, on Base Sepolia: try makes a test key on your machine, pays our demo with the test USDC it gets, and prints your address; fund that address with test USDC at faucet.circle.com; then buy reads your price and pays nothing, and the same line with --consent <token> pays it. On Base, buy key new --network base makes the key to fund with USDC.
    npx -y @vauban-pay/mcp try --network base-sepolia
    npx -y @vauban-pay/mcp buy http://127.0.0.1:8402/resource
  8. Collect. It books the split and sends your share to you; Vauban Pay withdraws its cut on its own, and neither withdrawal waits on the other.
    cast send $PAYOUT "retirerVendeur()" --rpc-url $RPC --account seller

Measured by us on 4 November 2026 on Base Sepolia, with our own test seller: contract created, registered, credited through this route, paid by an agent and collected in about a minute and a half; the payment settled in under three seconds.

On Starknet mainnet

Agents pay you in USDC, and the network fees come from a credit you fund in STRK. With the floor of 100000 used below (USDC units, six decimals), the cut is 6.48%. Live on Starknet mainnet with USDC.

The steps take sncast, from Starknet Foundry: the account it makes for you holds your STRK and receives your share in USDC. The commands use the public node that --network mainnet picks; your own node, with --url, is better.

curl --proto '=https' --tlsv1.2 -sSf https://sh.starkup.sh | sh

Then open a new terminal, where sncast --version answers.

  1. Your environment. Paste this block in the shell you use for the steps below.
    # Starknet mainnet, USDC
    export FACILITATOR=https://pay.vauban.tech/x402-tiers-starknet-mainnet
    export FACTORY=0x0165c2b685252d116a8a36ed853e8894f26b564cb4b83a274bc483a54879bf58
    export FEE_PAYER=0x026e0f4c5e493494ae7102aebce364fa67d7d88910a7d74d3e956a06e4c4e520
    export STRK=0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d
  2. Your account. This makes a Starknet account named seller, keeps its key in ~/.starknet_accounts/, and prints its address and the fee to deploy it.
    sncast account create --network mainnet --name seller
    Send STRK to that address, then deploy it. Keep the address as SELLER.
    sncast account deploy --network mainnet --name seller
    export SELLER=0x…
  3. Your payout contract. Create it on the factory with your price floor, in USDC units, written as two numbers (the floor, then 0). It is yours: it receives every payment and splits it. It is the payTo of your offer.
    sncast --account seller invoke --network mainnet --contract-address $FACTORY --function creer --calldata 100000 0
    Then read its address, printed as ContractAddress(0x…), and keep it as PAYOUT:
    sncast call --network mainnet --contract-address $FACTORY --function repartiteur_de --calldata $SELLER 100000 0
    export PAYOUT=0x…
  4. Register it. One request, no account. The answer is 201 with "statut":"inscrit".
    curl -X POST $FACILITATOR/vendeurs/v1/inscription -H 'content-type: application/json' -d "{\"repartiteur\":\"$PAYOUT\"}"
  5. Credit the network fees, on your own. Send STRK from your seller account to the fee payer. Each settlement debits one provision from your credit. A transfer below one provision is refused by name, and STRK sent to the fee payer is not returned. The line below sends one STRK (amounts in fri, 18 decimals).
    sncast --account seller invoke --network mainnet --contract-address $STRK --function transfer --calldata $FEE_PAYER 1000000000000000000 0
    Then post that transaction once Starknet reports its block as accepted on L1 (ACCEPTED_ON_L1), a few hours after the transfer (2 h 25 min on 8 November 2026); too early, the route says so and you retry. One credit per seller, shared by all your payout contracts.
    curl -X POST $FACILITATOR/vendeurs/v1/credit -H 'content-type: application/json' -d "{\"vendeur\":\"$SELLER\",\"tx\":\"0x…\"}"
    Your credit reads at $FACILITATOR/vendeurs/v1/credit/<your address>: its field palier gives the settlements it still covers, as a range, 0, 1-10 or plus-de-10. At 0, settlements are refused by name: top it up with a new transfer, posted the same way.
    curl $FACILITATOR/vendeurs/v1/credit/$SELLER
  6. Answer 402, let Vauban Pay settle. A request without payment gets 402 and the header PAYMENT-REQUIRED: the base64 of {"x402Version":2,"accepts":[<the offer>],"resource":{"url":"<your URL>","mimeType":"application/json"}}. The offer, with payTo set to your contract and a price of at least your floor:
    {
      "scheme": "exact",
      "network": "starknet:SN_MAIN",
      "amount": "100000",
      "asset": "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb",
      "payTo": "<PAYOUT>",
      "maxTimeoutSeconds": 300,
      "extra": { "feePayer": "0x026e0f4c5e493494ae7102aebce364fa67d7d88910a7d74d3e956a06e4c4e520" }
    }
    A request with the header PAYMENT-SIGNATURE carries a payment, in base64. Your server posts it, decoded, with the offer, first to verify (the answer says "isValid": true), then to settle. It serves the resource only on a settlement with "success": true that names a transaction, and returns that settlement, in base64, in the header PAYMENT-RESPONSE.
    POST $FACILITATOR/starknet/v1/verify
    POST $FACILITATOR/starknet/v1/settle
    { "x402Version": 2, "paymentPayload": <the decoded PAYMENT-SIGNATURE>, "paymentRequirements": <the offer> }
    A settlement with "success": false and no transaction moved nothing. Any other answer may have paid: never ask to pay again.
  7. Pay it as an agent would. With ours, @vauban-pay/mcp 0.21.0 or later (Node.js 22 or later), an agent pays it from a Starknet account it already has, deployed and holding USDC: buy key import keeps that account and reads its key from the standard input, never from an argument. Then buy reads your price and pays nothing, and the same line with --consent <token> pays it.
    npx -y @vauban-pay/mcp buy key import --address 0x…
    npx -y @vauban-pay/mcp buy <your URL>
    npx -y @vauban-pay/mcp buy <your URL> --consent <token>
  8. Collect. It books the split and sends your share to you; Vauban Pay withdraws its cut on its own, and neither withdrawal waits on the other.
    sncast --account seller invoke --network mainnet --contract-address $PAYOUT --function retirer_vendeur

On Solana mainnet

Agents pay you in USDC, and the network fees of each settlement are covered by Vauban Pay's fee payer: nothing to fund, the cut carries that cost. With the floor of 100000 used below (USDC units, six decimals), the cut is 2.84%. Live on Solana mainnet with USDC.

Your payout account is an account of the program, derived from your key and your price: it receives every payment and splits it. The key steps take the Agave tool suite; creating the payout account and collecting are two calls to the program that no published client builds yet, so their wire contract is given, for the Solana SDK of your choice.

sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"

Then open a new terminal, where solana --version answers.

  1. Your environment. Paste this block in the shell you use for the steps below.
    # Solana mainnet, USDC
    export FACILITATOR=https://pay.vauban.tech/x402-solana-mainnet-tiers
    export PROGRAM=95Tg5wFuE4EKxw1vVfMnyUmfqHPPS916FcYKkcXNTDiS
    export USDC=EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
    export FEE_PAYER=6am1GDzghJGK3vFSwbr9D1WyAXZjsYSqjGxC1dXckGU
  2. Your key. This makes a Solana key in seller.json and prints its address. Keep the address as SELLER. Send it some SOL: creating your payout account and collecting are transactions this key pays for, with their rent.
    solana-keygen new -o seller.json
    solana address -k seller.json
    export SELLER=<the address printed>
  3. Your payout account. One instruction to the program, signed by your key, with your price floor in USDC units. It creates your payout account, the program account derived from your key and that price, and its USDC vault. The address of the payout account is the payTo of your offer; keep it as PAYOUT.
    program: $PROGRAM
    payout account: the program address derived from ["caisse", SELLER, price as u64 little-endian]
    data: [0] ++ price as u64 little-endian ++ bump of the payout account (u8)
    accounts, in this order:
      1. SELLER (signer, writable)
      2. the payout account (writable)
      3. the USDC associated token account of the payout account (writable; its vault)
      4. $USDC (the mint)
      5. 11111111111111111111111111111111 (System program)
      6. TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA (SPL Token program)
      7. ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL (Associated Token program)
    The program refuses a price whose cut would be above its ceiling: at the floor used here it is accepted.
  4. Register it. One request, no account. The answer is 201 with "statut":"inscrite".
    curl -X POST $FACILITATOR/vendeurs/v1/inscription -H 'content-type: application/json' -d "{\"caisse\":\"$PAYOUT\"}"
  5. Answer 402, let Vauban Pay settle. A request without payment gets 402 and the header PAYMENT-REQUIRED: the base64 of {"x402Version":2,"accepts":[<the offer>],"resource":{"url":"<your URL>","mimeType":"application/json"}}. The offer, with payTo set to your payout account and a price of at least your floor:
    {
      "scheme": "exact",
      "network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
      "amount": "100000",
      "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "payTo": "<PAYOUT>",
      "maxTimeoutSeconds": 60,
      "extra": { "feePayer": "6am1GDzghJGK3vFSwbr9D1WyAXZjsYSqjGxC1dXckGU" }
    }
    A request with the header PAYMENT-SIGNATURE carries a payment, in base64. Your server posts it, decoded, with the offer, first to verify (the answer says "isValid": true), then to settle. It serves the resource only on a settlement with "success": true that names a transaction (its signature, in base58), and returns that settlement, in base64, in the header PAYMENT-RESPONSE. The offer gives the buyer sixty seconds.
    POST $FACILITATOR/svm/v1/verify
    POST $FACILITATOR/svm/v1/settle
    { "x402Version": 2, "paymentPayload": <the decoded PAYMENT-SIGNATURE>, "paymentRequirements": <the offer> }
    A settlement with "success": false and no transaction moved nothing. Any other answer may have paid: never ask to pay again.
  6. Pay it as an agent would. With ours, @vauban-pay/mcp 0.21.0 or later (Node.js 22 or later), an agent pays it from a Solana key it already has, holding USDC and needing no SOL: the key file and the node it reads are given by PAY_MCP_SVM_KEYPAIR_PATH and PAY_MCP_SVM_RPC_URL. Then buy reads your price and pays nothing, and the same line with --consent <token> pays it.
    export PAY_MCP_SVM_KEYPAIR_PATH=<your key file>
    export PAY_MCP_SVM_RPC_URL=<your node>
    npx -y @vauban-pay/mcp buy <your URL>
    npx -y @vauban-pay/mcp buy <your URL> --consent <token>
  7. Collect. One instruction to the program, sent by any key: it books the split and sends your share to your USDC account; the share always goes to you. If your USDC account does not exist yet, put the Associated Token program's create-idempotent instruction for it before this one, in the same transaction; the program does not create it. Vauban Pay withdraws its cut on its own.
    program: $PROGRAM
    data: [2]
    accounts, in this order:
      1. the payout account (writable)
      2. its USDC vault (writable)
      3. your USDC associated token account (writable; must exist: create it first, in the same transaction, with the Associated Token program)
      4. $USDC (the mint)
      5. TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA (SPL Token program)
Try it

Try it on your chain

Your agent buys per call, on Starknet, Base, Solana or Polygon. No sign-up, no subscription, one command: it makes a test key on your machine and pays with test money. Why: the price is read before anything is paid, and the payment is a plain transfer on the rail your agent already holds a key for.

  • Starknet

    • Starknet Sepoliatestnet

      One command pays a test call. Test money, no real value.

      npx -y @vauban-pay/mcp try --network starknet-sepolia

      43 s to the first payment, measured cold on 22 October 2026.

      Then, from the same key: a research observation, 0.01 STRK per call. Test money.

      npx -y @vauban-pay/mcp buy https://demo.pay.vauban.tech/starknet/v1/observations/pol-usdc-taker-flow-15m-v1

      95 research observations, per call, 0.01 STRK each. Test money, no real value. Not financial advice. No return is promised.

      The full list of the 95 observations, with the price and the URL of each.

      Also served here, for your own x402 client: the x402 market watch.

    • Starknet mainnetmainnet

      The x402 market watch, 1.7 STRK per call.

      npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-mainnet/v1/intel

      Monthly BTC signal, 1 STRK per call.

      npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-mainnet/v1/observations/monthly-v1
  • Base

    • Base Sepoliatestnet

      One command pays a test call. Test money, no real value.

      npx -y @vauban-pay/mcp try --network base-sepolia

      7 to 9.1 s to the first payment, measured cold on 28 October 2026.

      Then, from the same key: a research observation, 0.02 USDC per call. Test money.

      npx -y @vauban-pay/mcp buy https://demo.pay.vauban.tech/x402-base-sepolia/v1/observations/btc-usdc-realized-vol-15m-v1

      95 research observations, per call, 0.02 USDC each. Test money, no real value. Not financial advice. No return is promised.

      The full list of the 95 observations, with the price and the URL of each.

    • Base mainnetmainnet

      The x402 market watch, 0.10 USDC per call.

      npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/intel

      Monthly BTC signal, 0.05 USDC per call.

      npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-base-mainnet/v1/observations/monthly-v1
  • Solana

    • Solana devnettestnet

      One command pays the x402 market watch. Test money, no real value.

      npx -y @vauban-pay/mcp try --network solana-devnet

      Then, from the same key: Monthly BTC signal, 0.05 USDC per call. Test money.

      npx -y @vauban-pay/mcp buy https://demo.pay.vauban.tech/x402-solana-devnet/v1/observations/monthly-v1

      Then, from the same key: a research observation, 0.02 USDC per call. Test money.

      npx -y @vauban-pay/mcp buy https://demo.pay.vauban.tech/x402-solana-devnet/v1/observations/sol-usdc-drawdown-1h-v1

      95 research observations, per call, 0.02 USDC each. Test money, no real value. Not financial advice. No return is promised.

      The full list of the 95 observations, with the price and the URL of each.

    • Solana mainnetmainnet

      The x402 market watch, 0.10 USDC per call.

      PAY_MCP_SVM_KEYPAIR_PATH=~/.config/solana/id.json PAY_MCP_SVM_RPC_URL=<your Solana node> npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-solana-mainnet/v1/intel

      Monthly BTC signal, 0.05 USDC per call.

      PAY_MCP_SVM_KEYPAIR_PATH=~/.config/solana/id.json PAY_MCP_SVM_RPC_URL=<your Solana node> npx -y @vauban-pay/mcp buy https://pay.vauban.tech/x402-solana-mainnet/v1/observations/monthly-v1
  • Polygon

    • Polygon Amoytestnet

      One command pays a test call. Test money, no real value.

      npx -y @vauban-pay/mcp try --network polygon-amoy

      Then, from the same key: Monthly BTC signal, 0.05 USDC per call. Test money.

      npx -y @vauban-pay/mcp buy https://demo.pay.vauban.tech/x402-polygon-amoy/v1/observations/monthly-v1

Bring no wallet. No sign-up. Test money only on a test network. It makes a test key on your machine.

Mainnet

Pay in private, on Starknet mainnet

An offer can list a private entry beside its public ones. --private pays that entry instead, in USDC, from a card this command creates on your machine.

With --fund-from-account, your own Starknet account creates and funds the card in one transaction. It must be deployed and must hold USDC and STRK of that network. On Starknet mainnet this is the only way: add --fund-from-account.

You need Node.js 24.7 or later, and a node of the offer's network that you name with --rpc or STARKNET_RPC_URL (https).

The first time, it takes four lines, in this order:

npx -y @vauban-pay/mcp buy <url> --private --fund-from-account --rpc <your node>
npx -y @vauban-pay/mcp buy <url> --private --fund-from-account --rpc <your node> --consent <token>
npx -y @vauban-pay/mcp buy <url> --private --fund-from-account --rpc <your node> --consent <token> --accept-notice
npx -y @vauban-pay/mcp buy <url> --private --fund-from-account --rpc <your node> --consent <token> --accept-notice --recovery-file-saved <code>
  1. Reads the offer and prints the price, what the card takes from your account, and a consent token, the <token> of the next lines. Nothing is sent.
  2. Prints the notice of the service that prepares the payment, and stops. Nothing is sent.
  3. Accepts that notice, makes the card's keys, writes its recovery file, prints its path and a code, and stops. Nothing is sent.
  4. Once you have kept that file: creates and funds the card from your account, then pays.

With --fund-from-account, the first line also prints what the first payment takes from your account (the deposit, the STRK reserve, the bound on the fee of the creating transaction, and the most STRK in all), and its consent token carries those caps.

The offers that list this entry, for <url>:

  • Monthly BTC signal: https://pay.vauban.tech/x402-mainnet/v1/observations/monthly-v1
  • A demo call: https://pay.vauban.tech/x402-mainnet/v1/quote

Setup in the package README.

Also

What else Vauban Pay does

Each of these has run on mainnet.

  • Pay on Starknet, the merchant is paid on Base.

    A payment, settled on mainnet.

  • Move USDC from Base to Starknet.

    A transfer, settled on mainnet.

  • Private payments on STRK20.

    Private USDC payments on Starknet mainnet.