Quickstart - Anton Payments

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"

const response = await fetch("https://api.antonpayments.dev/v1/currencies", {
  headers: {
    Authorization: `DPoP ${process.env.ANTON_ACCESS_TOKEN}`,
    DPoP: dpopProof("GET", "https://api.antonpayments.dev/v1/currencies", process.env.ANTON_ACCESS_TOKEN),
  },
});
const { data } = await response.json();
console.log(`${data.length} currencies supported`);

$ch = curl_init("https://api.antonpayments.dev/v1/currencies");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: DPoP " . getenv("ANTON_ACCESS_TOKEN")],
]);
$data = json_decode(curl_exec($ch), true);
curl_close($ch);
echo count($data["data"]) . " currencies supported";

req, _ := http.NewRequest("GET", "https://api.antonpayments.dev/v1/currencies", nil)
req.Header.Set("Authorization", "DPoP "+os.Getenv("ANTON_ACCESS_TOKEN"))
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

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"
      }
    }
  }'

const res = await fetch("https://api.antonpayments.dev/v1/beneficiaries", {
  method: "POST",
  headers: {
    Authorization: `DPoP ${process.env.ANTON_ACCESS_TOKEN}`,
      DPoP: dpopProof(method, url, process.env.ANTON_ACCESS_TOKEN),
    "Content-Type": "application/json",
    "Idempotency-Key": "ben-quickstart-0001",
  },
  body: JSON.stringify({
    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",
      },
    },
  }),
});
const { id: beneficiaryId } = await res.json();
console.log(beneficiaryId); // ben_...

$ch = curl_init("https://api.antonpayments.dev/v1/beneficiaries");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: DPoP " . getenv("ANTON_ACCESS_TOKEN"),
        "Content-Type: application/json",
        "Idempotency-Key: ben-quickstart-0001",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "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",
            ],
        ],
    ]),
]);
$beneficiary = json_decode(curl_exec($ch), true);
curl_close($ch);
$beneficiaryId = $beneficiary["id"]; // ben_...

body := map[string]any{
    "type":         "individual",
    "country":      "GB",
    "external_ref": "quickstart-jane",
    "individual": map[string]any{
        "first_name":    "Jane",
        "last_name":     "Smith",
        "email":         "jane@example.com",
        "phone":         "+442079460000",
        "date_of_birth": "1988-05-12",
        "nationality":   "GB",
        "address": map[string]any{
            "street_line_1": "10 Example Street",
            "city":          "London",
            "postal_code":   "SW1A 1AA",
            "country":       "GB",
        },
    },
}
buf, _ := json.Marshal(body)
req, _ := http.NewRequest("POST", "https://api.antonpayments.dev/v1/beneficiaries", bytes.NewReader(buf))
req.Header.Set("Authorization", "DPoP "+os.Getenv("ANTON_ACCESS_TOKEN"))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "ben-quickstart-0001")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var beneficiary struct{ ID string `json:"id"` }
json.NewDecoder(resp.Body).Decode(&beneficiary)
// beneficiary.ID == "ben_..."

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"
    }
  }'

const res = await fetch(
  `https://api.antonpayments.dev/v1/beneficiaries/${beneficiaryId}/instruments`,
  {
    method: "POST",
    headers: {
      Authorization: `DPoP ${process.env.ANTON_ACCESS_TOKEN}`,
      DPoP: dpopProof(method, url, process.env.ANTON_ACCESS_TOKEN),
      "Content-Type": "application/json",
      "Idempotency-Key": "ins-quickstart-0001",
    },
    body: JSON.stringify({
      method: "uk_bank",
      currency: "GBP",
      country: "GB",
      label: "Primary GBP account",
      is_default: true,
      credentials: {
        account_number: "12345678",
        sort_code: "123456",
      },
    }),
  },
);
const { id: instrumentId } = await res.json();
console.log(instrumentId); // ins_...

