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

# Bouw een checkout met payment elements

> Ontwerp je eigen checkout rond de payment elements: verzamel een confirmation token in de browser, belast het vanaf je server en lever uit via een webhook

Ontwerp je eigen checkout rond de payment elements van Whop. De elements verzamelen de betaalmethode in PCI-geïsoleerde velden en geven je een bevestigingstoken. Je server geeft dat token door aan de Payments API om de betaling uit te voeren, of aan de Setup Intents API om de methode op te slaan. Daarna voltooit de browser elke stap die de koper nog moet doen.

De bestanden onder **Code** bevatten `Step X.Y`-opmerkingen die verwijzen naar de stappen hieronder. Kies één serverimplementatie en één clientimplementatie. De lijst bevat de bestanden voor elke optie.

## Het betaalformulier bouwen

### 1.1 De pakketten installeren (React)

Installeer de Whop Elements-pakketten voor 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 De scripttag toevoegen (JavaScript)

Laad het Whop Elements-script op de pagina waarop je checkout staat.

### 1.2 De elements koppelen

Maak een `Payments`-handle aan voor de variant via de bestaande eigenschap `plan` en koppel er drie elements onder. `EmailElement` verzamelt het e-mailadres van de koper en biedt een herkende Whop-koper een aanmelding aan die diens opgeslagen betaalmethoden ontgrendelt. `PaymentElement` toont de methoden die beschikbaar zijn voor de variant en het land van de koper, en verzamelt de velden van elke methode in gehoste frames, zodat kaartnummers je pagina nooit bereiken. `BrandingElement` toont de merchant-of-record-melding van Whop, die elk betaalformulier moet bevatten.

De handle bepaalt zelf de valuta, het bedrag en de betaalmethoden van de variant. Stel `returnUrl` in op een pagina die je via `https` host. Bankdoorverwijzingen, financieringsaanvragen en sommige 3D Secure-flows sturen de koper daar terug. Voeg er je eigen queryparameters aan toe, zoals de bestel-ID. Die blijven behouden tijdens de omweg.

