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

# Créer un checkout avec les Payment Elements

> Concevez votre propre checkout autour des payment elements : collectez un jeton de confirmation dans le navigateur, débitez-le depuis votre serveur et traitez la commande depuis un webhook

Concevez votre propre checkout autour des payment elements de Whop. Les éléments collectent le moyen de paiement dans des champs isolés conformes PCI et vous remettent un jeton de confirmation. Votre serveur transmet ce jeton à l'API Payments pour débiter, ou à l'API Setup Intents pour enregistrer le moyen de paiement. Le navigateur termine ensuite toute étape encore due par l'acheteur.

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 le formulaire de paiement

### 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 héberge votre checkout.

### 1.2 Monter les éléments

Créez un handle `Payments` pour la variante via la propriété `plan` existante et montez-y trois éléments. `EmailElement` collecte l'e-mail de l'acheteur et propose à un acheteur Whop reconnu une connexion qui débloque ses moyens de paiement enregistrés. `PaymentElement` affiche les moyens de paiement disponibles pour la variante et le pays de l'acheteur, et collecte les champs de chaque moyen dans des frames hébergées, de sorte que les numéros de carte n'atteignent jamais votre page. `BrandingElement` affiche la mention de Whop en tant que marchand officiel (merchant of record), que tout formulaire de paiement doit comporter.

Le handle détermine lui-même la devise, le montant et les moyens de paiement de la variante. Définissez `returnUrl` sur une page que vous hébergez en `https`. Les redirections bancaires, les demandes de financement et certains parcours 3D Secure y ramènent l'acheteur. Ajoutez-y vos propres paramètres de requête, comme l'ID de commande. Ils sont conservés pendant l'aller-retour.

Pour enregistrer un moyen de paiement sans le débiter, montez les mêmes éléments avec `mode: "setup"` et une `currency` au lieu d'un `plan`. Le guide [Enregistrer des moyens de paiement](https://docs.whop.com/fr/developer/guides/save-payment-methods.md) couvre ce formulaire.

### 1.3 Activer le bouton de paiement

`PaymentElement` signale `complete: true` via `onChange` une fois que l'acheteur a choisi un moyen de paiement et rempli les informations requises. Activez votre bouton de paiement à partir de ce signal. Le bouton vous appartient : son libellé, sa position et ce qui se passe lorsqu'on appuie dessus.

### 1.4 Créer le jeton de confirmation

Lors de l'appui, appelez `createConfirmationToken`. Il transforme ce que les éléments ont collecté en un jeton `ctok_` à usage unique qui représente le moyen de paiement. Le jeton contient l'e-mail et les informations de facturation recueillis par les éléments. Le choix d'un portefeuille ouvre Apple Pay ou Google Pay pendant cet appel, et l'appel est refusé tant qu'aucun `BrandingElement` n'est présent sur la page.

Envoyez le jeton à votre serveur avec votre propre référence de commande. Le jeton est la seule information sur le moyen de paiement qui quitte le navigateur.

## 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éfinissez `return_url` sur la même page que celle vers laquelle les éléments renvoient. Placez votre propre ID de commande dans `metadata` afin que le paiement et ses webhooks le transportent. Pour un formulaire en mode setup, transmettez plutôt le jeton à l'[API Setup Intents](https://docs.whop.com/fr/api-reference/setup-intents/create-setup-intent.md). Elle renvoie un setup intent avec un `client_secret` de même forme.

* `variant_id` est la variante que l'acheteur achète. Passez plutôt une `variant` en ligne pour débiter un montant qui n'est pas encore une variante enregistrée
* `confirmation_token` représente le moyen de paiement collecté par les éléments
* `metadata` relie le paiement à votre propre commande

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

Whop envoie `payment.succeeded` à votre endpoint de webhook une fois le paiement réussi, que l'acheteur ait payé directement ou soit revenu d'une étape externe. 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.

L'exécution de la commande a sa place ici et nulle part ailleurs. L'acheteur peut fermer le navigateur avant le chargement de votre page de retour, une redirection peut échouer, et n'importe qui peut saisir un paramètre de requête à la main. 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 une redirection bancaire, 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 `returnUrl` 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 externe arrive sur `returnUrl` **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. Les refus de carte n'atteignent jamais cette page, car `handleNextAction` les signale directement. La page de retour est le seul endroit où votre site voit un paiement externe échoué.

