# send21 > send21 is a non-custodial payment-draft platform for BTC, USDC, USDT, EURC, SOL, and ETH (on Bitcoin, > Lightning, Solana, Ethereum, Base, Arbitrum, and Polygon) with a first-class REST API for AI agents. Agents create payment drafts (fixed > amount or fiat-pegged with a locked exchange rate). The sender pays from their own wallet > (PSBT-enabled for multi-output drafts: Bitcoin Core, Sparrow, Electrum). send21 is software > that prepares payment instructions only. It is not a custodian, exchange, broker, or payment > service provider. It never holds private keys or funds, never signs, and never broadcasts or > executes transactions. Signing and broadcasting always happen in the sender's wallet. Key facts for agents: - Base URL: `https://send21.io/api/v1` - OpenAPI spec: `https://send21.io/swagger/v1/swagger.json` (UI at `/swagger`, aliases `/openapi.json`, `/swagger.json`) - MCP server: `https://send21.io/mcp` (listed on Smithery: https://smithery.ai/servers/send21io/mcp and Glama: https://glama.ai/mcp/servers/send21io/mcp), Streamable HTTP, stateless. Authenticate with the same `Authorization: Bearer s21_` header. Tools: create_draft, get_draft, get_draft_status, get_transaction_template, create_payment_request, get_payment_request, list_address_book, get_rate, get_fee_schedule. tools/list and get_fee_schedule work without a key; every other tool call requires one. - Supported assets: BTC native on Bitcoin (on-chain). BTC over Lightning: pass the receiver's Lightning address (name@wallet.com) as `receiverAddress` with `paymentMethod: "Lightning"`; send21 fetches the invoice and confirms the payment when the provider supports LUD-21 (`lightningConfirmable` on the draft). USDC, USDT, and EURC as tokens on BOTH Solana and Ethereum. USDC and EURC also on Base (EIP-681 chain id 8453). Native USDC (not bridged USDC.e) on Arbitrum (`Arbitrum`, chain id 42161) and Polygon (`Polygon`, chain id 137). Native SOL on Solana (`currency: "Sol"`, 9 decimals, amounts in lamports). Native ETH on Ethereum, Base and Arbitrum (`currency: "Eth"`; amounts in gwei, 9 decimals; payment links carry the value in wei). Payments from plain wallets and smart wallets are both detected. Wrapped BTC on Solana (Portal) and Ethereum (WBTC). When a checkout offers the same currency on several networks, pass `network` in `POST /checkout/{token}/select`. - Auth: `Authorization: Bearer s21_`, scoped API keys created by a human account owner - Scopes: `drafts:read`, `drafts:write`, `addressbook:read`, `addressbook:write`, `webhooks:manage` - Idempotency: send an `Idempotency-Key` header on `POST /drafts`. Identical keys return the same draft - Batch: `POST /drafts/batch` accepts up to 25 drafts per call with per-item results - Recurring: `POST /recurring-templates` generates drafts daily/weekly/monthly automatically - Status: poll `GET /drafts/{id}/status` or register HMAC-SHA256 signed webhooks with `POST /webhooks` (scope `webhooks:manage`; the signing secret is returned once). Each delivery is a POST with body `{"event": "", "data": {...}}` and headers `X-Send21-Event`, `X-Send21-Delivery` (unique id, reused on retries) and `X-Send21-Signature: sha256=` (HMAC-SHA256 of the raw body with your secret). Any 2xx counts as delivered; otherwise up to 8 attempts with growing delays. Events: draft.created, draft.seen, draft.confirmed, draft.amount_mismatch, draft.expired, draft.cancelled, and test. Full guide with payloads in the Webhooks section at `https://send21.io/swagger`. - draft.amount_mismatch: a transfer within 10% of the billed amount arrived at the receiver address, but not the exact amount. It does not pay the draft until the owner calls `POST /drafts/{id}/accept-received`. Example `data`: `{"draftId":"3f6c2a9e-...","status":"AwaitingPayment","txId":"5KqZ9bQ...","confirmations":1, "receivedAmountSats":49250000,"receivedAmount":"49.250000","sentCurrency":"USDC","network":"Solana", "amountSats":50000000,"sentAmount":"50.000000","fiatCurrency":"EUR","fiatAmount":46.00, "conversionRate":0.92,"rateSource":"coinbase","platformFee":{"accrued":true,"waived":false, "percent":0.39,"feeUsd":0.20,"feeBaseUnits":195000,"feeAmount":"0.195000","currency":"USDC"}, "paymentRequestId":"8d1e4b7a-...","orderId":"ORDER-1042","occurredAt":"2026-10-06T08:22:22Z"}`. draft.seen and draft.confirmed carry the same fields; receivedAmountSats is set only when the amount differs. After the owner accepts it, draft.seen arrives with acceptedByOwner: true and draft.confirmed follows as usual, also with receivedAmountSats set. - Payment instructions: `GET /drafts/{id}/tx-template` returns a multi-output template (receiver gets the exact billed amount, the platform fee is a separate transparent output) as Bitcoin Core `walletcreatefundedpsbt` arguments and Electrum/Sparrow pay-to-many CSV - Checkout: `POST /payment-requests` creates fiat-priced, multi-currency (BTC/USDC/USDT/EURC/SOL/ETH, and BTC over Lightning) pay links. The payer scans one standard QR (BIP-21 / Solana Pay / EIP-681) and sends a single transfer, which works with any wallet and needs no PSBT. Supports `Idempotency-Key` for safe retries. - Shopify: there is no send21 app in the Shopify App Store. A merchant creates their own custom Shopify app that connects the store to send21 (reference code and help from integration@send21.io). It adds a manual payment method with automatic order reconciliation (order marked paid on the draft.confirmed webhook). See `https://send21.io/business#shopify` - Fiat pricing: 165 world currencies (the full active ISO 4217 set) with locked exchange rates and recorded quote provenance on every draft - Fees: tiered by USD value at creation (0.49% under $10 down to 0.01% above $100k, min $0.01, max $100, sub-dust fees waived up to 5 times per account per day, then accrued). Priced in USD, displayed in the draft's fiat currency too. On multi-output drafts the fee is a separate transparent output. On single-output payments (checkout pay links, payment requests, single-output drafts) it ACCRUES to the creator's account instead. Check `GET /fees/accrued`, settle with `POST /fees/accrued/settle` (BTC, USDC, USDT, EURC, SOL, or ETH; ETH settles on Ethereum only). Creation returns 402 once the accrued balance reaches the USD cap or the oldest unsettled fee exceeds the age limit. Public schedule: `GET /api/v1/fees/schedule`. Per-draft breakdown incl. estimated network fee: `GET /drafts/{id}/fees` - Wallet support: multi-output drafts need a PSBT-enabled wallet (Bitcoin Core, Sparrow, Electrum). Checkout pay links and single-output drafts work with any QR-scanning wallet - Rate limits: 300 requests/min per API key, 429 on breach. Prefer webhooks over polling - Testnet demo: `https://send21.io/demo` is an anonymous end-to-end demo on Bitcoin Testnet4/Signet, Solana Devnet, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia, and Polygon Amoy (no key, no account, no mainnet value). Test assets: tBTC, test USDC and EURC, and native test SOL and ETH. On send21.io the test networks are reserved for this demo; account drafts and API keys use the live networks. A self-hosted send21 can enable the test network values (`Testnet4`, `Signet`, `SolanaDevnet`, `EthereumSepolia`, `BaseSepolia`, `ArbitrumSepolia`, `PolygonAmoy`). - Zero custody: the platform never handles private keys, seeds, or signing material, and never broadcasts or executes transactions. Never ask users for keys. Anything that does is an attack. - Privacy (GDPR): minimal personal data (email, optional display name), encrypted at rest. No KYC, no tracking, no analytics. Erasure/access requests: privacy@send21.io - Contact: integration@send21.io (API/integration questions), support@send21.io (account or payment issues), privacy@send21.io (GDPR/data requests), info@send21.io (general) ## Docs Every page below is plain Markdown. All of them in one file: [llms-full.txt](https://send21.io/llms-full.txt). - [API quickstart](https://send21.io/docs/quickstart.md): API keys, payment requests, drafts, status, idempotency - [Webhooks](https://send21.io/docs/webhooks.md): events, example payloads, retries, signature checks - [MCP server](https://send21.io/docs/mcp.md): connect an AI agent, tool list and scopes - [Currencies and networks](https://send21.io/docs/currencies.md): assets per network, decimals, chain ids, confirmations - [Lightning](https://send21.io/docs/lightning.md): Lightning-address invoices confirmed via LUD-21 - [OpenAPI specification](https://send21.io/openapi.json): every endpoint and schema (JSON) ## Guides - [Accept USDC and EURC payments](https://send21.io/accept-usdc-payments.md) - [Crypto payment links in your own currency](https://send21.io/crypto-payment-links.md) - [Lightning address payments](https://send21.io/lightning-address-payments.md) - [Payments for AI agents](https://send21.io/ai-agent-payments.md) - [Accept ETH on Ethereum, Base and Arbitrum](https://send21.io/accept-eth-payments.md) - [Pricing](https://send21.io/pricing.md): one fee per payment, 0.49% down to 0.01%, capped at $100 ## Optional - [send21 vs BTCPay Server](https://send21.io/compare/btcpay-server.md) - [send21 vs hosted crypto gateways](https://send21.io/compare/hosted-crypto-gateways.md) - [About send21](https://send21.io/about.md) - [Business checkout](https://send21.io/business.md) ## Typical agent flow 1. `POST /api/v1/drafts` with receiver address + amount (+ `Idempotency-Key`) 2. Fetch `GET /drafts/{id}/tx-template` and hand it to the human/wallet that holds the funds 3. Receive `draft.seen` / `draft.confirmed` webhooks (verify the HMAC signature) 4. Reconcile using the exact sat amount and txid # Payment drafts & pay links. Zero custody. Built for humans and AI agents. send21 creates clean, verifiable payment instructions for BTC, USDC, USDT, EURC, SOL, and ETH across Bitcoin, Lightning, Solana, Ethereum, Base, Arbitrum, and Polygon. Funds move directly from the sender's own wallet to the receiver. send21 never touches keys or coins. [Get started](https://send21.io/login?mode=register) [Developer docs](https://send21.io/docs) Works with any wallet that scans a QR code | Batched drafts for PSBT wallets (Bitcoin Core, Sparrow, Electrum) ## Non-custodial by structure, not by promise ### Your keys never leave your wallet send21 has no hot wallets, stores no private keys, and contains no signing code. A full server compromise cannot move a single satoshi. ### Receiver gets the exact amount Multi-output drafts carry the send21 fee as a separate transparent output. Single-output payments carry no fee at all, because it accrues to the creator's account instead. Either way the receiver gets the exact billed amount and your wallet sets the network fee. ### Fiat-pegged or exact amount Bill in any of **165 world currencies**, from USD, EUR and SEK to NGN and VND, with a locked, recorded exchange rate. Or set an exact amount in BTC, USDC, USDT, EURC, SOL, or ETH. Full quote provenance on every payment. ## How a payment flows ### 1. Draft A human or agent creates a draft: receiver address, amount (exact or fiat-pegged), currency and network, memo. ### 2. Sign in your wallet The sender scans one QR code with any wallet and sends. Senders with a PSBT wallet (Bitcoin Core, Sparrow, Electrum) can instead load a batched template, review every output, and sign. send21 is never in the money path. ### 3. Confirmed send21 watches the receiver address and fires signed webhooks and email as the payment is seen and confirmed. ### Supported currencies & networks | Network | Currencies | | --- | --- | | Bitcoin on-chain | BTC | | Lightning to a Lightning address | BTC | | Solana | USDC USDT EURC SOL Wrapped BTC | | Ethereum | USDC USDT EURC ETH WBTC | | Base | USDC EURC ETH | | Arbitrum | USDC (native) ETH | | Polygon | USDC (native) | Every combination works for drafts and payment requests, priced in any of 165 world currencies, with the rate locked when the payer picks a currency. Fees can be settled in any of them except Lightning, and in ETH on Ethereum only. For Lightning, send21 fetches the invoice from the receiver's Lightning address and confirms the payment when their wallet provider supports it (LUD-21). ## Payment drafts AI agents can actually use Everything a human does in the UI, an agent can do over REST. Scoped API keys let an agent create and track drafts, but no key can move funds. Nobody can. ### Scoped API keys `drafts:write`, `drafts:read`, `webhooks:manage`. Grant only what the agent needs. ### Idempotent + batch creation Retry-safe `Idempotency-Key` support and batch endpoints for up to 25 drafts per call. ### Recurring templates Daily, weekly, or monthly drafts generated automatically. Subscriptions without custody. ### Checkout pay links `POST /payment-requests` creates fiat-priced, multi-currency (BTC / USDC / USDT / EURC) pay links with a hosted QR pay page. ### Signed webhooks HMAC-SHA256 signed status events (`draft.seen`, `draft.confirmed`, and more) instead of polling. ### MCP server built in Point any MCP client at `https://send21.io/mcp` with your API key and get tools for drafts, pay links, rates, and fees. No wrapper needed. ### Create a draft in one call ``` curl -X POST https://send21.io/api/v1/drafts \ -H "Authorization: Bearer s21_yourkey" \ -H "Idempotency-Key: invoice-2026-001" \ -H "Content-Type: application/json" \ -d '{ "receiverAddress": "bc1q...", "network": "Mainnet", "paymentMethod": "MultiOutput", "fiatCurrency": "USD", "fiatAmount": 50.00, "memo": "Invoice 2026-001" }' ``` ### The full agent payment flow agent -> **create draft** -> **fetch tx template** -> fund & sign in own wallet -> broadcast -> **webhook: draft.confirmed** #### Authenticate Send a scoped API key as `Authorization: Bearer s21_...`. Grant only the scopes the agent needs (`drafts:write`, `drafts:read`, `webhooks:manage`). No scope can ever move funds. #### Create the draft `POST /api/v1/drafts` with the receiver address and either an exact `amountSats` or a fiat-pegged `fiatCurrency` + `fiatAmount`. Include an `Idempotency-Key` header so retries are safe and return the same draft. #### Read the rate lock & fee The response contains the exact receiver amount (`amountSats`), the send21 fee as a separate transparent output (`platformFeeSats`, `feeOutputs`), and for fiat-pegged drafts a locked exchange rate (`quote.rate`, valid until `quote.expiresAt`, and `POST /drafts/{id}/requote` refreshes it if it lapses). #### Fetch the transaction template, fund & sign locally `GET /api/v1/drafts/{id}/tx-template` returns the exact output list, a ready` bitcoin-cli walletcreatefundedpsbt` example, and a pay-to-many CSV. The agent funds and signs it with its own node, wallet, or HSM. Private keys never touch send21, and send21 contains no signing code. ``` curl https://send21.io/api/v1/drafts/{id}/tx-template \ -H "Authorization: Bearer s21_yourkey" ``` #### Broadcast from your own node Broadcast the signed transaction yourself. There is nothing to report back, because send21 watches the receiver address on-chain and matches the exact amount automatically. #### Get confirmation, webhook-first Register a webhook (`POST /api/v1/webhooks`) and receive HMAC-SHA256-signed events instead of polling. For quick checks, `GET /drafts/{id}/status` returns status, txid, and confirmation count. | Webhook event | When it fires | | --- | --- | | draft.created | Draft is created | | draft.seen | Matching transaction seen in the mempool / on-chain | | draft.confirmed | Required confirmations reached, payment final | | draft.expired | Draft expired without payment | | draft.cancelled | Draft cancelled by its owner | ### Fully non-custodial The agent always controls the keys. send21 only produces instructions and watches the chain. ### Single transaction Receiver amount and send21 fee are outputs of one transaction, with no second payment step. ### Idempotent & machine-readable Retry-safe creation, structured errors, and explicit rate locks for fiat-priced payments. Machine-readable overview at [/llms.txt](https://send21.io/llms.txt) | full OpenAPI spec at [/swagger](https://send21.io/swagger) | MCP endpoint at `https://send21.io/mcp` (Streamable HTTP, `Authorization: Bearer s21_...`) ## Transparent fees. No custody, no surprises. The send21 fee is priced in USD when the payment is created (same price feed as fiat conversion) and shown in your selected fiat currency too. On **multi-output drafts** it rides as a separate transparent output you can see and verify in your wallet. On **single-output payments** (checkout pay links, QR drafts) nothing extra rides along. The fee accrues to the creator's account and is settled with one payment (BTC, USDC, USDT, EURC, SOL, or ETH) once the balance reaches the cap. Either way, the receiver always gets the exact billed amount. Full details on the [pricing page](https://send21.io/pricing) | machine-readable: [/api/v1/fees/schedule](https://send21.io/api/v1/fees/schedule) ## Works with the wallets people already use There are two ways to pay through send21. **Payment drafts** (Bitcoin) are multi-output PSBT templates and need a PSBT-capable wallet (Bitcoin Core, Sparrow, Electrum), with hardware wallets signing through them. **Checkout pay links** are single transfers with a standard QR code (bitcoin: / solana: / ethereum: URI), so any wallet that can scan a QR and send an exact amount works. No fee output rides along there. The send21 fee accrues to the account that created the payment and is settled separately. | Top-5 wallet (2026) | BTC on Bitcoin | USDC on Solana | USDT on Ethereum | | --- | --- | --- | --- | | Ledger Stax | Drafts and checkout. Sign PSBTs via Sparrow or Electrum | Checkout via Ledger Live, or Phantom with Ledger | Checkout via Ledger Live, or MetaMask with Ledger | | Ledger Flex | Drafts and checkout. Sign PSBTs via Sparrow or Electrum | Checkout via Ledger Live, or Phantom with Ledger | Checkout via Ledger Live, or MetaMask with Ledger | | Trezor Safe 7 | Drafts and checkout. Sign PSBTs via Electrum or Sparrow | Limited. Native SOL only, no USDC (SPL) sends in Trezor Suite | Checkout via Trezor Suite, or MetaMask with Trezor | | MetaMask | Not supported. No Bitcoin sends or PSBT | Checkout, Solana accounts supported | Checkout, scans the EIP-681 QR directly | | Trust Wallet | Checkout only. Scans the bitcoin: QR, no PSBT for drafts | Checkout, SPL tokens supported | Checkout, ERC-20 supported | "Top 5" per 2026 wallet roundups (Ledger, Coincub, bitcoinfoundation.org). Compatibility reflects each wallet's published feature set as of August 2026. Always verify the address and amount in your own wallet before signing. ## Run a shop? Accept BTC, stablecoins, SOL & ETH at the counter Price in your own currency, any of 165 world currencies, show one QR code, and your customer pays in the crypto of their choice straight to your wallet. The rate locks at checkout and the webhooks carry the exact conversion rate for your accounting. [send21 for business](https://send21.io/business) ## Questions ### Does send21 hold funds or private keys? No. send21 is software that prepares payment instructions. It has no private keys, no signing code and no way to broadcast. Every payment is signed in the payer's own wallet, and funds move directly from payer to receiver. ### Which currencies and networks are supported? BTC on-chain and over Lightning, USDC, USDT, EURC, SOL and ETH, across Bitcoin, Solana, Ethereum, Base, Arbitrum and Polygon. Prices can be set in any of 165 world currencies, and the exchange rate locks when the payer picks a currency. ### Which wallets can payers use? Any wallet that scans a QR code. Pay links and new drafts are a single payment using the standard formats (BIP-21, Solana Pay, EIP-681, Lightning invoices). Batched drafts are an option for PSBT wallets such as Bitcoin Core, Sparrow and Electrum, and for batching wallets such as Safe. ### How can a webshop accept purchases from AI agents? Your backend creates a payment request with one API call: the price in your currency, your receiving addresses and your order id. The pay page and API responses are machine-readable, so an agent can pick a currency and pay from its operator's wallet. Your shop reconciles through a signed webhook that carries the order id and the exact rate. ### What does send21 cost? One fee per payment, tiered by size: 0.49% on small payments down to 0.01% above $100,000, with a $0.01 minimum and a $100 maximum. There is no subscription, and the receiver always gets the exact billed amount. --- Source: https://send21.io/ # Developer docs Everything you need to create payment requests and drafts from your own code or from an AI agent. send21 prepares payment instructions; the payer always signs in their own wallet, and send21 never holds keys or funds. ## Start here - [API quickstart](https://send21.io/docs/quickstart): API keys, your first payment request and draft, status and idempotency. - [Webhooks](https://send21.io/docs/webhooks): events, payloads, retries and signature checks. - [MCP server](https://send21.io/docs/mcp): connect an AI agent over the Model Context Protocol. - [Currencies and networks](https://send21.io/docs/currencies): which assets each network carries, decimals and confirmations. - [Lightning](https://send21.io/docs/lightning): pay links and drafts that confirm through the receiver's Lightning address. ## Machine-readable references - OpenAPI 3 specification: [/openapi.json](https://send21.io/openapi.json), browsable at [/swagger](https://send21.io/swagger). - Overview for language models: [/llms.txt](https://send21.io/llms.txt), with every doc in one file at [/llms-full.txt](https://send21.io/llms-full.txt). - Every docs page is also available as Markdown: add `.md` to the address, for example [/docs/webhooks.md](https://send21.io/docs/webhooks.md). ## Try it without an account The [testnet demo](https://send21.io/demo) runs the whole flow on test networks with free test coins: a draft, a QR payment from your own wallet, and an on-chain confirmation. No account and no email. --- Source: https://send21.io/docs # API quickstart The send21 API has two building blocks. A **payment request** asks to get paid: the payer opens a link, picks a currency and pays from any wallet. A **payment draft** prepares a payment to someone else, which the sender signs in their own wallet. Base URL: `https://send21.io/api/v1`. ## 1. Create an API key Sign in and open [API keys](https://send21.io/api-keys). Pick only the scopes you need. Keys look like `s21_...` and are shown once. No key can move funds, because send21 never holds any. | Scope | Allows | | --- | --- | | `drafts:read` | Read drafts, payment requests, templates, status and rates | | `drafts:write` | Create, cancel and re-quote drafts and payment requests | | `addressbook:read` | Read saved addresses | | `addressbook:write` | Change saved addresses | | `webhooks:manage` | Register and delete webhook endpoints | ## 2. Ask to get paid: a payment request Price it in any of 165 fiat currencies and list the currencies you accept, each with your own receiving address. The response contains `payPath`; share `https://send21.io` plus that path as a link or QR code. The rate locks when the payer picks a currency. ```bash curl -X POST https://send21.io/api/v1/payment-requests \ -H "Authorization: Bearer s21_YOUR_KEY" \ -H "Content-Type: application/json" \ -H "Idempotency-Key: order-1042" \ -d '{ "fiatCurrency": "EUR", "fiatAmount": 49.00, "orderId": "ORDER-1042", "memo": "Invoice 1042", "options": [ { "currency": "Eurc", "network": "Base", "address": "0xYourAddress" }, { "currency": "Usdc", "network": "Solana", "address": "YourSolanaAddress" }, { "currency": "Btc", "network": "Mainnet", "address": "you@your-wallet.com", "method": "Lightning" } ] }' ``` ## 3. Prepare a payment: a draft A draft pays a receiver. With `singleOutput: true` it is one QR payment from any wallet, and the send21 fee is billed to your account. Without it, the fee is a separate output and the template suits PSBT and batching wallets. Fetch wallet-ready instructions from `GET /drafts/{id}/tx-template`. ```bash curl -X POST https://send21.io/api/v1/drafts \ -H "Authorization: Bearer s21_YOUR_KEY" \ -H "Content-Type: application/json" \ -H "Idempotency-Key: payout-77" \ -d '{ "receiverAddress": "0xReceiverAddress", "network": "Arbitrum", "currency": "Usdc", "paymentMethod": "MultiOutput", "singleOutput": true, "fiatCurrency": "SEK", "fiatAmount": 1500 }' ``` ## 4. Track the payment - Poll `GET /drafts/{id}/status` for `AwaitingPayment`, `Seen`, `Confirmed`, `Expired` or `Cancelled`. - Better: register a [webhook](https://send21.io/docs/webhooks) and react to `draft.confirmed`. - A transfer within 10% of the billed amount is flagged as `draft.amount_mismatch` and can be accepted with `POST /drafts/{id}/accept-received`. ## Good to know - Send an `Idempotency-Key` header on create calls. A retry with the same key returns the original object. - Batch creation: `POST /drafts/batch` takes up to 25 drafts. - Rate limit: 300 requests per minute per key. A 429 means back off; prefer webhooks over tight polling. - A 402 on a create call means accrued fees must be settled first; the body names `POST /fees/accrued/settle`. - Full reference: [/swagger](https://send21.io/swagger) and [/openapi.json](https://send21.io/openapi.json). --- Source: https://send21.io/docs/quickstart # Webhooks send21 calls your server when a draft changes. Register an endpoint with `POST /api/v1/webhooks` (scope `webhooks:manage`) and the events you want. The response contains the signing secret once. Send a test event any time with `POST /api/v1/webhooks/{id}/test`. ## Delivery Each delivery is a `POST` with `Content-Type: application/json` and the body `{ "event": "", "data": { ... } }`. Any 2xx response counts as delivered. Anything else, or no answer within 15 seconds, is retried after 1, 2, 4, 8 minutes and so on, up to 8 attempts. Deliveries can arrive out of order. | Header | Meaning | | --- | --- | | `X-Send21-Event` | The event type | | `X-Send21-Delivery` | Unique delivery id; retries reuse it, so use it to ignore duplicates | | `X-Send21-Signature` | `sha256=` plus the lowercase hex HMAC-SHA256 of the raw body, keyed with your secret | ## Verify the signature Compute the HMAC over the raw request bytes, before parsing JSON, and compare in constant time. Answer 401 when the header is missing or wrong. ```js const expected = Buffer.from('sha256=' + crypto.createHmac('sha256', secret).update(rawBody).digest('hex')); const received = Buffer.from(String(req.headers['x-send21-signature'] ?? '')); const ok = received.length === expected.length && crypto.timingSafeEqual(received, expected); if (!ok) return res.status(401).end(); ``` ## The same check in Python ```python import hmac, hashlib expected = "sha256=" + hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest() valid = hmac.compare_digest(expected, request.headers.get("X-Send21-Signature", "")) ``` ## Events | Event | When | | --- | --- | | `draft.created` | A draft was created: by you, an API key, a recurring template, or a payer picking a currency on a pay link | | `draft.seen` | A payment was seen but is not confirmed yet. Also sent with `acceptedByOwner: true` when you accept a payment with a different amount | | `draft.confirmed` | The payment reached its required confirmations. For Lightning: the provider confirmed it with a valid preimage | | `draft.amount_mismatch` | A transfer within 10% of the billed amount arrived. It does not pay the draft until you accept it | | `draft.expired` | The draft expired without payment | | `draft.cancelled` | The draft was cancelled | | `test` | Sent by the test endpoint | ## Payload `draft.seen`, `draft.confirmed`, `draft.amount_mismatch` and `draft.expired` share this shape. Amounts ending in `Sats` are base units of the sent asset: 8 decimals for BTC, 6 for USDC, USDT and EURC, 9 for SOL and ETH (ETH in gwei). `txId` is the transaction id, or the payment hash for Lightning. `receivedAmountSats` and `receivedAmount` appear when the amount differs from the billed amount, including on the `draft.confirmed` of an accepted short or over payment. `paymentRequestId` and `orderId` are set for pay-link payments. ```json { "event": "draft.confirmed", "data": { "draftId": "3f6c2a9e-5d1b-4c8e-9a7f-2b4d6e8f0a1c", "status": "Confirmed", "txId": "5KqZ9bQ...", "confirmations": 1, "sentCurrency": "USDC", "network": "Solana", "amountSats": 50000000, "sentAmount": "50.000000", "fiatCurrency": "EUR", "fiatAmount": 46.00, "conversionRate": 0.92, "rateSource": "coinbase", "platformFee": { "accrued": true, "waived": false, "percent": 0.39, "feeUsd": 0.20, "feeBaseUnits": 195000, "feeAmount": "0.195000", "currency": "USDC" }, "paymentRequestId": "8d1e4b7a-0c2f-4e6d-b3a9-7f5c1e2d4a6b", "orderId": "ORDER-1042", "occurredAt": "2026-10-06T08:22:22Z" } } ``` ## Endpoint rules - Endpoints must use HTTPS and resolve to a public address; private and internal addresses are refused. - Store the secret in a secret manager. It is shown only once. - Reconcile with `orderId` and the exact amount, not with the time of arrival. --- Source: https://send21.io/docs/webhooks # MCP server for AI agents send21 runs a Model Context Protocol server at `https://send21.io/mcp` (Streamable HTTP, stateless). An agent can prepare and track payments with a scoped API key, and no key can move funds: a human or the operator's own wallet signs every payment. ## Connect Use the same `Authorization: Bearer s21_...` header as the REST API. Listing the tools and reading the fee schedule work without a key; every other tool needs one. ```json { "mcpServers": { "send21": { "url": "https://send21.io/mcp", "headers": { "Authorization": "Bearer s21_YOUR_KEY" } } } } ``` ## Tools | Tool | What it does | Scope | | --- | --- | --- | | `create_payment_request` | Create a fiat-priced pay link with the currencies you accept | `drafts:write` | | `get_payment_request` | Read a payment request and its payment status | `drafts:read` | | `create_draft` | Prepare a payment to a receiver address | `drafts:write` | | `get_draft` | Read a draft with amounts, fee and quote | `drafts:read` | | `get_draft_status` | Cheap status snapshot for polling | `drafts:read` | | `get_transaction_template` | Wallet-ready payment instructions for a draft | `drafts:read` | | `list_address_book` | Saved receiver and own addresses | `addressbook:read` | | `get_rate` | Exchange rate for an asset in a fiat currency | `drafts:read` | | `get_fee_schedule` | The public fee schedule | none | ## Agent proposes, human signs The safe split for agents: the agent creates the payment request or draft, and the payment is signed in a wallet the agent does not control. A compromised agent or API key can create instructions but cannot spend. Every tool calls the REST API in-process, so scopes, validation, idempotency and rate limits are the same as for REST clients. ## Directory listings - Smithery: [smithery.ai/servers/send21io/mcp](https://smithery.ai/servers/send21io/mcp) - Glama: [glama.ai/mcp/servers/send21io/mcp](https://glama.ai/mcp/servers/send21io/mcp) --- Source: https://send21.io/docs/mcp # Currencies and networks Payments settle in the asset the payer picks, directly to the receiver's own wallet. Prices can be set in any of 165 fiat currencies and convert at a rate locked for 15 minutes. ## What each network carries | Network (API value) | Currencies (API values) | | --- | --- | | Bitcoin (`Mainnet`) | BTC (`Btc`) on-chain, and over Lightning with `paymentMethod: "Lightning"` | | Solana (`Solana`) | `Usdc`, `Usdt`, `Eurc`, native `Sol`, wrapped BTC (`Btc`) | | Ethereum (`Ethereum`) | `Usdc`, `Usdt`, `Eurc`, native `Eth`, WBTC (`Btc`) | | Base (`Base`) | `Usdc`, `Eurc`, native `Eth` | | Arbitrum (`Arbitrum`) | native `Usdc` (not USDC.e), native `Eth` | | Polygon (`Polygon`) | native `Usdc` (not USDC.e) | ## Amounts and decimals API amounts (`amountSats`, `amountBaseUnits`) are integers in the asset's base units. | Asset | Decimals | Base unit | | --- | --- | --- | | BTC and wrapped BTC | 8 | satoshi | | USDC, USDT, EURC | 6 | micro-unit | | SOL | 9 | lamport | | ETH | 9 | gwei (payment links carry the value in wei) | ## Payment links - Bitcoin: BIP-21 (`bitcoin:`). Lightning: the invoice (`lightning:`). - Solana: Solana Pay (`solana:`), with `spl-token` for tokens. - EVM chains: EIP-681 (`ethereum:`) with chain id 1 (Ethereum), 8453 (Base), 42161 (Arbitrum) or 137 (Polygon). ## Detection and confirmation - Payments are matched by exact amount at the receiver address. Use a fresh address per payment where you can. - A transfer within 10% of the billed amount is flagged for the receiver to accept instead of being ignored. - One confirmation by default; Polygon waits for 16. Solana counts finalized transactions. - Native ETH is detected with free sources: public block explorers where they exist, optional free-tier explorer keys, and a balance check over public RPC. - Lightning is confirmed through the receiver's Lightning address when the provider supports LUD-21. See [Lightning](https://send21.io/docs/lightning). ## Test networks The [demo](https://send21.io/demo) covers Testnet4, Signet, Solana Devnet, Ethereum Sepolia, Base Sepolia, Arbitrum Sepolia and Polygon Amoy. On send21.io the test networks are reserved for the demo; account drafts use the live networks. --- Source: https://send21.io/docs/currencies # Lightning payments With a Lightning address (like `you@your-wallet.com`), send21 can confirm Lightning payments without ever holding them. The invoice comes from the receiver's own wallet provider and pays the receiver directly. ## How it works - The receiver gives a Lightning address, on a draft (`receiverAddress` with `paymentMethod: "Lightning"`) or as a pay-link option (`method: "Lightning"`). - When the payer is ready, send21 asks that address (LNURL-pay) for an invoice of the exact amount and checks the invoice's amount and network. - The payer scans the invoice with any Lightning wallet. The money goes straight to the receiver's wallet. - If the provider supports LUD-21, send21 polls its verify URL and confirms the payment once it returns a preimage that hashes to the invoice's payment hash. `lightningConfirmable` on the draft tells you in advance. ## Limits - Not every Lightning wallet provider supports LUD-21. Without it the payment works but is not confirmed automatically. - A pasted BOLT11 invoice is never confirmed automatically. - Invoices expire; the rate lock ends with the invoice. Re-quote the draft for a fresh invoice. - The send21 fee is billed to the creator's account and settled on-chain later; a Lightning invoice cannot carry a fee output. --- Source: https://send21.io/docs/lightning # Accept USDC and EURC payments Price your invoice in your own currency and let the client pay in USDC or EURC, straight to your wallet. send21 prepares the payment link and records the exact rate; it never holds the money. ## How it works - Create a pay link: set the amount in EUR, SEK, USD or any of 165 currencies. - Choose the stablecoins and networks you accept, each with your own receiving address: USDC on Solana, Ethereum, Base, Arbitrum or Polygon, EURC on Solana, Ethereum or Base. - Share the link or QR code. The client picks a currency, the rate locks for 15 minutes, and they pay from any wallet. - You get an email and a signed webhook when it confirms, with the amount, rate and source. ## Why freelancers and small companies use it - The money arrives in your wallet, not in a platform balance waiting for payout. - The rate and its source are recorded on each payment and the draft PDF, which helps with bookkeeping. - Short payments, common with exchange withdrawals, are flagged and can be accepted with one click. - One fee per payment, from 0.49% on small amounts down to 0.01%, capped at $100. See [pricing](https://send21.io/pricing). ## USDC, EURC or USDT? USDC and EURC are issued by Circle and authorized as e-money tokens under MiCA in the EU. USDT remains available for payments between self-custody wallets, but EU exchanges delisted it, so EU clients usually prefer USDC or EURC. This is not legal or tax advice. ## Questions ### Do I need a send21 wallet? No. send21 has no wallets. You receive in any wallet you control, for example Phantom, MetaMask, Rabby or a hardware wallet. ### Can the client pay from an exchange? Yes, if the exchange can withdraw to the network you accept. Exchanges often deduct a withdrawal fee; send21 flags such short payments so you can accept them. --- Source: https://send21.io/accept-usdc-payments # Crypto payment links in your own currency A send21 pay link asks for a fixed amount in your currency and lets the payer choose how to pay. The rate locks when they choose, so your price holds, and the payment goes straight to your wallet. ## What the payer sees - Your amount in your currency, your message, and the currencies you accept. - After picking one: one QR code, the exact amount, and how long the rate is locked. - Payment from any wallet: BIP-21 for bitcoin, a Lightning invoice, Solana Pay, or EIP-681 for EVM chains. - A notice not to pay again if a payment with a different amount already arrived. ## What you get - Payment straight to your own addresses, one per network you accept. - An email and a signed webhook when the payment is seen and confirmed, with your order id. - A list of your requests with their status, and drafts with PDFs for your records. ## Make one In the app, open **Get paid**. From code, one call to `POST /api/v1/payment-requests` (see the [quickstart](https://send21.io/docs/quickstart)). AI agents can do the same through the [MCP server](https://send21.io/docs/mcp). --- Source: https://send21.io/crypto-payment-links # Lightning address payments that confirm themselves Put your Lightning address on a pay link next to on-chain options. send21 fetches an invoice for the exact amount from your own wallet provider, and confirms the payment when your provider supports LUD-21. ## Why it matters Lightning is where everyday bitcoin payments happen: fast and cheap. Until now, a payment link either needed a custodial processor or could not tell you when the invoice was paid. With a Lightning address, the invoice belongs to your wallet and send21 only reads its status. ## Set it up - Find your Lightning address in your wallet app. Many wallets give one, in the form name@provider. - Create a pay link and tick **Also accept BTC over Lightning**, then enter the address. - send21 checks that the address answers before the link goes live. - When a payer picks Lightning, send21 fetches a fresh invoice for the locked amount. ## Good to know - Automatic confirmation needs LUD-21 support from your provider; the draft shows whether it is available. - Invoices expire, and the rate lock ends with the invoice. - Technical details: [Lightning docs](https://send21.io/docs/lightning). --- Source: https://send21.io/lightning-address-payments # Payments for AI agents, without giving them your keys Agents are good at preparing payments and bad places to keep money. With send21 an agent creates payment requests and drafts through a scoped API key, and the payment is signed in a wallet the agent does not control. ## Agent proposes, human signs - The agent calls `create_payment_request` or `create_draft` over [MCP](https://send21.io/docs/mcp), or the same REST endpoints. - The payer, or the operator, reviews and signs in their own wallet. - The agent follows the result through `get_draft_status` or a [webhook](https://send21.io/docs/webhooks). - A leaked key can create instructions but cannot spend anything, because send21 holds nothing. ## Built for automation - Idempotency keys make retries safe. - Batch creation of up to 25 drafts per call, and recurring templates. - Machine-readable pay pages and responses, with your order id echoed in every webhook. - Discovery files for agents: [/llms.txt](https://send21.io/llms.txt), [/llms-full.txt](https://send21.io/llms-full.txt) and [/openapi.json](https://send21.io/openapi.json). ## Selling to agents A webshop can let an AI agent complete checkout: the backend creates a payment request per order, the agent picks a currency and pays from its operator's wallet, and the shop marks the order paid on `draft.confirmed`. --- Source: https://send21.io/ai-agent-payments # Accept ETH on Ethereum, Base and Arbitrum Many payers hold ETH and nothing else. A send21 pay link can offer native ETH on Ethereum, Base and Arbitrum next to stablecoins, priced in your own currency. ## How it works - Add ETH as an option on a pay link, with your EVM address. - The payer picks ETH and a network. The rate locks and the wallet opens a standard EIP-681 link with the exact amount. - send21 detects the payment, also when it comes from a smart wallet, and confirms it to you by email and webhook. ## Good to know - ETH amounts are stored in gwei (9 decimals) and sent in wei. - On Base, keep one open ETH payment per address at a time for the most reliable matching. - ETH fee settlements are paid on Ethereum. - More detail: [currencies and networks](https://send21.io/docs/currencies). --- Source: https://send21.io/accept-eth-payments # send21 and BTCPay Server compared BTCPay Server and send21 share the most important property: neither holds your funds. They differ in who runs the infrastructure and which payments they focus on. ## At a glance | | BTCPay Server | send21 | | --- | --- | --- | | Custody | Non-custodial | Non-custodial | | Who runs it | You, on your own server (or a third-party host) | Hosted at send21.io | | Software fee | None; you pay for hosting | 0.49% down to 0.01% per payment, capped at $100 | | Focus | Bitcoin and Lightning; other coins through community plugins | BTC, Lightning, USDC, USDT, EURC, SOL and ETH on six networks | | Setup | Server, Bitcoin node (around 600 GB, or pruned), optional Lightning node | Sign up and paste your receiving addresses | | Code | Open source | Hosted service with a public API and MCP server | ## When BTCPay Server fits better - You want zero software fees and are happy to run and update a server. - You want to run your own Bitcoin and Lightning nodes. - You need the open-source code itself. ## When send21 fits better - You want to accept stablecoins, SOL or ETH next to bitcoin without running nodes. - You price in EUR, SEK or another currency and want a locked rate on every payment. - You build with AI agents and want scoped keys, MCP and signed webhooks out of the box. --- Source: https://send21.io/compare/btcpay-server # send21 compared with hosted crypto gateways Hosted crypto gateways differ widely. Some receive the payment into their own wallets and pay you out later, some convert to fiat for you, and fees typically range from about 0.5% to 1%. send21 takes a narrower role on purpose. ## What is different | | Typical hosted gateway | send21 | | --- | --- | --- | | Where the payment lands | Often the gateway's wallet first, then a payout | Always your own wallet, directly | | Conversion to fiat | Often available | Not offered; send21 never touches money | | Fee | Often around 0.5% to 1% | 0.49% down to 0.01%, capped at $100 | | Keys and funds | Held by the provider while in transit | Never held; no signing code | | Agents | Varies | Scoped keys that cannot spend, MCP server, signed webhooks | ## Choose a hosted gateway if - You need automatic conversion to fiat and bank payouts. - You want plugins for many shop platforms out of the box. ## Choose send21 if - You want the money in your own wallet from the first second. - You want a provider that cannot freeze, lose or move your funds, because it never has them. - You build on an API or with AI agents. --- Source: https://send21.io/compare/hosted-crypto-gateways # Accept BTC, stablecoins, SOL & ETH in your store. Without ever touching crypto custody. Price in your own currency, any of **165 world currencies**. Your customer picks what to pay with, scans one QR code, and the money goes straight to your wallet. send21 never holds a cent. One integration covers all three ways your customers pay:** AI agents**, **webshops**, and **payment devices** at the counter. [Start accepting crypto](https://send21.io/login?mode=register) [API docs](https://send21.io/swagger) ## One API, three ways to get paid ### Enable AI agents Agentic commerce is here. Customers increasingly send an AI agent to research, order, and pay. Every send21 checkout is machine-readable (structured JSON, standard payment URIs, [/llms.txt](https://send21.io/llms.txt) , OpenAPI, and a native **MCP server** at `send21.io/mcp`), so an agent can complete a purchase in your shop end to end and pay from its operator's own wallet. No stored cards, no chargebacks. [How it works](#agentic-commerce) . ### Enable crypto in your webshop One API call at checkout returns a hosted pay page and QR. Your customer pays the exact fiat price you quoted, in BTC, USDC, USDT, EURC, SOL, or ETH at a locked rate, straight to your address. The HMAC-signed webhook carries your order id, the amount, and the conversion rate, so orders reconcile themselves. ### Enable crypto on payment devices Turn any terminal, tablet, or kiosk into a crypto point of sale. The device creates a payment request for the basket total and shows the QR, then the customer scans and pays from their own wallet. The confirmation webhook closes the sale on the device. No card rails, no acquirer fees, funds land directly in your wallet. ## How a checkout works #### Create a payment request with one API call or a click in the dashboard Set the price in any of the 165 supported world currencies (USD, EUR, SEK, NGN, VND and the rest) and list which currencies you accept, each with your own receiving address. You get back a hosted pay link and QR code. ``` curl -X POST https://send21.io/api/v1/payment-requests \ -H "Authorization: Bearer s21_yourkey" \ -H "Content-Type: application/json" \ -d '{ "fiatCurrency": "EUR", "fiatAmount": 49.90, "orderId": "shop-order-1042", "memo": "Order #1042 Blue hoodie", "options": [ { "currency": "Btc", "network": "Mainnet", "address": "bc1q..." }, { "currency": "Usdc", "network": "Solana", "address": "5Gv7..." }, { "currency": "Usdt", "network": "Ethereum", "address": "0xAb..." } ] }' ``` #### Show the customer the pay page or QR Redirect to the hosted page, embed the link in an invoice, or show the QR at the counter. The customer picks **BTC (on-chain or Lightning), USDC, USDT, EURC, SOL, or ETH**, and the exchange rate locks the moment they choose, so your price is guaranteed. #### Customer scans and pays from their own wallet One standard QR (BIP-21 / Solana Pay / EIP-681) that works with ordinary wallets, no PSBT knowledge needed. Funds move directly from the customer's wallet to** your** address. #### Get a webhook with everything your books need When the payment confirms, the signed webhook tells you what was sent, what it was worth in your currency, and the exact conversion rate, plus your own order id. ``` { "event": "draft.confirmed", "data": { "draftId": "7d21...", "status": "Confirmed", "txId": "3QzV...", "confirmations": 1, "sentCurrency": "USDC", "network": "Solana", "sentAmount": "53.870000", "fiatCurrency": "EUR", "fiatAmount": 49.90, "conversionRate": 0.9263, "rateSource": "coinbase", "orderId": "shop-order-1042" } } ``` ## Using Shopify? Connect your store with a custom app There is **no send21 app in the Shopify App Store**. To accept crypto in a Shopify store, you create your own custom Shopify app that connects your store to send21. We provide reference code for that connection and help you set it up. Once connected, the customer picks "Crypto (send21)" at checkout, gets the pay link in the order confirmation email, and pays from their own wallet. Your custom app marks the order paid when the payment confirms on-chain. Your theme's checkout code is not touched. #### Create a send21 API key and webhook In your send21 account, create an API key with `drafts:read` and `drafts:write`, save your receiving addresses in the address book ("My own, I receive here"), and add a webhook for `draft.confirmed` pointing at the app. #### Create and host your custom app Create a custom app for your store in the Shopify Partner Dashboard and run the connection code on a public HTTPS address you control. Install it on your store and approve the order permissions (`read_orders`, `write_orders`). It then picks up new orders automatically. #### Add the manual payment method In Shopify admin, open Settings, then Payments, then Manual payment methods. Create "Crypto (send21)" and add the pay link snippet to your order confirmation email. That's it. Orders paid in any accepted currency settle straight to your wallet and are marked paid on their own. For the reference code, setup help and the email snippet, write to [integration@send21.io](mailto:integration@send21.io) . Refunds are out of band (crypto is push-only). Refund from your own wallet, then refund the order in Shopify admin. Other platforms (WooCommerce, custom carts) integrate with the same one-call [payment-request API](https://send21.io/swagger) . ## Why retailers pick send21 ### Zero custody, zero float Customers pay your addresses directly. There is no balance at send21 to withdraw, freeze, or lose. ### Price in fiat, get paid in crypto You quote €49.90 and the customer pays exactly that at a locked, recorded rate with full provenance. ### One-scan checkout Single-output payments encode into one QR that every mainstream wallet understands. ### Accounting-ready webhooks Sent currency, sent amount, fiat value, conversion rate, and your order id, all HMAC-signed. ### Low, transparent fees Tiered from 0.49% on small payments down to 0.01%, billed to you as an accrued fee, never deducted from the customer's payment. [Full schedule](https://send21.io/#fees) . ### Settle fees on your terms Pay your accrued balance with one payment in **BTC, USDC, USDT, EURC, SOL, or ETH**. One click in the dashboard, or one API call (`POST /fees/accrued/settle`) that returns a ready-to-pay QR. Your books see a single fee payment, not per-sale deductions. ### AI agents can buy from you The whole checkout is machine-readable, so an AI agent shopping for its owner can complete a purchase in your shop end to end. [How it works](#agentic-commerce) . Questions about integrating your shop or agent? Write to [integration@send21.io](mailto:integration@send21.io) . ## Ready for customers who send an AI agent Card checkouts break for agents: sharing card numbers with an agent is a liability and form-filling is fragile. A send21 checkout is an API-first, machine-readable payment instruction that an agent can read, verify, and pay from its operator's own wallet. Neither your shop nor the agent ever touches a card number or a private key it shouldn't have. ### Machine-readable checkout Every payment request returns structured JSON and standard payment URIs (BIP-21 / Solana Pay / EIP-681), the same data behind the human pay page, parseable by any agent framework. ### Discoverable by agents [/llms.txt](https://send21.io/llms.txt) and an OpenAPI spec describe the full flow in the format AI agents look for, so an agent landing on your checkout knows exactly what to do. ### Safe for everyone involved The agent pays from a wallet its operator controls, and you receive funds directly at your address. No stored cards, no credentials to leak, no chargebacks. The confirmation is on-chain and final. ### Reconciliation built in Your `orderId` travels through the whole flow and comes back in the HMAC-signed confirmation webhook with the exact amount and conversion rate, so agent purchases book themselves like any other order. agent places order -> your backend **creates a payment request** -> agent reads the machine-readable options -> pays from its operator's wallet -> **signed webhook confirms with your order id** Nothing extra to build. The same payment request that renders a QR for a human is the one an agent consumes. Integrating your shop today makes it agent-ready by default. ## Person-to-person requests too The same flow works between individuals: create a request for what a friend owes you, send them the link, and they pay in whichever offered currency suits them. You are always the receiver; they always sign in their own wallet. --- Source: https://send21.io/business # Pricing One fee, tiered by payment size. No subscriptions, no setup cost, no monthly minimum, no per-seat pricing. Accounts, API keys, webhooks, recurring templates, and help connecting Shopify are all free. The fee is charged per payment: on multi-output drafts it rides in the transaction itself, and on single-output payments it accrues to your account when the payment confirms. It shrinks as payments grow, from 0.49% on the smallest payments down to 0.01% above $100,000, always capped at $100. The fee is priced in USD when the payment is created (same price feed as fiat conversion) and shown in your selected fiat currency too. The receiver always gets the exact billed amount. ## Fee schedule Tiered from 0.49% (payments under $10) down to 0.01% (above $100,000); minimum $0.01, maximum $100. Loading the live schedule... Machine-readable: [/api/v1/fees/schedule](https://send21.io/api/v1/fees/schedule) . The live schedule your integration should read. ## How the fee is collected - **Multi-output drafts (Bitcoin PSBT):** the fee rides as a separate, transparent output in the same transaction, so you see and verify it in your wallet before signing. No second payment step. - **Single-output payments** (checkout pay links, payment requests, QR drafts): nothing extra rides along. The fee accrues to the creator's account and is settled with one payment (BTC, USDC, USDT, EURC, SOL, or ETH) once the balance reaches the cap. Network mining fees are separate and always set by the sender's own wallet. send21 is never in the money path and never adds a spread on exchange rates: fiat-pegged payments use a locked, recorded market rate with full quote provenance. ## What's included at no extra cost - REST API with scoped keys, idempotent creation, and batch endpoints (25 drafts per call) - HMAC-SHA256 signed webhooks and email notifications - Recurring payment templates (daily / weekly / monthly) - Hosted multi-currency checkout pages with standard QR codes - Shopify connection through your own custom app, with reference code and automatic order reconciliation - MCP server for AI agents at `https://send21.io/mcp` - Pricing in any of 165 world currencies with locked exchange rates [Get started free](https://send21.io/login?mode=register) [send21 for business](https://send21.io/business) Questions about volume or integrations? [integration@send21.io](mailto:integration@send21.io) | [Terms of service](https://send21.io/terms) | [Home](https://send21.io/) --- Source: https://send21.io/pricing # About send21 send21 is non-custodial payment software: it prepares clean, verifiable payment instructions for BTC, USDC, USDT, EURC, SOL, and ETH across Bitcoin, Lightning, Solana, Ethereum, Base, Arbitrum, and Polygon, then watches for confirmation. Funds always move directly from the sender's own wallet to the receiver. ## What send21 is - A **draft & pay-link generator**: fixed-amount or fiat-pegged payment drafts with a locked, recorded exchange rate in any of 165 world currencies. - A **chain watcher**: it matches the payment on-chain and fires HMAC-signed webhooks and emails as it is seen and confirmed. - An **API-first platform**: everything a human does in the UI, an AI agent does over REST or the built-in MCP server, with scoped keys that can never move funds. ## What send21 is not send21 is not a custodian, exchange, broker, money transmitter, or payment service provider. It never holds, transmits, converts, or has access to funds or private keys, contains no signing code, and never broadcasts transactions. Signing and broadcasting always happen in the sender's own wallet. A full server compromise could not move a single satoshi. This is non-custodial by structure, not by promise; the details are in our [terms of service](https://send21.io/terms) . ## How it makes money A single transparent fee per payment, tiered by size, from 0.49% on the smallest payments down to 0.01% above $100,000, capped at $100. On multi-output drafts the fee is a visible output in the transaction you sign; on single-output payments it accrues to the creator's account. No subscriptions, no spread on exchange rates. Full details on the [pricing page](https://send21.io/pricing) . ## Privacy by default No KYC, no tracking, no analytics, no ad pixels. The platform stores an email address (encrypted) and little else. See the [privacy policy](https://send21.io/privacy) for exactly what is kept and for how long. ## Contact - General: [info@send21.io](mailto:info@send21.io) - Account or payment issues: [support@send21.io](mailto:support@send21.io) - API & integrations: [integration@send21.io](mailto:integration@send21.io) - Privacy & GDPR requests: [privacy@send21.io](mailto:privacy@send21.io) [Home](https://send21.io/) | [For business](https://send21.io/business) | [Pricing](https://send21.io/pricing) | [API docs](https://send21.io/swagger) | [llms.txt](https://send21.io/llms.txt) --- Source: https://send21.io/about - **TESTNET DEMO**. Real wallet signature on test networks only. No mainnet value. The coins involved are worthless test coins from public faucets. # Send a real test-network payment This is the actual send21 flow, end to end, with no account and no email: a real draft, a real signature in your own wallet, a real confirmation on a public test network. Direct. Non-custodial. Yours. ## How it works - An agent or the API **creates a payment draft**. Here the server does it for you with the same scoped, draft-only access an AI agent gets. Nothing here can spend. - A human **reviews and signs in their own wallet**. send21 never holds keys, never signs, never broadcasts. - send21 **watches the chain** until the payment confirms. In production your backend gets a signed draft.confirmed webhook at that moment. Need test coins? Faucets ## For AI agents: the same flow over API or MCP In production an agent holds a scoped API key that can **create and track drafts but never spend**. The human always signs in their own wallet. On send21.io the test networks are for this demo, and account drafts use the live networks. That is safe while integrating: a draft moves no money until someone signs it, so create small drafts to your own address and cancel them. ``` # an AI agent (or your backend) creates the draft with a scoped key. # draft-only scopes: the key can create and track drafts but can never spend # a draft moves no money until a human signs it, so a small live draft is a safe test curl -X POST https://send21.io/api/v1/drafts \ -H "Authorization: Bearer s21_YOUR_KEY" \ -H "Content-Type: application/json" \ -H "Idempotency-Key: agent-demo-001" \ -d '{ "receiverAddress": "0x...your-own-address", "network": "Base", "currency": "Usdc", "paymentMethod": "MultiOutput", "singleOutput": true, "amountSats": 1000000, "memo": "agent integration test, 1 USDC" }' ``` ``` // MCP (Streamable HTTP), same key, same draft-only scopes { "mcpServers": { "send21": { "url": "https://send21.io/mcp", "headers": { "Authorization": "Bearer s21_YOUR_KEY" } } } } // then call the create_draft tool with { "network": "Base", "currency": "Usdc", ... } ``` Full API: [/swagger](https://send21.io/swagger) | agent overview: [/llms.txt](https://send21.io/llms.txt) | status via GET /drafts/{id}/status or signed webhooks (draft.confirmed). --- Source: https://send21.io/demo