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

# Ouvrir une feuille de portefeuille depuis votre propre bouton

> Ouvrez la feuille Apple Pay ou Google Pay depuis un bouton que vous affichez, fixez vous-même le prix de la commande et débitez le jeton de confirmation depuis votre serveur

Utilisez la ressource payment request lorsque vous affichez vous-même le bouton d'achat et fixez vous-même le prix de la commande. Un seul appui ouvre la fenêtre Apple Pay ou Google Pay, la fenêtre vous remet un jeton de confirmation, et votre serveur transmet ce jeton à l'API Payments pour débiter.

Les fichiers sous **Code** contiennent des commentaires `Step X.Y` qui renvoient aux étapes ci-dessous. Choisissez une implémentation serveur et une implémentation client. La liste comprend les fichiers de chaque option.

## Créer votre bouton de portefeuille

### 1.1 Installer les paquets (React)

Installez les paquets Whop Elements pour React.

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

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

### 1.1 Ajouter la balise script (JavaScript)

Chargez le script Whop Elements sur la page qui affiche le bouton.

### 1.2 Créer la payment request

Créez la requête avec votre compte, la devise et le montant en unités mineures. `lineItems` correspond aux lignes que la fenêtre affiche sous le total. Rien n'est monté : la ressource est la fenêtre du portefeuille sans élément, et le bouton vous appartient.

Les portefeuilles ne s'ouvrent que sur les pages dont le domaine est prêt pour Apple Pay. Suivez [Activer Apple Pay et Google Pay](https://docs.whop.com/fr/payments/apple-pay.md) une fois par domaine, servez la page en `https` et testez sur un véritable appareil sur lequel un portefeuille est configuré.

### 1.3 Vérifier quels portefeuilles peuvent payer

Attendez `canMakePayment()` avant d'afficher un bouton. Il indique avec quels portefeuilles cet appareil, ce compte et ce domaine peuvent payer, et il prépare la fenêtre pour qu'elle puisse s'ouvrir de manière synchrone par la suite. N'affichez un bouton que pour un portefeuille ayant renvoyé `true`.

