> ## 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.

# Quickstart

> Create a sandbox customer, enable a capability, and run a pay-in, payout, or issued bank account flow.

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:

```bash theme={null}
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`](/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"}'
```

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](/integration/recipients) or [Send funds](/integration/send-funds).

## 4. Find an eligible capability

List supported capabilities with [`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}"
```

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}`](/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 '{}'
```

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](/integration/onboarding/capabilities-and-requirements).

For this walkthrough, set the capability to `ready` with [`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"}'
```

This test control is not production onboarding. Refetch with [`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}"
```

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`](/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"}'
```

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](/integration/onboarding/capabilities-and-requirements).

Refetch the wallet with [`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}"
```

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

<Tabs>
  <Tab title="Pay-in">
    Create a USD-to-USDC quote with [`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
    ```

    Store `data.id` as `QUOTE_ID`, then execute it with [`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
    ```

    Store `data.id` as `TRANSFER_ID`. Fetch instructions with [`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}"
    ```

    The response contains `data.transferId` and `data.instructions`. Store `data.transferId` as `TRANSFER_ID` and `data.instructions` as `FUNDING_INSTRUCTIONS`.
  </Tab>

  <Tab title="Payout">
    Fund the ready wallet with [`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"}'
    ```

    Create a customer-owned ACH account with [`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
    ```

    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](/integration/onboarding/capabilities-and-requirements).

    Refetch it with [`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}"
    ```

    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`](/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
    ```

    Store `data.id` as `QUOTE_ID`, execute it with [`POST /v3/transfers`](/api-reference/money-movement/post-v3-transfers), and store the returned `data.id` as `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="Issued bank account">
    Create an ACH/USD account settled to the ready wallet with [`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
    ```

    Store `data.id` as `BANK_ACCOUNT_ID`, then read provisioning with [`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}"
    ```

    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.
  </Tab>
</Tabs>

For pay-ins and payouts, monitor `TRANSFER_ID` with [`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="Pay-in" icon="arrow-down-to-line" href="/integration/receive-funds">Build the complete pay-in flow.</Card>
  <Card title="Payout" icon="arrow-up-from-line" href="/integration/send-funds">Build production payout handling.</Card>
  <Card title="Issued bank account" icon="building-columns" href="/integration/issue-bank-account">Handle provisioning and details.</Card>
</CardGroup>

Next, add [webhooks](/integration/webhooks). Each request above already links to its complete API Reference schema and status page.


## Related topics

- [Integration overview](/integration/overview.md)
- [API reference](/api-reference/introduction.md)
- [Authentication](/integration/authentication.md)