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

# Express Checkout toevoegen

> Plaats Apple Pay- en Google Pay-knoppen voor betalen met één druk op je pagina met het Express Checkout-element, rechtstreeks vanuit de browser, en lever uit vanuit een webhook

Plaats Apple Pay- en Google Pay-knoppen voor afrekenen met één druk op een productpagina met het Express Checkout-element. Whop toont de wallets waarmee het apparaat kan betalen en bevestigt de betaling voor je. Je server luistert alleen naar de webhook.

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.

## De walletknoppen toevoegen

### 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 de knoppen staan.

### 1.2 De knoppen koppelen

Koppel `ExpressCheckoutElement` binnen een `Checkout`-handle en geef de variant door via de bestaande eigenschap `plan`. Het element toont alleen de wallets waarmee het apparaat van de koper kan betalen, met de meest native wallet voor de browser eerst, en toont niets wanneer er geen wallet beschikbaar is. Houd voor die kopers een gewone checkoutroute op de pagina.

Geef `metadata`, zoals je eigen bestel-ID, mee op de handle. Whop kopieert die naar de betaling en naar elke webhook erover. Stel `returnUrl` in op een pagina die je via `https` host. Een afgeronde aankoop stuurt het tabblad daarheen door, net als een betaling die een stap op een volledige pagina nodig had.

Wallets openen alleen op pagina's waarvan het domein klaar is voor Apple Pay. Volg [Apple Pay en Google Pay inschakelen](https://docs.whop.com/nl/payments/apple-pay.md) eenmaal per domein, lever de pagina via `https` en test op een echt apparaat waarop een wallet is ingesteld.

### 1.3 De wallets en lay-out kiezen

`wallets` beperkt welke wallets mogen worden getoond, bijvoorbeeld `["apple_pay"]`. Het element toont nooit een wallet die het apparaat of de betaalmethodeconfiguratie van de checkout niet ondersteunt, dus de lijst is een bovengrens, geen belofte.

`layout` bepaalt de indeling van de knoppen. `auto` volgt de breedte van de container, en `horizontal` of `vertical` dwingt één indeling af. `appearance` op de handle bepaalt het thema van de uitkomst- en foutregels van het element.

### 1.4 De voltooiing vastleggen

Een druk opent het walletvenster. Wanneer de koper autoriseert, bevestigt Whop de betaling op de checkoutsessie, en het vinkje in het venster volgt op die bevestiging. `onComplete` wordt één keer aangeroepen zodra het resultaat vaststaat, vóór een eventuele navigatie naar `returnUrl`. Gebruik het voor analytics en advertentiepixels.

Lever er niet vanuit uit. Een checkout die bij een latere paginalading wordt hersteld, roept het opnieuw aan voor hetzelfde resultaat. Een betaling die is vertrokken voor een stap op een volledige pagina, wordt in plaats daarvan op de retourpagina voltooid.

## De retourpagina afhandelen

### 2.1 De uitkomst uit de URL lezen

De meeste walletbetalingen worden inline afgerond, en een betaling die nog een stap nodig heeft, voert die uit in een dialoogvenster wanneer de stap daarin past. Een stap die alleen op een volledige pagina kan draaien, zoals een bankdoorverwijzing, verlaat de pagina en stuurt de koper terug naar `returnUrl`, **wat er ook gebeurde**. Whop voegt twee queryparameters toe. `payment` is de `pay_`-ID. `status` is `succeeded` wanneer de koper heeft betaald, en `failed` of `canceled` wanneer dat niet zo is.

Je eigen parameters, zoals `order`, blijven in de URL staan. Het element meldt inline weigeringen zelf, dus de retourpagina is de enige plek waar je site een mislukte stap buiten de site ziet.

### 2.2 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 het product. Alles daarbuiten, zoals `processing`, betekent dat de betaling nog in behandeling is. Laat de koper weten dat je per e-mail bevestigt.

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.

## Uitleveren vanaf je server

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

De webhookhelper wordt meegeleverd met de Whop SDK. Installeer die op de server die de webhook ontvangt.

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

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

### 3.1 De Whop SDK installeren (Express)

De webhookhelper wordt meegeleverd met de Whop SDK. Installeer die op de server die de webhook ontvangt.

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

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

### 3.1 De Whop SDK installeren (Python)

De webhookhelper wordt meegeleverd met de Whop SDK. Installeer die op de server die de webhook ontvangt.

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

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

### 3.2 De betalingswebhook afhandelen