### 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 checkout. 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 formulaire 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 — `PaymentForm.tsx`

```tsx PaymentForm.tsx theme={null}
// Step 1.1: Install the packages
import { useState } from "react";
import {
	BrandingElement,
	EmailElement,
	PaymentElement,
	Payments,
	WhopElements,
	usePayments,
	useWhop,
} from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function CheckoutPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			{/* Step 1.2: Mount the elements */}
			<Payments
				accountId="biz_xxxxxxxxxxxxx"
				plan="plan_xxxxxxxxxxxxx"
				returnUrl={`https://yoursite.com/checkout/return?order=${orderId}`}
			>
				<PaymentForm orderId={orderId} />
			</Payments>
		</WhopElements>
	);
}

function PaymentForm({ orderId }: { orderId: string }) {
	const payments = usePayments();
	const whop = useWhop();
	const [ready, setReady] = useState(false);
	const [error, setError] = useState<string | null>(null);

	async function pay() {
		if (!payments || !whop) return;
		setError(null);

		// Step 1.4: Create the confirmation token
		// A single-use ctok_ token that stands in for the payment method. Card data never touches your page.
		const { confirmationToken } = await payments.createConfirmationToken({});

		const response = await fetch("/api/pay", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({ confirmationToken, 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 step wasn't completed. Try again.");
	}

	return (
		<>
			{/* Step 1.2: Mount the elements */}
			<EmailElement />
			{/* Step 1.3: Enable the pay button */}
			<PaymentElement onChange={(event) => setReady(event.complete)} />
			{/* Step 1.2: Mount the elements */}
			<BrandingElement />
			{/* Step 1.3: Enable the pay button */}
			<button disabled={!ready} onClick={pay}>
				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 — `checkout.html`

```html checkout.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>
    <div id="email"></div>
    <div id="payment"></div>
    <div id="branding"></div>
    <button id="pay" disabled>Pay</button>
    <p id="error" role="alert"></p>

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

      // Step 1.2: Mount the elements
      const whop = window.WhopElements();
      const payments = whop.payments.create({
        accountId: "biz_xxxxxxxxxxxxx",
        plan: "plan_xxxxxxxxxxxxx",
        returnUrl: `https://yoursite.com/checkout/return?order=${orderId}`,
      });

      payments.create("email").mount("#email");
      const payButton = document.querySelector("#pay");
      const errorLine = document.querySelector("#error");

      // Step 1.3: Enable the pay button
      payments
        .create("payment", { onChange: (event) => (payButton.disabled = !event.complete) })
        .mount("#payment");
      // Step 1.2: Mount the elements
      payments.create("branding").mount("#branding");

      payButton.addEventListener("click", async () => {
        errorLine.textContent = "";

        // Step 1.4: Create the confirmation token
        // A single-use ctok_ token that stands in for the payment method. Card data never touches your page.
        const { confirmationToken } = await payments.createConfirmationToken({});

        const response = await fetch("/api/pay", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ confirmationToken, 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 step wasn't completed. Try again.";
      });
    </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,
		variant_id: "plan_xxxxxxxxxxxxx",
		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,
		variant_id: "plan_xxxxxxxxxxxxx",
		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"],
            "variant_id": "plan_xxxxxxxxxxxxx",
            "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 des payment elements](https://docs.whop.com/fr/elements/latest/payments/overview) : chaque option, événement et méthode du handle Payments.
* [Express checkout](https://docs.whop.com/fr/developer/guides/express-checkout.md) : ajoutez Apple Pay et Google Pay en un clic à côté du formulaire.
* [Enregistrer des moyens de paiement](https://docs.whop.com/fr/developer/guides/save-payment-methods.md) : enregistrez un moyen de paiement sans le débiter, puis débitez-le plus tard depuis votre serveur.
* [Intégrer un checkout](https://docs.whop.com/fr/developer/guides/embed-checkout.md) : passez le formulaire et intégrez directement l'intégralité du checkout de Whop.
