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

> Legen Sie einen Sandbox-Kunden an, aktivieren Sie eine Fähigkeit und führen Sie einen Pay-in-, Payout- oder ausgegebenen Bankkonto-Flow aus.

Legen Sie einen Kunden an, bereiten Sie eine wiederverwendbare Wallet vor und führen Sie den benötigten Sandbox-Flow aus.

## 1. Sandbox konfigurieren

Verwenden Sie einen Sandbox-API-Schlüssel von Ihrem Backend aus:

```bash theme={null}
export API_BASE='https://platform.swipelux.com'
export SWIPELUX_SANDBOX_API_KEY='replace-with-your-sandbox-key'
```

Der Schlüssel wählt die Sandbox-Umgebung auf dem gemeinsamen API-Host aus.

## 2. Kunden anlegen

Legen Sie einen individuellen Kunden mit [`POST /v3/customers`](/api-reference/customers/post-v3-customers) an:

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

Speichern Sie `data.id` als `CUSTOMER_ID`.

## 3. Ergebnis wählen

* **Pay-in:** USD empfangen und USDC in die ausgegebene Wallet des Kunden abwickeln.
* **Payout:** USDC von der ausgegebenen Wallet des Kunden an ein kundeneigenes Bankkonto senden.
* **Ausgegebenes Bankkonto:** Ein ACH/USD-Konto ausgeben, das in die ausgegebene Wallet des Kunden abgewickelt wird.

Für einen Drittparteien-Payout folgen Sie [Empfänger](/de/integration/recipients) oder [Gelder senden](/de/integration/send-funds).

## 4. Eine geeignete Fähigkeit finden

Listen Sie unterstützte Fähigkeiten mit [`GET /v3/customers/{customerId}/capabilities/supported`](/api-reference/capabilities/get-v3-customers-by-customer-id-capabilities-supported) auf:

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

Wählen Sie einen Antwort-Eintrag mit `availability` gleich `available` oder `beta`, `eligibility.eligible` gleich `true`, den benötigten `directions` und `method` sowie dem passenden `accountType`. Verwenden Sie die ausgegebene Wallet des Kunden als Pay-in-Ziel, Payout-Quelle oder Settlement-Konto des Bankkontos; verwenden Sie das kundeneigene Konto als `destinationId` für diesen Payout-Pfad. Wenn `institutions` zurückgegeben werden, verwenden Sie nur eine zurückgegebene Institutionsauswahl. Speichern Sie die `id` des Eintrags als `CAPABILITY_ID`; kodieren Sie keine universelle Fähigkeits-ID fest.

## 5. Fähigkeit anfordern

Fordern Sie die ausgewählte Fähigkeit mit [`POST /v3/customers/{customerId}/capabilities/{capabilityId}`](/api-reference/capabilities/post-v3-customers-by-customer-id-capabilities-by-capability-id) an:

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

Speichern Sie `data.status` als `CAPABILITY_STATUS` und `data.openTaskIds` als `TASK_IDS`.

## 6. Onboarding in der Sandbox abschließen

Wenn `TASK_IDS` nicht leer ist, erledigen Sie jede aktuelle Anforderung über [Fähigkeiten und Aufgaben](/de/integration/onboarding/capabilities-and-requirements).

Für dieses Walkthrough setzen Sie die Fähigkeit mit [`POST /v3/sandbox/customers/{customerId}/capabilities/{capabilityId}/status`](/api-reference/sandbox/post-v3-sandbox-customers-by-customer-id-capabilities-by-capability-id-status) auf `ready`:

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

Dieses Testkontrollmittel ist kein produktives Onboarding. Rufen Sie den Status mit [`GET /v3/customers/{customerId}/capabilities/{capabilityId}`](/api-reference/capabilities/get-v3-customers-by-customer-id-capabilities-by-capability-id) erneut ab:

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

Aktualisieren Sie `CAPABILITY_STATUS` und `TASK_IDS` aus `data.status` und `data.openTaskIds`. Fahren Sie nur fort, wenn `CAPABILITY_STATUS` gleich `ready` ist.

## 7. Den ausgewählten Flow aufbauen