Whop stuurt `payment.succeeded` naar je webhookendpoint zodra de koper heeft betaald. 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. Een walletbetaling meldt `apple_pay` of `google_pay` in `payment_method_type`, en de betaling bevat de `metadata` die je op de Checkout-handle hebt ingesteld.

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

## Code

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

```tsx BuyButton.tsx theme={null}
// Step 1.1: Install the packages
import { Checkout, ExpressCheckoutElement, WhopElements } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";

export function BuyButton({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			{/* Step 1.2: Mount the buttons */}
			<Checkout
				plan="plan_xxxxxxxxxxxxx"
				metadata={{ order_id: orderId }}
				returnUrl={`https://yoursite.com/checkout/return?order=${orderId}`}
				// Step 1.4: Record the completion
				onComplete={(completion) => {
					if (completion.result === "payment") {
						// Fire analytics or ad pixels here. Fulfill from the webhook, not from this callback.
						console.log("Express checkout completed", completion.paymentId);
					}
				}}
			>
				{/* Step 1.3: Pick the wallets and layout */}
				<ExpressCheckoutElement layout="horizontal" wallets={["apple_pay", "google_pay"]} />
			</Checkout>
		</WhopElements>
	);
}
```

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

```tsx CheckoutReturn.tsx theme={null}
export function CheckoutReturn() {
	// Step 2.1: Read the outcome from the URL
	// Whop appends `payment` and `status` 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 2.2: Show the right face
	if (status === "succeeded") {
		return (
			<section>
				<h1>Thanks for your order</h1>
				<p>Payment {paymentId} is complete. A receipt is on its way to your email.</p>
			</section>
		);
	}

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

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

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

```html buy.html theme={null}
<!DOCTYPE html>
<html>
  <head>
    <!-- Step 1.1: Add the script tag -->
    <script src="https://cdn.whop.com/elements/amber/elements.js" data-whop-elements></script>
  </head>
  <body>
    <div id="express-checkout"></div>

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

      // Step 1.2: Mount the buttons
      const checkout = window.WhopElements().checkout.create({
        plan: "plan_xxxxxxxxxxxxx",
        metadata: { order_id: orderId },
        returnUrl: `https://yoursite.com/checkout/return?order=${orderId}`,
        // Step 1.4: Record the completion
        onComplete: (completion) => {
          if (completion.result === "payment") {
            // Fire analytics or ad pixels here. Fulfill from the webhook, not from this callback.
            console.log("Express checkout completed", completion.paymentId);
          }
        },
      });
      // Step 1.3: Pick the wallets and layout
      checkout
        .create("expressCheckout", { layout: "horizontal", wallets: ["apple_pay", "google_pay"] })
        .mount("#express-checkout");
    </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 2.1: Read the outcome from the URL
      // Whop appends `payment` and `status` 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 2.2: 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/webhooks/whop/route.ts`

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

export async function POST(request: NextRequest) {
	// Step 3.2: Handle the payment 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 3.2: Handle the payment webhook
	// metadata.order_id is the value you set on the Checkout handle.
	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 3.1: Install the Whop SDK
import { unwrapWebhook } from "@whop/sdk/helpers";
import express from "express";

const app = express();

// Step 3.2: Handle the payment webhook
// Read the raw body on this route: 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 on the Checkout handle.
			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 3.1: Install the Whop SDK
import os

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

app = FastAPI()


# Step 3.2: Handle the payment 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 on the Checkout handle.
    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 van het Express Checkout-element](https://docs.whop.com/nl/elements/latest/checkout/expressCheckout.md): elke optie, elk event en elke stylinghook van het element.
* [Een wallet-sheet openen vanuit je eigen knop](https://docs.whop.com/nl/developer/guides/payment-request.md): render de knop zelf en bepaal zelf de prijs van de bestelling met de payment request-resource.
* [Apple Pay en Google Pay inschakelen](https://docs.whop.com/nl/payments/apple-pay.md): voeg Apple Pay toe aan je domein.
* [Een checkout insluiten](https://docs.whop.com/nl/developer/guides/embed-checkout.md): het volledige checkout-formulier, dat de wallet-knoppen er al boven toont.


## Related topics

- [Open een wallet-sheet vanuit je eigen knop](https://docs.whop.com/nl/developer/guides/payment-request.md)
- [Betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md)
- [ExpressCheckoutElement](https://docs.whop.com/nl/elements/latest/checkout/expressCheckout.md)
