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

# Enregistrer des moyens de paiement

> Enregistrez la carte d'un client en mode setup avec les éléments de paiement ou un checkout hébergé, ou pendant le checkout, puis débitez plus tard le moyen enregistré hors session.

Utilisez des moyens de paiement enregistrés pour débiter automatiquement vos clients pour des abonnements, des renouvellements ou une facturation à l'usage. Le client enregistre sa carte une seule fois via un parcours Whop hébergé ou intégré, et vous pouvez la débiter à tout moment par la suite.

> [!TIP]
>
> Associez ce guide aux [webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) : écoutez `setup_intent.succeeded` pour confirmer l'enregistrement, puis `payment.succeeded` / `payment.failed` pour suivre les débits ultérieurs.

## Choisir votre parcours d'enregistrement

Deux options, selon que l'utilisateur paie aussi en ce moment ou non.

| | Mode setup (collecte uniquement) | Enregistrement pendant le checkout |
| - | - | - |
| **Débite l'utilisateur maintenant** | Non | Oui |
| **Cas d'usage** | Inscription à un essai gratuit, carte enregistrée avant une facturation à l'usage | Abonnement qui se renouvelle après le premier checkout payant |
| **Comment** | Montez les [éléments de paiement](https://docs.whop.com/fr/elements/latest/payments/overview) en `mode: "setup"` et [créez un setup intent](https://docs.whop.com/fr/api-reference/setup-intents/create-setup-intent.md) avec le jeton de confirmation, ou ouvrez une [configuration de checkout](https://docs.whop.com/fr/api-reference/checkout-configurations/create-a-checkout-configuration.md) en mode setup sous forme de checkout hébergé ou dans l'[élément Checkout](https://docs.whop.com/fr/elements/latest/checkout/overview) | Montez les éléments de paiement avec `setupFutureUsage: "off_session"` et créez le paiement avec le jeton de confirmation |
| **Webhook à écouter** | `setup_intent.succeeded` | `payment.succeeded` (son `payment_method_id` est le moyen enregistré) |

Le reste de cette page couvre le mode setup de bout en bout, puis montre comment débiter ultérieurement un moyen enregistré.

## Enregistrer un moyen de paiement avec les éléments de paiement

Construisez le formulaire d'enregistrement sur les [éléments de paiement](https://docs.whop.com/fr/elements/latest/payments/overview) en `mode: "setup"`. L'élément ne propose que les moyens pouvant être enregistrés, affiche à l'acheteur le consentement d'utilisation future qu'exige l'enregistrement et vous remet un jeton de confirmation. Vous transformez ce jeton en setup intent depuis votre serveur, et le `client_secret` du setup intent finalise toute étape encore due par l'acheteur.

**1. Monter le formulaire en mode setup**

Transmettez `mode="setup"` et la devise avec laquelle le moyen enregistré sera utilisé. Il n'y a pas de montant, donc les limites de montant ne s'appliquent pas. Définissez `returnUrl` sur une page que vous hébergez en `https`. Les inscriptions bancaires et certains parcours 3D Secure y ramènent l'acheteur.

```tsx React theme={null}
import { useState } from "react";
import {
  WhopElements,
  Payments,
  EmailElement,
  PaymentElement,
  BrandingElement,
  usePayments,
  useWhop,
} from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function SavePaymentMethodPage() {
  return (
    <WhopElements elements={loadWhop()}>
      <Payments
        accountId="biz_XXXXXXXX"
        mode="setup"
        currency="usd"
        returnUrl="https://yoursite.com/billing/saved"
      >
        <SaveForm />
      </Payments>
    </WhopElements>
  );
}

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

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

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      setError("The payment method couldn't be saved. Try a different one.");
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    setError(result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.");
  }

  return (
    <>
      <EmailElement />
      <PaymentElement onChange={(event) => setReady(event.complete)} />
      <BrandingElement />
      <button disabled={!ready} onClick={save}>
        Save payment method
      </button>
      {error && <p role="alert">{error}</p>}
    </>
  );
}
```

```html JavaScript theme={null}
<script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>

<div id="email"></div>
<div id="payment"></div>
<div id="branding"></div>
<button id="save" disabled>Save payment method</button>
<p id="error" role="alert"></p>

<script type="module">
  const whop = window.WhopElements();
  const payments = whop.payments.create({
    accountId: "biz_XXXXXXXX",
    mode: "setup",
    currency: "usd",
    returnUrl: "https://yoursite.com/billing/saved",
  });

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

  payments.create("email").mount("#email");
  payments
    .create("payment", { onChange: (event) => (saveButton.disabled = !event.complete) })
    .mount("#payment");
  payments.create("branding").mount("#branding");

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

    const { confirmationToken } = await payments.createConfirmationToken({});

    const response = await fetch("/api/save-payment-method", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ confirmationToken }),
    });
    const setupIntent = await response.json();
    if (setupIntent.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (setupIntent.status === "canceled") {
      errorLine.textContent = "The payment method couldn't be saved. Try a different one.";
      return;
    }
    if (setupIntent.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }

    const result = await whop.payments.handleNextAction({
      clientSecret: setupIntent.client_secret,
    });
    if (result.redirected) return;
    if (result.status === "succeeded") {
      window.location.assign("/billing/saved");
      return;
    }
    if (result.status === "processing") {
      window.location.assign("/billing/pending");
      return;
    }
    errorLine.textContent = result.lastPaymentError?.message ?? "The payment method wasn't saved. Try again.";
  });
</script>
```

Le jeton porte le consentement affiché par l'élément. Un jeton collecté depuis un formulaire en mode paiement est refusé par le setup intent : montez donc en `mode="setup"` lorsque l'acheteur ne paie pas.

**2. Créer le setup intent sur votre serveur**

[Créez un setup intent](https://docs.whop.com/fr/api-reference/setup-intents/create-setup-intent.md) avec le jeton de confirmation. Whop identifie l'acheteur à partir de l'e-mail du jeton et répond `201 Created` avec le setup intent. Celui-ci porte le `status`, un `client_secret` pour toute étape encore due par l'acheteur et, une fois `succeeded`, le moyen enregistré sous `payment_method_id`. Joignez des `metadata` pour relier le moyen enregistré à un client de votre système. Elles vous sont renvoyées dans le webhook. Envoyez une [`Idempotency-Key`](https://docs.whop.com/fr/developer/api/idempotency) pour qu'une requête relancée n'enregistre jamais le moyen deux fois.

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

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

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

  const setupIntent = await client.setupIntents.create({
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmationToken,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  });

  return Response.json({
    id: setupIntent.id,
    status: setupIntent.status,
    client_secret: setupIntent.client_secret,
  });
}
```

```python Python theme={null}
import os
from flask import Flask, jsonify, request
from whop_sdk import Whop

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

@app.post("/api/save-payment-method")
def save_payment_method():
    setup_intent = client.setup_intents.create(
        request={
            "account_id": "biz_XXXXXXXX",
            "confirmation_token": request.get_json()["confirmationToken"],
            "currency": "usd",
            "return_url": "https://yoursite.com/billing/saved",
            "metadata": {"customer_id": "my_internal_user_id"},
        },
    )
    return jsonify(id=setup_intent.id, status=setup_intent.status, client_secret=setup_intent.client_secret)
```

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

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

post "/api/save-payment-method" do
  confirmation_token = JSON.parse(request.body.read)["confirmationToken"]

  setup_intent = client.setup_intents.create(
    account_id: "biz_XXXXXXXX",
    confirmation_token: confirmation_token,
    currency: "usd",
    return_url: "https://yoursite.com/billing/saved",
    metadata: { customer_id: "my_internal_user_id" },
  )

  { id: setup_intent.id, status: setup_intent.status, client_secret: setup_intent.client_secret }.to_json
end
```

**3. Finaliser toute étape en attente**

Un setup intent renvoyé avec `succeeded` a le moyen enregistré. `requires_action` signifie que l'acheteur doit encore effectuer une étape, comme 3D Secure ou une inscription bancaire. Transmettez le `client_secret` à `handleNextAction`, le même appel que celui du parcours de paiement. Il exécute une étape en ligne dans une boîte de dialogue ou envoie l'acheteur vers votre `returnUrl`. Faites un branchement selon le `status` qu'il renvoie : `succeeded` signifie que le moyen est enregistré, `processing` que la décision est en cours, et toute autre valeur nécessite une nouvelle tentative. Une boîte de dialogue fermée laisse le setup en `requires_action` sans erreur, et `lastPaymentError` indique la raison lorsque la tentative échoue. `processing` signifie que le processeur n'a pas encore tranché : affichez donc un état en attente et laissez le webhook ci-dessous confirmer l'enregistrement. `canceled` signifie que l'acheteur a abandonné l'étape ou que le fournisseur a refusé le moyen : `last_setup_error` indique la raison du fournisseur et reste `null` lorsque l'acheteur est parti. Pour lire l'état depuis votre serveur, [récupérez le setup intent](https://docs.whop.com/fr/api-reference/setup-intents/retrieve-setup-intent.md) et faites un branchement sur le même `status`, ou interrogez l'endpoint plus léger [Retrieve setup status](https://docs.whop.com/fr/api-reference/setup-intents/retrieve-setup-status.md) tant qu'une étape est en attente.

**4. Gérer la finalisation**

Écoutez le webhook `setup_intent.succeeded` pour récupérer l'ID du moyen de paiement et vos `metadata`. C'est le seul signal qui survit à un onglet fermé, et le même gestionnaire sert au parcours hébergé ci-dessous. Le setup intent porte également `payment_instrument` pour l'affichage : un nom, le jeu d'icônes standard et, pour une carte, sa marque, ses quatre derniers chiffres et sa date d'expiration. Vous pouvez afficher le moyen enregistré sans requête supplémentaire. Les webhooks épinglés à une version de l'API antérieure à 2026-09-22-1 transmettent plutôt le moyen enregistré sous `payment_method.id`.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

  return new Response("OK", { status: 200 });
}

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Saved method:", setupIntent.payment_instrument?.display_name);
  console.log("Metadata:", setupIntent.metadata);
}
```

Le moyen de paiement est désormais enregistré et autorisé pour ce membre. Débitez-le en suivant les étapes de [Débiter un moyen de paiement enregistré](#charge-a-saved-payment-method).

## Enregistrer un moyen de paiement avec un checkout hébergé

**1. Créer une configuration de checkout en mode setup**

[Créez une configuration de checkout](https://docs.whop.com/fr/api-reference/checkout-configurations/create-a-checkout-configuration.md) sans variante pour collecter les informations de paiement sans débiter. Ajoutez des métadonnées pour pouvoir relier le membre et le moyen de paiement à un client de votre système.

```typescript TypeScript theme={null}
const checkoutConfiguration = await whopsdk.checkoutConfigurations.create({
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
});
```

```python Python theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
    account_id="biz_XXXXXX",
    mode="setup",
    redirect_url="https://mywebsite.com/return_location",
    metadata={"customer_id": "my_internal_user_id"},
)
```

```ruby Ruby theme={null}
checkout_configuration = whopsdk.checkout_configurations.create(
  account_id: "biz_XXXXXX",
  mode: "setup",
  redirect_url: "https://mywebsite.com/return_location",
  metadata: { customer_id: "my_internal_user_id" },
)
```

```rust Rust theme={null}
let checkout_configuration = client
    .checkout_configurations
    .create(
        &CreateCheckoutConfigurationsRequest {
            account_id: Some("biz_XXXXXX".to_string()),
            mode: Some(CreateCheckoutConfigurationsRequestMode::Setup),
            redirect_url: Some("https://mywebsite.com/return_location".to_string()),
            metadata: Some(HashMap::from([(
                "customer_id".to_string(),
                json!("my_internal_user_id"),
            )])),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
checkoutConfiguration, err := client.CheckoutConfigurations.Create(context.TODO(), &whopsdk.CreateCheckoutConfigurationsRequest{
    AccountID:   whopsdk.String("biz_XXXXXX"),
    Mode:        whopsdk.CreateCheckoutConfigurationsRequestModeSetup.Ptr(),
    RedirectURL: whopsdk.String("https://mywebsite.com/return_location"),
    Metadata:    map[string]any{"customer_id": "my_internal_user_id"},
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(checkoutConfiguration.ID)
```

**2. Diriger l'utilisateur vers le checkout**

Montez l'élément Checkout ou redirigez l'utilisateur pour qu'il enregistre son moyen de paiement.

> [tab] Intégré
>
> ```tsx theme={null}
> import { WhopElements, Checkout, CheckoutElement } from "@whop/elements-react";
> import { loadWhop } from "@whop/elements";
>
> export default function SavePayment({ configurationId }: { configurationId: string }) {
>   return (
>     <WhopElements elements={loadWhop()}>
>       <Checkout
>         checkoutConfiguration={configurationId}
>         returnUrl="https://yoursite.com/setup/complete"
>       >
>         <CheckoutElement />
>       </Checkout>
>     </WhopElements>
>   );
> }
> ```
>
> Une configuration en mode setup monte le même élément sous forme d'enregistrement
> de moyen de paiement : rien n'est débité, et le checkout terminé redirige vers
> `returnUrl` avec `setup_intent_id` dans la chaîne de requête. Confirmez l'enregistrement
> à partir du webhook `setup_intent.succeeded` plutôt qu'à partir de la redirection.

> [tab] Redirection
>
> ```typescript theme={null}
> window.location.href = checkoutConfiguration.purchase_url;
> ```

**3. Gérer la finalisation**

Écoutez le webhook `setup_intent.succeeded` pour récupérer l'ID du moyen de paiement. Le setup intent porte `checkout_configuration_id` et les `metadata` de la configuration, que vous pouvez utiliser pour relier le membre et le moyen de paiement à un client de votre système.

> [!NOTE]
>
> Confirmez l'enregistrement à partir du webhook plutôt qu'à l'arrivée de l'acheteur sur votre `redirect_url`. C'est le seul signal qui survit à un onglet fermé.

> [!TIP]
>
> L'exemple utilise `waitUntil` de `@vercel/functions` pour exécuter le gestionnaire après avoir répondu `200`. Sur d'autres environnements d'exécution (Bun, Cloudflare Workers, Fastify, Hono), remplacez-le par la primitive de tâche en arrière-plan équivalente de votre framework ou par une file de tâches. Consultez le [guide des webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md) pour les équivalents de gestionnaires en Python et Ruby.

```typescript theme={null}
import { waitUntil } from "@vercel/functions";
import type { NextRequest } from "next/server";
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { Whop } from "@whop/sdk";

export async function POST(request: NextRequest): Promise<Response> {
  const requestBodyText = await request.text();
  const headers = Object.fromEntries(request.headers);
  const webhookData = unwrapWebhook<{ type: string; data: Whop.SetupIntent }>(requestBodyText, { headers, key: process.env.WHOP_WEBHOOK_SECRET });

  if (webhookData.type === "setup_intent.succeeded") {
    waitUntil(handleSetupSucceeded(webhookData.data));
  }

  return new Response("OK", { status: 200 });
}

async function handleSetupSucceeded(setupIntent: Whop.SetupIntent) {
  console.log("Payment method ID:", setupIntent.payment_method_id);
  console.log("Member ID:", setupIntent.member_id);
  console.log("Checkout configuration ID:", setupIntent.checkout_configuration_id);
  console.log("Metadata:", setupIntent.metadata);
}
```

Le moyen de paiement est désormais enregistré et autorisé pour ce membre.

## Débiter un moyen de paiement enregistré

**1. Obtenir le moyen de paiement**

[Listez les moyens de paiement enregistrés](https://docs.whop.com/fr/api-reference/legacy/payment-methods/list-payment-methods.md) d'un membre, ou utilisez le `payment_method_id` du setup intent de l'étape précédente.

```typescript TypeScript theme={null}
const payment_methods = await whopsdk.paymentMethods.list({
  member_id: "mber_XXXXXXXX",
});

const payment_method = payment_methods.data[0];
```

```python Python theme={null}
payment_methods = whopsdk.payment_methods.list(member_id="mber_XXXXXXXX")
payment_method = payment_methods.items[0]
```

```ruby Ruby theme={null}
# list returns an Enumerable that pages for you; there is no `.data` on it
payment_method = whopsdk.payment_methods.list(member_id: "mber_XXXXXXXX").first
```

```rust Rust theme={null}
let payment_methods = client
    .payment_methods
    .list(
        &PaymentMethodsListQueryRequest {
            member_id: Some("mber_XXXXXXXX".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

let payment_method = &payment_methods.data[0];
```

```go Go theme={null}
page, err := client.PaymentMethods.List(context.TODO(), &whopsdk.ListPaymentMethodsRequest{
    MemberID: whopsdk.String("mber_XXXXXXXX"),
})
if err != nil {
    log.Fatal(err)
}

paymentMethod := page.Results[0]
fmt.Println(paymentMethod)
```

**2. Créer un paiement hors session**

Débitez le moyen de paiement sans interaction du client. L'[endpoint de création de paiement](https://docs.whop.com/fr/api-reference/payments/create-payment.md) renvoie immédiatement un objet paiement et traite le débit de manière asynchrone.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
});

console.log("Payment:", payment.id);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "member_id": "mber_XXXXXXXX",
        "payment_method_id": "payt_XXXXXXXXX",
    },
)

print("Payment:", payment.id)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  member_id: "mber_XXXXXXXX",
  payment_method_id: "payt_XXXXXXXXX",
)

puts "Payment: #{payment.id}"
```

```rust Rust theme={null}
let payment = client
    .payments
    .create(
        &CreatePaymentsRequestBody::CreatePaymentsRequestBodyOne(
            CreatePaymentsRequestBodyOne::builder()
                .account_id("biz_XXXXXXXX")
                .variant_id("plan_XXXXXXXX")
                .member_id("mber_XXXXXXXX")
                .payment_method_id("payt_XXXXXXXXX")
                .build()
                .unwrap(),
        ),
        None,
    )
    .await?;

println!("Payment: {}", payment.payment_fields.id);
```

```go Go theme={null}
payment, err := client.Payments.Create(context.TODO(), &whopsdk.CreatePaymentsRequest{
    CreatePaymentsRequestOne: &whopsdk.CreatePaymentsRequestOne{
        AccountID:       "biz_XXXXXXXX",
        VariantID:       "plan_XXXXXXXX",
        MemberID:        "mber_XXXXXXXX",
        PaymentMethodID: whopsdk.String("payt_XXXXXXXXX"),
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println("Payment:", payment.ID)
```

> [!TIP]
>
> Vous pouvez aussi envoyer des `line_items` pour combiner des variantes existantes avec une tarification créée en ligne. Chaque élément accepte exactement l'un des champs `variant_id` ou `variant` :
>
> ```json theme={null}
> {
>   "account_id": "biz_XXXXXXXX",
>   "member_id": "mber_XXXXXXXX",
>   "payment_method_id": "payt_XXXXXXXX",
>   "line_items": [
>     { "variant_id": "plan_XXXXXXXX", "quantity": 1 },
>     {
>       "variant": {
>         "product_id": "prod_XXXXXXXX",
>         "currency": "usd",
>         "billing_type": "one_time",
>         "initial_price": 7,
>         "allow_multiple_quantity": true
>       },
>       "quantity": 3
>     }
>   ]
> }
> ```
>
> La création d'une variante nécessite `plan:create` en plus de `payment:charge`. La réutilisation d'une variante correspondante via `product_id` ne nécessite que `payment:charge`. Une définition `product` en ligne nécessite aussi `access_pass:create` pour créer le produit, ou `access_pass:update` pour en mettre à jour un existant. Les variantes doivent appartenir au compte du paiement et respecter les règles de compatibilité du panier. La `variant` en ligne utilise le même comportement « trouver ou créer » qu'une `variant` de premier niveau. Transmettez `force_create_new_plan: true` pour forcer la création d'une nouvelle variante. Les champs imbriqués de variante et de produit suivent `Api-Version-Date`, et les propriétés inconnues sont rejetées. Utilisez une `Idempotency-Key` pour rejouer la requête sans créer d'autre paiement.
>
> Pour appliquer une réduction, transmettez l'ID de l'un de vos [codes promo](https://docs.whop.com/fr/manage-your-business/growth-marketing/promo-codes.md) dans `promo_code_id`, et Whop calcule le prix réduit pour vous. Le code promo doit être actif et valide pour la variante, et la variante doit appartenir à un produit.

**3. Gérer les événements de paiement**

Écoutez les webhooks de paiement pour suivre les réussites et les échecs.

```typescript theme={null}
if (webhookData.type === "payment.succeeded") {
  await fulfillOrder(webhookData.data);
}

if (webhookData.type === "payment.failed") {
  await notifyCustomer(webhookData.data.customer_email, webhookData.data.failure_message);
}
```

## Enregistrer pendant le checkout

Pour enregistrer un moyen de paiement tout en débitant l'acheteur, construisez le checkout sur les [éléments de paiement](https://docs.whop.com/fr/elements/latest/payments/overview) et transmettez `setupFutureUsage: "off_session"` sur le handle `Payments`. Les éléments affichent à l'acheteur le consentement d'enregistrement et l'inscrivent dans le jeton de confirmation, et le paiement n'enregistre le moyen que lorsque ce consentement est attesté.

La propriété Elements permettant de sélectionner une variante reste nommée `plan` pour des raisons de compatibilité.

**1. Monter le formulaire avec le consentement d'enregistrement**

```tsx theme={null}
<WhopElements elements={loadWhop()}>
  <Payments
    accountId="biz_XXXXXXXX"
    plan="plan_XXXXXXXX"
    setupFutureUsage="off_session"
    returnUrl="https://yoursite.com/checkout/complete"
  >
    <EmailElement />
    <PaymentElement onChange={(event) => setReady(event.complete)} />
    <BrandingElement />
  </Payments>
</WhopElements>
```

[Créer un checkout avec les éléments de paiement](https://docs.whop.com/fr/developer/guides/payment-elements.md) détaille le bouton de paiement, `createConfirmationToken` et `handleNextAction`.

**2. Créer le paiement avec le jeton de confirmation**

La réponse de création correspond au paiement tel qu'ouvert, pas à son issue. Le `payment_method_id` du moyen enregistré arrive dans le webhook `payment.succeeded` une fois le débit finalisé.

```typescript TypeScript theme={null}
const payment = await whopsdk.payments.create({
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmationToken,
  return_url: "https://yoursite.com/checkout/complete",
});

console.log("Payment:", payment.id, payment.status);
```

```python Python theme={null}
payment = whopsdk.payments.create(
    request={
        "account_id": "biz_XXXXXXXX",
        "variant_id": "plan_XXXXXXXX",
        "confirmation_token": confirmation_token,
        "return_url": "https://yoursite.com/checkout/complete",
    },
)

print("Payment:", payment.id, payment.status)
```

```ruby Ruby theme={null}
payment = whopsdk.payments.create(
  account_id: "biz_XXXXXXXX",
  variant_id: "plan_XXXXXXXX",
  confirmation_token: confirmation_token,
  return_url: "https://yoursite.com/checkout/complete",
)

puts "Payment: #{payment.id} #{payment.status}"
```

**3. Le débiter plus tard**

`payment_method_id` est le moyen `payt_` à utiliser dans [Débiter un moyen de paiement enregistré](#charge-a-saved-payment-method). Il reste `null` lorsque rien n'a été enregistré. Le webhook `payment.succeeded` porte le même champ, et c'est le chemin qui survit à un onglet fermé.

## Étapes suivantes

> [card] [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
>
> Des checkouts ponctuels et d'abonnement à associer à votre parcours d'enregistrement.

> [card] [Élément Checkout](https://docs.whop.com/fr/elements/latest/checkout/overview)
>
> Montez le checkout Whop sur votre propre site avec Whop Elements.

> [card] [Écouter les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Suivez `setup_intent.succeeded`, `payment.succeeded` et `payment.failed`.

> [card] [Portail de facturation](https://docs.whop.com/fr/payments-and-billing/manage-billing/billing-portal.md)
>
> Permettez aux clients de gérer et de supprimer leurs moyens de paiement enregistrés.


## Related topics

- [Accepter des paiements](https://docs.whop.com/fr/developer/guides/accept-payments.md)
- [Vue d'ensemble des paiements](https://docs.whop.com/fr/developer/payments/overview.md)
- [Créer un checkout avec les Payment Elements](https://docs.whop.com/fr/developer/guides/payment-elements.md)
