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

# Activer les versements des sous-comptes

> Permettez à vos sous-comptes de gérer leurs propres versements avec Whop Elements ou un portail hébergé

Permettez à vos sous-comptes d'effectuer eux-mêmes la vérification Know Your Customer (KYC), d'ajouter des méthodes de versement et de retirer leurs fonds. Vous pouvez monter les surfaces de portefeuille de [Whop Elements](https://docs.whop.com/fr/elements/latest/getting-started.md) directement dans votre application ou rediriger les utilisateurs vers un portail hébergé par Whop.

## Portail de versement intégré

### Implémentation côté serveur

Pour monter les éléments de portefeuille, générez un jeton d'accès pour le sous-compte sur votre serveur. Les éléments lisent le solde et les versements de ce compte avec ce jeton. Consultez [Authentification et clés API](https://docs.whop.com/fr/developer/guides/auth-scoping.md) pour savoir comment restreindre la portée de ce jeton et comment il se compare aux autres types d'identifiants de Whop.

```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] [API Create Access Token](https://docs.whop.com/fr/api-reference/legacy/access-tokens/create-access-token.md)
>
> Consultez la référence complète de l'API pour la génération de jetons d'accès et tous les
> paramètres disponibles

## Configuration côté client

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

## Implémentation côté client

Créez un handle `Wallet` pour le sous-compte et montez sous celui-ci les surfaces dont vous avez besoin. Le handle transmet son jeton d'accès à chaque élément placé sous lui : générez donc un seul jeton portant tous les scopes que ces éléments lisent.

```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]
>
> Sur iOS, le SDK de portefeuille fournit `BalanceElement`, `ListElement` et `ActivityElement`. Consultez [Premiers pas avec Elements](https://docs.whop.com/fr/elements/latest/getting-started.md) et choisissez l'onglet Swift.

### Vérification d'identité

Un sous-compte doit vérifier son identité avant de pouvoir effectuer un retrait. Montez l'[élément KYC](https://docs.whop.com/fr/elements/latest/verifications/kyc.md) pour le parcours complet dans la page, qui collecte les informations, exécute la session du fournisseur hébergé et communique le résultat. Ou montez l'[élément RequiredActions](https://docs.whop.com/fr/elements/latest/dashboard/required-actions.md) pour afficher toutes les actions en attente, vérification comprise, et permettre à l'utilisateur de lancer chacune d'elles.

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

## Options de `Wallet`

| Option | Type | Obligatoire | Description |
| - | - | - | - |
| `accountId` | `string` | Oui | L'ID du sous-compte, préfixé par `biz_`. |
| `accessToken` | `string` | Oui, sur votre propre domaine | Le jeton fourni par votre serveur. Sans lui, les lectures utilisent la session whop.com de l'utilisateur, ce qui ne fonctionne que sur whop.com. |
| `currency` | `string` | Non | Code ISO 4217 pour les champs de montant. Vaut `usd` par défaut. |
| `appearance` | `Appearance` | Non | Thème et style par partie pour chaque élément placé sous le handle. Consultez [Apparence](https://docs.whop.com/fr/elements/latest/appearance.md). |

Toutes les options, tous les événements et toutes les méthodes sont listés dans la [référence Wallet](https://docs.whop.com/fr/elements/latest/wallet/overview).

### Scopes

Les éléments lisent les données avec le jeton que vous générez : accordez donc sur ce seul jeton tous les scopes dont ils ont besoin :

* [Balances](https://docs.whop.com/fr/elements/latest/wallet/balances) et [Activity](https://docs.whop.com/fr/elements/latest/wallet/activity.md) lisent `company:balance:read`.
* [Withdraw](https://docs.whop.com/fr/elements/latest/wallet/withdraw.md) nécessite `payout:withdraw_funds`, `payout:destination:read`, ainsi que `payout:create_destination` pour ajouter une banque.
* [KYC](https://docs.whop.com/fr/elements/latest/verifications/kyc.md) nécessite `identity:read` et `identity:write`.

Un jeton créé sans `scoped_actions` hérite de toutes les permissions de votre clé API.

### Actualiser le jeton

Les jetons d'accès expirent par défaut au bout d'une heure, et au maximum au bout de trois heures. Définissez-en un nouveau sur le handle avant son expiration :

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

En React, transmettez la nouvelle valeur dans la prop `accessToken`.

> [!NOTE]
>
> `accessToken` est une valeur que vous définissez, et non un callback appelé par le SDK. `Verifications` fait exception : il accepte un callback `getToken` et l'appelle avant le montage de l'élément.

## Portail de versement hébergé

Au lieu d'intégrer le portail de versement dans votre application, vous pouvez rediriger les utilisateurs vers un portail de versement hébergé par Whop. C'est utile lorsque vous ne voulez pas créer d'interface personnalisée ou avez besoin d'une intégration rapide.

Créez un lien de compte et redirigez l'utilisateur vers l'URL renvoyée :

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

Dans cet exemple :

* `account_id` est la plateforme ou le sous-compte
* `use_case` indique le type de portail
* `return_url` est l'adresse vers laquelle Whop redirige l'utilisateur lorsqu'il souhaite revenir sur votre site
* `refresh_url` est l'adresse vers laquelle Whop redirige l'utilisateur si la session expire

### Cas d'usage disponibles

| Cas d'usage | Description |
| - | - |
| `account_onboarding` | KYC et vérification d'identité |
| `payouts_portal` | Versements, méthodes de versement, KYC et vérification d'identité |

Après avoir créé le lien de compte, redirigez l'utilisateur vers l'`url` renvoyée dans la réponse. L'utilisateur termine le parcours de versement sur le portail hébergé par Whop, puis Whop le redirige vers votre `return_url`.

## Ressources associées

> [card] [Éléments de portefeuille](https://docs.whop.com/fr/elements/latest/wallet/overview)
>
> Toutes les surfaces de portefeuille avec leurs options, événements et scopes

> [card] [Payer les sous-comptes](https://docs.whop.com/fr/developer/platforms/collect-payments-for-subaccounts.md)
>
> Transférez des fonds vers des sous-comptes


## Related topics

- [Versements manuels aux sous-comptes](https://docs.whop.com/fr/developer/platforms/manual-payouts.md)
- [Encaisser des paiements pour des sous-comptes](https://docs.whop.com/fr/developer/platforms/collect-payments-for-subaccounts.md)
- [Inscrire des sous-comptes](https://docs.whop.com/fr/developer/platforms/enroll-subaccounts.md)
