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

# Tilføj Express Checkout

> Placer Apple Pay- og Google Pay-knapper med ét tryk på din side med Express Checkout-elementet, direkte fra browseren, og lever fra et webhook

Placer Apple Pay- og Google Pay-knapper med ét tryk på en produktside med Express Checkout-elementet. Whop viser de wallets, enheden kan betale med, og bekræfter betalingen for dig. Din server lytter kun efter webhooket.

Filerne under **Kode** indeholder `Step X.Y`-kommentarer, der henviser tilbage til trinnene nedenfor. Vælg én serverimplementering og én klientimplementering. Listen indeholder filerne for alle muligheder.

## Tilføj wallet-knapperne

### 1.1 Installér pakkerne (React)

Installér Whop Elements-pakkerne til 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 Tilføj script-tagget (JavaScript)

Indlæs Whop Elements-scriptet på den side, der viser knapperne.

### 1.2 Montér knapperne

Montér `ExpressCheckoutElement` inde i et `Checkout`-handle, og send varianten med via den eksisterende `plan`-egenskab. Elementet viser kun de wallets, køberens enhed kan betale med, med browserens bedste native wallet først, og viser intet, hvor ingen wallet er tilgængelig. Behold en almindelig checkout-mulighed på siden til disse købere.

Send `metadata`, såsom dit eget ordre-ID, med på handlet. Whop kopierer det til betalingen og til hvert webhook om den. Sæt `returnUrl` til en side, du hoster over `https`. Et gennemført køb omdirigerer fanen dertil, og det samme gør en betaling, der krævede et trin på en hel side.

Wallets åbner kun på sider, hvis domæne er klar til Apple Pay. Følg [Aktivér Apple Pay og Google Pay](https://docs.whop.com/da/payments/apple-pay.md) én gang pr. domæne, server siden over `https`, og test på en rigtig enhed med en opsat wallet.

### 1.3 Vælg wallets og layout

`wallets` begrænser, hvilke wallets der må vises, for eksempel `["apple_pay"]`. Elementet viser aldrig en wallet, som enheden eller checkoutens betalingsmetodekonfiguration ikke kan understøtte, så listen er et loft, ikke et løfte.

`layout` arrangerer knapperne. `auto` følger containerens bredde, og `horizontal` eller `vertical` gennemtvinger én opstilling. `appearance` på handlet styrer temaet for elementets resultat- og fejllinjer.

### 1.4 Registrér gennemførelsen

Et tryk åbner wallet-arket. Når køberen godkender, bekræfter Whop betalingen på checkout-sessionen, og arkets flueben følger den bekræftelse. `onComplete` udløses, når resultatet står fast, før en eventuel navigation til `returnUrl`. Brug det til analytics og annoncepixels.

Lever ikke ud fra det. En checkout, der gendannes ved en senere sideindlæsning, udløser det igen for det samme resultat. En betaling, der forlod siden for et trin på en hel side, gennemføres i stedet på retursiden.

## Håndtér retursiden

### 2.1 Læs resultatet fra URL'en

De fleste wallet-betalinger afregnes direkte på siden, og en betaling, der stadig kræver et trin, kører det i en dialog, når trinnet kan være i en. Et trin, der kun kan køre på en hel side, såsom en bankomdirigering, forlader siden og sender køberen tilbage til `returnUrl`, **uanset hvad der skete**. Whop tilføjer to query-parametre. `payment` er `pay_`-ID'et. `status` er `succeeded`, når køberen har betalt, og `failed` eller `canceled`, når de ikke har.

Dine egne parametre, såsom `order`, bliver på URL'en. Elementet rapporterer selv afvisninger direkte på siden, så retursiden er det eneste sted, hvor dit website ser et mislykket trin uden for siden.

### 2.2 Vis den rigtige visning

Forgren på `status`. `succeeded` får takkesiden. `failed` og `canceled` får en besked om, at køberen ikke blev opkrævet, og et link tilbage til produktet. Alt andet, såsom `processing`, betyder, at opkrævningen stadig afventer. Fortæl køberen, at du bekræfter via e-mail.

Behandl siden som en visning af resultatet, ikke som bevis for betaling. Alle kan skrive `status=succeeded` i en URL. Adgang, downloads og ordrelevering kommer fra `payment.succeeded`-webhooket på din server.

## Lever fra din server

### 3.1 Installér Whop SDK (Next.js)

Webhook-hjælperen følger med Whop SDK. Installér det på den server, der modtager webhooket.

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

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

### 3.1 Installér Whop SDK (Express)

Webhook-hjælperen følger med Whop SDK. Installér det på den server, der modtager webhooket.

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

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

### 3.1 Installér Whop SDK (Python)

Webhook-hjælperen følger med Whop SDK. Installér det på den server, der modtager webhooket.

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

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

### 3.2 Håndtér betalings-webhooket

Whop sender `payment.succeeded` til dit webhook-endpoint, når køberen har betalt. Verificér signaturen med SDK-hjælperen, og udfør derefter leveringsarbejdet: markér ordren som betalt, giv adgang, og send e-mailen. En wallet-betaling angiver `apple_pay` eller `google_pay` i `payment_method_type`, og betalingen indeholder de `metadata`, du har sat på Checkout-handlet.

Levering hører hjemme her og ingen andre steder. Køberen kan lukke browseren, før din returside indlæses, en omdirigering kan mislykkes, og alle kan skrive en query-parameter i hånden. Følg [Webhooks-guiden](https://docs.whop.com/da/developer/guides/webhooks.md) for at oprette webhooket og gemme dets `ws_`-hemmelighed som `WHOP_WEBHOOK_SECRET`.

## Kode

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

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

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

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

## Næste trin

* [Reference for Express Checkout-elementet](https://docs.whop.com/da/elements/latest/checkout/expressCheckout.md): alle indstillinger, events og styling-hooks på elementet.
* [Åbn et wallet-ark fra din egen knap](https://docs.whop.com/da/developer/guides/payment-request.md): render selv knappen, og prissæt selv ordren med payment request-ressourcen.
* [Aktivér Apple Pay og Google Pay](https://docs.whop.com/da/payments/apple-pay.md): tilføj Apple Pay til dit domæne.
* [Indlejr en checkout](https://docs.whop.com/da/developer/guides/embed-checkout.md): den fulde checkout-formular, som allerede viser wallet-knapperne over sig.


## Related topics

- [Åbn et wallet-ark fra din egen knap](https://docs.whop.com/da/developer/guides/payment-request.md)
- [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
- [ExpressCheckoutElement](https://docs.whop.com/da/elements/latest/checkout/expressCheckout.md)