Apple et Google exigent chacun leur propre visuel de bouton sur un bouton personnalisé. Suivez les [directives relatives au bouton Apple Pay](https://developer.apple.com/design/human-interface-guidelines/apple-pay) et les [directives de marque Google Pay](https://developers.google.com/pay/api/web/guides/brand-guidelines).

### 1.4 Ouvrir la fenêtre et envoyer le jeton à votre serveur

Appelez `show(type)` en tout premier dans le gestionnaire d'appui du bouton, avant tout `await`. Apple refuse une fenêtre ouverte en dehors de ce geste de l'utilisateur, c'est pourquoi `canMakePayment()` a été exécuté à l'avance. La fenêtre demande l'e-mail de l'acheteur, sauf si vous en passez un avec `show("apple_pay", \{ email \})`.

`show` se résout une fois que l'acheteur a autorisé le paiement. `ctok` est le jeton de confirmation à usage unique, `type` désigne le portefeuille, et `payer` contient l'e-mail, le nom, le téléphone et le pays de facturation de l'acheteur tels que le portefeuille les a fournis. Si l'acheteur ferme la fenêtre, `show` est rejeté avec une erreur `payment_request_cancelled`. La fenêtre se ferme avec une coche dès que le jeton est émis, avant la confirmation de votre serveur : affichez donc le résultat de votre serveur sur votre page.

Envoyez `ctok` à votre serveur avec votre propre référence de commande. Pour collecter une adresse de livraison et proposer des options de livraison, définissez `requestShipping` et répondez aux changements de la fenêtre avec `updateWith`. La [référence PaymentRequest](https://docs.whop.com/fr/elements/latest/payments/paymentRequest.md) couvre ces gestionnaires.

## Débiter depuis votre serveur

### 2.1 Installer le SDK Whop (Next.js)

Installez le SDK Whop et créez un client avec votre clé API de compte. La clé reste sur le serveur. Le navigateur ne la voit jamais.

```bash npm theme={null}
npm install @whop/sdk @vercel/functions
```

```bash pnpm theme={null}
pnpm add @whop/sdk @vercel/functions
```

### 2.1 Installer le SDK Whop (Express)

Installez le SDK Whop et créez un client avec votre clé API de compte. La clé reste sur le serveur. Le navigateur ne la voit jamais.

```bash npm theme={null}
npm install @whop/sdk express
```

```bash pnpm theme={null}
pnpm add @whop/sdk express
```

### 2.1 Installer le SDK Whop (Python)

Installez le SDK Whop et créez un client avec votre clé API de compte. La clé reste sur le serveur. Le navigateur ne la voit jamais.

```bash pip theme={null}
pip install whop-sdk fastapi
```

```bash poetry theme={null}
poetry add whop-sdk fastapi
```

### 2.2 Créer le paiement à partir du jeton de confirmation

Transmettez le jeton à l'API Payments. Whop identifie l'acheteur grâce à l'e-mail du jeton, débite la variante et renvoie le paiement avec un `client_secret`. Renvoyez `id`, `status` et `client_secret` au navigateur. Le `client_secret` ne débloque que ce paiement précis, il peut donc être exposé sans risque.

Débitez ce que la fenêtre a affiché. Le `amount` de la requête est exprimé en unités mineures, donc `1000` dans la fenêtre correspond ici à un `initial_price` de `10.0`. Passez une `variant` en ligne pour trouver ou créer une variante pour ce prix, ou `variant_id` pour une variante que vous avez déjà créée. Définissez `return_url` sur la page où l'acheteur doit arriver après une étape en pleine page, et placez votre propre ID de commande dans `metadata` afin que le paiement et ses webhooks le transportent.

* Une `variant` en ligne trouve ou crée la variante pour ce prix. Utilisez `variant_id` lorsque le prix existe déjà sous forme de variante
* `confirmation_token` représente la carte du portefeuille autorisée dans la fenêtre
* `metadata` relie le paiement à votre propre commande
* Pour les biens physiques, envoyez le `shipping.address` du résultat avec le jeton et transmettez-le en tant que `shipping_address`

### 2.3 Exécuter la commande depuis le webhook

Whop envoie `payment.succeeded` à votre endpoint de webhook une fois le paiement réussi. Vérifiez la signature avec l'utilitaire du SDK, puis exécutez la commande : marquez la commande comme payée, accordez l'accès et envoyez l'e-mail. Un paiement par portefeuille indique `apple_pay` ou `google_pay` dans `payment_method_type`.

L'exécution de la commande a sa place ici et nulle part ailleurs. La coche de la fenêtre, le navigateur et un paramètre de requête peuvent tous indiquer un paiement sans que celui-ci soit réglé. Suivez le [guide des webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) pour créer le webhook et stocker son secret `ws_` dans `WHOP_WEBHOOK_SECRET`.

## Finaliser le paiement

### 3.1 Gérer l'action suivante

Un paiement qui revient avec le statut `paid` est terminé. Tout autre statut signifie que l'acheteur a encore une étape à effectuer, comme 3D Secure, ou que le paiement est encore en attente. Transmettez le `client_secret` à `handleNextAction`. Il exécute une étape en ligne dans une boîte de dialogue et se résout avec `redirected: false`, ou envoie l'acheteur vers votre `return_url` et se résout avec `redirected: true`.

Faites un branchement sur le `status` renvoyé. `succeeded` signifie que l'acheteur a payé, `processing` que le paiement est encore en attente, et toute autre valeur nécessite une nouvelle tentative. `lastPaymentError` contient le motif lorsqu'il y en a un. Une boîte de dialogue fermée laisse le paiement à l'état `requires_action` sans erreur : l'absence d'erreur ne signifie donc jamais une réussite.

### 3.2 Lire le résultat dans l'URL

Un acheteur parti vers une étape en pleine page arrive sur `return_url` **quoi qu'il s'y soit passé**. Whop ajoute trois paramètres de requête. `payment` est l'ID `pay_`. `status` vaut `succeeded` lorsque l'acheteur a payé, `failed` ou `canceled` dans le cas contraire, et un statut d'attente comme `processing` tant que le paiement n'est pas décidé. `client_secret` permet à la page d'interroger le statut du paiement si elle souhaite attendre une décision.

Vos propres paramètres, comme `order`, restent dans l'URL. `handleNextAction` signale lui-même les refus en ligne, si bien que la page de retour est le seul endroit où votre site voit une étape externe échouée.

### 3.3 Afficher le bon écran

Faites un branchement sur `status`. `succeeded` affiche la page de remerciement. `failed` et `canceled` affichent un message indiquant que l'acheteur n'a pas été débité, ainsi qu'un lien pour revenir au produit. Toute autre valeur signifie que le paiement est encore en attente. Indiquez à l'acheteur que vous confirmerez par e-mail. Les parcours en ligne du gestionnaire du bouton envoient l'acheteur vers la même page avec les mêmes paramètres, si bien qu'une seule page gère toutes les issues.

Considérez cette page comme un affichage du résultat, et non comme une preuve de paiement. N'importe qui peut saisir `status=succeeded` dans une URL. L'accès, les téléchargements et l'exécution des commandes proviennent du webhook `payment.succeeded` sur votre serveur.

## Code

### Client : React — `WalletButtons.tsx`

```tsx WalletButtons.tsx theme={null}
// Step 1.1: Install the packages
import { useEffect, useRef, useState } from "react";
import { WhopElements, useWhop } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";
import type { PaymentRequestResource } from "@whop/elements/payments";

type Wallet = "apple_pay" | "google_pay";

export function ProductPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			<WalletButtons orderId={orderId} />
		</WhopElements>
	);
}

function WalletButtons({ orderId }: { orderId: string }) {
	const whop = useWhop();
	const requestRef = useRef<PaymentRequestResource | null>(null);
	const [wallets, setWallets] = useState<Wallet[]>([]);
	const [error, setError] = useState<string | null>(null);

	useEffect(() => {
		if (!whop) return;
		// Step 1.2: Create the payment request
		// Amounts are in minor units: 1000 is $10.00.
		const paymentRequest = whop.payments.paymentRequest.create({
			accountId: "biz_xxxxxxxxxxxxx",
			currency: "usd",
			amount: 1000,
			lineItems: [{ label: "Pro access", amount: 1000 }],
		});
		requestRef.current = paymentRequest;
		// Step 1.3: Check which wallets can pay
		paymentRequest.canMakePayment().then(({ applePay, googlePay }) => {
			setWallets([
				...(applePay ? (["apple_pay"] as const) : []),
				...(googlePay ? (["google_pay"] as const) : []),
			]);
		});
	}, [whop]);

	async function pay(wallet: Wallet) {
		const paymentRequest = requestRef.current;
		if (!paymentRequest || !whop) return;
		setError(null);

		// Step 1.4: Open the sheet and send the token to your server
		// show() must run inside the press handler, before any await, or Apple refuses the sheet.
		let ctok: string;
		try {
			({ ctok } = await paymentRequest.show(wallet));
		} catch (err) {
			if ((err as Error).message !== "payment_request_cancelled") {
				setError("The wallet sheet couldn't complete. Try again.");
			}
			return;
		}

		const response = await fetch("/api/pay", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({ confirmationToken: ctok, orderId }),
		});
		const payment = await response.json();

		// Step 3.1: Handle the next action
		if (payment.status === "paid") {
			window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
			return;
		}

		// Anything but paid means the buyer still has a step, or the charge is still being decided.
		const result = await whop.payments.handleNextAction({
			clientSecret: payment.client_secret,
		});
		// The buyer left for an off-site step; they come back on the return page.
		if (result.redirected) return;

		if (result.status === "succeeded") {
			window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
			return;
		}
		if (result.status === "processing") {
			window.location.assign(`/checkout/return?order=${orderId}&status=processing&payment=${payment.id}`);
			return;
		}
		// A dismissed dialog leaves the payment at requires_action with no error, so a missing error never means success.
		setError(result.lastPaymentError?.message ?? "The payment wasn't completed. Try again.");
	}

	return (
		<>
			{/* Step 1.3: Check which wallets can pay */}
			{wallets.map((wallet) => (
				<button key={wallet} onClick={() => pay(wallet)}>
					{wallet === "apple_pay" ? "Pay with Apple Pay" : "Pay with Google Pay"}
				</button>
			))}
			{error && <p role="alert">{error}</p>}
		</>
	);
}
```

### Client : React — `CheckoutReturn.tsx`

```tsx CheckoutReturn.tsx theme={null}
export function CheckoutReturn() {
	// Step 3.2: Read the outcome from the URL
	// Whop appends `payment`, `status`, and `client_secret` to your returnUrl. Your own parameters (here `order`) survive.
	const params = new URLSearchParams(window.location.search);
	const paymentId = params.get("payment");
	const status = params.get("status");
	const orderId = params.get("order");

	// Step 3.3: Show the right face
	if (status === "succeeded") {
		return (
			<section>
				<h1>Thanks for your order</h1>
				<p>Payment {paymentId} is complete. A receipt is on its way to your email.</p>
			</section>
		);
	}

	if (status === "failed" || status === "canceled") {
		return (
			<section>
				<h1>Your payment did not go through</h1>
				<p>No money was taken. You can try again with another payment method.</p>
				<a href={`/checkout?order=${orderId}`}>Back to checkout</a>
			</section>
		);
	}

	return (
		<section>
			<h1>Confirming your payment</h1>
			<p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
		</section>
	);
}
```

### Client : JavaScript — `buy.html`

```html buy.html theme={null}
<!DOCTYPE html>
<html>
  <head>
    <!-- Step 1.1: Add the script tag -->
    <script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
  </head>
  <body>
    <button id="apple-pay" hidden>Pay with Apple Pay</button>
    <button id="google-pay" hidden>Pay with Google Pay</button>
    <p id="error" role="alert"></p>

    <script type="module">
      const orderId = new URLSearchParams(window.location.search).get("order");

      // Step 1.2: Create the payment request
      // Amounts are in minor units: 1000 is $10.00.
      const whop = window.WhopElements();
      const paymentRequest = whop.payments.paymentRequest.create({
        accountId: "biz_xxxxxxxxxxxxx",
        currency: "usd",
        amount: 1000,
        lineItems: [{ label: "Pro access", amount: 1000 }],
      });

      // Step 1.3: Check which wallets can pay
      const { applePay, googlePay } = await paymentRequest.canMakePayment();
      document.querySelector("#apple-pay").hidden = !applePay;
      document.querySelector("#google-pay").hidden = !googlePay;

      const errorLine = document.querySelector("#error");

      async function pay(wallet) {
        errorLine.textContent = "";

        // Step 1.4: Open the sheet and send the token to your server
        // show() must run inside the press handler, before any await, or Apple refuses the sheet.
        let ctok;
        try {
          ({ ctok } = await paymentRequest.show(wallet));
        } catch (err) {
          if (err.message !== "payment_request_cancelled") {
            errorLine.textContent = "The wallet sheet couldn't complete. Try again.";
          }
          return;
        }

        const response = await fetch("/api/pay", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ confirmationToken: ctok, orderId }),
        });
        const payment = await response.json();

        // Step 3.1: Handle the next action
        if (payment.status === "paid") {
          window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
          return;
        }

        // Anything but paid means the buyer still has a step, or the charge is still being decided.
        const result = await whop.payments.handleNextAction({
          clientSecret: payment.client_secret,
        });
        // The buyer left for an off-site step; they come back on the return page.
        if (result.redirected) return;

        if (result.status === "succeeded") {
          window.location.assign(`/checkout/return?order=${orderId}&status=succeeded&payment=${payment.id}`);
          return;
        }
        if (result.status === "processing") {
          window.location.assign(`/checkout/return?order=${orderId}&status=processing&payment=${payment.id}`);
          return;
        }
        // A dismissed dialog leaves the payment at requires_action with no error, so a missing error never means success.
        errorLine.textContent = result.lastPaymentError?.message ?? "The payment wasn't completed. Try again.";
      }

      // Step 1.3: Check which wallets can pay
      document.querySelector("#apple-pay").addEventListener("click", () => pay("apple_pay"));
      document.querySelector("#google-pay").addEventListener("click", () => pay("google_pay"));
    </script>
  </body>
</html>
```

### Client : JavaScript — `return.html`

```html return.html theme={null}
<!DOCTYPE html>
<html>
  <body>
    <section id="succeeded" hidden>
      <h1>Thanks for your order</h1>
      <p>Payment <span id="payment-id"></span> is complete. A receipt is on its way to your email.</p>
    </section>
    <section id="failed" hidden>
      <h1>Your payment did not go through</h1>
      <p>No money was taken. You can try again with another payment method.</p>
      <a id="retry" href="/checkout">Back to checkout</a>
    </section>
    <section id="pending" hidden>
      <h1>Confirming your payment</h1>
      <p>Your payment is still being processed. We will email you as soon as it is confirmed.</p>
    </section>

    <script type="module">
      // Step 3.2: Read the outcome from the URL
      // Whop appends `payment`, `status`, and `client_secret` to your returnUrl. Your own parameters (here `order`) survive.
      const params = new URLSearchParams(window.location.search);
      const paymentId = params.get("payment");
      const status = params.get("status");
      const orderId = params.get("order");

      // Step 3.3: Show the right face
      if (status === "succeeded") {
        document.querySelector("#payment-id").textContent = paymentId;
        document.querySelector("#succeeded").hidden = false;
      } else if (status === "failed" || status === "canceled") {
        document.querySelector("#retry").href = `/checkout?order=${orderId}`;
        document.querySelector("#failed").hidden = false;
      } else {
        document.querySelector("#pending").hidden = false;
      }
    </script>
  </body>
</html>
```

### Serveur : Next.js — `app/api/pay/route.ts`

```typescript app/api/pay/route.ts theme={null}
// Step 2.1: Install the Whop SDK
import { WhopClient } from "@whop/sdk";

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

export async function POST(request: Request) {
	const { confirmationToken, orderId } = await request.json();

	// Step 2.2: Create the payment from the confirmation token
	const payment = await whop.payments.create({
		account_id: process.env.WHOP_ACCOUNT_ID,
		// Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
		variant: { currency: "usd", initial_price: 10.0, billing_type: "one_time" },
		confirmation_token: confirmationToken,
		return_url: `https://yoursite.com/checkout/return?order=${orderId}`,
		metadata: { order_id: orderId },
	});

	// client_secret is safe to send to the browser. Your API key never is.
	return Response.json({
		id: payment.id,
		status: payment.status,
		client_secret: payment.client_secret,
	});
}
```

### Serveur : Next.js — `app/api/webhooks/whop/route.ts`

```typescript app/api/webhooks/whop/route.ts theme={null}
import { waitUntil } from "@vercel/functions";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
	// Step 2.3: Fulfill from the webhook
	// Give the raw body. Parsing it first changes the bytes and the signature check fails.
	const payload = await request.text();
	const headers = Object.fromEntries(request.headers);

	const event = unwrapWebhook(payload, {
		headers,
		key: process.env.WHOP_WEBHOOK_SECRET!,
	});

	if (event.type === "payment.succeeded") {
		waitUntil(fulfillOrder(event.data));
	}

	// Respond in less than 5 seconds, or Whop retries.
	return new Response("OK", { status: 200 });
}

