Quickstart

Create a customer, prepare one reusable wallet, and run the sandbox flow you need.

1. Configure sandbox

Use a sandbox API key from your backend:

export API_BASE='https://platform.swipelux.com'
export SWIPELUX_SANDBOX_API_KEY='replace-with-your-sandbox-key'

The key selects the sandbox environment on the shared API host.

2. Create a customer

Create an individual customer with POST /v3/customers:

curl --request POST \
  "${API_BASE}/v3/customers" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-customer-001" \
  --header "Content-Type: application/json" \
  --data '{"type":"individual","externalId":"quickstart-customer-001"}'

Store data.id as CUSTOMER_ID.

3. Choose the outcome

Pay-in: receive USD and settle USDC into the customer’s issued wallet.
Payout: send USDC from the customer’s issued wallet to a customer-owned bank account.
Issued bank account: issue an ACH/USD account that settles into the customer’s issued wallet.

For a third-party payout, follow Recipients or Send funds.

4. Find an eligible capability

List supported capabilities with GET /v3/customers/{customerId}/capabilities/supported:

curl --request GET \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/capabilities/supported" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Choose a response entry with availability set to available or beta, eligibility.eligible set to true, the needed directions and method, and the matching accountType. Use the customer’s issued wallet as the pay-in destination, payout source, or bank-account settlement account; use the customer-owned account as destinationId for this payout path. If institutions are returned, use only a returned institution choice. Store the entry’s id as CAPABILITY_ID; do not hardcode a universal capability ID.

5. Request the capability

Request the selected capability with POST /v3/customers/{customerId}/capabilities/{capabilityId}:

