Merchant Payouts from Your Coinflow wallet

This is the most common payout flow for platforms that hold a user balance and disburse to that user when they request a withdrawal — gaming platforms, marketplaces, gig economy apps, reward programs, SaaS creator earnings, and similar.

Your backend tracks the balance. When a user requests a payout, you call Coinflow to (1) verify the user’s identity, (2) save where they want their money sent, and (3) initiate the payout. Funds come out of your Coinflow wallet.

Best for

Platforms where the merchant tracks user balances and initiates payouts on the user’s behalf.

Source of funds

Your Coinflow wallet — the same balance that receives proceeds from Coinflow Checkout.

Supported destinations

US bank account, US debit card (push-to-card), IBAN (EUR/GBP), PIX (BRL).

UI

API-driven. Coinflow optionally provides a pre-built Bank Authentication UI that handles KYC + linking a destination.

How the flow works

sequenceDiagram
    autonumber
    participant User
    participant Merchant as Your backend
    participant Coinflow

    User->>Merchant: Requests payout
    Merchant->>Coinflow: Verify identity (KYC/KYB)
    Coinflow-->>Merchant: Withdrawer record
    Merchant->>Coinflow: Add payout destination (bank / card / IBAN / PIX)
    Merchant->>Coinflow: Get quote (amount + fees + speed options)
    Coinflow-->>Merchant: Quote breakdown
    Merchant->>Coinflow: Initiate payout (debits your Coinflow wallet)
    Coinflow->>User: Funds delivered to destination
    Coinflow->>Merchant: Webhook (success or failure)

Prerequisites

Complete account setup first

This integration assumes you’ve completed the Account Setup prerequisites — sandbox merchant account, API key, team access, and any product-specific configuration (settlement location, chargeback protection, or wallet funding).

Before sending real payouts, you’ll need:

1. A merchant account (register on sandbox) and an API key.
2. A funded Coinflow wallet. In sandbox, contact the Coinflow team for test funds. In production, your balance fills from Coinflow Checkout proceeds.
3. (Optional) Webhook endpoint configured to receive payout status updates — see Withdraw Webhooks.

Authorization Headers:

• Authorization — Your API key from the merchant dashboard.
• x-coinflow-auth-user-id — A unique customer ID from your own systems identifying the payer or payee.
• x-coinflow-auth-session-key — A JWT that authorizes the payer. Valid for 24 hours; refresh after expiry.

Implementation

Step 1: Verify the withdrawer (KYC/KYB)

Every user must complete identity verification before their first payout. Once verified, the same user can be paid out repeatedly with no re-verification.

Choose the path that matches how you handle identity today:

Coinflow handles KYC (most common)

Pass the user’s details to Coinflow and we run identity verification end-to-end.

US withdrawers require full SSN, address, and date of birth.

Request

POST https://api-sandbox.coinflow.cash/api/withdraw/kyc

curl -X POST https://api-sandbox.coinflow.cash/api/withdraw/kyc \
     -H "x-coinflow-auth-user-id: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "info": {
    "email": "string",
    "firstName": "string",
    "surName": "string",
    "physicalAddress": "string",
    "city": "string",
    "state": "string",
    "zip": "string",
    "country": "string",
    "dob": "string",
    "ssn": "string"
  }
}'

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw/kyc"

payload = { "info": {
        "email": "string",
        "firstName": "string",
        "surName": "string",
        "physicalAddress": "string",
        "city": "string",
        "state": "string",
        "zip": "string",
        "country": "string",
        "dob": "string",
        "ssn": "string"
    } }