async function fulfillOrder(payment: Record<string, any>) {
	// Step 2.3: Fulfill from the webhook
	// metadata.order_id is the value you set when you created the payment.
	const orderId = payment.metadata?.order_id;
	console.log(`[PAYMENT SUCCEEDED] ${payment.id} for order ${orderId}`);
	// Mark the order paid in your database and grant access here.
}
```

### Serveur : Express — `server.ts`

```typescript server.ts theme={null}
// Step 2.1: Install the Whop SDK
import { WhopClient } from "@whop/sdk";
import { unwrapWebhook } from "@whop/sdk/helpers";
import express from "express";

const app = express();

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

app.post("/api/pay", express.json(), async (req, res) => {
	const { confirmationToken, orderId } = req.body;

	// Step 2.2: Create the payment from the confirmation token
	const payment = await whop.payments.create({
		account_id: process.env.WHOP_ACCOUNT_ID,
		// Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
		variant: { currency: "usd", initial_price: 10.0, billing_type: "one_time" },
		confirmation_token: confirmationToken,
		return_url: `https://yoursite.com/checkout/return?order=${orderId}`,
		metadata: { order_id: orderId },
	});

	// client_secret is safe to send to the browser. Your API key never is.
	res.json({
		id: payment.id,
		status: payment.status,
		client_secret: payment.client_secret,
	});
});

