Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.antonpayments.com/llms.txt

Use this file to discover all available pages before exploring further.

This walks you from an empty sandbox to a delivered payout. It takes about five minutes if you already have sandbox OAuth credentials and a working DPoP proof signer.
Every request below uses the sandbox (https://api.antonpayments.dev) and a test OAuth client (ant_oc_test_...). No real funds move. Switch to https://api.antonpayments.com with ant_oc_live_* credentials when you’re ready for production — see Going Live.

​
Before you start

You need:
  • Sandbox OAuth credentials from the merchant dashboard — client_id, client_secret, and the DPoP private key the portal generated for you. Sandbox access is available before KYB — you do not need an approved merchant account to finish this quickstart.
  • A working DPoP proof signer. The Authentication page has a copy-paste curl + openssl + python script. Use it (or a JOSE library in your language) to mint an access token and sign per-request proofs.
  • curl, Node 18+, PHP 8+, or Go 1.21+ — any one is enough for the examples.
Mint an access token and store it. Examples below assume: 
export ANTON_ACCESS_TOKEN=eyJhbGciOiJFUzI1NiIs...   # from POST /oauth/token
# Each request also requires a fresh DPoP proof header (see /authentication).
The Authorization: DPoP $ANTON_ACCESS_TOKEN header is shown on every example. The DPoP: <proof> header is implied — refer to Authentication for the per-request signing.

​
Step 1: Verify your token

Hit any authenticated endpoint with your token. Reference data like /v1/currencies works as a zero-side-effect smoke test. 
curl https://api.antonpayments.dev/v1/currencies \
  -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
  -H "DPoP: $ANTON_DPOP_PROOF"
A 200 OK with a currency list means your key is authenticated and ready to go.

​
Step 2: Create a beneficiary

A beneficiary is who you’re paying — a person or business. Personal details (name, address, DOB) are tokenized in Basis Theory on creation; Anton’s database never holds them in plaintext. 
curl https://api.antonpayments.dev/v1/beneficiaries \
  -X POST \
  -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
  -H "DPoP: $ANTON_DPOP_PROOF" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: ben-quickstart-0001" \
  -d '{
    "type": "individual",
    "country": "GB",
    "external_ref": "quickstart-jane",
    "individual": {
      "first_name": "Jane",
      "last_name": "Smith",
      "email": "jane@example.com",
      "phone": "+442079460000",
      "date_of_birth": "1988-05-12",
      "nationality": "GB",
      "address": {
        "street_line_1": "10 Example Street",
        "city": "London",
        "postal_code": "SW1A 1AA",
        "country": "GB"
      }
    }
  }'
Save the returned id (prefixed ben_). You’ll use it in the next step.

​
Step 3: Attach a payment instrument

A beneficiary is the identity; an instrument is where the money goes — a bank account, wallet, or card. One beneficiary can have many instruments. Credentials (account numbers, wallet addresses, card PANs) are tokenized in Basis Theory on receipt. This example attaches a UK bank account. See GET /v1/payment-methods for the complete per-country catalog. 
curl https://api.antonpayments.dev/v1/beneficiaries/$BENEFICIARY_ID/instruments \
  -X POST \
  -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
  -H "DPoP: $ANTON_DPOP_PROOF" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: ins-quickstart-0001" \
  -d '{
    "method": "uk_bank",
    "currency": "GBP",
    "country": "GB",
    "label": "Primary GBP account",
    "is_default": true,
    "credentials": {
      "account_number": "12345678",
      "sort_code": "123456"
    }
  }'
Save the returned id (prefixed ins_).

​
Step 4: Send a payout

Now send a payout from your sandbox balance to the beneficiary’s instrument. You specify both a source_amount (what you pay) and a dest_amount (what the beneficiary receives) plus fixed_side to tell Anton which is authoritative. For same-currency payouts these are identical. 
curl https://api.antonpayments.dev/v1/payouts \
  -X POST \
  -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
  -H "DPoP: $ANTON_DPOP_PROOF" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: pay-quickstart-0001" \
  -d '{
    "beneficiary_id": "'"$BENEFICIARY_ID"'",
    "instrument_id": "'"$INSTRUMENT_ID"'",
    "source_amount": "250.00",
    "source_currency": "GBP",
    "dest_amount": "250.00",
    "dest_currency": "GBP",
    "method": "faster_payment",
    "rail_type": "fiat",
    "fixed_side": "fixed_dest",
    "purpose": "contractor_payment",
    "reference": "INV-QS-001"
  }'
The payout starts at pending_screening. In the sandbox, it moves through the full lifecycle in seconds: 
pending_screening → pending_approval → approved → processing → sent → completed
Every transition fires a payout.* webhook event — see How Anton Evaluates Payouts for what each state means and how to handle manual_review.
Polling works while you’re developing, but production integrations should subscribe to webhooks. Create a subscription pointing at an HTTPS endpoint you control:
cURL
curl https://api.antonpayments.dev/v1/webhooks \
  -X POST \
  -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
  -H "DPoP: $ANTON_DPOP_PROOF" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.example.com/webhooks/anton",
    "events": [
      "payout.completed",
      "payout.failed",
      "payout.returned",
      "payout.screening_failed"
    ]
  }'
The response includes a one-time secret (whsec_...). Store it securely — you’ll use it to verify every delivery. See Webhook Signing for the HMAC-SHA256 verification recipe.
Never poll in production. Polling wastes your rate-limit budget and misses events. Webhook deliveries are signed, retried on failure, and replayable from the event history via GET /v1/webhooks/events/{id}/deliveries.

​
What’s next?

Send a payout

The full payout flow with economics, corridors, and FX.

Handle webhooks

Set up real-time notifications with signed deliveries.

Manage beneficiaries

Deduplication, PII updates, archive/restore, and ops workflows.

How Anton evaluates payouts

Screening, velocity, and the Anton Engine — what each state means.

Batch payouts

Upload a CSV and send thousands of payouts in one call.

Go live

Checklist to promote your integration from sandbox to production.