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

# Indlejr en checkout

> Indsæt hele Whops checkout på din side med Checkout-elementet, direkte fra browseren, og lever fra et webhook

Placer hele Whops checkout på din egen side med Checkout-elementet. Det kører helt i browseren. Din server lytter kun efter det webhook, der fortæller, at køberen har betalt.

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.

## Indlejr checkout

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

### 1.2 Montér Checkout-elementet

Montér `CheckoutElement` inde i et `Checkout`-handle, og send varianten med via den eksisterende `plan`-egenskab. Elementet åbner selv checkout-sessionen, prissætter ordren og indsamler alt, hvad sælgeren har sat op. Det kræver ingen serverkode og ingen API-nøgle på siden: varianten definerer prisen, så browseren angiver aldrig et beløb.

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`. Køberen lander der efter et betalingstrin uden for siden, såsom 3D Secure, en bankside eller en finansieringsansøgning. Tilføj dine egne query-parametre til den, såsom ordre-ID'et. De overlever rundturen.

For at tilknytte en affiliatekode, en rabatkode eller kampagneattribution skal du sende `affiliateCode`, `promoCode` eller `attribution` med på handlet. En [checkout-konfiguration](https://docs.whop.com/da/api-reference/checkout-configurations/create-a-checkout-configuration.md), der er oprettet på din server, er kun nødvendig, når du vil holde disse forudindstillinger ude af klientkoden.

### 1.3 Registrér gennemførelsen

`onComplete` udløses én gang, når checkout gennemføres inde i elementet, 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, og et betalingstrin uden for siden gennemføres i stedet på retursiden.

## Håndtér retursiden

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

Køberen ankommer til `returnUrl`, **uanset hvad der skete** under trinnet uden for siden. 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. En finansieringsansøgning, som långiveren har afvist, lander her med `status=canceled`, præcis som en godkendt lander med `status=succeeded`.

Dine egne parametre, såsom `order`, bliver på URL'en. Kortafvisninger når aldrig denne side, fordi elementet viser dem direkte. Retursiden er det eneste sted, hvor dit website ser en mislykket betaling 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 checkout. 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. 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 — `CheckoutPage.tsx`

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

export function CheckoutPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			{/* Step 1.2: Mount the Checkout element */}
			<Checkout
				plan="plan_xxxxxxxxxxxxx"
				metadata={{ order_id: orderId }}
				returnUrl={`https://yoursite.com/checkout/return?order=${orderId}`}
				// Step 1.3: 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("Checkout completed", completion.paymentId);
					}
				}}
			>
				{/* Step 1.2: Mount the Checkout element */}
				<CheckoutElement />
			</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 — `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="checkout"></div>

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

      // Step 1.2: Mount the Checkout element
      const checkout = window.WhopElements().checkout.create({
        plan: "plan_xxxxxxxxxxxxx",
        metadata: { order_id: orderId },
        returnUrl: `https://yoursite.com/checkout/return?order=${orderId}`,
        // Step 1.3: 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("Checkout completed", completion.paymentId);
          }
        },
      });
      // Step 1.2: Mount the Checkout element
      checkout.create("checkout").mount("#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 Checkout-elementet](https://docs.whop.com/da/elements/latest/checkout/overview): alle indstillinger, events og metoder på Checkout-handlet.
* [Byg en checkout med betalingselementer](https://docs.whop.com/da/developer/guides/payment-elements.md): design selv formularen, og bekræft betalingen fra din server.
* [Webhooks](https://docs.whop.com/da/developer/guides/webhooks.md): opret endpointet, gem signeringsnøglen, og håndter genforsøg.
* [Test i sandkassen](https://docs.whop.com/da/developer/guides/sandbox.md): kør en testopkrævning med kort, der lykkes, fejler og kræver handling.


## Related topics

- [Byg en checkout med Payment Elements](https://docs.whop.com/da/developer/guides/payment-elements.md)
- [Tilføj Express Checkout](https://docs.whop.com/da/developer/guides/express-checkout.md)
- [Oversigt over betalinger](https://docs.whop.com/da/developer/payments/overview.md)
