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

# Åbn et wallet-ark fra din egen knap

> Åbn Apple Pay- eller Google Pay-arket fra en knap, du selv renderer, prissæt ordren selv, og opkræv bekræftelsestokenet fra din server

Brug payment request-ressourcen, når du selv viser købsknappen og selv prissætter ordren. Ét tryk åbner Apple Pay- eller Google Pay-arket, arket giver dig et bekræftelsestoken, og din server sender tokenet til Payments API'et for at opkræve betaling.

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.

## Byg din wallet-knap

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

### 1.2 Opret payment request'en

Opret request'en med din konto, valutaen og beløbet i mindste enheder. `lineItems` er de rækker, arket viser under totalen. Intet monteres: ressourcen er wallet-arket uden et element, og knappen er din.

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 Tjek, hvilke wallets der kan betale

Afvent `canMakePayment()`, før du viser en knap. Den rapporterer, hvilke wallets denne enhed, denne konto og dette domæne kan betale med, og den forbereder arket, så det senere kan åbne synkront. Vis kun en knap for en wallet, der kom tilbage som `true`.

Apple og Google kræver hver deres egen knapgrafik på en brugerdefineret knap. Følg [Apple Pay-retningslinjerne for knapper](https://developer.apple.com/design/human-interface-guidelines/apple-pay) og [Google Pay-brandretningslinjerne](https://developers.google.com/pay/api/web/guides/brand-guidelines).

### 1.4 Åbn arket, og send tokenet til din server

Kald `show(type)` som det allerførste i knappens tryk-handler, før enhver `await`. Apple afviser et ark, der åbnes uden for den brugerhandling, og derfor kørte `canMakePayment()` på forhånd. Arket beder om køberens e-mail, medmindre du sender en med `show("apple_pay", \{ email \})`.

`show` resolver, når køberen godkender. `ctok` er det engangsbekræftelsestoken, `type` angiver wallet'en, og `payer` indeholder køberens e-mail, navn, telefonnummer og faktureringsland, som wallet'en leverede dem. En køber, der lukker arket, får `show` til at afvise med en `payment_request_cancelled`-fejl. Arket lukker med et flueben, så snart tokenet er oprettet, før din server bekræfter, så vis din servers resultat på din side.

Send `ctok` til din server sammen med din egen ordrereference. For at indsamle en leveringsadresse og tilbyde leveringsmuligheder skal du sætte `requestShipping` og besvare arkets ændringer med `updateWith`. [PaymentRequest-referencen](https://docs.whop.com/da/elements/latest/payments/paymentRequest.md) dækker disse handlers.

## Opkræv fra din server

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

Installér Whop SDK, og opret en klient med din kontos API-nøgle. Nøglen bliver på serveren. Browseren ser den aldrig.

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

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

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

Installér Whop SDK, og opret en klient med din kontos API-nøgle. Nøglen bliver på serveren. Browseren ser den aldrig.

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

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

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

Installér Whop SDK, og opret en klient med din kontos API-nøgle. Nøglen bliver på serveren. Browseren ser den aldrig.

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

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

### 2.2 Opret betalingen ud fra bekræftelsestokenet

Send tokenet til Payments API'et. Whop finder køberen ud fra tokenets e-mail, opkræver varianten og returnerer betalingen med en `client_secret`. Returnér `id`, `status` og `client_secret` til browseren. `client_secret` låser kun op for denne ene betaling, så den er sikker at eksponere.

Opkræv det, arket viste. Request'ens `amount` er i mindste enheder, så `1000` på arket er en `initial_price` på `10.0` her. Send en inline `variant` for at finde eller oprette en variant til denne pris, eller `variant_id` for en variant, du allerede har oprettet. Sæt `return_url` til den side, køberen skal lande på efter et trin på en hel side, og læg dit eget ordre-ID i `metadata`, så betalingen og dens webhooks indeholder det.

* En inline `variant` finder eller opretter varianten til denne pris. Brug `variant_id`, når prisen allerede findes som en variant
* `confirmation_token` repræsenterer det wallet-kort, arket har godkendt
* `metadata` knytter betalingen til din egen ordre
* For fysiske varer skal du sende resultatets `shipping.address` med tokenet og videregive den som `shipping_address`

### 2.3 Lever ud fra webhooket

Whop sender `payment.succeeded` til dit webhook-endpoint, når opkrævningen lykkes. 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`.

Levering hører hjemme her og ingen andre steder. Arkets flueben, browseren og en query-parameter kan alle sige betalt, uden at opkrævningen er afregnet. 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`.

## Afslut betalingen

### 3.1 Håndtér den næste handling

En betaling, der kommer tilbage som `paid`, er gennemført. Alt andet betyder, at køberen stadig har et trin, såsom 3D Secure, eller at opkrævningen stadig afventer. Send `client_secret` til `handleNextAction`. Den kører et trin direkte på siden i en dialog og resolver med `redirected: false`, eller sender køberen til din `return_url` og resolver med `redirected: true`.

Forgren på den `status`, den returnerer. `succeeded` betyder, at køberen har betalt, `processing` betyder, at opkrævningen stadig afventer, og alt andet kræver et nyt forsøg. `lastPaymentError` indeholder årsagen, når der er en. En lukket dialog efterlader betalingen på `requires_action` uden fejl, så en manglende fejl betyder aldrig succes.

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

En køber, der forlod siden for et trin på en hel side, ankommer til `return_url`, **uanset hvad der skete** der. Whop tilføjer tre query-parametre. `payment` er `pay_`-ID'et. `status` er `succeeded`, når køberen har betalt, `failed` eller `canceled`, når de ikke har, og en afventende status såsom `processing`, mens opkrævningen stadig er uafgjort. `client_secret` lader siden polle betalingens status, hvis den vil vente på en afgørelse.

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

### 3.3 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 betyder, at opkrævningen stadig afventer. Fortæl køberen, at du bekræfter via e-mail. De direkte forløb i knappens handler sender køberen til den samme side med de samme parametre, så én side håndterer alle udfald.

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.

## Kode

### Klient: React — `WalletButtons.tsx`

```tsx WalletButtons.tsx theme={null}
// Step 1.1: Install the packages
import { useEffect, useRef, useState } from "react";
import { WhopElements, useWhop } from "@whop/elements-react";
import { loadWhop } from "@whop/elements";
import type { PaymentRequestResource } from "@whop/elements/payments";

type Wallet = "apple_pay" | "google_pay";

export function ProductPage({ orderId }: { orderId: string }) {
	return (
		<WhopElements elements={loadWhop()}>
			<WalletButtons orderId={orderId} />
		</WhopElements>
	);
}

function WalletButtons({ orderId }: { orderId: string }) {
	const whop = useWhop();
	const requestRef = useRef<PaymentRequestResource | null>(null);
	const [wallets, setWallets] = useState<Wallet[]>([]);
	const [error, setError] = useState<string | null>(null);

	useEffect(() => {
		if (!whop) return;
		// Step 1.2: Create the payment request
		// Amounts are in minor units: 1000 is $10.00.
		const paymentRequest = whop.payments.paymentRequest.create({
			accountId: "biz_xxxxxxxxxxxxx",
			currency: "usd",
			amount: 1000,
			lineItems: [{ label: "Pro access", amount: 1000 }],
		});
		requestRef.current = paymentRequest;
		// Step 1.3: Check which wallets can pay
		paymentRequest.canMakePayment().then(({ applePay, googlePay }) => {
			setWallets([
				...(applePay ? (["apple_pay"] as const) : []),
				...(googlePay ? (["google_pay"] as const) : []),
			]);
		});
	}, [whop]);

	async function pay(wallet: Wallet) {
		const paymentRequest = requestRef.current;
		if (!paymentRequest || !whop) return;
		setError(null);

		// Step 1.4: Open the sheet and send the token to your server
		// show() must run inside the press handler, before any await, or Apple refuses the sheet.
		let ctok: string;
		try {
			({ ctok } = await paymentRequest.show(wallet));
		} catch (err) {
			if ((err as Error).message !== "payment_request_cancelled") {
				setError("The wallet sheet couldn't complete. Try again.");
			}
			return;
		}

		const response = await fetch("/api/pay", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({ confirmationToken: ctok, 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 wasn't completed. Try again.");
	}

	return (
		<>
			{/* Step 1.3: Check which wallets can pay */}
			{wallets.map((wallet) => (
				<button key={wallet} onClick={() => pay(wallet)}>
					{wallet === "apple_pay" ? "Pay with Apple Pay" : "Pay with Google Pay"}
				</button>
			))}
			{error && <p role="alert">{error}</p>}
		</>
	);
}
```

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

### 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>
    <button id="apple-pay" hidden>Pay with Apple Pay</button>
    <button id="google-pay" hidden>Pay with Google Pay</button>
    <p id="error" role="alert"></p>

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

      // Step 1.2: Create the payment request
      // Amounts are in minor units: 1000 is $10.00.
      const whop = window.WhopElements();
      const paymentRequest = whop.payments.paymentRequest.create({
        accountId: "biz_xxxxxxxxxxxxx",
        currency: "usd",
        amount: 1000,
        lineItems: [{ label: "Pro access", amount: 1000 }],
      });

      // Step 1.3: Check which wallets can pay
      const { applePay, googlePay } = await paymentRequest.canMakePayment();
      document.querySelector("#apple-pay").hidden = !applePay;
      document.querySelector("#google-pay").hidden = !googlePay;

      const errorLine = document.querySelector("#error");

      async function pay(wallet) {
        errorLine.textContent = "";

        // Step 1.4: Open the sheet and send the token to your server
        // show() must run inside the press handler, before any await, or Apple refuses the sheet.
        let ctok;
        try {
          ({ ctok } = await paymentRequest.show(wallet));
        } catch (err) {
          if (err.message !== "payment_request_cancelled") {
            errorLine.textContent = "The wallet sheet couldn't complete. Try again.";
          }
          return;
        }

        const response = await fetch("/api/pay", {
          method: "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({ confirmationToken: ctok, 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 wasn't completed. Try again.";
      }

      // Step 1.3: Check which wallets can pay
      document.querySelector("#apple-pay").addEventListener("click", () => pay("apple_pay"));
      document.querySelector("#google-pay").addEventListener("click", () => pay("google_pay"));
    </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 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,
		// Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
		variant: { currency: "usd", initial_price: 10.0, billing_type: "one_time" },
		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,
		// Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
		variant: { currency: "usd", initial_price: 10.0, billing_type: "one_time" },
		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"],
            # Charge what the sheet showed: 1000 minor units on the sheet is an initial_price of 10.0 here.
            "variant": {"currency": "usd", "initial_price": 10.0, "billing_type": "one_time"},
            "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.
```

## Næste trin

* [PaymentRequest-reference](https://docs.whop.com/da/elements/latest/payments/paymentRequest.md): handlers for ændringer af forsendelse og fakturering, `updateWith` og alle indstillinger på ressourcen.
* [Tilføj express checkout](https://docs.whop.com/da/developer/guides/express-checkout.md): lad Whop rendere wallet-knapperne for en variant og bekræfte betalingen for dig.
* [Aktivér Apple Pay og Google Pay](https://docs.whop.com/da/payments/apple-pay.md): tilføj Apple Pay til dit domæne.
* [Webhooks](https://docs.whop.com/da/developer/guides/webhooks.md): opret endpointet, gem signeringshemmeligheden, og håndter genforsøg.


## Related topics

- [Tilføj Express Checkout](https://docs.whop.com/da/developer/guides/express-checkout.md)
- [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
- [Wallet](https://docs.whop.com/da/elements/latest/wallet/overview.md)
