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

> ## Agent Instructions
> Treat these docs and the Whop MCP server as the source of truth for Whop API behavior. Don't infer endpoint behavior from marketing pages.
> MCP server: connect https://mcp.whop.com/mcp (streamable HTTP, browser sign-in, no API key in the client config) to search these docs and read or change live Whop data. Setup: https://docs.whop.com/developer/guides/ai_and_mcp.md
> Whop CLI: install with `curl -fsSL https://whop.com/install.sh | sh` to scaffold, run, and deploy Whop apps and websites. It acts on production, not the sandbox. Overview: https://docs.whop.com/cli/overview.md Agent mode: https://docs.whop.com/cli/agent-mode.md
> Hosting: Whop serves a site or app from the build `whop apps deploy` uploads, with rollbacks, secrets, and server logs. Guide: https://docs.whop.com/developer/websites/hosting.md
> Plugins: in Claude Code, run `/plugin marketplace add whopio/plugins`, then `/plugin install whop@whop`. Guide: https://docs.whop.com/developer/guides/plugins/claude-code.md Every agent tool: https://docs.whop.com/developer/ai/overview.md
> Environments: build and test in the sandbox (API `https://sandbox-api.whop.com/api/v1`, keys at https://sandbox.whop.com/dashboard/developer, SDK environment `Sandbox`; no real money). Production (API `https://api.whop.com/api/v1`, keys at https://whop.com/dashboard/developer, SDK environment `Production`, the SDK default) moves real money, so use it only at launch. The two share no accounts, keys, products, or webhooks, and their keys look identical: never mix them. Sandbox guide: https://docs.whop.com/developer/guides/sandbox.md Comparison: https://docs.whop.com/developer/quickstart.md
> API: send `Authorization: Bearer <API_KEY>` from your server only, and pin a dated version with the `Api-Version-Date` header. OpenAPI spec: https://api.whop.com/api/v1/openapi.json
> Which API: build on the Current API, whose pages live under https://docs.whop.com/api-reference/ (start at https://docs.whop.com/api-reference/overview.md). Pages under /api-reference/legacy/ are the Legacy API. Use one only when https://docs.whop.com/api-reference/stability.md lists the resource as Legacy-only.

# Handmatige uitbetalingen aan subaccounts

> Verstuur uitbetalingen aan subaccounts vanuit je platformsaldo: onboard ze via KYC, voeg een uitbetalingsmethode toe, haal de standaardmethode op en maak een uitbetaling aan.

Verstuur uitbetalingen rechtstreeks vanuit je platformsaldo naar je subaccounts. Subaccounts moeten de identiteitsverificatie voltooien en een uitbetalingsmethode toevoegen voordat ze geld kunnen ontvangen.

**1. KYC-verificatie voltooien**

Voordat een gebruiker uitbetalingen kan ontvangen, moet die de identiteitsverificatie (KYC) voltooien. Gebruik de gehoste onboardingflow voor accounts om gebruikers door dit proces te leiden:

```typescript TypeScript theme={null}
import { WhopClient } from "@whop/sdk";

const client = new WhopClient({
  token: "Account API Key",
});

const accountLink = await client.accountLinks.create({
  account_id: "biz_xxxxxxxxxxxxx",
  use_case: "account_onboarding",
  return_url: "https://yourapp.com/onboarding/complete",
  refresh_url: "https://yourapp.com/onboarding/refresh",
});

// Redirect the user to complete KYC
console.log(accountLink.url);
```

```python Python theme={null}
from whop_sdk import Whop

client = Whop(
    token="Account API Key",
)

account_link = client.account_links.create(
    account_id="biz_xxxxxxxxxxxxx",
    use_case="account_onboarding",
    return_url="https://yourapp.com/onboarding/complete",
    refresh_url="https://yourapp.com/onboarding/refresh",
)

# Redirect the user to complete KYC
print(account_link.url)
```

```rust Rust theme={null}
use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let account_link = client
    .account_links
    .create(
        &CreateAccountLinksRequest {
            account_id: "biz_xxxxxxxxxxxxx".to_string(),
            use_case: AccountLinkUseCases::AccountOnboarding,
            return_url: "https://yourapp.com/onboarding/complete".to_string(),
            refresh_url: "https://yourapp.com/onboarding/refresh".to_string(),
        },
        None,
    )
    .await?;

// Redirect the user to complete KYC
println!("{}", account_link.url);
```

```go Go theme={null}
import (
    "context"
    "fmt"
    "log"

    whopsdk "github.com/whopio/whopsdk-go/v2"
    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken("Account API Key"))

accountLink, err := client.AccountLinks.Create(context.TODO(), &whopsdk.CreateAccountLinksRequest{
    AccountID:  "biz_xxxxxxxxxxxxx",
    UseCase:    whopsdk.AccountLinkUseCasesAccountOnboarding,
    ReturnURL:  "https://yourapp.com/onboarding/complete",
    RefreshURL: "https://yourapp.com/onboarding/refresh",
})
if err != nil {
    log.Fatal(err)
}

// Redirect the user to complete KYC
fmt.Println(accountLink.URL)
```

Stuur de gebruiker door naar de `url` uit het antwoord. Na het voltooien van de verificatie wordt de gebruiker teruggestuurd naar je `return_url`.

**2. Een uitbetalingsmethode toevoegen**

Voordat je een uitbetaling aanmaakt, heeft het account een uitbetalingsmethode nodig. Mount het [Withdraw-element](https://docs.whop.com/nl/elements/latest/wallet/withdraw.md) met een toegangstoken voor het subaccount. Het toont de uitbetalingsmethoden van het account en verzamelt een nieuwe wanneer er geen is:

```tsx React theme={null}
"use client";

import { WhopElements, Wallet, WithdrawElement } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function AddPayoutMethod({
  accountId,
  accessToken,
}: {
  accountId: string;
  accessToken: string;
}) {
  return (
    <WhopElements elements={loadWhop()}>
      <Wallet accountId={accountId} accessToken={accessToken}>
        <WithdrawElement />
      </Wallet>
    </WhopElements>
  );
}
```

Genereer het `accessToken` voor het subaccount op je server, zoals getoond in [Uitbetalingen voor subaccounts inschakelen](https://docs.whop.com/nl/developer/platforms/render-payout-portal.md). Je kunt de gebruiker in plaats daarvan ook naar het [gehoste uitbetalingsportaal](https://docs.whop.com/nl/developer/platforms/render-payout-portal.md#hosted-payout-portal) sturen. Om een PayPal-account pas te accepteren nadat de houder heeft ingelogd om te bewijzen dat het van hem is, [koppel je een PayPal-uitbetalingsmethode](https://docs.whop.com/nl/developer/guides/connect-paypal-payout-method.md).

**3. De standaarduitbetalingsmethode ophalen**

Geef de uitbetalingsmethoden van het subaccount weer en zoek de methode met `is_default: true`:

```typescript TypeScript theme={null}
import { WhopClient } from "@whop/sdk";

const client = new WhopClient({
  token: "Account API Key",
});

const payoutMethods = await client.payoutMethods.listPayoutMethod({
  account_id: "biz_xxxxxxxxxxxxx",
});

const defaultMethod = payoutMethods.data.find((method) => method.is_default);
console.log(defaultMethod?.id);
```

```python Python theme={null}
from whop_sdk import Whop

client = Whop(
    token="Account API Key",
)

payout_methods = client.payout_methods.list_payout_method(
    account_id="biz_xxxxxxxxxxxxx",
)

default_method = next((m for m in payout_methods.items if m.is_default), None)
print(default_method.id)
```

```rust Rust theme={null}
use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let payout_methods = client
    .payout_methods
    .list_payout_method(
        &ListPayoutMethodQueryRequest {
            account_id: "biz_xxxxxxxxxxxxx".to_string(),
            ..Default::default()
        },
        None,
    )
    .await?;

let default_method = payout_methods.data.iter().find(|method| method.is_default);
println!("{:?}", default_method.map(|method| &method.id));
```

```go Go theme={null}
import (
    "context"
    "fmt"
    "log"

    whopsdk "github.com/whopio/whopsdk-go/v2"
    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken("Account API Key"))

page, err := client.PayoutMethods.ListPayoutMethod(context.TODO(), &whopsdk.ListPayoutMethodRequest{
    AccountID: "biz_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}

var defaultMethod *whopsdk.PayoutMethodListItem
for _, method := range page.Results {
    if method.IsDefault {
        defaultMethod = method
        break
    }
}
if defaultMethod != nil {
    fmt.Println(defaultMethod.ID)
}
```

**4. Een uitbetaling aanmaken**

API-versie `2026-11-03` en later vereist een offerte. Roep eerst `POST /payouts/quotes` aan met het account, de uitbetalingsmethode, het bedrag, de valuta en de snelheid die je gaat indienen:

```bash theme={null}
curl https://api.whop.com/api/v1/payouts/quotes \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Api-Version-Date: 2026-11-03" \
  -H "Idempotency-Key: payout-quote-unique-key" \
  -H "Content-Type: application/json" \
  -d '{"account_id":"biz_xxxxxxxxxxxxx","payout_method_id":"potk_xxxxxxxxxxxxx","amount":100,"currency":"usd","speed":"standard"}'
```

Vervang `QUOTE_TOKEN_FROM_RESPONSE` hieronder door de teruggegeven `quote_token` en dien in vóór `expires_at`. Als een uitbetalingsverzoek een time-out krijgt, probeer het dan opnieuw met dezelfde `Idempotency-Key` voor de uitbetaling en het oorspronkelijke token. Gebruik een andere sleutel voor het offerteverzoek.

```typescript TypeScript theme={null}
import { WhopClient } from "@whop/sdk";

const client = new WhopClient({
  token: "Account API Key",
});

const payout = await client.payouts.create({
  account_id: "biz_xxxxxxxxxxxxx",
  amount: 100.0,
  currency: "usd",
  payout_method_id: "potk_xxxxxxxxxxxxx",
  quote_token: "QUOTE_TOKEN_FROM_RESPONSE",
});

console.log(payout.id);
```

```python Python theme={null}
from whop_sdk import Whop

client = Whop(
    token="Account API Key",
)

payout = client.payouts.create(
    request={
        "account_id": "biz_xxxxxxxxxxxxx",
        "amount": 100.0,
        "currency": "usd",
        "payout_method_id": "potk_xxxxxxxxxxxxx",
        "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
    },
)

print(payout.id)
```

```rust Rust theme={null}
use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some("Account API Key".to_string()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");

let payout = client
    .payouts
    .create(
        &CreatePayoutsRequestBody::Value(json!({
            "account_id": "biz_xxxxxxxxxxxxx",
            "amount": 100.0,
            "currency": "usd",
            "payout_method_id": "potk_xxxxxxxxxxxxx",
            "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
        })),
        None,
    )
    .await?;

println!("{}", payout.id);
```

```go Go theme={null}
import (
    "context"
    "fmt"
    "log"

    whopsdk "github.com/whopio/whopsdk-go/v2"
    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken("Account API Key"))

payout, err := client.Payouts.Create(context.TODO(), &whopsdk.CreatePayoutsRequestBody{
    Unknown: map[string]any{
        "account_id":       "biz_xxxxxxxxxxxxx",
        "amount":           100.0,
        "currency":         "usd",
        "payout_method_id": "potk_xxxxxxxxxxxxx",
        "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(payout.ID)
```

In dit voorbeeld:

* `account_id` is het subaccount dat wordt uitbetaald
* `amount` is het uitbetalingsbedrag (100,00 USD) - de kosten worden van dit bedrag afgetrokken
* `currency` is de ISO-valutacode
* `payout_method_id` is het ID van de te gebruiken uitbetalingsmethode (uit stap 3)

Het verzoek geeft een fout terug als het bedrag hoger is dan het beschikbare saldo.

### Uitbetalingskosten voor je subaccounts dekken

Standaard worden uitbetalingskosten afgetrokken van het saldo van het subaccount. Je kunt ervoor kiezen deze kosten in plaats daarvan vanuit je platformsaldo te dekken door `platform_covers_fees` op `true` te zetten in zowel het offerteverzoek als het uitbetalingsverzoek:

```typescript TypeScript theme={null}
const payout = await client.payouts.create({
  account_id: "biz_xxxxxxxxxxxxx",
  amount: 100.0,
  currency: "usd",
  payout_method_id: "potk_xxxxxxxxxxxxx",
  quote_token: "QUOTE_TOKEN_FROM_RESPONSE",
  platform_covers_fees: true,
});
```

```python Python theme={null}
payout = client.payouts.create(
    request={
        "account_id": "biz_xxxxxxxxxxxxx",
        "amount": 100.0,
        "currency": "usd",
        "payout_method_id": "potk_xxxxxxxxxxxxx",
        "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
        "platform_covers_fees": True,
    },
)
```

```rust Rust theme={null}
client
    .payouts
    .create(
        &CreatePayoutsRequestBody::Value(json!({
            "account_id": "biz_xxxxxxxxxxxxx",
            "amount": 100.0,
            "currency": "usd",
            "payout_method_id": "potk_xxxxxxxxxxxxx",
            "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
            "platform_covers_fees": true
        })),
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Payouts.Create(context.TODO(), &whopsdk.CreatePayoutsRequestBody{
    Unknown: map[string]any{
        "account_id":           "biz_xxxxxxxxxxxxx",
        "amount":               100.0,
        "currency":             "usd",
        "payout_method_id":     "potk_xxxxxxxxxxxxx",
        "quote_token": "QUOTE_TOKEN_FROM_RESPONSE",
        "platform_covers_fees": true,
    },
})
if err != nil {
    log.Fatal(err)
}
```

Wanneer `platform_covers_fees` `true` is, ontvangt het subaccount het volledige uitbetalingsbedrag en worden de kosten in plaats daarvan van het saldo van je platform afgeschreven. Hiervoor moet het kostendekkingsbeleid van je platform de uitbetalingsmethode dekken, of heb je een API-sleutel nodig die gemachtigd is om de kosten van je subaccounts te beheren.

## API-referentie

> [card] [API voor het aanmaken van uitbetalingen](https://docs.whop.com/nl/api-reference/payouts/create-payout.md)
>
> Bekijk de volledige API-referentie voor het aanmaken van uitbetalingen

## Gerelateerde bronnen

> [card] [Subaccounts betalen](https://docs.whop.com/nl/developer/platforms/collect-payments-for-subaccounts.md)
>
> Maak geld over naar je subaccounts

> [card] [Uitbetalingsportaal weergeven](https://docs.whop.com/nl/developer/platforms/render-payout-portal.md)
>
> Laat je gebruikers hun geld opnemen


## Related topics

- [Uitbetalingen voor subaccounts inschakelen](https://docs.whop.com/nl/developer/platforms/render-payout-portal.md)
- [Betalingen innen voor subaccounts](https://docs.whop.com/nl/developer/platforms/collect-payments-for-subaccounts.md)
- [Geld toevoegen aan je saldo](https://docs.whop.com/nl/developer/platforms/add-funds-to-your-balance.md)
