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

# Aktivér udbetalinger for underkonti

> Lad dine underkonti administrere deres egne udbetalinger med Whop Elements eller en hostet portal

Lad dine underkonti selv gennemføre Know Your Customer-verifikation (KYC), tilføje udbetalingsmetoder og hæve deres midler. Du kan montere [Whop Elements](https://docs.whop.com/da/elements/latest/getting-started.md)-wallet-fladerne direkte i din app eller omdirigere brugere til en portal hostet af Whop.

## Indlejret udbetalingsportal

### Implementering på serversiden

For at montere wallet-elementerne skal du generere et adgangstoken for underkontoen på din server. Elementerne læser kontoens saldo og udbetalinger med det. Se [Godkendelse og API-nøgler](https://docs.whop.com/da/developer/guides/auth-scoping.md) for, hvordan du afgrænser tokenets scope, og hvordan det sammenlignes med Whops andre typer legitimationsoplysninger.

```tsx Next.JS theme={null}
// app/api/token/route.ts
import { WhopClient } from "@whop/sdk";
import type { NextRequest } from "next/server";

const whop = new WhopClient({
	token: process.env.WHOP_API_KEY,
});

export async function GET(request: NextRequest) {
	// Authenticate your user here
	const accountId = request.nextUrl.searchParams.get("accountId");

	if (!accountId) {
		return new Response(null, { status: 400 });
	}
	const tokenResponse = await whop.accessTokens
		.create({
			account_id: accountId,
		})
		.catch(() => {
			return null;
		});
	if (!tokenResponse) {
		return new Response(null, { status: 500 });
	}
	const token = tokenResponse.token;
	return Response.json({
		token,
	});
}
```

```typescript Express.js theme={null}
import express from "express";
import { WhopClient } from "@whop/sdk";

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

app.use(express.json());

app.post("/api/access-token", async (req, res) => {
	// Authenticate your user here
	const { accountId } = req.body;

	const { token } = await client.accessTokens.create({
		account_id: accountId,
	});

	res.json({ token });
});

app.listen(3000, () => {
	console.log("Server running on port 3000");
});
```

```python Python theme={null}
from whop_sdk import Whop
from flask import Flask, request, jsonify

app = Flask(__name__)
client = Whop(token="Account API Key")

@app.route('/api/access-token', methods=['POST'])
def create_access_token():
    data = request.get_json()
    # Authenticate your user here
    account_id = data.get('accountId')

    access_token = client.access_tokens.create(
        account_id=account_id
    )

    return jsonify({'token': access_token.token})
```

> [card] [Create Access Token API](https://docs.whop.com/da/api-reference/legacy/access-tokens/create-access-token.md)
>
> Se den fulde API-reference for generering af adgangstokens og alle tilgængelige
> parametre

## Opsætning på klientsiden

```bash npm theme={null}
npm install @whop/elements-react @whop/elements
```

```bash pnpm theme={null}
pnpm add @whop/elements-react @whop/elements
```

```html HTML theme={null}
<script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
```

## Implementering på klientsiden

Opret ét `Wallet`-handle for underkontoen, og monter de flader, du har brug for, under det. Handlet sender sit adgangstoken til alle elementer under det, så generer ét token, der har alle de scopes, elementerne læser med.

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

import { useEffect, useState } from "react";
import {
	ActivityElement,
	BalanceElement,
	Balances,
	Wallet,
	WhopElements,
	WithdrawElement,
} from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function PayoutPortal({ accountId }: { accountId: string }) {
	const [accessToken, setAccessToken] = useState<string | null>(null);

	useEffect(() => {
		fetch(`/api/token?accountId=${accountId}`)
			.then((res) => res.json())
			.then((data) => setAccessToken(data.token));
	}, [accountId]);

	if (!accessToken) return null;

	return (
		<WhopElements elements={loadWhop()}>
			<Wallet accountId={accountId} accessToken={accessToken}>
				<Balances>
					<BalanceElement />
				</Balances>
				<WithdrawElement />
				<ActivityElement />
			</Wallet>
		</WhopElements>
	);
}
```

```html JavaScript theme={null}
<div id="balance"></div>
<div id="withdraw"></div>
<div id="activity"></div>

<script type="module">
  const accountId = "biz_xxxxxxxxxxxxx";
  const { token } = await (await fetch(`/api/token?accountId=${accountId}`)).json();

  const wallet = window.WhopElements().wallet.create({ accountId, accessToken: token });
  wallet.create("balances").create("balance").mount("#balance");
  wallet.create("withdraw").mount("#withdraw");
  wallet.create("activity").mount("#activity");
</script>
```

> [!NOTE]
>
> På iOS leveres wallet-SDK'et med `BalanceElement`, `ListElement` og `ActivityElement`. Se [Kom godt i gang med Elements](https://docs.whop.com/da/elements/latest/getting-started.md), og vælg fanen Swift.

### Identitetsverifikation

En underkonto skal verificere sin identitet, før den kan hæve. Monter [KYC-elementet](https://docs.whop.com/da/elements/latest/verifications/kyc.md) for det fulde flow på siden, som indsamler oplysningerne, kører den hostede udbydersession og rapporterer resultatet. Eller monter [RequiredActions-elementet](https://docs.whop.com/da/elements/latest/dashboard/required-actions.md) for at vise alle udestående handlinger, herunder verifikation, og lade brugeren starte hver af dem.

```tsx React theme={null}
import { WhopElements, Verifications, KycElement } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function VerifyIdentity({ accountId }: { accountId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			<Verifications
				accountId={accountId}
				getToken={() =>
					fetch(`/api/token?accountId=${accountId}`)
						.then((res) => res.json())
						.then((data) => data.token)
				}
			>
				<KycElement onCompleted={() => console.log("Verified")} />
			</Verifications>
		</WhopElements>
	);
}
```

## `Wallet`-indstillinger

| Indstilling | Type | Påkrævet | Beskrivelse |
| - | - | - | - |
| `accountId` | `string` | Ja | Underkontoens ID med præfikset `biz_`. |
| `accessToken` | `string` | Ja, på dit eget domæne | Tokenet fra din server. Uden det bruger læsninger seerens whop.com-session, som kun virker på whop.com. |
| `currency` | `string` | Nej | ISO 4217-kode for beløbsfelter. Standard er `usd`. |
| `appearance` | `Appearance` | Nej | Tema og styling pr. del for alle elementer under handlet. Se [Appearance](https://docs.whop.com/da/elements/latest/appearance.md). |

Alle indstillinger, hændelser og metoder er angivet i [Wallet-referencen](https://docs.whop.com/da/elements/latest/wallet/overview).

### Scopes

Elementerne læser med det token, du genererer, så giv alle de scopes, de har brug for, på det ene token:

* [Balances](https://docs.whop.com/da/elements/latest/wallet/balances) og [Activity](https://docs.whop.com/da/elements/latest/wallet/activity.md) læser `company:balance:read`.
* [Withdraw](https://docs.whop.com/da/elements/latest/wallet/withdraw.md) kræver `payout:withdraw_funds`, `payout:destination:read` og `payout:create_destination` for at tilføje en bank.
* [KYC](https://docs.whop.com/da/elements/latest/verifications/kyc.md) kræver `identity:read` og `identity:write`.

Et token oprettet uden `scoped_actions` arver alle tilladelser fra din API-nøgle.

### Fornyelse af tokenet

Adgangstokens udløber som standard efter én time og højst efter tre timer. Angiv et nyt på handlet, før det udløber:

```ts theme={null}
wallet.update({ accessToken: await fetchToken(accountId) });
```

I React skal du sende den nye værdi som prop'en `accessToken`.

> [!NOTE]
>
> `accessToken` er en værdi, du angiver, ikke et callback, som SDK'et kalder. `Verifications` er undtagelsen: det tager et `getToken`-callback og kalder det, før elementet monteres.

## Hostet udbetalingsportal

I stedet for at indlejre udbetalingsportalen i din app kan du omdirigere brugere til en udbetalingsportal hostet af Whop. Det er nyttigt, når du ikke vil bygge en brugerdefineret brugerflade eller har brug for en hurtig integration.

Opret et kontolink, og omdiriger brugeren til den returnerede URL:

```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: "payouts_portal",
	return_url: "https://yourapp.com/payouts/complete",
	refresh_url: "https://yourapp.com/payouts/refresh",
});

// Redirect the user to the hosted portal
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="payouts_portal",
    return_url="https://yourapp.com/payouts/complete",
    refresh_url="https://yourapp.com/payouts/refresh",
)

