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

# Betaalmethoden opslaan

> Sla de kaart van een klant op in setup-modus met payment elements of een gehoste checkout, of tijdens de checkout, en belast de opgeslagen methode later off-session.

Gebruik opgeslagen betaalmethoden om klanten automatisch te belasten voor abonnementen, verlengingen of facturering op basis van gebruik. De klant slaat zijn kaart één keer op via een gehoste of ingesloten flow van Whop, en daarna kun je die op elk moment belasten.

> [!TIP]
>
> Combineer deze gids met [webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md): luister naar `setup_intent.succeeded` om het opslaan te bevestigen, en daarna naar `payment.succeeded` / `payment.failed` om toekomstige afschrijvingen te volgen.

## Kies je opslagflow

Twee routes, afhankelijk van of de gebruiker ook nu betaalt.

| | Setup-modus (alleen verzamelen) | Opslaan tijdens de checkout |
| - | - | - |
| **Belast de gebruiker nu** | Nee | Ja |
| **Use case** | Aanmelding voor een gratis proefperiode, kaart in het bestand vóór facturering op basis van gebruik | Abonnement dat na de eerste betaalde checkout wordt verlengd |
| **Hoe** | Mount de [payment elements](https://docs.whop.com/nl/elements/latest/payments/overview) in `mode: "setup"` en [maak een setup intent aan](https://docs.whop.com/nl/api-reference/setup-intents/create-setup-intent.md) met het bevestigingstoken, of open een [checkoutconfiguratie](https://docs.whop.com/nl/api-reference/checkout-configurations/create-a-checkout-configuration.md) in setup-modus als gehoste checkout of in het [Checkout-element](https://docs.whop.com/nl/elements/latest/checkout/overview) | Mount de payment elements met `setupFutureUsage: "off_session"` en maak de betaling aan met het bevestigingstoken |
| **Webhook om naar te luisteren** | `setup_intent.succeeded` | `payment.succeeded` (de `payment_method_id` daarvan is de opgeslagen methode) |

De rest van deze pagina behandelt de setup-modus van begin tot eind en laat daarna zien hoe je een opgeslagen methode later belast.

## Een betaalmethode opslaan met de payment elements

Bouw het opslagformulier op de [payment elements](https://docs.whop.com/nl/elements/latest/payments/overview) in `mode: "setup"`. Het element biedt alleen methoden aan die kunnen worden opgeslagen, toont de koper de toestemming voor toekomstig gebruik die het opslaan vereist en geeft je een bevestigingstoken. Vanaf je server zet je dat token om in een setup intent, en met de `client_secret` van de setup intent rond je elke stap af die de koper nog moet doen.

**1. Het formulier mounten in setup-modus**

Geef `mode="setup"` door en de valuta waarmee de opgeslagen methode wordt gebruikt. Er is geen bedrag, dus bedraglimieten gelden niet. Stel `returnUrl` in op een pagina die je via `https` host. Bankinschrijvingen en sommige 3D Secure-flows brengen de koper daar terug.

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

Het token bevat de toestemming die het element heeft getoond. Een token dat is verzameld met een formulier in betaalmodus wordt door de setup intent geweigerd, dus mount in `mode="setup"` wanneer de koper niet betaalt.

**2. De setup intent aanmaken op je server**

[Maak een setup intent aan](https://docs.whop.com/nl/api-reference/setup-intents/create-setup-intent.md) met het bevestigingstoken. Whop bepaalt de koper aan de hand van het e-mailadres in het token en antwoordt met `201 Created` en de setup intent. Die bevat de `status`, een `client_secret` voor elke stap die de koper nog moet doen en, zodra de status `succeeded` is, de opgeslagen methode als `payment_method_id`. Voeg `metadata` toe om de opgeslagen methode aan een klant in je systeem te koppelen. Die komt terug in de webhook. Stuur een [`Idempotency-Key`](https://docs.whop.com/nl/developer/api/idempotency) mee zodat een herhaald verzoek de methode nooit twee keer opslaat.

```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. Openstaande stappen afronden**

Een setup intent die terugkomt met `succeeded` heeft de methode opgeslagen. `requires_action` betekent dat de koper nog een stap moet doen, zoals 3D Secure of een bankinschrijving. Geef de `client_secret` door aan `handleNextAction`, dezelfde aanroep die de betaalflow gebruikt. Die voert een inline stap uit in een dialoogvenster of stuurt de koper naar je `returnUrl`. Vertak op de `status` die wordt teruggegeven: bij `succeeded` is de methode opgeslagen, bij `processing` wordt nog beslist en al het andere vereist een nieuwe poging. Een gesloten dialoogvenster laat de setup op `requires_action` staan zonder fout, en `lastPaymentError` bevat de reden wanneer de poging mislukt. `processing` betekent dat de verwerker nog beslist, dus toon een wachtstatus en laat de webhook hieronder het opslaan bevestigen. `canceled` betekent dat de koper de stap heeft afgebroken of dat de provider de methode heeft geweigerd: `last_setup_error` bevat de reden van de provider en blijft `null` wanneer de koper is weggegaan. Om de status in plaats daarvan vanaf je server uit te lezen, [haal je de setup intent op](https://docs.whop.com/nl/api-reference/setup-intents/retrieve-setup-intent.md) en vertak je op dezelfde `status`, of poll je het lichtere [Retrieve setup status](https://docs.whop.com/nl/api-reference/setup-intents/retrieve-setup-status.md) zolang een stap openstaat.

**4. Voltooiing afhandelen**

Luister naar de webhook `setup_intent.succeeded` om het ID van de betaalmethode en je `metadata` terug te krijgen. Dit is het enige signaal dat een gesloten tabblad overleeft, en dezelfde handler bedient ook de gehoste flow hieronder. De setup intent bevat ook `payment_instrument` voor weergave: een naam, de standaard iconenset en bij een kaart het merk, de laatste vier cijfers en de vervaldatum. Je kunt de opgeslagen methode tonen zonder nog een verzoek. Webhooks die zijn vastgezet op een versie vóór API-versie 2026-09-22-1 bevatten de opgeslagen methode in plaats daarvan als `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);
}
```

De betaalmethode is nu opgeslagen en geautoriseerd voor dit lid. Belast deze met de stappen in [Een opgeslagen betaalmethode belasten](#charge-a-saved-payment-method).

## Een betaalmethode opslaan met een gehoste checkout

**1. Een checkoutconfiguratie aanmaken in setup-modus**

[Maak een checkoutconfiguratie aan](https://docs.whop.com/nl/api-reference/checkout-configurations/create-a-checkout-configuration.md) zonder variant om betaalgegevens te verzamelen zonder af te schrijven. Voeg metadata toe om het lid en de betaalmethode aan een klant in je systeem te kunnen koppelen.

```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. De gebruiker naar de checkout leiden**

Mount het Checkout-element of stuur de gebruiker door om de betaalmethode op te slaan.

> [tab] Ingesloten
>
> ```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>
>   );
> }
> ```
>
> Een configuratie in setup-modus mount hetzelfde element als het opslaan van een
> betaalmethode: er wordt niets afgeschreven en de voltooide checkout stuurt door naar
> `returnUrl` met `setup_intent_id` in de querystring. Bevestig het opslaan
> aan de hand van de webhook `setup_intent.succeeded` in plaats van de redirect.

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

**3. Voltooiing afhandelen**

Luister naar de webhook `setup_intent.succeeded` om het ID van de betaalmethode op te halen. De setup intent bevat `checkout_configuration_id` en de `metadata` van de configuratie, waarmee je het lid en de betaalmethode aan een klant in je systeem kunt koppelen.

> [!NOTE]
>
> Bevestig het opslaan aan de hand van de webhook in plaats van de aankomst van de koper op je `redirect_url`. Dit is het enige signaal dat een gesloten tabblad overleeft.

> [!TIP]
>
> Het voorbeeld gebruikt `waitUntil` uit `@vercel/functions` om de handler uit te voeren nadat met `200` is geantwoord. Vervang dit in andere runtimes (Bun, Cloudflare Workers, Fastify, Hono) door de equivalente achtergrondtaakfunctie van je framework of een job queue. Zie de [gids over webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md) voor equivalente handlers in Python en 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);
}
```

De betaalmethode is nu opgeslagen en geautoriseerd voor dit lid.

## Een opgeslagen betaalmethode belasten

**1. De betaalmethode ophalen**

[Geef de opgeslagen betaalmethoden](https://docs.whop.com/nl/api-reference/legacy/payment-methods/list-payment-methods.md) van een lid weer, of gebruik de `payment_method_id` uit de setup intent van de vorige stap.

```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. Een off-session betaling aanmaken**

