Démarrage rapide

Créez un client, préparez un portefeuille réutilisable et exécutez le flux sandbox dont vous avez besoin.

1. Configurer le sandbox

Utilisez une clé API sandbox depuis votre backend :

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

La clé sélectionne l’environnement sandbox sur l’hôte API partagé.

2. Créer un client

Créez un client individuel avec 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"}'

Stockez data.id en tant que CUSTOMER_ID.

3. Choisir le résultat

Encaissement : recevez des USD et réglez en USDC dans le portefeuille émis du client.
Paiement : envoyez des USDC depuis le portefeuille émis du client vers un compte bancaire détenu par le client.
Compte bancaire émis : émettez un compte ACH/USD qui règle dans le portefeuille émis du client.

Pour un paiement à un tiers, suivez Destinataires ou Envoyer des fonds.

4. Trouver une capacité éligible

Listez les capacités prises en charge avec 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}"

Choisissez une entrée de réponse avec availability défini sur available ou beta, eligibility.eligible défini sur true, les directions et la method nécessaires, et le accountType correspondant. Utilisez le portefeuille émis du client comme destination d’encaissement, source de paiement ou compte de règlement du compte bancaire ; utilisez le compte détenu par le client comme destinationId pour ce chemin de paiement. Si des institutions sont renvoyées, utilisez uniquement un choix d’institution renvoyé. Stockez l’id de l’entrée en tant que CAPABILITY_ID ; ne codez pas en dur un ID de capacité universel.

5. Demander la capacité

Demandez la capacité sélectionnée avec 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 '{}'

Stockez data.status en tant que CAPABILITY_STATUS et data.openTaskIds en tant que TASK_IDS.

6. Terminer l’onboarding en sandbox

Si TASK_IDS n’est pas vide, complétez chaque exigence actuelle via Capacités et tâches. Pour cette procédure, définissez la capacité sur ready avec 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"}'

Ce contrôle de test n’est pas un onboarding de production. Récupérez à nouveau avec 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}"

Actualisez CAPABILITY_STATUS et TASK_IDS depuis data.status et data.openTaskIds. Continuez uniquement lorsque CAPABILITY_STATUS est ready.

7. Construire le flux sélectionné

Créez un portefeuille USDC émis sur Base avec 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"}'

Stockez data.id en tant que FLOW_WALLET_ID, data.status en tant que FLOW_WALLET_STATUS, et data.openTaskIds en tant que FLOW_WALLET_TASK_IDS. Si FLOW_WALLET_TASK_IDS n’est pas vide, complétez les tâches actuelles via Capacités et tâches. Récupérez à nouveau le portefeuille avec 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}"

Actualisez FLOW_WALLET_STATUS et FLOW_WALLET_TASK_IDS depuis data.status et data.openTaskIds. Continuez uniquement lorsque FLOW_WALLET_STATUS est ready.

Encaissement
Paiement
Compte bancaire émis

Créez un devis USD vers USDC avec 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

Stockez data.id en tant que QUOTE_ID, puis exécutez-le avec 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

Stockez data.id en tant que TRANSFER_ID. Récupérez les instructions avec GET /v3/transfers/{transferId}/instructions :

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

La réponse contient data.transferId et data.instructions. Stockez data.transferId en tant que TRANSFER_ID et data.instructions en tant que FUNDING_INSTRUCTIONS.

Alimentez le portefeuille prêt avec 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"}'

Créez un compte ACH détenu par le client avec 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

Stockez data.id en tant que PAYOUT_ACCOUNT_ID, data.status en tant que PAYOUT_ACCOUNT_STATUS, et data.openTaskIds en tant que PAYOUT_ACCOUNT_TASK_IDS. Si PAYOUT_ACCOUNT_TASK_IDS n’est pas vide, complétez les tâches actuelles via Capacités et tâches.Récupérez-le à nouveau avec 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}"

Actualisez PAYOUT_ACCOUNT_STATUS et PAYOUT_ACCOUNT_TASK_IDS depuis data.status et data.openTaskIds. Continuez uniquement lorsque PAYOUT_ACCOUNT_STATUS est ready, puis créez le devis avec 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

Stockez data.id en tant que QUOTE_ID, exécutez-le avec POST /v3/transfers, et stockez le data.id renvoyé en tant que 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

Créez un compte ACH/USD réglé sur le portefeuille prêt avec 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

Stockez data.id en tant que BANK_ACCOUNT_ID, puis lisez le provisionnement avec 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}"

Stockez data.status en tant que BANK_ACCOUNT_STATUS, data.details en tant que BANK_ACCOUNT_DETAILS, et data.openTaskIds en tant que BANK_ACCOUNT_TASK_IDS. Complétez toutes les tâches actuelles, puis lisez à nouveau le compte jusqu’à ce que son statut permette son utilisation et que data.details soit présent.Les coordonnées bancaires peuvent ne pas être présentes immédiatement. La branche est terminée lorsque vous pouvez présenter les coordonnées bancaires réutilisables exactes renvoyées dans BANK_ACCOUNT_DETAILS. Ne construisez ou n’affichez jamais de coordonnées fictives pendant que le compte est encore en cours de provisionnement.

Pour les encaissements et les paiements, surveillez TRANSFER_ID avec GET /v3/transfers/{transferId} :

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

Encaissement

Construisez le flux d’encaissement complet.

Paiement

Construisez la gestion des paiements en production.

Compte bancaire émis

Gérez le provisionnement et les coordonnées.

Ensuite, ajoutez des webhooks. Chaque requête ci-dessus renvoie déjà à son schéma complet de Référence API et à sa page de statut.

Commencer

Intégrer les clients

Construire les flux monétaires

Mise en production

Démarrage rapide

1. Configurer le sandbox

2. Créer un client

3. Choisir le résultat

4. Trouver une capacité éligible

5. Demander la capacité

6. Terminer l’onboarding en sandbox

7. Construire le flux sélectionné

Encaissement

Paiement

Compte bancaire émis

​1. Configurer le sandbox

​2. Créer un client

​3. Choisir le résultat

​4. Trouver une capacité éligible

​5. Demander la capacité

​6. Terminer l’onboarding en sandbox

​7. Construire le flux sélectionné

Encaissement

Paiement

Compte bancaire émis

1. Configurer le sandbox

2. Créer un client

3. Choisir le résultat

4. Trouver une capacité éligible

5. Demander la capacité

6. Terminer l’onboarding en sandbox

7. Construire le flux sélectionné