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

# Tilmeld underkonti

> Opret underkonti for virksomhederne eller personerne på din platform, og send dem et link til at afslutte onboarding.

For at tilmelde en underkonto på din platform skal du oprette et Account-objekt for den under din platformkonto. Kontoen kan derefter modtage direkte opkrævninger, modtage overførsler og bruge Whops udbetalingsflows.

## Eksempel

Opret en konto for underkontoen:

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

I dette eksempel:

* `email` er underkontoens e-mailadresse. Whop bruger den til at identificere underkontoen og sende vigtige notifikationer.
* Account-API-nøglen afgør, hvilken platformkonto der ejer underkontoen.
* `title` er underkontoens påkrævede visningsnavn.
* `external_id` er din platforms eget ID for denne underkonto, f.eks. dit butiks-ID. Hvert ID svarer til én underkonto, og du kan slå kontoen op via det senere.
* `metadata` indeholder brugerdefinerede nøgle-værdi-par, f.eks. `seller_tier`, en klassificering eller et niveau for underkontoen (f.eks. "bronze", "silver" eller "gold").
* Svaret indeholder et `account.id`, som du kan bruge til at referere til denne underkonto i fremtidige API-kald

> [!TIP]
>
> E-mailadressen skal tilhøre den underkonto (virksomhed eller
> enkeltperson), der skal administrere kontoen. Denne person modtager notifikationer om
> kontoopsætning og betalinger.

## Find en underkonto via dit ID

Vis dine underkonti med `external_id` for at få kontoen til en af dine poster. Afslut værdien med `%` for at få alle konti, hvis ID starter med et navnerum, du har valgt, f.eks. `shopline:%`. Matchning skelner mellem store og små bogstaver, `_` matcher bogstaveligt, og `%` virker kun til sidst, så ID'er, du opretter, kan ikke indeholde det.

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

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

Update Account angiver eller rydder `external_id` på en eksisterende underkonto. Kun din platform kan ændre det. Underkontoen kan læse det, men ikke redigere det.

## Genbrug af en e-mailadresse

Flere underkonti kan dele én e-mailadresse, så længe hver af dem har et særskilt `external_id`. Oprettelse af en konto er idempotent på parret af e-mail og `external_id`:

* **Nyt `external_id`**: Whop opretter en ny underkonto, selv når e-mailen allerede er i brug.
* **Samme e-mail og `external_id`**: Whop returnerer den eksisterende underkonto i stedet for at oprette en dublet, så genforsøg er sikre.
* **`external_id` allerede brugt med en anden e-mail**: Whop returnerer `409` i stedet for at oprette en ekstra konto med det ID. Se [Erstat kontoen bag et ID](#replace-the-account-behind-an-id) for at flytte ID'et til den nye konto i samme request.
* **Intet `external_id`**: Whop returnerer den eksisterende underkonto for den e-mail, der ikke har noget `external_id`, hvis der findes en.

Konti, der deler en e-mail, administreres af den samme Whop-bruger, nemlig den person, der modtager den indbakke.

> [!NOTE]
>
> Tidligere versioner af denne guide placerede `external_id` i `metadata`. Whop accepterer det stadig dér i alle API-
> versioner, sætter `external_id` ud fra det og returnerer det i `metadata`. Det følger samme regler som feltet på øverste niveau,
> herunder `409`, når en anden underkonto allerede har det, så send `reassign_external_id: true` for at genbruge et.
> Ændring af `metadata.external_id` senere ændrer ikke `external_id`. Brug Update Account for at ændre det. Nye
> integrationer bør sende feltet på øverste niveau.

## Erstat kontoen bag et ID

Når du genudsteder en konto hos dig, f.eks. en butik, der skifter ejer, skal du oprette den nye underkonto med samme `external_id` og `reassign_external_id: true`. Whop flytter ID'et til den nye underkonto i samme request i stedet for at returnere `409`.

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

* Den underkonto, der havde ID'et, slettes ikke og ændres ikke på nogen anden måde. Den forbliver aktiv med `external_id` sat til `null`, beholder sin `metadata` og saldo og sender en `account.updated`-webhook. Slet den selv, hvis du ikke længere har brug for den.
* Hvis oprettelsen mislykkes, bliver ID'et, hvor det var.
* Requesten kræver tilladelsen `company:update` på din platformkonto samt `company:create_child`, fordi den ændrer en eksisterende underkonto.
* En request med samme e-mail og `external_id` som en eksisterende underkonto returnerer den underkonto, selv når den sætter flaget.
* ID'et flyttes kun mellem dine egne underkonti.

For at flytte et ID mellem to underkonti, der allerede findes, skal du kalde Update Account to gange: ryd `external_id` på den gamle, og sæt det derefter på den anden. Update Account har ingen `reassign_external_id`, og hvis du sætter ID'et, før du rydder det, returneres `409`.

## Afslut onboarding

Hvis modtageren ikke allerede har en Whop-konto, skal du sende vedkommende et onboardinglink til kontoen, efter du har oprettet den. Modtageren gennemfører Know Your Customer-verifikation (KYC) via linket, og derefter kan kontoen modtage overførsler og andre udbetalingsflows.

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

Når modtageren har gennemført onboarding, kan du:

* oprette checkout-flows for vedkommende med application fees.
* overføre midler til vedkommendes kontosaldo.
* lade vedkommende hæve midler med udbetalingsportalen.

## Kom godt i gang

Før du kan tilmelde underkonti, skal du konfigurere din platformkonto:

1. **Tilmeld dig en platformkonto**: Opret en konto på [whop.com/dashboard](https://whop.com/dashboard)
2. **Generer en Account-API-nøgle**: Gå til siden med dine udviklerindstillinger, og generer en Account-API-nøgle
3. **Brug API-nøglen til godkendelse**: Det er med denne API-nøgle, du godkender dig mod det aktuelle API og styrer dine underkonti

Account-API-nøglen giver de nødvendige tilladelser til at oprette og administrere underkonti under din platformkonto.

## Brugerdefinerede metadata

Du kan knytte brugerdefinerede metadata til konti, når du opretter dem. Metadata giver dig mulighed for at gemme yderligere oplysninger om hver underkonto som nøgle-værdi-par. Det er nyttigt til:

* At spore underkontoniveauer eller klassificeringer
* At linke til poster i din platforms database

Whop gemmer metadata på Account-objektet og returnerer dem ved hver læsning, men du kan ikke filtrere konti efter dem. Placer i stedet den identifikator, du slår konti op efter, i `external_id`.

## API-reference

> [card] [Create Account API](https://docs.whop.com/da/api-reference/accounts/create-account.md)
>
> Se den fulde API-reference for oprettelse af konti og alle tilgængelige parametre

## Næste trin

Efter du har oprettet en Account for en underkonto:

> [card] [Opkræv og fordel betalinger](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md)
>
> Vælg mellem direkte opkrævninger og overførsler

> [card] [Vis udbetalingsportalen](https://docs.whop.com/da/developer/platforms/render-payout-portal.md)
>
> Lad underkonti hæve deres midler


## Related topics

- [Opkræv betalinger for underkonti](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md)
- [Synkroniser brugere til indlejret chat](https://docs.whop.com/da/developer/guides/chat/sync-users.md)
- [Platform-quickstart](https://docs.whop.com/da/developer/platforms/quickstart.md)
