> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dakota.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Foreign exchange (FX)

> Check available currencies and request an FX quote for a SWIFT payment.

Use FX to send or receive foreign currencies over SWIFT. Check which currencies are available to your Customer, then request indicative pricing or a fixed quote.

## Supported currencies

| Code | Currency |
| - | - |
| AUD | Australian dollar |
| CAD | Canadian dollar |
| CHF | Swiss franc |
| CZK | Czech koruna |
| EUR | Euro |
| GBP | Pound sterling |
| HKD | Hong Kong dollar |
| HUF | Hungarian forint |
| JPY | Japanese yen |
| MXN | Mexican peso |
| NOK | Norwegian krone |
| NZD | New Zealand dollar |
| PLN | Polish złoty |
| SEK | Swedish krona |
| SGD | Singapore dollar |
| ZAR | South African rand |

(Accurate as of October 20, 2026)

> [!NOTE]
>
> Availability varies by customer, direction and quote mode. Check the API before offering a currency in your integration. USD uses its existing payment rail, outside this FX list.

## Check available currencies

Call [`GET /customers/{customer_id}/fx-currencies`](/api-reference/customers/list-available-swift-fx-currencies) to check availability for a Customer. Use `direction=outgoing` for payouts or `direction=incoming` for deposits.

```bash theme={null}
curl --get "https://api.platform.dakota.xyz/customers/$CUSTOMER_ID/fx-currencies" \
  --data-urlencode "direction=outgoing" \
  -H "X-API-Key: $DAKOTA_API_KEY"
```

**Response:**

```json theme={null}
{
  "rail": "swift",
  "direction": "outgoing",
  "currencies": [
    {
      "currency": "EUR",
      "minor_units": 2,
      "fixed_enabled": true,
      "indicative_enabled": true
    }
  ]
}
```

| Field | Description |
| - | - |
| `currency` | The currency code. |
| `minor_units` | Decimal places for the currency. JPY uses zero. |
| `fixed_enabled` | Whether fixed quotes are available for this customer and direction. |
| `indicative_enabled` | Whether indicative pricing is available for this customer and direction. |

## Choose a quote mode

| Flow | Mode | Before funding |
| - | - | - |
| Outgoing one-off or reusable account | Indicative | Preview the conversion; the rate is not locked. |
| Outgoing one-off | Fixed, when enabled | Wait for `issued`, then check the funding terms and expiry. |
| Incoming reusable account | Indicative only | Estimate the conversion; the bank instructions do not change. |

Fixed quotes are available on request and are not generally available yet. Check the customer's returned `fixed_enabled` and `indicative_enabled` flags for the direction you need.

## Send an FX payment