Erstellen Sie eine ausgegebene USDC-Wallet auf Base mit [`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"}'
```

Speichern Sie `data.id` als `FLOW_WALLET_ID`, `data.status` als `FLOW_WALLET_STATUS` und `data.openTaskIds` als `FLOW_WALLET_TASK_IDS`. Wenn `FLOW_WALLET_TASK_IDS` nicht leer ist, erledigen Sie die aktuellen Aufgaben über [Fähigkeiten und Aufgaben](/de/integration/onboarding/capabilities-and-requirements).

Rufen Sie die Wallet mit [`GET /v3/customers/{customerId}/accounts/{accountId}`](/api-reference/accounts/get-v3-customers-by-customer-id-accounts-by-account-id) erneut ab:

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

Aktualisieren Sie `FLOW_WALLET_STATUS` und `FLOW_WALLET_TASK_IDS` aus `data.status` und `data.openTaskIds`. Fahren Sie nur fort, wenn `FLOW_WALLET_STATUS` gleich `ready` ist.

<Tabs>
  <Tab title="Pay-in">
    Erstellen Sie ein USD-zu-USDC-Quote mit [`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
    ```

    Speichern Sie `data.id` als `QUOTE_ID` und führen Sie es dann mit [`POST /v3/transfers`](/api-reference/money-movement/post-v3-transfers) aus:

    ```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
    ```

    Speichern Sie `data.id` als `TRANSFER_ID`. Rufen Sie die Anweisungen mit [`GET /v3/transfers/{transferId}/instructions`](/api-reference/money-movement/get-v3-transfers-by-transfer-id-instructions) ab:

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

    Die Antwort enthält `data.transferId` und `data.instructions`. Speichern Sie `data.transferId` als `TRANSFER_ID` und `data.instructions` als `FUNDING_INSTRUCTIONS`.
  </Tab>

  <Tab title="Payout">
    Finanzieren Sie die bereite Wallet mit [`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"}'
    ```

    Legen Sie ein kundeneigenes ACH-Konto mit [`POST /v3/customers/{customerId}/accounts`](/api-reference/accounts/post-v3-customers-by-customer-id-accounts) an:

    ```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
    ```

    Speichern Sie `data.id` als `PAYOUT_ACCOUNT_ID`, `data.status` als `PAYOUT_ACCOUNT_STATUS` und `data.openTaskIds` als `PAYOUT_ACCOUNT_TASK_IDS`. Wenn `PAYOUT_ACCOUNT_TASK_IDS` nicht leer ist, erledigen Sie die aktuellen Aufgaben über [Fähigkeiten und Aufgaben](/de/integration/onboarding/capabilities-and-requirements).

    Rufen Sie es erneut mit [`GET /v3/customers/{customerId}/accounts/{accountId}`](/api-reference/accounts/get-v3-customers-by-customer-id-accounts-by-account-id) ab:

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

    Aktualisieren Sie `PAYOUT_ACCOUNT_STATUS` und `PAYOUT_ACCOUNT_TASK_IDS` aus `data.status` und `data.openTaskIds`. Fahren Sie nur fort, wenn `PAYOUT_ACCOUNT_STATUS` gleich `ready` ist, und erstellen Sie dann das Quote mit [`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
    ```

    Speichern Sie `data.id` als `QUOTE_ID`, führen Sie es mit [`POST /v3/transfers`](/api-reference/money-movement/post-v3-transfers) aus und speichern Sie das zurückgegebene `data.id` als `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="Ausgegebenes Bankkonto">
    Legen Sie ein ACH/USD-Konto an, das in die bereite Wallet abgewickelt wird, mit [`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
    ```

    Speichern Sie `data.id` als `BANK_ACCOUNT_ID` und lesen Sie dann die Bereitstellung mit [`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}"
    ```

    Speichern Sie `data.status` als `BANK_ACCOUNT_STATUS`, `data.details` als `BANK_ACCOUNT_DETAILS` und `data.openTaskIds` als `BANK_ACCOUNT_TASK_IDS`. Erledigen Sie alle aktuellen Aufgaben und lesen Sie dann das Konto erneut, bis sein Status die Nutzung erlaubt und `data.details` vorhanden ist.

    Bankdaten sind möglicherweise nicht sofort verfügbar. Der Zweig ist abgeschlossen, wenn Sie die genauen wiederverwendbaren Bankdaten präsentieren können, die in `BANK_ACCOUNT_DETAILS` zurückgegeben wurden. Konstruieren oder zeigen Sie niemals Platzhalter-Koordinaten an, während das Konto noch bereitgestellt wird.
  </Tab>
</Tabs>

Für Pay-ins und Payouts überwachen Sie `TRANSFER_ID` mit [`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="/de/integration/receive-funds">Bauen Sie den vollständigen Pay-in-Flow auf.</Card>
  <Card title="Payout" icon="arrow-up-from-line" href="/de/integration/send-funds">Bauen Sie die produktive Payout-Verarbeitung auf.</Card>
  <Card title="Ausgegebenes Bankkonto" icon="building-columns" href="/de/integration/issue-bank-account">Behandeln Sie die Bereitstellung und Details.</Card>
</CardGroup>

Fügen Sie als Nächstes [Webhooks](/de/integration/webhooks) hinzu. Jede oben genannte Anfrage verlinkt bereits auf ihr vollständiges API-Referenz-Schema und die Statusseite.


## Related topics

- [Integrationsübersicht](/de/integration/overview.md)
- [API-Referenz](/de/api-reference/introduction.md)
- [Authentifizierung](/de/integration/authentication.md)