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

# Connecter un moyen de versement PayPal

> Ajoutez PayPal comme moyen de versement en demandant au titulaire du compte de se connecter à PayPal, afin que les versements ne soient envoyés qu'à un compte vérifié à son nom.

Assurez-vous que les versements n'atteignent qu'un compte PayPal appartenant au titulaire. Le titulaire se connecte à PayPal au lieu de saisir une adresse e-mail, et Whop enregistre l'adresse e-mail fournie par PayPal dès que le nom correspond à sa configuration de versement.

| | Connexion avec PayPal (ce guide) | E-mail saisi |
| - | - | - |
| **E-mail de versement** | Fourni par PayPal | Saisi par le titulaire |
| **Prouve que le compte appartient au titulaire** | Oui | Non |
| **Intégration** | Une redirection et une page de retour | Un appel API |

> [!NOTE]
>
> Avant de commencer, vous avez besoin de :
>
> * Une clé API disposant des scopes `payout:destination:read` et `payout:create_destination`.
> * La connexion PayPal activée sur le compte. Contactez Whop pour l'activer. En attendant, `supports_paypal_login` vaut `false` et l'étape 2 renvoie `403`.
> * Une [configuration de versement](https://docs.whop.com/fr/developer/verification/overview.md) terminée. Whop compare le nom qui y figure avec celui du compte PayPal.
> * Une page `https` vers laquelle PayPal renverra le titulaire, sur un domaine ajouté au compte ou à sa plateforme. Ajoutez-le avec [Create Domain](https://docs.whop.com/fr/api-reference/domains/create-domain.md) et `verification: {}`. Il n'est pas nécessaire que la vérification soit terminée. `https://localhost` fonctionne pour les tests.
> * Le SDK Whop 2.5.0 ou une version ultérieure, si vous utilisez un SDK.

## Fonctionnement de la redirection

Tout se déroule dans le navigateur du titulaire, dans un seul onglet. Vous n'appelez jamais PayPal directement.

1. Votre serveur démarre une session et obtient une `authorize_url` sur PayPal.
2. Le navigateur du titulaire s'y rend, puis le titulaire se connecte et approuve.
3. PayPal renvoie le navigateur vers Whop, qui lit l'adresse e-mail, le nom et le statut de vérification du compte.
4. Whop envoie le navigateur vers votre `return_url` avec `?paypal_link_token=…` ou `?error=…`.
5. Votre serveur transmet le jeton à Whop, qui vérifie le nom et enregistre le moyen de versement.

## Trouver le moyen de versement

[Listez les moyens de versement pris en charge](https://docs.whop.com/fr/api-reference/payouts/list-supported-payout-methods.md) et conservez l'`id` de celui qui a `supports_paypal_login: true`. Les SDK parcourent pour vous toutes les pages de résultats.

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

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

const supportedMethods = await client.payouts.supportedMethods.list({
	account_id: "biz_xxxxxxxxxxxxx",
	destination_currency: "usd",
});

let paypalMethodId: string | undefined;
for await (const method of supportedMethods) {
	if (method.supports_paypal_login) {
		paypalMethodId = method.id;
		break;
	}
}
if (!paypalMethodId) throw new Error("PayPal login is not enabled for this account");
```

```python Python theme={null}
import os

from whop_sdk import Whop

client = Whop(token=os.environ["WHOP_API_KEY"])

supported_methods = client.payouts.supported_methods.list(
    account_id="biz_xxxxxxxxxxxxx",
    destination_currency="usd",
)

paypal_method_id = next(
    (method.id for method in supported_methods if method.supports_paypal_login),
    None,
)
if paypal_method_id is None:
    raise RuntimeError("PayPal login is not enabled for this account")
```

```ruby Ruby theme={null}
require "whop_sdk"

client = Whop_sdk::Client.new(token: ENV.fetch("WHOP_API_KEY"))

paypal_method = client.payouts.supported_methods
  .list(account_id: "biz_xxxxxxxxxxxxx", destination_currency: "usd")
  .find(&:supports_paypal_login)
raise "PayPal login is not enabled for this account" if paypal_method.nil?

paypal_method_id = paypal_method.id
```

```go Go theme={null}
import (
	"context"
	"fmt"
	"log"
	"os"

	whopsdk "github.com/whopio/whopsdk-go/v2"
	"github.com/whopio/whopsdk-go/v2/client"
	"github.com/whopio/whopsdk-go/v2/option"
	"github.com/whopio/whopsdk-go/v2/payouts"
)

ctx := context.TODO()
client := client.NewWhop(option.WithToken(os.Getenv("WHOP_API_KEY")))

page, err := client.Payouts.SupportedMethods.List(ctx, &payouts.ListSupportedMethodsRequest{
	AccountID:           whopsdk.String("biz_xxxxxxxxxxxxx"),
	DestinationCurrency: whopsdk.String("usd"),
})
if err != nil {
	log.Fatal(err)
}

var paypalMethodID string
methods := page.Iterator()
for methods.Next(ctx) {
	method := methods.Current()
	if method.SupportsPaypalLogin != nil && *method.SupportsPaypalLogin {
		paypalMethodID = method.ID
		break
	}
}
if err := methods.Err(); err != nil {
	log.Fatal(err)
}
if paypalMethodID == "" {
	log.Fatal("PayPal login is not enabled for this account")
}
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/supported_methods?account_id=biz_xxxxxxxxxxxxx&destination_currency=usd" \
  -H "Authorization: Bearer $WHOP_API_KEY"
```

## Démarrer la connexion

[Créez une session de liaison PayPal](https://docs.whop.com/fr/api-reference/payouts/create-paypal-link-session.md) et redirigez le titulaire vers son `authorize_url`. La session expire au bout de 15 minutes, à `expires_at`.

```typescript TypeScript theme={null}
const session = await client.payouts.paypalLinkSessions.create({
	account_id: "biz_xxxxxxxxxxxxx",
	supported_payout_method_id: paypalMethodId,
	destination_currency: "usd",
	return_url: "https://yourapp.example/settings/payouts",
});

// Redirect the holder's browser to this URL
console.log(session.authorize_url);
```

```python Python theme={null}
session = client.payouts.paypal_link_sessions.create(
    account_id="biz_xxxxxxxxxxxxx",
    supported_payout_method_id=paypal_method_id,
    destination_currency="usd",
    return_url="https://yourapp.example/settings/payouts",
)

# Redirect the holder's browser to this URL
print(session.authorize_url)
```

```ruby Ruby theme={null}
session = client.payouts.paypal_link_sessions.create(
  account_id: "biz_xxxxxxxxxxxxx",
  supported_payout_method_id: paypal_method_id,
  destination_currency: "usd",
  return_url: "https://yourapp.example/settings/payouts",
)

# Redirect the holder's browser to this URL
puts session.authorize_url
```

```go Go theme={null}
session, err := client.Payouts.PaypalLinkSessions.Create(ctx, &payouts.CreatePaypalLinkSessionsRequest{
	AccountID:               whopsdk.String("biz_xxxxxxxxxxxxx"),
	SupportedPayoutMethodID: paypalMethodID,
	DestinationCurrency:     whopsdk.String("usd"),
	ReturnURL:               "https://yourapp.example/settings/payouts",
})
if err != nil {
	log.Fatal(err)
}

// Redirect the holder's browser to this URL
fmt.Println(session.AuthorizeURL)
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/paypal_link_sessions" \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "account_id": "biz_xxxxxxxxxxxxx",
    "supported_payout_method_id": "podst_xxxxxxxxxxxxx",
    "destination_currency": "usd",
    "return_url": "https://yourapp.example/settings/payouts"
  }'
```

Le navigateur revient vers votre `return_url` avec l'un des paramètres suivants :

| Chaîne de requête | Signification | Étape suivante |
| - | - | - |
| `?paypal_link_token=…` | Le titulaire s'est connecté | Enregistrez le moyen de versement sous 15 minutes |
| `?error=paypal_login_canceled` | Le titulaire a abandonné | Proposez de recommencer |
| `?error=paypal_login_failed` | PayPal a refusé, le lien a été réutilisé ou l'échange a échoué | Démarrez une nouvelle session |

Si le titulaire termine après `expires_at`, ou après la suppression du domaine de `return_url` du compte, Whop ne peut pas le renvoyer vers votre page. Il voit alors une page « Invalid or expired link ».

## Enregistrer le moyen de versement

Sur votre serveur, [créez le moyen de versement enregistré](https://docs.whop.com/fr/api-reference/payouts/create-saved-payout-method.md) avec `paypal_link_token` à la place de `fields`. Utilisez les mêmes `account_id`, `supported_payout_method_id` et `destination_currency` que pour la session, car le jeton ne fonctionne qu'avec ceux-ci. Whop enregistre l'adresse e-mail PayPal et nomme le moyen de versement d'après elle.

```typescript TypeScript theme={null}
// paypalLinkToken is the paypal_link_token from your return_url's query string
const method = await client.payouts.methods.create({
	account_id: "biz_xxxxxxxxxxxxx",
	supported_payout_method_id: paypalMethodId,
	destination_currency: "usd",
	paypal_link_token: paypalLinkToken,
});

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

```python Python theme={null}
# paypal_link_token is the value from your return_url's query string
method = client.payouts.methods.create(
    account_id="biz_xxxxxxxxxxxxx",
    supported_payout_method_id=paypal_method_id,
    destination_currency="usd",
    paypal_link_token=paypal_link_token,
)

print(method.id)
```

```ruby Ruby theme={null}
# paypal_link_token is the value from your return_url's query string
method = client.payouts.methods.create(
  account_id: "biz_xxxxxxxxxxxxx",
  supported_payout_method_id: paypal_method_id,
  destination_currency: "usd",
  paypal_link_token: paypal_link_token,
)

puts method.id
```

```go Go theme={null}
// paypalLinkToken is the paypal_link_token from your return_url's query string
method, err := client.Payouts.Methods.Create(ctx, &payouts.CreateMethodsRequest{
	AccountID:               whopsdk.String("biz_xxxxxxxxxxxxx"),
	SupportedPayoutMethodID: paypalMethodID,
	DestinationCurrency:     whopsdk.String("usd"),
	PaypalLinkToken:         whopsdk.String(paypalLinkToken),
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(method.ID)
```

```bash cURL theme={null}
curl "https://api.whop.com/api/v1/payouts/methods" \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "account_id": "biz_xxxxxxxxxxxxx",
    "supported_payout_method_id": "podst_xxxxxxxxxxxxx",
    "destination_currency": "usd",
    "paypal_link_token": "'"$PAYPAL_LINK_TOKEN"'"
  }'
```

La réponse correspond au nouveau moyen de versement (version abrégée) :

```json theme={null}
{
	"object": "payout_method",
	"id": "potk_xxxxxxxxxxxxx",
	"nickname": "PayPal j•••@example.com",
	"institution_name": "PayPal",
	"destination_currency": "usd"
}
```

Vous pouvez désormais [envoyer un versement](https://docs.whop.com/fr/developer/platforms/manual-payouts.md) vers ce moyen.

### Si Whop refuse le compte

Whop répond `400` avec un `message` destiné au titulaire, par exemple en cas de nom ne correspondant pas. Affichez-le tel quel.

* **Le jeton reste valide après un refus** : relancez donc une erreur temporaire avec le même jeton.
* **Si le message indique de connecter à nouveau PayPal**, démarrez une nouvelle session une fois que le titulaire a corrigé le problème.
* **Un compte PayPal non vérifié ou une adresse e-mail non confirmée est tout de même enregistré.**

## Ce que voit le titulaire

L'écran de consentement de PayPal indique que Whop est l'application qui demande son adresse e-mail, son nom et son statut de vérification. Chaque redirection reste dans l'onglet qui a ouvert PayPal : si vous utilisez une fenêtre pop-up, votre page de retour doit donc notifier la fenêtre qui l'a ouverte, puis se fermer.

## Étapes suivantes

> [card] [Envoyer un versement](https://docs.whop.com/fr/developer/platforms/manual-payouts.md)
>
> Effectuez un versement vers le moyen PayPal que vous venez d'enregistrer

> [card] [Référence de l'API Payouts](https://docs.whop.com/fr/api-reference/payouts/payout)
>
> Tous les endpoints relatifs aux versements et aux moyens de versement
