> ## 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.

# Quickstart

> Send your first payout in five minutes. You'll create a beneficiary, attach a payment instrument, and fire a sandbox payout end to end.

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.

<Info>
  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](/guides/going-live).
</Info>

## Before you start

You need:

* **Sandbox OAuth credentials** from the [merchant dashboard](https://app.antonpayments.com) — `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](/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:

```bash theme={}
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](/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.

<CodeGroup>
  ```bash cURL theme={}
  curl https://api.antonpayments.dev/v1/currencies \
    -H "Authorization: DPoP $ANTON_ACCESS_TOKEN" \
    -H "DPoP: $ANTON_DPOP_PROOF"
  ```

  ```javascript JavaScript theme={}
  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`);
  ```

  ```php PHP theme={}
  $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";
  ```

  ```go Go theme={}
  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()
  ```
</CodeGroup>

<Check>
  A `200 OK` with a currency list means your key is authenticated and ready to go.
</Check>

***

## 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.

<CodeGroup>
  ```bash cURL theme={}
  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"
        }
      }
    }'
  ```

  ```javascript JavaScript theme={}
  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_...
  ```

  ```php PHP theme={}
  $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_...
  ```

  ```go Go theme={}
  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_..."
  ```
</CodeGroup>

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`](/api-reference/reference-data/list-payment-methods) for the complete per-country catalog.

<CodeGroup>
  ```bash cURL theme={}
  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"
      }
    }'
  ```

  ```javascript JavaScript theme={}
  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_...
  ```

  ```php PHP theme={}
  $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_...
  ```

  ```go Go theme={}
  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_..."
  ```
</CodeGroup>

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.

<CodeGroup>
  ```bash cURL theme={}
  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"
    }'
  ```

  ```javascript JavaScript theme={}
  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"
  ```

  ```php PHP theme={}
  $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"];
  ```

  ```go Go theme={}
  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"
  ```
</CodeGroup>

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](/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:

```bash cURL theme={}
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](/api-reference/webhook-signing) for the HMAC-SHA256 verification recipe.

<Tip>
  **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`.
</Tip>

***

## What's next?

<CardGroup cols={2}>
  <Card title="Send a payout" icon="paper-plane" href="/guides/send-a-payout">
    The full payout flow with economics, corridors, and FX.
  </Card>

  <Card title="Handle webhooks" icon="bell" href="/guides/handle-webhooks">
    Set up real-time notifications with signed deliveries.
  </Card>

  <Card title="Manage beneficiaries" icon="users" href="/guides/manage-beneficiaries">
    Deduplication, PII updates, archive/restore, and ops workflows.
  </Card>

  <Card title="How Anton evaluates payouts" icon="shield-halved" href="/how-anton-evaluates-payouts">
    Screening, velocity, and the Anton Engine — what each state means.
  </Card>

  <Card title="Batch payouts" icon="layer-group" href="/guides/batch-payouts">
    Upload a CSV and send thousands of payouts in one call.
  </Card>

  <Card title="Go live" icon="rocket" href="/guides/going-live">
    Checklist to promote your integration from sandbox to production.
  </Card>
</CardGroup>