// Step 2.3: Fulfill from the webhook
// Read the raw body on this route only: parsing it first changes the bytes and the signature check fails.
app.post(
	"/api/webhooks/whop",
	express.raw({ type: "application/json" }),
	(req, res) => {
		const event = unwrapWebhook(req.body.toString("utf8"), {
			headers: req.headers,
			key: process.env.WHOP_WEBHOOK_SECRET!,
		});

		if (event.type === "payment.succeeded") {
			// metadata.order_id is the value you set when you created the payment.
			const orderId = event.data.metadata?.order_id;
			console.log(`[PAYMENT SUCCEEDED] ${event.data.id} for order ${orderId}`);
			// Mark the order paid in your database and grant access here.
		}

		// Respond in less than 5 seconds, or Whop retries.
		res.sendStatus(200);
	},
);

app.listen(3000);
```

### Serveur : Python — `server.py`

```python server.py theme={null}
# Step 2.1: Install the Whop SDK
import os

from fastapi import BackgroundTasks, FastAPI, Request, Response
from whop_sdk import Whop
from whop_sdk.lib.verify_webhook import unwrap

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


@app.post("/api/pay")
async def pay(request: Request):
    body = await request.json()

    # Step 2.2: Create the payment from the confirmation token
    payment = client.payments.create(
        request={
            "account_id": os.environ["WHOP_ACCOUNT_ID"],
            # Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
            "variant": {"currency": "usd", "initial_price": 10.0, "billing_type": "one_time"},
            "confirmation_token": body["confirmationToken"],
            "return_url": f"https://yoursite.com/checkout/return?order={body['orderId']}",
            "metadata": {"order_id": body["orderId"]},
        },
    )

    # client_secret is safe to send to the browser. Your API key never is.
    return {
        "id": payment.id,
        "status": payment.status,
        "client_secret": payment.client_secret,
    }


