> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.coinflow.cash/guides/payouts/payout-methods/supported-payout-methods/crypto/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.coinflow.cash/_mcp/server.

# Crypto

> **Warning**
>
> **This page is for advanced / cryptocurrency-native companies.** If that's not you, head back to the [Quickstart](/guides/getting-started/quickstart) for the standard flows.

## Crypto Payouts

Crypto Payouts let you pay a user in cryptocurrency instead of to a bank account, card, or wallet app. Your integration provides the destination wallet address, chain, and token; Coinflow funds the transfer from your Coinflow wallet.

> **Info**
>
> **How It Works**
>
> 1. You create a **destructive API key** — a dedicated, highest-risk credential that can only perform crypto payouts
> 2. Your integration calls the delegated payout endpoint with `speed: "crypto"` and the user's destination address, chain, and token
> 3. Coinflow debits your Coinflow wallet for the payout amount plus the delivery fee, screens the destination for compliance, and delivers the tokens on the destination chain
> 4. The withdrawal completes with a shareable receipt link you can send to your user as proof of payment

> **Warning**
>
> **On-chain transfers are final.** They settle in seconds and cannot be recalled, reversed, cancelled, or refunded. Coinflow does **not** validate destination addresses — if the address your integration provides is wrong, malformed for the chain, or controlled by an attacker, the funds are gone. Address, chain, token, and amount are your responsibility.

---

## Prerequisites

Before using Crypto Payouts, ensure:

* Crypto payouts are enabled on your merchant account — contact the [Coinflow integrations team](mailto:sales@coinflowlabs.app) to enable this feature
* The user (withdrawer) has completed [KYC verification](/guides/payouts/kyc-verification)
* Your Coinflow wallet holds enough balance to cover the payout amount plus the delivery fee
* You have created a **destructive API key** (see below)

### Create a Destructive API Key

Crypto payouts require a dedicated API key with the `destructive` role. This key is fully isolated:

* It is the **only** credential that can initiate crypto payouts — your admin, editor, and viewer keys cannot, and neither can dashboard sessions

#### Open API Keys in the dashboard

