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

# Subaccounts inschrijven

> Maak subaccounts aan voor de bedrijven of personen op je platform en stuur ze een link om de onboarding af te ronden.

Maak een Account-object aan onder je platformaccount om een subaccount op je platform in te schrijven. Dat account kan daarna directe afschrijvingen accepteren, overboekingen ontvangen en de uitbetalingsflows van Whop gebruiken.

## Voorbeeld

Maak een account aan voor het subaccount:

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

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

const account = await client.accounts.create({
	email: "merchant@example.com",
	title: "Acme Merchant Store",
	external_id: "user_12345",
	metadata: {
		seller_tier: "gold",
	},
});

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

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

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

account = client.accounts.create(
    email="merchant@example.com",
    title="Acme Merchant Store",
    external_id="user_12345",
    metadata={
        "seller_tier": "gold",
    },
)

print(account.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 account = client
    .accounts
    .create(
        &CreateAccountsRequest {
            email: Some("merchant@example.com".to_string()),
            title: "Acme Merchant Store".to_string(),
            external_id: Some("user_12345".to_string()),
            metadata: Some(HashMap::from([
                ("seller_tier".to_string(), json!("gold")),
            ])),
            ..Default::default()
        },
        None,
    )
    .await?;

println!("{}", account.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"))

account, err := client.Accounts.Create(context.TODO(), &whopsdk.CreateAccountsRequest{
    Email: whopsdk.String("merchant@example.com"),
    Title: "Acme Merchant Store",
    ExternalID: whopsdk.String("user_12345"),
    Metadata: map[string]any{
        "seller_tier": "gold",
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(account.ID)
```

In dit voorbeeld:

* `email` is het e-mailadres van het subaccount. Whop gebruikt het om het subaccount te identificeren en belangrijke meldingen te versturen.
* De Account API-sleutel bepaalt welk platformaccount eigenaar is van het subaccount.
* `title` is de verplichte weergavenaam van het subaccount.
* `external_id` is het eigen ID van je platform voor dit subaccount, bijvoorbeeld je winkel-ID. Elk ID hoort bij één subaccount, en je kunt het account er later mee opzoeken.
* `metadata` bevat aangepaste key-valueparen, zoals `seller_tier`, een classificatie of niveau voor het subaccount (bijv. "bronze", "silver" of "gold").
* Het antwoord bevat een `account.id` waarmee je in toekomstige API-aanroepen naar dit subaccount kunt verwijzen

> [!TIP]
>
> Het e-mailadres moet toebehoren aan het subaccount (bedrijf of
> particulier) dat het account gaat beheren. Deze persoon ontvangt meldingen over
> het instellen van het account en over betalingen.

## Een subaccount vinden aan de hand van je ID

Geef je subaccounts weer met `external_id` om het account bij een van je records op te halen. Eindig de waarde met `%` om elk account op te halen waarvan het ID begint met een namespace die je hebt gekozen, zoals `shopline:%`. De vergelijking is hoofdlettergevoelig, `_` wordt letterlijk vergeleken en `%` werkt alleen aan het einde, dus ID's die je aanmaakt, mogen dit teken niet bevatten.

```typescript TypeScript theme={null}
const accounts = await client.accounts.list({ external_id: "user_12345" });

console.log(accounts.data[0]?.id);
```

Update Account stelt `external_id` in op een bestaand subaccount of wist het. Alleen je platform kan het wijzigen. Het subaccount kan het lezen, maar niet bewerken.

## Een e-mailadres hergebruiken

Meerdere subaccounts kunnen één e-mailadres delen, zolang elk een eigen `external_id` heeft. Het aanmaken van een account is idempotent op het paar van e-mailadres en `external_id`:

* **Nieuwe `external_id`**: Whop maakt een nieuw subaccount aan, ook wanneer het e-mailadres al in gebruik is.
* **Hetzelfde e-mailadres en dezelfde `external_id`**: Whop geeft het bestaande subaccount terug in plaats van een duplicaat aan te maken, dus herhaalpogingen zijn veilig.
* **`external_id` al gebruikt met een ander e-mailadres**: Whop geeft een `409` terug in plaats van een tweede account met dat ID aan te maken. Zie [Het account achter een ID vervangen](#replace-the-account-behind-an-id) om het ID in hetzelfde verzoek naar het nieuwe account te verplaatsen.
* **Geen `external_id`**: Whop geeft het bestaande subaccount voor dat e-mailadres zonder `external_id` terug, als dat er is.

Accounts die een e-mailadres delen, worden beheerd door dezelfde Whop-gebruiker: de persoon die die inbox ontvangt.

> [!NOTE]
>
> Eerdere versies van deze gids plaatsten `external_id` in `metadata`. Whop accepteert het daar nog steeds in elke API-
> versie, stelt `external_id` ermee in en geeft het terug in `metadata`. Het volgt dezelfde regels als het veld op het hoogste niveau,
> inclusief de `409` wanneer een ander subaccount het al heeft, dus stuur `reassign_external_id: true` om er een te hergebruiken.
> Als je `metadata.external_id` later wijzigt, verandert `external_id` niet. Gebruik Update Account om het te wijzigen. Nieuwe
> integraties moeten het veld op het hoogste niveau versturen.

## Het account achter een ID vervangen

Wanneer je aan jouw kant een account opnieuw uitgeeft, bijvoorbeeld een winkel die naar een nieuwe eigenaar gaat, maak dan het nieuwe subaccount aan met dezelfde `external_id` en `reassign_external_id: true`. Whop verplaatst het ID in hetzelfde verzoek naar het nieuwe subaccount in plaats van een `409` terug te geven.

```typescript TypeScript theme={null}
const account = await client.accounts.create({
	email: "new-owner@example.com",
	external_id: "user_12345",
	reassign_external_id: true,
});
```

* Het subaccount dat het ID had, wordt niet verwijderd of op een andere manier gewijzigd. Het blijft actief met `external_id` ingesteld op `null`, behoudt zijn `metadata` en saldo, en verstuurt een `account.updated`-webhook. Verwijder het zelf als je het niet meer nodig hebt.
* Als het aanmaken mislukt, blijft het ID waar het was.
* Het verzoek heeft zowel de permissie `company:update` op je platformaccount als `company:create_child` nodig, omdat het een bestaand subaccount wijzigt.
* Een verzoek met hetzelfde e-mailadres en dezelfde `external_id` als een bestaand subaccount geeft dat subaccount terug, ook wanneer de flag is ingesteld.
* Het ID wordt alleen tussen je eigen subaccounts verplaatst.

Roep Update Account twee keer aan om een ID tussen twee bestaande subaccounts te verplaatsen: wis `external_id` op het oude account en stel het daarna in op het andere. Update Account heeft geen `reassign_external_id`, en als je het ID instelt voordat je het wist, krijg je een `409`.

## Onboarding afronden

Als de ontvanger nog geen Whop-account heeft, stuur dan een onboardinglink voor het account nadat je het account hebt aangemaakt. Via die link voltooit de ontvanger de Know Your Customer-verificatie (KYC), waarna het account overboekingen en andere uitbetalingsflows kan ontvangen.

```typescript TypeScript theme={null}
const accountLink = await client.accountLinks.create({
	account_id: account.id,
	refresh_url: "https://yourapp.com/onboarding/refresh",
	return_url: "https://yourapp.com/onboarding/complete",
	use_case: "account_onboarding",
});

console.log(accountLink.url);
```

```python Python theme={null}
account_link = client.account_links.create(
    account_id=account.id,
    refresh_url="https://yourapp.com/onboarding/refresh",
    return_url="https://yourapp.com/onboarding/complete",
    use_case="account_onboarding",
)

print(account_link.url)
```

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

println!("{}", account_link.url);
```

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

fmt.Println(accountLink.URL)
```

Nadat de ontvanger de onboarding heeft voltooid, kun je:

* checkoutflows voor hen aanmaken met applicatievergoedingen.
* geld overmaken naar hun accountsaldo.
* hen geld laten opnemen met het uitbetalingsportaal.

## Aan de slag

Voordat je subaccounts kunt inschrijven, moet je je platformaccount instellen:

1. **Registreer een platformaccount**: maak een account aan op [whop.com/dashboard](https://whop.com/dashboard)
2. **Genereer een Account API-sleutel**: ga naar de pagina met je ontwikkelaarsinstellingen en genereer een Account API-sleutel
3. **Gebruik de API-sleutel voor authenticatie**: met deze API-sleutel authenticeer je bij de huidige API en beheer je je subaccounts

De Account API-sleutel geeft de benodigde permissies om subaccounts onder je platformaccount aan te maken en te beheren.

## Aangepaste metadata

Je kunt aangepaste metadata aan accounts koppelen wanneer je ze aanmaakt. Met metadata sla je aanvullende informatie over elk subaccount op als key-valueparen. Dit is handig voor:

* Het bijhouden van niveaus of classificaties van subaccounts
* Het koppelen aan databaserecords van je platform

Whop slaat metadata op bij het Account-object en geeft deze bij elke leesactie terug, maar je kunt accounts er niet op filteren. Zet de identifier waarmee je accounts opzoekt in plaats daarvan in `external_id`.

## API-referentie

> [card] [API voor het aanmaken van accounts](https://docs.whop.com/nl/api-reference/accounts/create-account.md)
>
> Bekijk de volledige API-referentie voor het aanmaken van accounts en alle beschikbare parameters

## Volgende stappen

Na het aanmaken van een Account voor een subaccount:

> [card] [Betalingen innen en verdelen](https://docs.whop.com/nl/developer/platforms/collect-payments-for-subaccounts.md)
>
> Kies tussen directe afschrijvingen en overboekingen

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


## Related topics

- [Betalingen innen voor subaccounts](https://docs.whop.com/nl/developer/platforms/collect-payments-for-subaccounts.md)
- [Gebruikers synchroniseren met ingesloten chat](https://docs.whop.com/nl/developer/guides/chat/sync-users.md)
- [Platform-quickstart](https://docs.whop.com/nl/developer/platforms/quickstart.md)
