endpoint.farm_ ALPHA v0.0.1

Get started

Two ways in: sell an endpoint as a provider, or call a paid endpoint as a buyer or agent. No accounts or API keys for buyers — payment is the auth.

I want to sell an endpoint I want to call one

How payment works

Every paid endpoint runs on one open standard: x402. It turns HTTP's long-unused 402 Payment Required response into a real, machine-payable paywall — no accounts, no API keys, no invoices. The payment is the access token. Here is exactly what happens in a single paid call.

  1. The agent calls your URL. An ordinary HTTP request, with no payment attached.
  2. The relay answers 402 with a price quote. Instead of the result, it returns the price and exactly where to pay — Base or Stellar, in USDC, to an on-chain splitter contract.
  3. The agent signs a payment — it doesn't send one. Its wallet signs an authorization for that exact amount to that exact splitter (an EIP-3009 authorization on Base, a Soroban authorization on Stellar). Signing is gasless: nothing is broadcast, no ETH or XLM is spent. The signed authorization goes into an X-PAYMENT header and the request is repeated.
  4. We settle it on-chain in one transaction. Our facilitator verifies the signature and submits a single call to the splitter contract, paying the gas itself. The splitter atomically moves the buyer's USDC — your price to your wallet, the fee to endpoint.farm — in the same transaction. We never receive your share; the contract routes it directly.
  5. Only then do we deliver. With payment settled, the relay forwards the original request to your real API and returns its response, plus an X-PAYMENT-RECEIPT header proving what was paid.
The quote for a $0.10 call
Provider price$0.10
Protocol fee (10%)+$0.01
Buyer pays$0.11
Provider receives$0.10

Why it's built this way

  • No accounts, for anyone. Buyers pay per call with a wallet; providers never run billing, invoicing, or Stripe.
  • Non-custodial by design. The payTo in every quote is an immutable splitter contract — not us, and not directly the provider — so your revenue is never held by endpoint.farm.
  • Gasless for the payer. The buyer only signs; we broadcast and pay the gas. The buyer spends USDC and nothing else.

USDC is quoted in atomic units as strings — 6 decimals on Base, 7 on Stellar — so 110000 means $0.11. Base fits the EVM / Coinbase ecosystem; Stellar's near-zero fees make sub-cent, high-frequency calls actually economical. Today everything runs on testnet (Base Sepolia + Stellar testnet) with test USDC; the identical flow switches to mainnet at go-live.

For providers — sell an endpoint

Point us at an API or MCP server you already run. We mint a paid, agent-callable x402 URL in front of it and settle USDC straight to your wallet. Listing is free; you keep 100% of your price.

1

Sign in

No password. Request a magic link from the login page and you're in.

2

Add a payout wallet

In the dashboard, add the Base (0x…) or Stellar (G…) wallet you want paid to. Bring your own — we never custody it.

3

Create the endpoint

Give us the origin URL + method, set a price per call, and pick Base, Stellar, or both. It starts as a draft.

4

Publish & get paid

Publish to mint the live URL (and optionally list it in the marketplace). Agents call and pay; the on-chain splitter settles your price to your wallet.

Wrapping an API

The relay forwards each paid call to your origin and returns its response unchanged. Your real endpoint never sees a payment — it only sees a normal request after settlement clears. Your live URL looks like:

https://api.endpoint.farm/r/<your-slug>/<endpoint-slug>

Wrapping an MCP server

Wrap a Streamable-HTTP MCP server and price each tool independently. The agent pays per tools/call; free methods like tools/list, initialize, and pings pass through untouched. The MCP endpoint looks like:

https://api.endpoint.farm/m/<your-slug>/<server-slug>

Create one from the dashboard (the MCP server tab in "Create an endpoint") or over the provider automation API — see the API reference.

How pricing works

You set the price per call and keep all of it. endpoint.farm adds a flat 10% protocol fee on top (minimum $0.005 per call), paid by the buyer — not taken from your revenue. Every 402 shows the full breakdown: your price, the fee, the total, your wallet, and the splitter. See the profit calculator.

How you get paid

Settlement is non-custodial and automatic — there's nothing to claim or withdraw. Every paid call settles on-chain through an immutable splitter that sends your price to your wallet and the fee to endpoint.farm in one atomic transaction. Provider revenue is never held by endpoint.farm.

  • Bring a wallet that can receive USDC on each chain you accept — a Base address (0x…) and/or a Stellar account (G…).
  • Stellar needs a USDC trustline. The receiving account must trust the USDC asset or the transfer can't land — add it once in your wallet before going live.
  • Payment arrives per call. USDC shows up in your wallet the moment a call settles; no batching, no payout schedule, no minimum.
  • Testnet today. You'll receive test USDC on Base Sepolia / Stellar testnet while we're in beta; mainnet payouts switch on at go-live with no change on your side.

For buyers & agents — call a paid endpoint

Paying is the auth. There are no accounts or API keys — you call the URL, get a price, sign an x402 payment, and call again. The flow is plain HTTP, so any client that can set headers can pay.

1

Call the URL

Make a normal request to the relay URL. If it's a paid endpoint you'll get an HTTP 402 Payment Required instead of the result.

2

Read the price

The 402 carries a PAYMENT-REQUIRED header (and JSON body) listing every route you can pay on — network, asset, amount, and the splitter to pay.

3

Pay & retry

Sign a USDC payment for one route, base64url-encode it into an X-PAYMENT header, and resend. You get the result plus an X-PAYMENT-RECEIPT.

1 · The 402 you get back

The accepts array lists one entry per (scheme, network) the endpoint supports. Amounts are atomic USDC strings. payTo is the immutable on-chain splitter, never a wallet we control.

HTTP/1.1 402 Payment Required PAYMENT-REQUIRED: <base64url JSON> { "x402Version": 1, "error": "payment required", "accepts": [ { "scheme": "exact", "network": "eip155:8453", "maxAmountRequired": "110000", "resource": "https://api.endpoint.farm/r/acme/weather", "asset": "0x…USDC", "payTo": "0x…splitter", "expiresAt": "2026-06-05T12:00:00+00:00", "extra": { "providerAmount": "100000", "feeAmount": "10000", "assetDecimals": 6 } } ] }

2 · Pay and call again

Pick one accepts entry, sign the USDC transfer for that network (EIP-3009 on Base, a Soroban authorization on Stellar), then base64url-encode {network, payload} into the X-PAYMENT header and repeat the request.

GET /r/acme/weather HTTP/1.1 Host: api.endpoint.farm X-PAYMENT: <base64url {"network":"eip155:8453","payload":…}> → HTTP/1.1 200 OK X-PAYMENT-RECEIPT: <base64url settlement receipt> { …your API's normal response… }

The inner payload on Base carries the signed split and routing — the signature binds these exact values so it can't be replayed or re-pointed at a different payee:

{ "from": "0x…payer", "provider": "0x…provider wallet", "providerAmount": "100000", "feeAmount": "10000", "total": "110000", "paymentConfigVersion": 1, "validAfter": 0, "validBefore": 1749124800, "payerSalt": "0x…", "signature": "0x…" }

We verify, settle on-chain, and only then forward to the origin — your call is never released before payment clears.

Signing it

The signature is over a routing-bound digest (the split, the config version, the validity window, and a per-payment salt), so producing it correctly is fiddly by hand. A first-party SDK that builds the payload, signs, and handles the 402 retry for you is on the way — until it ships, buyer integration is hands-on and we'll help you wire it up. Stellar uses the same envelope with a Soroban authorization entry in place of the Base signature.

Browse the marketplace