Go to **Developers → API Keys** in the [merchant dashboard](https://sandbox-merchant.coinflow.cash/api-keys) and click **Create Key**.

#### Select the Destructive role

Choose **Destructive** as the key's role. Read the risk statements shown in the dialog and check both acknowledgment boxes — creation is blocked until you do, and your acknowledgment is recorded in your account's audit log.

#### Restrict and store the key

Add the IP addresses or CIDR ranges your servers call from (required in production). The key is shown **once** — store it in a secrets manager. Never put it in frontend code, a repository, a config file, or a support ticket.

> **Warning**
>
> **If this key leaks, you bear the loss.** Anyone holding it can drain your available balance with irreversible transfers. A key exposed in source control, CI logs, error reporting, a browser bundle, or a compromised machine is still a valid key, and Coinflow cannot distinguish its use from your own. If you suspect exposure, disable and revoke the key in the dashboard immediately.

---

## Supported Chains & Tokens

Every chain and token is identified by a stable id: `chainId` is a [CAIP-2](https://chainagnostic.org/CAIPs/caip-2) chain id (e.g. `eip155:8453`) and `tokenId` is the lowercase token symbol (e.g. `usdc`). These ids are the values your integration passes as the payout destination's `chain` and `token` — they never vary by delivery route, and the same pair always has the same ids.

Retrieve the chains and tokens enabled for your account dynamically:

### Request

GET [https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens](https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens)

```curl
curl https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens \
     -H "Authorization: <apiKey>"
```

```python
import requests

url = "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens"

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens")
  .header("Authorization", "<apiKey>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/crypto/tokens")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (200)

```json
{
  "chains": [
    {
      "chainId": "string",
      "name": "string",
      "logoUrl": "string",
      "tokens": [
        {
          "tokenId": "string",
          "symbol": "string",
          "name": "string",
          "logoUrl": "string"
        }
      ]
    }
  ]
}
```

> **Warning**
>
> The response shown is an **example**. The actual chains, tokens, and image URLs differ between sandbox and production and reflect what is enabled on your account. Always use the API response to populate your UI, and pass the returned `chainId` and `tokenId` verbatim in your payout requests — chain display names are **not** accepted.

---

## Quote a Crypto Payout

Preview a crypto payout before sending it: the total your Coinflow wallet would be debited, the fee, the USD value the user receives, and the amount of the destination token that will be delivered. Quoting is read-only — nothing moves — and accepts your **admin** key as well as your destructive key.

```json
{
  "userId": "user-1234",
  "amount": { "cents": 2500, "currency": "USD" },
  "account": {
    "chain": "eip155:8453",
    "token": "usdc"
  }
}
```

### Request

POST [https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto](https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto)

```curl
curl -X POST https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto \
     -H "Authorization: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "userId": "string",
  "amount": {
    "cents": 1,
    "currency": "USD"
  },
  "account": {
    "token": "string",
    "chain": "string"
  }
}'
```

```python
import requests

url = "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto"

payload = {
    "userId": "string",
    "amount": {
        "cents": 1,
        "currency": "USD"
    },
    "account": {
        "token": "string",
        "chain": "string"
    }
}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"userId":"string","amount":{"cents":1,"currency":"USD"},"account":{"token":"string","chain":"string"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto"

	payload := strings.NewReader("{\n  \"userId\": \"string\",\n  \"amount\": {\n    \"cents\": 1,\n    \"currency\": \"USD\"\n  },\n  \"account\": {\n    \"token\": \"string\",\n    \"chain\": \"string\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"userId\": \"string\",\n  \"amount\": {\n    \"cents\": 1,\n    \"currency\": \"USD\"\n  },\n  \"account\": {\n    \"token\": \"string\",\n    \"chain\": \"string\"\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"userId\": \"string\",\n  \"amount\": {\n    \"cents\": 1,\n    \"currency\": \"USD\"\n  },\n  \"account\": {\n    \"token\": \"string\",\n    \"chain\": \"string\"\n  }\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto', [
  'body' => '{
  "userId": "string",
  "amount": {
    "cents": 1,
    "currency": "USD"
  },
  "account": {
    "token": "string",
    "chain": "string"
  }
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"userId\": \"string\",\n  \"amount\": {\n    \"cents\": 1,\n    \"currency\": \"USD\"\n  },\n  \"account\": {\n    \"token\": \"string\",\n    \"chain\": \"string\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "userId": "string",
  "amount": [
    "cents": 1,
    "currency": "USD"
  ],
  "account": [
    "token": "string",
    "chain": "string"
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated/quote/crypto")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (200)

```json
{
  "quote": {
    "cents": 1,
    "currency": "USD"
  },
  "totalMerchantDebit": {
    "cents": 1,
    "currency": "USD"
  },
  "userPayout": {
    "cents": 1,
    "currency": "USD"
  },
  "merchantFees": {
    "cents": 1,
    "currency": "USD"
  },
  "deliveryAmount": "string"
}
```

The response's `deliveryAmount` is the amount of the requested destination token the user will receive, as a decimal string in the token's own units.

> **Warning**
>
> Quotes for non-stablecoin tokens (SOL, ETH, …) are estimates at the current market rate and are **not guaranteed** — the delivered amount is finalized when the payout is processed.

---

## Initiate a Crypto Payout

Call the standard delegated payout endpoint with `speed: "crypto"` and the on-chain destination as the `account`, authenticated with your **destructive API key**. A crypto payout's request body looks like:

```json
{
  "userId": "user-1234",
  "amount": { "cents": 2500 },
  "speed": "crypto",
  "idempotencyKey": "d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b",
  "account": {
    "address": "0x1234abcd...",
    "chain": "eip155:8453",
    "token": "usdc"
  }
}
```

> **Warning**
>
> All values above (`userId`, address, idempotency key) are **examples** — replace them with real values from your integration.

### Request

POST [https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated](https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated)

**`Crypto Payout`**

```curl Crypto Payout
curl -X POST https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated \
     -H "Authorization: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "speed": "crypto",
  "userId": "user-1234",
  "idempotencyKey": "d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b",
  "account": {
    "address": "0x1234abcd...",
    "chain": "eip155:8453",
    "token": "usdc"
  },
  "amount": {
    "cents": 2500
  }
}'
```

**`Crypto Payout`**

```python Crypto Payout
import requests

url = "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated"

payload = {
    "speed": "crypto",
    "userId": "user-1234",
    "idempotencyKey": "d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b",
    "account": {
        "address": "0x1234abcd...",
        "chain": "eip155:8453",
        "token": "usdc"
    },
    "amount": { "cents": 2500 }
}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

**`Crypto Payout`**

```javascript Crypto Payout
const url = 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"speed":"crypto","userId":"user-1234","idempotencyKey":"d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b","account":{"address":"0x1234abcd...","chain":"eip155:8453","token":"usdc"},"amount":{"cents":2500}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**`Crypto Payout`**

```go Crypto Payout
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated"

	payload := strings.NewReader("{\n  \"speed\": \"crypto\",\n  \"userId\": \"user-1234\",\n  \"idempotencyKey\": \"d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b\",\n  \"account\": {\n    \"address\": \"0x1234abcd...\",\n    \"chain\": \"eip155:8453\",\n    \"token\": \"usdc\"\n  },\n  \"amount\": {\n    \"cents\": 2500\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

**`Crypto Payout`**

```ruby Crypto Payout
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"speed\": \"crypto\",\n  \"userId\": \"user-1234\",\n  \"idempotencyKey\": \"d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b\",\n  \"account\": {\n    \"address\": \"0x1234abcd...\",\n    \"chain\": \"eip155:8453\",\n    \"token\": \"usdc\"\n  },\n  \"amount\": {\n    \"cents\": 2500\n  }\n}"

response = http.request(request)
puts response.read_body
```

**`Crypto Payout`**

```java Crypto Payout
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"speed\": \"crypto\",\n  \"userId\": \"user-1234\",\n  \"idempotencyKey\": \"d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b\",\n  \"account\": {\n    \"address\": \"0x1234abcd...\",\n    \"chain\": \"eip155:8453\",\n    \"token\": \"usdc\"\n  },\n  \"amount\": {\n    \"cents\": 2500\n  }\n}")
  .asString();
```

**`Crypto Payout`**

```php Crypto Payout
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated', [
  'body' => '{
  "speed": "crypto",
  "userId": "user-1234",
  "idempotencyKey": "d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b",
  "account": {
    "address": "0x1234abcd...",
    "chain": "eip155:8453",
    "token": "usdc"
  },
  "amount": {
    "cents": 2500
  }
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

**`Crypto Payout`**

```csharp Crypto Payout
using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"speed\": \"crypto\",\n  \"userId\": \"user-1234\",\n  \"idempotencyKey\": \"d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b\",\n  \"account\": {\n    \"address\": \"0x1234abcd...\",\n    \"chain\": \"eip155:8453\",\n    \"token\": \"usdc\"\n  },\n  \"amount\": {\n    \"cents\": 2500\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`Crypto Payout`**

```swift Crypto Payout
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "speed": "crypto",
  "userId": "user-1234",
  "idempotencyKey": "d9a4d8f2-1b2c-4e5f-8a7b-3c6d9e0f1a2b",
  "account": [
    "address": "0x1234abcd...",
    "chain": "eip155:8453",
    "token": "usdc"
  ],
  "amount": ["cents": 2500]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/merchant/withdraws/payout/delegated")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### Response (200)

```json
{
  "effectiveSpeed": "crypto",
  "signature": "4Cv4nbe6fkGpdSYcqhPHXkdndeiyTa8mhFoWW5x3vroxRibAUssrbXZ5VW4vxkPedcX3xTRKu7ZpkJXWKdJBCGuq"
}
```

### Request Fields

| Field             | Description                                                                                                                                                 |
| ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `userId`          | The ID of the KYC-verified user being paid                                                                                                                  |
| `amount.cents`    | The payout amount in USD cents. The user receives exactly this when your account covers withdraw fees; otherwise your configured payout fee comes out of it |
| `speed`           | Must be `"crypto"`                                                                                                                                          |
| `idempotencyKey`  | A unique key (V4 UUID recommended). Retries with the same key return the original result instead of paying twice                                            |
| `account.address` | The user's wallet address on the destination chain. **Not validated by Coinflow**                                                                           |
| `account.chain`   | A `chainId` from the crypto payout tokens endpoint (e.g. `eip155:8453`)                                                                                     |
| `account.token`   | A `tokenId` from the crypto payout tokens endpoint — the lowercase token symbol, matched case-insensitively                                                 |

> **Tip**
>
> Reusing an `idempotencyKey` is always safe: a retry returns the original payout's signature instead of sending funds twice — a key can never produce a second transfer, so always use a fresh key for a new payout.

### Fees

Coinflow covers the on-chain delivery cost. Your account's configured crypto payout fee follows your fee-responsibility setting: when your account covers withdraw fees, the user receives exactly `amount` and your Coinflow wallet is debited `amount` plus the fee in a single transfer; otherwise your wallet is debited exactly `amount` and the fee comes out of the delivered amount. Fees are never billed separately or invoiced later — they appear on the withdrawal record as merchant-paid or user-paid fees accordingly.

Crypto payouts are enabled and priced per token tier (stablecoins/majors ex: BTC, SOL, ETH) on your account — contact the [integrations team](mailto:sales@coinflowlabs.app) to enable them or adjust pricing.

---

## Compliance Screening

Every destination address is screened against sanctions and risk intelligence immediately **before delivery** — no funds leave Coinflow to a destination that hasn't passed screening.

* If a flag is raised, the payout pauses in `pending` while Coinflow's compliance team reviews it. Cleared payouts resume automatically; confirmed matches remain blocked and Coinflow will contact you.

---

## Tracking & Proof of Payment

Crypto payouts appear on the **Withdrawals** tab of the merchant dashboard with the destination token and chain shown as the payout method. Opening a withdrawal shows the chain the funds were sent on, the destination wallet, and — once the transfer completes — a **proof of payment** receipt: a block-explorer link you can copy and send to your user.

Programmatically:

* You receive the standard [withdraw webhooks](/guides/developer-resources/webhooks/withdraw-webhooks): `Withdraw Pending` when the payout is accepted and `Withdraw Success` when the tokens are delivered.
* Look up any payout via `GET /merchant/withdraws?search=<idempotencyKey>`. Completed crypto payouts include a `cryptoPayoutInfo` object with the destination `chain`, `token`, `destinationAddress`, the delivery transaction signature, and the shareable receipt URL.
* The withdrawal's expected delivery date is set to the actual completion time when the transfer lands — crypto payouts typically complete within minutes.

---

## Errors

#### 401 / 403 — authorization

* `Crypto withdrawals require an API key with the destructive scope` — you called `speed: "crypto"` with an admin or other non-destructive credential. Use your crypto sends key.
* `Destructive API keys can only be used for crypto withdrawals` — your crypto sends key was used for a non-crypto payout speed. Use your admin key for those.

#### 400 — request problems

* `account must be a crypto destination with address, chain and token for crypto withdrawals` — the destination object is missing or incomplete.
* `Unsupported chain: ...` / `Token ... is not supported on chain ...` — pass a `chainId` and `tokenId` from the crypto payout tokens endpoint. Chain display names (e.g. `"Base"`) are not accepted.
* `Crypto payouts are not enabled for this merchant` — the destination token's tier isn't enabled on your account; contact the [integrations team](mailto:sales@coinflowlabs.app).
* `No crypto payout provider is configured for this merchant` — crypto payouts aren't enabled on your account yet; contact the [integrations team](mailto:sales@coinflowlabs.app).

#### 402 / 409 / 503 — funding and retries

* `402 Insufficient Funds` — your Coinflow wallet can't cover the payout plus your configured payout fee.
* `409 Idempotency key conflict` — the original request with this key is still in flight; wait for it to finish and retry to receive its result.
* `503` — the funding transfer hit a temporary issue; retry the request immediately with the **same** `idempotencyKey`.