Belast de betaalmethode zonder interactie van de klant. Het [endpoint voor het aanmaken van betalingen](https://docs.whop.com/nl/api-reference/payments/create-payment.md) geeft direct een betalingsobject terug en verwerkt de afschrijving asynchroon.

```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]
>
> Je kunt ook `line_items` versturen om bestaande varianten te combineren met inline aangemaakte prijzen. Elk item accepteert precies één van `variant_id` of `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
>     }
>   ]
> }
> ```
>
> Voor het aanmaken van een variant zijn zowel `plan:create` als `payment:charge` vereist. Voor het hergebruiken van een overeenkomende variant via `product_id` is alleen `payment:charge` nodig. Een inline `product`-definitie vereist ook `access_pass:create` om het product aan te maken, of `access_pass:update` om een bestaand product bij te werken. Varianten moeten bij het betalingsaccount horen en voldoen aan de compatibiliteitsregels van de winkelwagen. De inline `variant` gebruikt hetzelfde zoek-of-maak-gedrag als een `variant` op het hoogste niveau. Geef `force_create_new_plan: true` door om een nieuwe variant af te dwingen. Geneste variant- en productvelden volgen `Api-Version-Date`, en onbekende eigenschappen worden geweigerd. Gebruik een `Idempotency-Key` om het verzoek opnieuw af te spelen zonder nog een betaling aan te maken.
>
> Geef het ID van een van je [promotiecodes](https://docs.whop.com/nl/manage-your-business/growth-marketing/promo-codes.md) door als `promo_code_id` om een korting toe te passen, en Whop berekent de afgeprijsde prijs voor je. De promotiecode moet actief en geldig zijn voor de variant, en de variant moet bij een product horen.

**3. Betalingsevents afhandelen**

Luister naar betalingswebhooks om succes of mislukking te volgen.

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

## Opslaan tijdens de checkout

Om een betaalmethode op te slaan terwijl je de koper belast, bouw je de checkout op de [payment elements](https://docs.whop.com/nl/elements/latest/payments/overview) en geef je `setupFutureUsage: "off_session"` door op de `Payments`-handle. De elements tonen de koper de toestemming voor het opslaan en leggen die vast op het bevestigingstoken, en de betaling slaat de methode alleen veilig op wanneer die toestemming is bevestigd.

De Elements-property voor het selecteren van een variant heet om compatibiliteitsredenen nog steeds `plan`.

**1. Het formulier mounten met toestemming voor opslaan**

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

[Een checkout bouwen met payment elements](https://docs.whop.com/nl/developer/guides/payment-elements.md) loopt de betaalknop, `createConfirmationToken` en `handleNextAction` door.

**2. De betaling aanmaken met het bevestigingstoken**

Het antwoord op het aanmaken is de betaling zoals die is geopend, niet de uitkomst ervan. De `payment_method_id` van de opgeslagen methode komt binnen via de webhook `payment.succeeded` zodra de afschrijving is voltooid.

```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. Later belasten**

`payment_method_id` is de `payt_`-methode die je gebruikt in [Een opgeslagen betaalmethode belasten](#charge-a-saved-payment-method). Het blijft `null` wanneer er niets is opgeslagen. De webhook `payment.succeeded` bevat hetzelfde veld, en dat is de route die een gesloten tabblad overleeft.

## Volgende stappen

> [card] [Betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md)
>
> Eenmalige checkouts en abonnementscheckouts om te combineren met je opslagflow.

> [card] [Checkout-element](https://docs.whop.com/nl/elements/latest/checkout/overview)
>
> Mount de Whop-checkout op je eigen site met Whop Elements.

> [card] [Naar webhooks luisteren](https://docs.whop.com/nl/developer/guides/webhooks.md)
>
> Volg `setup_intent.succeeded`, `payment.succeeded` en `payment.failed`.

> [card] [Factureringsportaal](https://docs.whop.com/nl/payments-and-billing/manage-billing/billing-portal.md)
>
> Laat klanten hun opgeslagen betaalmethoden beheren en verwijderen.


## Related topics

- [Betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md)
- [Facturen](https://docs.whop.com/nl/developer/guides/invoices.md)
- [Lidmaatschappen](https://docs.whop.com/nl/developer/guides/memberships.md)