This example funds a CAD payout with RD on Base. Start with an approved Customer and a Destination that supports CAD and SWIFT. Follow [recipient setup](/documentation/common-flows#create-a-recipient-and-destination) and the [SWIFT destination requirements](/documentation/destinations-recipients#creating-iban-destinations); use the beneficiary's actual bank instructions.

For the documented `fiat_iban` path, SWIFT requires a BIC and bank address, together with the beneficiary and bank details. Follow the [country-specific address requirements](/documentation/destinations-recipients#address-fields); use intermediary instructions only when supplied by the beneficiary's bank.

### 1. Create the one-off

Examples use production. For sandbox, use `base-sepolia` instead of `base-mainnet` and `https://api.platform.sandbox.dakota.xyz` as the API base URL.

[Create a one-off transfer](/api-reference/transactions/create-a-one-off-transfer) to get the transaction ID and its deposit address. Generate a key once for this request:

```bash theme={null}
CREATE_KEY=$(uuidgen)
```

```bash theme={null}
curl -X POST https://api.platform.dakota.xyz/transactions \
  -H "X-API-Key: $DAKOTA_API_KEY" \
  -H "X-Idempotency-Key: $CREATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "'"$CUSTOMER_ID"'",
    "destination_id": "'"$DESTINATION_ID"'",
    "source_network_id": "base-mainnet",
    "source_asset": "RD",
    "destination_asset": "CAD",
    "destination_payment_rail": "swift"
  }'
```

Keep the returned `id` as `$TRANSACTION_ID`, together with `crypto_address`, `source_asset` and `source_network_id`. Creating the one-off does not fund it. A retry of this creation request uses the same `$CREATE_KEY`.

### 2. Request a quote

[Request pricing](/api-reference/transactions/request-a-directional-fx-quote-or-estimate) for that transaction. This indicative request estimates the CAD payout from spending 100 RD. `amount_side: "source"` specifies the funding-token quantity; use `"destination"` to specify a CAD target instead.

```bash theme={null}
QUOTE_KEY=$(uuidgen)
```

```bash theme={null}
curl -X POST https://api.platform.dakota.xyz/fx/quotes \
  -H "X-API-Key: $DAKOTA_API_KEY" \
  -H "X-Idempotency-Key: $QUOTE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "direction": "outgoing",
    "mode": "indicative",
    "source_asset": "RD",
    "destination_asset": "CAD",
    "amount": "100",
    "amount_side": "source",
    "transaction_id": "'"$TRANSACTION_ID"'"
  }'
```

For a fixed quote, choose `mode: "fixed"` when making the request, if enabled. Keep the same `$QUOTE_KEY` for retries of that request; do not change its inputs or mode while retrying.

Use the returned quote, rather than calculating a conversion in your application:

| Field | How to use it |
| - | - |
| `status`, `mode` | An indicative `estimated` price is not a lock. Do not fund a fixed quote until it is `issued`. |
| `quote_id` | Retain it for fixed-quote status reads, including a pending request. |
| `source_asset`, `destination_asset` | Confirm the funding token and payout currency match the transaction. |
| `funding_amount` | Token quantity to send, including the developer fee. |
| `funding_amount_smallest_units`, `funding_decimals` | Exact token precision for the funding amount. |
| `target_amount` | Quoted payout amount; an indicative amount can change. |
| `expires_at` | For fixed quotes, check the lock's expiry before funding. |
| `eligible_networks` | Uses CAIP-2 chain IDs: Base is `eip155:8453` (`base-mainnet`); sandbox is `eip155:84532` (`base-sepolia`). Match the chain, not the slug string. |

A `202` fixed-quote response is pending. [Read that quote](/api-reference/transactions/get-an-owned-one-off-fx-quote) before funding:

```bash theme={null}
curl --get "https://api.platform.dakota.xyz/fx/quotes/$QUOTE_ID" \
  --data-urlencode "transaction_id=$TRANSACTION_ID" \
  -H "X-API-Key: $DAKOTA_API_KEY"
```

### 3. Fund the payment

Transfer the quoted `funding_amount` of the quoted asset to the one-off's existing `crypto_address`, on its matching network. Do not send the CAD target amount as RD or assume the funding token is worth one USD. For a Dakota Wallet, use the existing [sign-and-send flow](/documentation/common-flows#sign-and-send-a-transaction) and [Wallet Transaction Signing](/documentation/wallet-signing).

There is no separate FX execute call. The deposit funds the payment; a quote or wallet broadcast does not mean the SWIFT payout is complete.

For fixed pricing, on-chain inclusion time counts—not when you broadcast. Funding included at or after `expires_at`, or in another supported asset, is handled with indicative market pricing instead of the locked rate, subject to payment checks. A short deposit, an uncertain inclusion time, or a transfer detected much later can be held for review. If funds may already have been sent, reconcile the existing transaction before sending again.

### 4. Track the payout

Read [`GET /transactions/{transaction_id}`](/api-reference/transactions/get-a-transaction) and handle `transaction.one_off.created` and `transaction.one_off.updated` using the [webhook guide](/documentation/webhooks#transaction-events). Follow the transaction through processing and completion, then keep handling later updates in case the bank returns the wire.

Reconcile actual receipt and final FX fields, not the original requested amount or preview. `fx_pricing.state: "quoted"` can change; `"final"` reports the applied rate and fee. A missing `fx_settlement` means the settlement amount is unknown, even if the transaction is completed. Bank/intermediary deductions can reduce what the beneficiary receives; see [SWIFT caveats](/documentation/advanced-flows#swift-caveats).

## Reusable accounts and incoming funds

For repeated payouts, follow [account setup in Common Flows](/documentation/common-flows) and the [SWIFT setup guide](/documentation/advanced-flows#swift-payouts-international-wire). An outgoing reusable account uses `account_id` for indicative pricing; fixed mode is one-off only. Deposits create auto transactions: use [`GET /auto-transactions/{auto_transaction_id}`](/api-reference/auto-transactions/get-details-of-a-specific-auto-account-transaction) and `transaction.auto.created` / `transaction.auto.updated`, not the one-off endpoints/events.

For incoming funds, follow [SWIFT for onramps](/documentation/advanced-flows#swift-for-onramps) and give the sender the complete returned bank instructions. An optional incoming estimate uses an automatic account's `account_id`, `direction: "incoming"`, `amount_side: "source"` and indicative mode. The actual received deposit triggers conversion; an estimate does not send funds or change the instructions.

## In Financial Account

For a supported foreign SWIFT recipient, preview the conversion or lock an available fixed quote. Review **You send**, **Recipient gets** and any fixed expiry. **Send Now** creates the payment for review; **Confirm & Sign**, or the required other approver, authorizes funding. Pending or expired fixed quotes cannot be sent. If approval is interrupted, check the existing transaction in History before creating another.

## Quote status and errors

Reading a fixed quote does not refresh pricing or extend expiry. If an unfunded quote expires, obtain new pricing. If funding may already have happened, check the existing transaction or contact support before retrying; do not assume funds were refunded. A returned wire is not necessarily refunded yet.

For currency-discovery requests:

| Response | What to do |
| - | - |
| `200` with `currencies: []` | No foreign currency is available for this customer and direction. This does not confirm USD SWIFT is ready. |
| `401` | Check the API key used for the request. |
| `503` | Availability could not be determined. Read the error detail; retry temporary failures with backoff, or contact support for provisioning issues. |

Quote requests can also return `403` for permission refusals, `409` for conflicts or unavailable fixed-quote capacity, or `422` for unsupported request or resource combinations. Read the error detail before changing or retrying the request. See the [API error reference](/api-reference/errors) for the full contract.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.