Om een betaalmethode op te slaan zonder er iets mee af te rekenen, koppel je dezelfde elements met `mode: "setup"` en een `currency` in plaats van een `plan`. De gids [Betaalmethoden opslaan](https://docs.whop.com/nl/developer/guides/save-payment-methods.md) behandelt dat formulier.

### 1.3 De betaalknop inschakelen

`PaymentElement` meldt `complete: true` via `onChange` zodra de koper een methode heeft gekozen en heeft ingevuld wat die nodig heeft. Schakel je betaalknop op basis daarvan in. De knop is van jou: het label, de positie en wat er gebeurt bij een druk erop.

### 1.4 Het bevestigingstoken aanmaken

Roep bij een druk op de knop `createConfirmationToken` aan. Die zet wat de elements hebben verzameld om in een `ctok_`-token voor eenmalig gebruik dat de betaalmethode vertegenwoordigt. Het token bevat het e-mailadres en de factuurgegevens die de elements hebben verzameld. Een gekozen wallet opent Apple Pay of Google Pay tijdens deze aanroep, en de aanroep weigert zolang er geen `BrandingElement` op de pagina staat.

Stuur het token samen met je eigen bestelreferentie naar je server. Het token is het enige over de betaalmethode dat de browser verlaat.

## Afrekenen vanaf je server

### 2.1 De Whop SDK installeren (Next.js)

Installeer de Whop SDK en maak een client aan met je Account API-sleutel. De sleutel blijft op de server. De browser ziet hem nooit.

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

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

### 2.1 De Whop SDK installeren (Express)

Installeer de Whop SDK en maak een client aan met je Account API-sleutel. De sleutel blijft op de server. De browser ziet hem nooit.

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

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

### 2.1 De Whop SDK installeren (Python)

Installeer de Whop SDK en maak een client aan met je Account API-sleutel. De sleutel blijft op de server. De browser ziet hem nooit.

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

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

### 2.2 De betaling aanmaken vanuit het bevestigingstoken

Geef het token door aan de Payments API. Whop bepaalt de koper aan de hand van het e-mailadres in het token, rekent de variant af en retourneert de betaling met een `client_secret`. Stuur `id`, `status` en `client_secret` terug naar de browser. De `client_secret` ontgrendelt alleen deze ene betaling, dus je kunt hem veilig blootstellen.

Stel `return_url` in op dezelfde pagina waarnaar de elements terugkeren. Zet je eigen bestel-ID in `metadata` zodat de betaling en de bijbehorende webhooks die bevatten. Geef voor een formulier in setupmodus het token in plaats daarvan door aan de [Setup Intents API](https://docs.whop.com/nl/api-reference/setup-intents/create-setup-intent.md). Die retourneert een setup intent met dezelfde `client_secret`-vorm.

* `variant_id` is de variant die de koper aanschaft. Geef in plaats daarvan een inline `variant` mee om een bedrag af te rekenen dat nog geen opgeslagen variant is
* `confirmation_token` vertegenwoordigt de betaalmethode die de elements hebben verzameld
* `metadata` koppelt de betaling terug aan je eigen bestelling

### 2.3 Uitleveren vanuit de webhook

Whop stuurt `payment.succeeded` naar je webhookendpoint zodra de betaling slaagt, of de koper nu inline heeft betaald of terugkwam van een stap buiten de site. Verifieer de handtekening met de SDK-helper en voer daarna het uitleverwerk uit: markeer de bestelling als betaald, verleen toegang en verstuur de e-mail.

Uitlevering hoort hier thuis en nergens anders. De koper kan de browser sluiten voordat je retourpagina laadt, een doorverwijzing kan mislukken en iedereen kan handmatig een queryparameter typen. Volg de [Webhooks-gids](https://docs.whop.com/nl/developer/guides/webhooks.md) om de webhook aan te maken en het `ws_`-geheim op te slaan als `WHOP_WEBHOOK_SECRET`.

## De betaling voltooien

### 3.1 De volgende actie afhandelen

Een betaling die terugkomt met `paid` is voltooid. Al het andere betekent dat de koper nog een stap moet doen, zoals 3D Secure of een bankdoorverwijzing, of dat de betaling nog in behandeling is. Geef de `client_secret` door aan `handleNextAction`. Die voert een inline stap uit in een dialoogvenster en wordt afgerond met `redirected: false`, of stuurt de koper naar je `returnUrl` en wordt afgerond met `redirected: true`.

Vertak op de `status` die wordt geretourneerd. `succeeded` betekent dat de koper heeft betaald, `processing` betekent dat de betaling nog in behandeling is, en al het andere vereist een nieuwe poging. `lastPaymentError` bevat de reden als die er is. Een gesloten dialoogvenster laat de betaling op `requires_action` staan zonder fout, dus een ontbrekende fout betekent nooit dat de betaling is geslaagd.

### 3.2 De uitkomst uit de URL lezen

Een koper die is vertrokken voor een stap buiten de site, komt op `returnUrl` terecht, **wat er daar ook gebeurde**. Whop voegt drie queryparameters toe. `payment` is de `pay_`-ID. `status` is `succeeded` wanneer de koper heeft betaald, `failed` of `canceled` wanneer dat niet zo is, en een status in behandeling zoals `processing` zolang er over de betaling nog niet is beslist. Met `client_secret` kan de pagina de status van de betaling pollen als die op een beslissing wil wachten.

Je eigen parameters, zoals `order`, blijven in de URL staan. Kaartweigeringen bereiken deze pagina nooit, omdat `handleNextAction` ze inline meldt. De retourpagina is de enige plek waar je site een mislukte betaling buiten de site ziet.

### 3.3 De juiste weergave tonen

Vertak op `status`. `succeeded` krijgt de bedankpagina. `failed` en `canceled` krijgen een melding dat de koper niets in rekening is gebracht, plus een link terug naar de checkout. Al het andere betekent dat de betaling nog in behandeling is. Laat de koper weten dat je per e-mail bevestigt. De inline routes in het formulier sturen de koper naar dezelfde pagina met dezelfde parameters, dus één pagina handelt elke afloop af.

Behandel de pagina als een weergave van de uitkomst, niet als betalingsbewijs. Iedereen kan `status=succeeded` in een URL typen. Toegang, downloads en de afhandeling van bestellingen komen voort uit de webhook `payment.succeeded` op je server.

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

### Server: 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,
	});
}
```

### Server: 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.
}
```

### Server: 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);
```

### Server: 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.
```

## Volgende stappen

* [Referentie voor payment elements](https://docs.whop.com/nl/elements/latest/payments/overview): elke optie, elk event en elke methode op de Payments-handle.
* [Express checkout](https://docs.whop.com/nl/developer/guides/express-checkout.md): voeg Apple Pay en Google Pay met één druk op de knop toe naast het formulier.
* [Betaalmethoden opslaan](https://docs.whop.com/nl/developer/guides/save-payment-methods.md): sla een betaalmethode op zonder te belasten en belast die later vanaf je server.
* [Een checkout insluiten](https://docs.whop.com/nl/developer/guides/embed-checkout.md): sla het formulier over en voeg in plaats daarvan de volledige checkout van Whop in.


## Related topics

- [Betaalmethoden opslaan](https://docs.whop.com/nl/developer/guides/save-payment-methods.md)
- [Een checkout insluiten](https://docs.whop.com/nl/developer/guides/embed-checkout.md)
- [CheckoutElement](https://docs.whop.com/nl/elements/latest/checkout/checkout.md)