headers = {
    "x-coinflow-auth-user-id": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw/kyc';
const options = {
  method: 'POST',
  headers: {'x-coinflow-auth-user-id': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"info":{"email":"string","firstName":"string","surName":"string","physicalAddress":"string","city":"string","state":"string","zip":"string","country":"string","dob":"string","ssn":"string"}}'
};

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw/kyc"

	payload := strings.NewReader("{\n  \"info\": {\n    \"email\": \"string\",\n    \"firstName\": \"string\",\n    \"surName\": \"string\",\n    \"physicalAddress\": \"string\",\n    \"city\": \"string\",\n    \"state\": \"string\",\n    \"zip\": \"string\",\n    \"country\": \"string\",\n    \"dob\": \"string\",\n    \"ssn\": \"string\"\n  }\n}")

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

	req.Header.Add("x-coinflow-auth-user-id", "<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))

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw/kyc")

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

request = Net::HTTP::Post.new(url)
request["x-coinflow-auth-user-id"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"info\": {\n    \"email\": \"string\",\n    \"firstName\": \"string\",\n    \"surName\": \"string\",\n    \"physicalAddress\": \"string\",\n    \"city\": \"string\",\n    \"state\": \"string\",\n    \"zip\": \"string\",\n    \"country\": \"string\",\n    \"dob\": \"string\",\n    \"ssn\": \"string\"\n  }\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/withdraw/kyc")
  .header("x-coinflow-auth-user-id", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"info\": {\n    \"email\": \"string\",\n    \"firstName\": \"string\",\n    \"surName\": \"string\",\n    \"physicalAddress\": \"string\",\n    \"city\": \"string\",\n    \"state\": \"string\",\n    \"zip\": \"string\",\n    \"country\": \"string\",\n    \"dob\": \"string\",\n    \"ssn\": \"string\"\n  }\n}")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/withdraw/kyc', [
  'body' => '{
  "info": {
    "email": "string",
    "firstName": "string",
    "surName": "string",
    "physicalAddress": "string",
    "city": "string",
    "state": "string",
    "zip": "string",
    "country": "string",
    "dob": "string",
    "ssn": "string"
  }
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-coinflow-auth-user-id' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw/kyc");
var request = new RestRequest(Method.POST);
request.AddHeader("x-coinflow-auth-user-id", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"info\": {\n    \"email\": \"string\",\n    \"firstName\": \"string\",\n    \"surName\": \"string\",\n    \"physicalAddress\": \"string\",\n    \"city\": \"string\",\n    \"state\": \"string\",\n    \"zip\": \"string\",\n    \"country\": \"string\",\n    \"dob\": \"string\",\n    \"ssn\": \"string\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

import Foundation

let headers = [
  "x-coinflow-auth-user-id": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["info": [
    "email": "string",
    "firstName": "string",
    "surName": "string",
    "physicalAddress": "string",
    "city": "string",
    "state": "string",
    "zip": "string",
    "country": "string",
    "dob": "string",
    "ssn": "string"
  ]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw/kyc")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "user": true,
    "watchlistExempt": "Unknown",
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "dwolla": {
      "customerId": "string",
      "status": "pending",
      "acceptedTerms": "2024-01-15T09:30:00Z",
      "verification": {
        "reference": "string",
        "status": "pending",
        "vendor": "middesk",
        "name": "string",
        "attested": true,
        "shareToken": "string",
        "shareTokenStatus": "string",
        "sessionToken": "string",
        "rejectionReasons": [
          "string"
        ]
      }
    },
    "watchlistId": "string"
  }
}

Non-US withdrawers require email and country only at this step. The user completes identity verification through a hosted link returned in the response.

Upload identity documents

If your platform already collects identity documents (front + back of ID), send them to Coinflow directly via multipart upload.

Request

POST https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc

curl -X POST https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc \
     -H "x-coinflow-auth-user-id: <apiKey>" \
     -H "Content-Type: multipart/form-data" \
     -F email="string" \
     -F country="string" \
     -F idType="string" \
     -F merchantId="string" \
     -F idFront=@string \
     -F idBack=@<file1>

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc"

files = {
    "idFront": "open('string', 'rb')",
    "idBack": "open('<file1>', 'rb')"
}
payload = {
    "email": "string",
    "country": "string",
    "idType": "string",
    "merchantId": "string"
}
headers = {"x-coinflow-auth-user-id": "<apiKey>"}

response = requests.post(url, data=payload, files=files, headers=headers)

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc';
const form = new FormData();
form.append('email', 'string');
form.append('country', 'string');
form.append('idType', 'string');
form.append('merchantId', 'string');
form.append('idFront', 'string');
form.append('idBack', '<file1>');

const options = {method: 'POST', headers: {'x-coinflow-auth-user-id': '<apiKey>'}};

options.body = form;

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"email\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"country\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idType\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"merchantId\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idFront\"; filename=\"string\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idBack\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("x-coinflow-auth-user-id", "<apiKey>")

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

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

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

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc")

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

request = Net::HTTP::Post.new(url)
request["x-coinflow-auth-user-id"] = '<apiKey>'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"email\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"country\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idType\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"merchantId\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idFront\"; filename=\"string\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idBack\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001--\r\n"

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

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

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc")
  .header("x-coinflow-auth-user-id", "<apiKey>")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"email\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"country\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idType\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"merchantId\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idFront\"; filename=\"string\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idBack\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc', [
  'multipart' => [
    [
        'name' => 'email',
        'contents' => 'string'
    ],
    [
        'name' => 'country',
        'contents' => 'string'
    ],
    [
        'name' => 'idType',
        'contents' => 'string'
    ],
    [
        'name' => 'merchantId',
        'contents' => 'string'
    ],
    [
        'name' => 'idFront',
        'filename' => 'string',
        'contents' => null
    ],
    [
        'name' => 'idBack',
        'filename' => '<file1>',
        'contents' => null
    ]
  ]
  'headers' => [
    'x-coinflow-auth-user-id' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc");
var request = new RestRequest(Method.POST);
request.AddHeader("x-coinflow-auth-user-id", "<apiKey>");
request.AddParameter("undefined", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"email\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"country\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idType\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"merchantId\"\r\n\r\nstring\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idFront\"; filename=\"string\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"idBack\"; filename=\"<file1>\"\r\nContent-Type: application/octet-stream\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

import Foundation

let headers = ["x-coinflow-auth-user-id": "<apiKey>"]
let parameters = [
  [
    "name": "email",
    "value": "string"
  ],
  [
    "name": "country",
    "value": "string"
  ],
  [
    "name": "idType",
    "value": "string"
  ],
  [
    "name": "merchantId",
    "value": "string"
  ],
  [
    "name": "idFront",
    "fileName": "string"
  ],
  [
    "name": "idBack",
    "fileName": "<file1>"
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw/kyc-doc")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "user": true,
    "watchlistExempt": "Unknown",
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "dwolla": {
      "customerId": "string",
      "status": "pending",
      "acceptedTerms": "2024-01-15T09:30:00Z",
      "verification": {
        "reference": "string",
        "status": "pending",
        "vendor": "middesk",
        "name": "string",
        "attested": true,
        "shareToken": "string",
        "shareTokenStatus": "string",
        "sessionToken": "string",
        "rejectionReasons": [
          "string"
        ]
      }
    },
    "watchlistId": "string"
  }
}

Share a token from an existing identity provider

If you’ve already verified the user through your own identity provider, you can pass a share token instead of re-verifying. Requires a tri-party data-sharing agreement — contact the Coinflow team with your identity provider’s client ID to set this up.

Request

POST https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token

curl -X POST https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token \
     -H "x-coinflow-auth-user-id: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "vendor": "sumsub",
  "shareToken": "string",
  "country": "string",
  "email": "string"
}'

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token"

payload = {
    "vendor": "sumsub",
    "shareToken": "string",
    "country": "string",
    "email": "string"
}
headers = {
    "x-coinflow-auth-user-id": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token';
const options = {
  method: 'POST',
  headers: {'x-coinflow-auth-user-id': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"vendor":"sumsub","shareToken":"string","country":"string","email":"string"}'
};

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token"

	payload := strings.NewReader("{\n  \"vendor\": \"sumsub\",\n  \"shareToken\": \"string\",\n  \"country\": \"string\",\n  \"email\": \"string\"\n}")

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

	req.Header.Add("x-coinflow-auth-user-id", "<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))

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token")

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

request = Net::HTTP::Post.new(url)
request["x-coinflow-auth-user-id"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"vendor\": \"sumsub\",\n  \"shareToken\": \"string\",\n  \"country\": \"string\",\n  \"email\": \"string\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token")
  .header("x-coinflow-auth-user-id", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"vendor\": \"sumsub\",\n  \"shareToken\": \"string\",\n  \"country\": \"string\",\n  \"email\": \"string\"\n}")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token', [
  'body' => '{
  "vendor": "sumsub",
  "shareToken": "string",
  "country": "string",
  "email": "string"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-coinflow-auth-user-id' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token");
var request = new RestRequest(Method.POST);
request.AddHeader("x-coinflow-auth-user-id", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"vendor\": \"sumsub\",\n  \"shareToken\": \"string\",\n  \"country\": \"string\",\n  \"email\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

import Foundation

let headers = [
  "x-coinflow-auth-user-id": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "vendor": "sumsub",
  "shareToken": "string",
  "country": "string",
  "email": "string"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw/kyc/share-token")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "user": true,
    "watchlistExempt": "Unknown",
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "dwolla": {
      "customerId": "string",
      "status": "pending",
      "acceptedTerms": "2024-01-15T09:30:00Z",
      "verification": {
        "reference": "string",
        "status": "pending",
        "vendor": "middesk",
        "name": "string",
        "attested": true,
        "shareToken": "string",
        "shareTokenStatus": "string",
        "sessionToken": "string",
        "rejectionReasons": [
          "string"
        ]
      }
    },
    "watchlistId": "string"
  }
}

Attest to your own KYC (KYC Reliance)

For merchants with their own approved KYC program. Requires Compliance review and approval from the Coinflow team before use.

Request

POST https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested

curl -X POST https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested \
     -H "x-coinflow-auth-user-id: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "country": "string",
  "email": "string",
  "firstName": "string",
  "surName": "string",
  "physicalAddress": "string",
  "city": "string",
  "state": "string",
  "zip": "string",
  "dob": "string"
}'

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested"

payload = {
    "country": "string",
    "email": "string",
    "firstName": "string",
    "surName": "string",
    "physicalAddress": "string",
    "city": "string",
    "state": "string",
    "zip": "string",
    "dob": "string"
}
headers = {
    "x-coinflow-auth-user-id": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested';
const options = {
  method: 'POST',
  headers: {'x-coinflow-auth-user-id': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"country":"string","email":"string","firstName":"string","surName":"string","physicalAddress":"string","city":"string","state":"string","zip":"string","dob":"string"}'
};

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested"

	payload := strings.NewReader("{\n  \"country\": \"string\",\n  \"email\": \"string\",\n  \"firstName\": \"string\",\n  \"surName\": \"string\",\n  \"physicalAddress\": \"string\",\n  \"city\": \"string\",\n  \"state\": \"string\",\n  \"zip\": \"string\",\n  \"dob\": \"string\"\n}")

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

	req.Header.Add("x-coinflow-auth-user-id", "<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))

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested")

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

request = Net::HTTP::Post.new(url)
request["x-coinflow-auth-user-id"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"country\": \"string\",\n  \"email\": \"string\",\n  \"firstName\": \"string\",\n  \"surName\": \"string\",\n  \"physicalAddress\": \"string\",\n  \"city\": \"string\",\n  \"state\": \"string\",\n  \"zip\": \"string\",\n  \"dob\": \"string\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested")
  .header("x-coinflow-auth-user-id", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"country\": \"string\",\n  \"email\": \"string\",\n  \"firstName\": \"string\",\n  \"surName\": \"string\",\n  \"physicalAddress\": \"string\",\n  \"city\": \"string\",\n  \"state\": \"string\",\n  \"zip\": \"string\",\n  \"dob\": \"string\"\n}")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested', [
  'body' => '{
  "country": "string",
  "email": "string",
  "firstName": "string",
  "surName": "string",
  "physicalAddress": "string",
  "city": "string",
  "state": "string",
  "zip": "string",
  "dob": "string"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-coinflow-auth-user-id' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested");
var request = new RestRequest(Method.POST);
request.AddHeader("x-coinflow-auth-user-id", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"country\": \"string\",\n  \"email\": \"string\",\n  \"firstName\": \"string\",\n  \"surName\": \"string\",\n  \"physicalAddress\": \"string\",\n  \"city\": \"string\",\n  \"state\": \"string\",\n  \"zip\": \"string\",\n  \"dob\": \"string\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

import Foundation

let headers = [
  "x-coinflow-auth-user-id": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "country": "string",
  "email": "string",
  "firstName": "string",
  "surName": "string",
  "physicalAddress": "string",
  "city": "string",
  "state": "string",
  "zip": "string",
  "dob": "string"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw/kyc/attested")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "user": true,
    "watchlistExempt": "Unknown",
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "dwolla": {
      "customerId": "string",
      "status": "pending",
      "acceptedTerms": "2024-01-15T09:30:00Z",
      "verification": {
        "reference": "string",
        "status": "pending",
        "vendor": "middesk",
        "name": "string",
        "attested": true,
        "shareToken": "string",
        "shareTokenStatus": "string",
        "sessionToken": "string",
        "rejectionReasons": [
          "string"
        ]
      }
    },
    "watchlistId": "string"
  }
}

451 response? Coinflow needs additional info from the user. Redirect them to the verificationLink in the response body — they’ll upload a photo ID and complete a selfie verification. After they finish, poll GET /withdraw until verification.status === "approved".

Step 2: Check the withdrawer’s verification status

After KYC, fetch the withdrawer record to confirm verification status before adding a payout destination. You can call this at any time to look up a withdrawer.

Request

GET https://api-sandbox.coinflow.cash/api/withdraw

curl https://api-sandbox.coinflow.cash/api/withdraw \
     -H "x-coinflow-auth-wallet: <apiKey>"

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw"

headers = {"x-coinflow-auth-wallet": "<apiKey>"}

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

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw';
const options = {method: 'GET', headers: {'x-coinflow-auth-wallet': '<apiKey>'}};

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw"

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

	req.Header.Add("x-coinflow-auth-wallet", "<apiKey>")

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

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

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

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw")

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

request = Net::HTTP::Get.new(url)
request["x-coinflow-auth-wallet"] = '<apiKey>'

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

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

HttpResponse<String> response = Unirest.get("https://api-sandbox.coinflow.cash/api/withdraw")
  .header("x-coinflow-auth-wallet", "<apiKey>")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api-sandbox.coinflow.cash/api/withdraw', [
  'headers' => [
    'x-coinflow-auth-wallet' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw");
var request = new RestRequest(Method.GET);
request.AddHeader("x-coinflow-auth-wallet", "<apiKey>");
IRestResponse response = client.Execute(request);

import Foundation

let headers = ["x-coinflow-auth-wallet": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "bankAccounts": [
      {
        "last4": "string",
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "accountNumberOnlyHash": "string",
        "isDeleted": true,
        "isTokenized": true,
        "accountNumber": "string"
      }
    ],
    "cards": [
      {
        "last4": "string",
        "token": "string",
        "type": "VISA",
        "disbursementStatus": "Immediate",
        "createdAt": "2024-01-15T09:30:00Z",
        "isDeleted": true,
        "currency": "USD",
        "nameOnCard": "string",
        "expMonth": "string",
        "expYear": "string"
      }
    ],
    "ibans": [
      {
        "last4": "string",
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "sortCode": "string",
        "bic": "string"
      }
    ],
    "swifts": [
      {
        "alias": "string",
        "token": "string",
        "reference": "string",
        "last4": "string",
        "accountHash": "string",
        "beneficiaryBankName": "string",
        "beneficiaryBankAddress": {
          "address1": "string",
          "city": "string",
          "state": "string",
          "zip": "string",
          "country": "string",
          "address2": "string"
        },
        "swiftCode": "string",
        "intermediaryBank": {
          "swiftCode": "string",
          "bankAddress": {
            "address1": "string",
            "city": "string",
            "state": "string",
            "zip": "string",
            "country": "string",
            "address2": "string"
          },
          "bankName": "string"
        }
      }
    ],
    "pixes": [
      {
        "key": "string",
        "accountHash": "string",
        "token": "string"
      }
    ],
    "efts": [
      {
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "mask": "string",
        "isDeleted": true,
        "accountNumber": "string",
        "institutionId": "string",
        "institution": "string",
        "transit_number": "string"
      }
    ],
    "mobiles": [
      {
        "alias": "string",
        "token": "string",
        "type": "mobile",
        "genus": "applepay",
        "disbursementStatus": "Immediate",
        "currency": "USD",
        "deletedAt": "2024-01-15T09:30:00Z",
        "expMonth": "string",
        "expYear": "string"
      }
    ],
    "p2cAvailable": true,
    "applePayAvailable": true,
    "bankCurrencyOptions": [
      "USD"
    ],
    "freeWithdrawSpeeds": [
      "asap"
    ],
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "venmo": {
      "alias": "string",
      "token": "string",
      "type": "venmo",
      "isDeleted": true
    },
    "paypal": {
      "alias": "string",
      "token": "string",
      "type": "paypal",
      "isDeleted": true
    },
    "interac": {
      "alias": "string",
      "token": "string",
      "type": "interac",
      "isDeleted": true
    }
  }
}

Step 3: Add a payout destination

Save the place the user wants to receive funds. Available destinations depend on the country they verified under.

Want to skip building destination UI? Coinflow’s Bank Authentication UI embeds the entire KYC + destination flow in your app. If you use it, you can skip Step 1 and Step 3 — you’ll only need the quote and payout endpoints below.

US bank account

For US ACH and RTP payouts.

Request

POST https://api-sandbox.coinflow.cash/api/withdraw/account

curl -X POST https://api-sandbox.coinflow.cash/api/withdraw/account \
     -H "x-coinflow-auth-user-id: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "alias": "string",
  "routingNumber": "string",
  "accountNumber": "string",
  "type": "checking"
}'

import requests

url = "https://api-sandbox.coinflow.cash/api/withdraw/account"

payload = {
    "alias": "string",
    "routingNumber": "string",
    "accountNumber": "string",
    "type": "checking"
}
headers = {
    "x-coinflow-auth-user-id": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())

const url = 'https://api-sandbox.coinflow.cash/api/withdraw/account';
const options = {
  method: 'POST',
  headers: {'x-coinflow-auth-user-id': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"alias":"string","routingNumber":"string","accountNumber":"string","type":"checking"}'
};

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

package main

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

func main() {

	url := "https://api-sandbox.coinflow.cash/api/withdraw/account"

	payload := strings.NewReader("{\n  \"alias\": \"string\",\n  \"routingNumber\": \"string\",\n  \"accountNumber\": \"string\",\n  \"type\": \"checking\"\n}")

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

	req.Header.Add("x-coinflow-auth-user-id", "<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))

}

require 'uri'
require 'net/http'

url = URI("https://api-sandbox.coinflow.cash/api/withdraw/account")

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

request = Net::HTTP::Post.new(url)
request["x-coinflow-auth-user-id"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"alias\": \"string\",\n  \"routingNumber\": \"string\",\n  \"accountNumber\": \"string\",\n  \"type\": \"checking\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api-sandbox.coinflow.cash/api/withdraw/account")
  .header("x-coinflow-auth-user-id", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"alias\": \"string\",\n  \"routingNumber\": \"string\",\n  \"accountNumber\": \"string\",\n  \"type\": \"checking\"\n}")
  .asString();

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.coinflow.cash/api/withdraw/account', [
  'body' => '{
  "alias": "string",
  "routingNumber": "string",
  "accountNumber": "string",
  "type": "checking"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-coinflow-auth-user-id' => '<apiKey>',
  ],
]);

echo $response->getBody();

using RestSharp;

var client = new RestClient("https://api-sandbox.coinflow.cash/api/withdraw/account");
var request = new RestRequest(Method.POST);
request.AddHeader("x-coinflow-auth-user-id", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"alias\": \"string\",\n  \"routingNumber\": \"string\",\n  \"accountNumber\": \"string\",\n  \"type\": \"checking\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

import Foundation

let headers = [
  "x-coinflow-auth-user-id": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "alias": "string",
  "routingNumber": "string",
  "accountNumber": "string",
  "type": "checking"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.coinflow.cash/api/withdraw/account")! 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)

{
  "withdrawer": {
    "_id": "string",
    "wallet": "string",
    "blockchain": "solana",
    "wallets": [
      {
        "wallet": "string",
        "blockchain": "solana"
      }
    ],
    "email": "string",
    "availability": {
      "status": "Functional",
      "reason": "string",
      "editor": "string",
      "updatedAt": "2024-01-15T09:30:00Z"
    },
    "currency": "USD",
    "merchant": "string",
    "verification": {
      "reference": "string",
      "status": "pending",
      "vendor": "middesk",
      "name": "string",
      "attested": true,
      "shareToken": "string",
      "shareTokenStatus": "string",
      "sessionToken": "string",
      "rejectionReasons": [
        "string"
      ]
    },
    "riskScoreOverride": true,
    "country": "string",
    "bankAccounts": [
      {
        "last4": "string",
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "accountNumberOnlyHash": "string",
        "isDeleted": true,
        "isTokenized": true,
        "accountNumber": "string"
      }
    ],
    "cards": [
      {
        "last4": "string",
        "token": "string",
        "type": "VISA",
        "disbursementStatus": "Immediate",
        "createdAt": "2024-01-15T09:30:00Z",
        "isDeleted": true,
        "currency": "USD",
        "nameOnCard": "string",
        "expMonth": "string",
        "expYear": "string"
      }
    ],
    "ibans": [
      {
        "last4": "string",
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "sortCode": "string",
        "bic": "string"
      }
    ],
    "swifts": [
      {
        "alias": "string",
        "token": "string",
        "reference": "string",
        "last4": "string",
        "accountHash": "string",
        "beneficiaryBankName": "string",
        "beneficiaryBankAddress": {
          "address1": "string",
          "city": "string",
          "state": "string",
          "zip": "string",
          "country": "string",
          "address2": "string"
        },
        "swiftCode": "string",
        "intermediaryBank": {
          "swiftCode": "string",
          "bankAddress": {
            "address1": "string",
            "city": "string",
            "state": "string",
            "zip": "string",
            "country": "string",
            "address2": "string"
          },
          "bankName": "string"
        }
      }
    ],
    "pixes": [
      {
        "key": "string",
        "accountHash": "string",
        "token": "string"
      }
    ],
    "efts": [
      {
        "accountHash": "string",
        "alias": "string",
        "token": "string",
        "reference": "string",
        "mask": "string",
        "isDeleted": true,
        "accountNumber": "string",
        "institutionId": "string",
        "institution": "string",
        "transit_number": "string"
      }
    ],
    "mobiles": [
      {
        "alias": "string",
        "token": "string",
        "type": "mobile",
        "genus": "applepay",
        "disbursementStatus": "Immediate",
        "currency": "USD",
        "deletedAt": "2024-01-15T09:30:00Z",
        "expMonth": "string",
        "expYear": "string"
      }
    ],
    "p2cAvailable": true,
    "applePayAvailable": true,
    "bankCurrencyOptions": [
      "USD"
    ],
    "freeWithdrawSpeeds": [
      "asap"
    ],
    "originalCurrency": "USD",
    "geoBlockOverride": {
      "reason": "string",
      "setBy": "string",
      "setAt": "2024-01-15T09:30:00Z",
      "expiresAt": "2024-01-15T09:30:00Z"
    },
    "blockCardReuseExempt": true,
    "createdAt": "2024-01-15T09:30:00Z",
    "venmo": {
      "alias": "string",
      "token": "string",
      "type": "venmo",
      "isDeleted": true
    },
    "paypal": {
      "alias": "string",
      "token": "string",
      "type": "paypal",
      "isDeleted": true
    },
    "interac": {
      "alias": "string",
      "token": "string",
      "type": "interac",
      "isDeleted": true
    }
  }
}