$url = "https://api.antonpayments.dev/v1/beneficiaries/{$beneficiaryId}/instruments";
$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: DPoP " . getenv("ANTON_ACCESS_TOKEN"),
        "Content-Type: application/json",
        "Idempotency-Key: ins-quickstart-0001",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "method" => "uk_bank",
        "currency" => "GBP",
        "country" => "GB",
        "label" => "Primary GBP account",
        "is_default" => true,
        "credentials" => [
            "account_number" => "12345678",
            "sort_code" => "123456",
        ],
    ]),
]);
$instrument = json_decode(curl_exec($ch), true);
curl_close($ch);
$instrumentId = $instrument["id"]; // ins_...

url := fmt.Sprintf("https://api.antonpayments.dev/v1/beneficiaries/%s/instruments", beneficiaryID)
body := map[string]any{
    "method":     "uk_bank",
    "currency":   "GBP",
    "country":    "GB",
    "label":      "Primary GBP account",
    "is_default": true,
    "credentials": map[string]any{
        "account_number": "12345678",
        "sort_code":      "123456",
    },
}
buf, _ := json.Marshal(body)
req, _ := http.NewRequest("POST", url, bytes.NewReader(buf))
req.Header.Set("Authorization", "DPoP "+os.Getenv("ANTON_ACCESS_TOKEN"))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "ins-quickstart-0001")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var instrument struct{ ID string `json:"id"` }
json.NewDecoder(resp.Body).Decode(&instrument)
// instrument.ID == "ins_..."

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"
  }'

const res = await fetch("https://api.antonpayments.dev/v1/payouts", {
  method: "POST",
  headers: {
    Authorization: `DPoP ${process.env.ANTON_ACCESS_TOKEN}`,
      DPoP: dpopProof(method, url, process.env.ANTON_ACCESS_TOKEN),
    "Content-Type": "application/json",
    "Idempotency-Key": "pay-quickstart-0001",
  },
  body: JSON.stringify({
    beneficiary_id: beneficiaryId,
    instrument_id: instrumentId,
    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",
  }),
});
const payout = await res.json();
console.log(payout.id, payout.status); // pay_...  "pending_screening"

$ch = curl_init("https://api.antonpayments.dev/v1/payouts");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: DPoP " . getenv("ANTON_ACCESS_TOKEN"),
        "Content-Type: application/json",
        "Idempotency-Key: pay-quickstart-0001",
    ],
    CURLOPT_POSTFIELDS => json_encode([
        "beneficiary_id" => $beneficiaryId,
        "instrument_id"  => $instrumentId,
        "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",
    ]),
]);
$payout = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $payout["id"] . " " . $payout["status"];

body := map[string]any{
    "beneficiary_id":   beneficiaryID,
    "instrument_id":    instrumentID,
    "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",
}
buf, _ := json.Marshal(body)
req, _ := http.NewRequest("POST", "https://api.antonpayments.dev/v1/payouts", bytes.NewReader(buf))
req.Header.Set("Authorization", "DPoP "+os.Getenv("ANTON_ACCESS_TOKEN"))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Idempotency-Key", "pay-quickstart-0001")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()

var payout struct{ ID, Status string }
json.NewDecoder(resp.Body).Decode(&payout)
// payout.ID == "pay_..."  payout.Status == "pending_screening"

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.

Step 5: Listen for webhooks (recommended)

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.

​Before you start

​Step 1: Verify your token

​Step 2: Create a beneficiary

​Step 3: Attach a payment instrument

​Step 4: Send a payout

​Step 5: Listen for webhooks (recommended)

​What’s next?

Send a payout

Handle webhooks

Manage beneficiaries

How Anton evaluates payouts

Batch payouts

Go live

Before you start

Step 1: Verify your token

Step 2: Create a beneficiary

Step 3: Attach a payment instrument

Step 4: Send a payout

Step 5: Listen for webhooks (recommended)

What’s next?