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

# Démarrage rapide

> Créez un client sandbox, activez une capacité et exécutez un flux d'encaissement, de paiement ou de compte bancaire émis.

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 :

```bash theme={null}
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`](/api-reference/customers/post-v3-customers) :

```bash theme={null}
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](/fr/integration/recipients) ou [Envoyer des fonds](/fr/integration/send-funds).

## 4. Trouver une capacité éligible

Listez les capacités prises en charge avec [`GET /v3/customers/{customerId}/capabilities/supported`](/api-reference/capabilities/get-v3-customers-by-customer-id-capabilities-supported) :

```bash theme={null}
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}`](/api-reference/capabilities/post-v3-customers-by-customer-id-capabilities-by-capability-id) :

```bash theme={null}
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](/fr/integration/onboarding/capabilities-and-requirements).

Pour cette procédure, définissez la capacité sur `ready` avec [`POST /v3/sandbox/customers/{customerId}/capabilities/{capabilityId}/status`](/api-reference/sandbox/post-v3-sandbox-customers-by-customer-id-capabilities-by-capability-id-status) :

```bash theme={null}
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}`](/api-reference/capabilities/get-v3-customers-by-customer-id-capabilities-by-capability-id) :

```bash theme={null}
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`](/api-reference/accounts/post-v3-customers-by-customer-id-accounts) :

```bash theme={null}
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](/fr/integration/onboarding/capabilities-and-requirements).

Récupérez à nouveau le portefeuille avec [`GET /v3/customers/{customerId}/accounts/{accountId}`](/api-reference/accounts/get-v3-customers-by-customer-id-accounts-by-account-id) :

```bash theme={null}
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`.

<Tabs>
  <Tab title="Encaissement">
    Créez un devis USD vers USDC avec [`POST /v3/quotes`](/api-reference/money-movement/post-v3-quotes) :

    ```bash theme={null}
    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`](/api-reference/money-movement/post-v3-transfers) :

    ```bash theme={null}
    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`](/api-reference/money-movement/get-v3-transfers-by-transfer-id-instructions) :

    ```bash theme={null}
    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`.
  </Tab>

  <Tab title="Paiement">
    Alimentez le portefeuille prêt avec [`POST /v3/sandbox/accounts/{accountId}/topup`](/api-reference/sandbox/post-v3-sandbox-accounts-by-account-id-topup) :

    ```bash theme={null}
    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`](/api-reference/accounts/post-v3-customers-by-customer-id-accounts) :

    ```bash theme={null}
    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](/fr/integration/onboarding/capabilities-and-requirements).

    Récupérez-le à nouveau avec [`GET /v3/customers/{customerId}/accounts/{accountId}`](/api-reference/accounts/get-v3-customers-by-customer-id-accounts-by-account-id) :

    ```bash theme={null}
    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`](/api-reference/money-movement/post-v3-quotes) :

    ```bash theme={null}
    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`](/api-reference/money-movement/post-v3-transfers), et stockez le `data.id` renvoyé en tant que `TRANSFER_ID` :

    ```bash theme={null}
    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
    ```
  </Tab>

  <Tab title="Compte bancaire émis">
    Créez un compte ACH/USD réglé sur le portefeuille prêt avec [`POST /v3/customers/{customerId}/accounts`](/api-reference/accounts/post-v3-customers-by-customer-id-accounts) :

    ```bash theme={null}
    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}`](/api-reference/accounts/get-v3-customers-by-customer-id-accounts-by-account-id) :

    ```bash theme={null}
    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.
  </Tab>
</Tabs>

Pour les encaissements et les paiements, surveillez `TRANSFER_ID` avec [`GET /v3/transfers/{transferId}`](/api-reference/money-movement/get-v3-transfers-by-transfer-id) :

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

<CardGroup cols={3}>
  <Card title="Encaissement" icon="arrow-down-to-line" href="/fr/integration/receive-funds">Construisez le flux d'encaissement complet.</Card>
  <Card title="Paiement" icon="arrow-up-from-line" href="/fr/integration/send-funds">Construisez la gestion des paiements en production.</Card>
  <Card title="Compte bancaire émis" icon="building-columns" href="/fr/integration/issue-bank-account">Gérez le provisionnement et les coordonnées.</Card>
</CardGroup>

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


## Related topics

- [Vue d'ensemble de l'intégration](/fr/integration/overview.md)
- [Référence API](/fr/api-reference/introduction.md)
- [Authentification](/fr/integration/authentication.md)
- [Vue d'ensemble](/fr/knowledge-base/compliance/overview.md)