curl --request POST \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/capabilities/${CAPABILITY_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-capability-001" \
  --header "Content-Type: application/json" \
  --data '{}'

Store data.status as CAPABILITY_STATUS and data.openTaskIds as TASK_IDS.

6. Complete onboarding in sandbox

If TASK_IDS is not empty, complete each current requirement through Capabilities and tasks. For this walkthrough, set the capability to ready with POST /v3/sandbox/customers/{customerId}/capabilities/{capabilityId}/status:

curl --request POST \
  "${API_BASE}/v3/sandbox/customers/${CUSTOMER_ID}/capabilities/${CAPABILITY_ID}/status" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{"status":"ready"}'

This test control is not production onboarding. Refetch with GET /v3/customers/{customerId}/capabilities/{capabilityId}:

curl --request GET \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/capabilities/${CAPABILITY_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Refresh CAPABILITY_STATUS and TASK_IDS from data.status and data.openTaskIds. Continue only when CAPABILITY_STATUS is ready.

7. Build the selected flow

Create one issued USDC wallet on Base with POST /v3/customers/{customerId}/accounts:

curl --request POST \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-flow-wallet-001" \
  --header "Content-Type: application/json" \
  --data '{"origin":"issued","type":"wallet","currency":"USDC","network":"base"}'

Store data.id as FLOW_WALLET_ID, data.status as FLOW_WALLET_STATUS, and data.openTaskIds as FLOW_WALLET_TASK_IDS. If FLOW_WALLET_TASK_IDS is not empty, complete the current tasks through Capabilities and tasks. Refetch the wallet with GET /v3/customers/{customerId}/accounts/{accountId}:

curl --request GET \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts/${FLOW_WALLET_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Refresh FLOW_WALLET_STATUS and FLOW_WALLET_TASK_IDS from data.status and data.openTaskIds. Continue only when FLOW_WALLET_STATUS is ready.

Pay-in
Payout
Issued bank account

Create a USD-to-USDC quote with POST /v3/quotes:

curl --request POST \
  "${API_BASE}/v3/quotes" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-payin-quote-001" \
  --header "Content-Type: application/json" \
  --data @- <<JSON
{"customerId":"${CUSTOMER_ID}","capabilityId":"${CAPABILITY_ID}","in":{"amount":"150.00","currency":"USD"},"destinationId":"${FLOW_WALLET_ID}","out":{"currency":"USDC"}}
JSON

Store data.id as QUOTE_ID, then execute it with POST /v3/transfers:

curl --request POST \
  "${API_BASE}/v3/transfers" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-payin-transfer-001" \
  --header "Content-Type: application/json" \
  --data @- <<JSON
{"quoteId":"${QUOTE_ID}"}
JSON

Store data.id as TRANSFER_ID. Fetch instructions with GET /v3/transfers/{transferId}/instructions:

curl --request GET \
  "${API_BASE}/v3/transfers/${TRANSFER_ID}/instructions" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

The response contains data.transferId and data.instructions. Store data.transferId as TRANSFER_ID and data.instructions as FUNDING_INSTRUCTIONS.

Fund the ready wallet with POST /v3/sandbox/accounts/{accountId}/topup:

curl --request POST \
  "${API_BASE}/v3/sandbox/accounts/${FLOW_WALLET_ID}/topup" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Content-Type: application/json" \
  --data '{"amount":"250.00","currency":"USDC"}'

Create a customer-owned ACH account with POST /v3/customers/{customerId}/accounts:

curl --request POST \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-payout-account-001" \
  --header "Content-Type: application/json" \
  --data @- <<'JSON'
{"origin":"external","type":"bank","methods":["ach"],"country":"US","currency":"USD","details":{"routingNumber":"021000021","accountNumber":"123456789","accountType":"checking","bankName":"Example Bank","accountHolderName":"Amina Diallo"}}
JSON

Store data.id as PAYOUT_ACCOUNT_ID, data.status as PAYOUT_ACCOUNT_STATUS, and data.openTaskIds as PAYOUT_ACCOUNT_TASK_IDS. If PAYOUT_ACCOUNT_TASK_IDS is not empty, complete the current tasks through Capabilities and tasks.Refetch it with GET /v3/customers/{customerId}/accounts/{accountId}:

curl --request GET \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts/${PAYOUT_ACCOUNT_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Refresh PAYOUT_ACCOUNT_STATUS and PAYOUT_ACCOUNT_TASK_IDS from data.status and data.openTaskIds. Continue only when PAYOUT_ACCOUNT_STATUS is ready, then create the quote with POST /v3/quotes:

curl --request POST \
  "${API_BASE}/v3/quotes" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-payout-quote-001" \
  --header "Content-Type: application/json" \
  --data @- <<JSON
{"customerId":"${CUSTOMER_ID}","capabilityId":"${CAPABILITY_ID}","in":{"amount":"150.00","currency":"USDC","accountId":"${FLOW_WALLET_ID}"},"destinationId":"${PAYOUT_ACCOUNT_ID}","out":{"currency":"USD"}}
JSON

Store data.id as QUOTE_ID, execute it with POST /v3/transfers, and store the returned data.id as TRANSFER_ID:

curl --request POST \
  "${API_BASE}/v3/transfers" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-payout-transfer-001" \
  --header "Content-Type: application/json" \
  --data @- <<JSON
{"quoteId":"${QUOTE_ID}"}
JSON

Create an ACH/USD account settled to the ready wallet with POST /v3/customers/{customerId}/accounts:

curl --request POST \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}" \
  --header "Idempotency-Key: quickstart-bank-account-001" \
  --header "Content-Type: application/json" \
  --data @- <<JSON
{"origin":"issued","type":"bank","method":"ach","country":"US","currency":"USD","settlement":{"accountId":"${FLOW_WALLET_ID}"}}
JSON

Store data.id as BANK_ACCOUNT_ID, then read provisioning with GET /v3/customers/{customerId}/accounts/{accountId}:

curl --request GET \
  "${API_BASE}/v3/customers/${CUSTOMER_ID}/accounts/${BANK_ACCOUNT_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Store data.status as BANK_ACCOUNT_STATUS, data.details as BANK_ACCOUNT_DETAILS, and data.openTaskIds as BANK_ACCOUNT_TASK_IDS. Complete any current tasks, then read the account again until its status permits use and data.details is present.Bank details may not be present immediately. The branch is complete when you can present the exact reusable bank details returned in BANK_ACCOUNT_DETAILS. Never construct or display placeholder coordinates while the account is still provisioning.

For pay-ins and payouts, monitor TRANSFER_ID with GET /v3/transfers/{transferId}:

curl --request GET \
  "${API_BASE}/v3/transfers/${TRANSFER_ID}" \
  --header "X-API-Key: ${SWIPELUX_SANDBOX_API_KEY}"

Pay-in

Build the complete pay-in flow.

Payout

Build production payout handling.

Issued bank account

Handle provisioning and details.

Next, add webhooks. Each request above already links to its complete API Reference schema and status page.

Get started

Onboard customers

Build money flows

Launch

1. Configure sandbox

2. Create a customer

3. Choose the outcome

4. Find an eligible capability

5. Request the capability

6. Complete onboarding in sandbox

7. Build the selected flow

Pay-in

Payout

Issued bank account

​1. Configure sandbox

​2. Create a customer

​3. Choose the outcome

​4. Find an eligible capability

​5. Request the capability

​6. Complete onboarding in sandbox

​7. Build the selected flow

Pay-in

Payout

Issued bank account

1. Configure sandbox

2. Create a customer

3. Choose the outcome

4. Find an eligible capability

5. Request the capability

6. Complete onboarding in sandbox

7. Build the selected flow