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

# Versements manuels aux sous-comptes

> Envoyez des versements aux sous-comptes depuis le solde de votre plateforme : intégrez-les via le KYC, ajoutez une méthode de versement, obtenez la méthode par défaut et créez un versement.

Envoyez des versements directement à vos sous-comptes depuis le solde de votre plateforme. Les sous-comptes doivent effectuer la vérification d'identité et ajouter une méthode de versement avant de pouvoir recevoir des fonds.

**1. Effectuer la vérification KYC**

Avant de pouvoir recevoir des versements, un utilisateur doit effectuer la vérification d'identité (KYC). Utilisez le parcours d'onboarding de compte hébergé pour guider les utilisateurs dans cette démarche :

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

Redirigez l'utilisateur vers l'`url` renvoyée dans la réponse. Une fois la vérification terminée, il sera redirigé vers votre `return_url`.

**2. Ajouter une méthode de versement**

Avant de créer un versement, le compte a besoin d'une méthode de versement. Montez l'[élément Withdraw](https://docs.whop.com/fr/elements/latest/wallet/withdraw.md) avec un jeton d'accès pour le sous-compte. Il liste les méthodes de versement du compte et en collecte une nouvelle s'il n'en existe aucune :

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

Générez l'`accessToken` sur votre serveur pour le sous-compte, comme indiqué dans [Activer les versements des sous-comptes](https://docs.whop.com/fr/developer/platforms/render-payout-portal.md). Vous pouvez aussi envoyer l'utilisateur vers le [portail de versement hébergé](https://docs.whop.com/fr/developer/platforms/render-payout-portal.md#hosted-payout-portal). Pour n'accepter un compte PayPal qu'après que son titulaire s'est connecté pour prouver qu'il en est propriétaire, [connectez une méthode de versement PayPal](https://docs.whop.com/fr/developer/guides/connect-paypal-payout-method.md).

**3. Obtenir la méthode de versement par défaut**

Listez les méthodes de versement du sous-compte et trouvez celle qui a `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. Créer un versement**

La version d'API `2026-11-03` et les suivantes exigent un devis. Appelez d'abord `POST /payouts/quotes` avec le compte, la méthode de versement, le montant, la devise et la vitesse que vous allez soumettre :

```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"}'
```

Remplacez `QUOTE_TOKEN_FROM_RESPONSE` ci-dessous par le `quote_token` renvoyé et soumettez la requête avant `expires_at`. Si une requête de versement expire, réessayez avec la même `Idempotency-Key` de versement et le jeton d'origine. Utilisez une clé différente pour la requête de devis.

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

Dans cet exemple :

* `account_id` est le sous-compte à qui verser les fonds
* `amount` est le montant du versement (100,00 USD) - les frais seront déduits de ce montant
* `currency` est le code de devise ISO
* `payout_method_id` est l'ID de la méthode de versement à utiliser (issu de l'étape 3)

La requête renverra une erreur si le montant dépasse le solde disponible.

### Prendre en charge les frais de versement de vos sous-comptes

Par défaut, les frais de versement sont déduits du solde du sous-compte. Vous pouvez choisir de prendre ces frais en charge depuis le solde de votre plateforme en définissant `platform_covers_fees` sur `true` à la fois dans la requête de devis et dans la requête de versement :

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

Lorsque `platform_covers_fees` vaut `true`, le sous-compte reçoit l'intégralité du montant du versement et les frais sont débités du solde de votre plateforme. Cela nécessite que la politique de prise en charge des frais de votre plateforme couvre la méthode de versement, ou une clé API autorisée à gérer les frais de vos sous-comptes.

## Référence de l'API

> [card] [API Create Payout](https://docs.whop.com/fr/api-reference/payouts/create-payout.md)
>
> Consultez la référence complète de l'API pour la création de versements

## Ressources associées

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

> [card] [Afficher le portail de versement](https://docs.whop.com/fr/developer/platforms/render-payout-portal.md)
>
> Permettez à vos utilisateurs de retirer leurs fonds