# Step 2.3: Fulfill from the webhook
@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request, background: BackgroundTasks):
    # Give the raw body. Parsing it first changes the bytes and the signature check fails.
    payload = await request.body()

    event = unwrap(payload, dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "payment.succeeded":
        background.add_task(fulfill_order, event["data"])

    # Respond in less than 5 seconds, or Whop retries.
    return Response(status_code=200)


def fulfill_order(payment):
    # metadata.order_id is the value you set when you created the payment.
    order_id = (payment.get("metadata") or {}).get("order_id")
    print(f"[PAYMENT SUCCEEDED] {payment['id']} for order {order_id}")
    # Mark the order paid in your database and grant access here.
```

## Étapes suivantes

* [Référence de PaymentRequest](https://docs.whop.com/fr/elements/latest/payments/paymentRequest.md) : les gestionnaires de changement de livraison et de facturation, `updateWith`, et chaque option de la ressource.
* [Ajouter l'express checkout](https://docs.whop.com/fr/developer/guides/express-checkout.md) : laissez Whop afficher les boutons de portefeuille pour une variante et confirmer le paiement à votre place.
* [Activer Apple Pay et Google Pay](https://docs.whop.com/fr/payments/apple-pay.md) : ajoutez Apple Pay à votre domaine.
* [Webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) : créez l'endpoint, stockez le secret de signature et gérez les nouvelles tentatives.


## Related topics

- [Ajouter Express Checkout](https://docs.whop.com/fr/developer/guides/express-checkout.md)
- [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
- [ListElement](https://docs.whop.com/fr/elements/latest/wallet/balances-list.md)