# Redirect the user to the hosted portal
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::PayoutsPortal,
            return_url: "https://yourapp.com/payouts/complete".to_string(),
            refresh_url: "https://yourapp.com/payouts/refresh".to_string(),
        },
        None,
    )
    .await?;

// Redirect the user to the hosted portal
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.AccountLinkUseCasesPayoutsPortal,
    ReturnURL:  "https://yourapp.com/payouts/complete",
    RefreshURL: "https://yourapp.com/payouts/refresh",
})
if err != nil {
    log.Fatal(err)
}

// Redirect the user to the hosted portal
fmt.Println(accountLink.URL)
```

I dette eksempel:

* `account_id` er platformen eller underkontoen
* `use_case` angiver portaltypen
* `return_url` er der, hvor Whop omdirigerer brugeren hen, når vedkommende vil vende tilbage til dit website
* `refresh_url` er der, hvor Whop omdirigerer brugeren hen, hvis sessionen udløber

### Tilgængelige anvendelser

| Anvendelse | Beskrivelse |
| - | - |
| `account_onboarding` | KYC og identitetsverifikation |
| `payouts_portal` | Udbetalinger, udbetalingsmetoder, KYC og identitetsverifikation |

Når du har oprettet kontolinket, skal du omdirigere brugeren til den `url`, der returneres i svaret. Brugeren gennemfører udbetalingsflowet på portalen hostet af Whop, hvorefter Whop omdirigerer vedkommende til din `return_url`.

## Relaterede ressourcer

> [card] [Wallet-elementer](https://docs.whop.com/da/elements/latest/wallet/overview)
>
> Alle wallet-flader med deres indstillinger, hændelser og scopes

> [card] [Betal underkonti](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md)
>
> Overfør midler til underkonti


## Related topics

- [Manuelle udbetalinger til underkonti](https://docs.whop.com/da/developer/platforms/manual-payouts.md)
- [Eksempelintegration](https://docs.whop.com/da/developer/guides/example-integration.md)
- [Opkræv betalinger for underkonti](https://docs.whop.com/da/developer/platforms/collect-payments-for-subaccounts.md)
