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

# Byg en checkout med Payment Elements

> Design din egen checkout omkring betalingselementerne: indsaml et bekræftelsestoken i browseren, opkræv det fra din server, og lever fra en webhook

Design din egen checkout omkring Whops betalingselementer. Elementerne indsamler betalingsmetoden i PCI-isolerede felter og giver dig et bekræftelsestoken. Din server sender det token til Payments API'et for at opkræve betaling eller til Setup Intents API'et for at gemme metoden. Browseren afslutter derefter ethvert trin, som køberen stadig mangler.

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 betalingsformularen

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

### 1.2 Montér elementerne

Opret et `Payments`-handle til varianten via den eksisterende `plan`-egenskab, og montér tre elementer under det. `EmailElement` indsamler køberens e-mail og tilbyder en genkendt Whop-køber et login, der låser op for deres gemte betalingsmetoder. `PaymentElement` viser de metoder, der er tilgængelige for varianten og køberens land, og indsamler hver metodes felter i hostede frames, så kortnumre aldrig når din side. `BrandingElement` viser Whops merchant-of-record-meddelelse, som enhver betalingsformular skal indeholde.

Handlet finder selv variantens valuta, beløb og betalingsmetoder. Sæt `returnUrl` til en side, du hoster over `https`. Bankomdirigeringer, finansieringsansøgninger og nogle 3D Secure-flows sender køberen tilbage dertil. Tilføj dine egne query-parametre til den, såsom ordre-ID'et. De overlever rundturen.

For at gemme en betalingsmetode uden at opkræve den skal du montere de samme elementer med `mode: "setup"` og en `currency` i stedet for en `plan`. Guiden [Gem betalingsmetoder](https://docs.whop.com/da/developer/guides/save-payment-methods.md) dækker den formular.

### 1.3 Aktivér betalingsknappen

`PaymentElement` rapporterer `complete: true` via `onChange`, når køberen har valgt en metode og udfyldt det, den kræver. Aktivér din betalingsknap ud fra det. Du ejer knappen: dens tekst, dens placering og hvad der sker ved tryk.

### 1.4 Opret bekræftelsestokenet

Ved tryk skal du kalde `createConfirmationToken`. Det omdanner det, elementerne har indsamlet, til et engangs-`ctok_`-token, der repræsenterer betalingsmetoden. Tokenet indeholder den e-mail og de faktureringsoplysninger, elementerne har indsamlet. Valg af en wallet åbner Apple Pay eller Google Pay under dette kald, og kaldet afvises, så længe der ikke er noget `BrandingElement` på siden.

Send tokenet til din server sammen med din egen ordrereference. Tokenet er det eneste om betalingsmetoden, der forlader browseren.

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

Sæt `return_url` til den samme side, som elementerne vender tilbage til. Læg dit eget ordre-ID i `metadata`, så betalingen og dens webhooks indeholder det. For en formular i setup-tilstand skal du i stedet sende tokenet til [Setup Intents API'et](https://docs.whop.com/da/api-reference/setup-intents/create-setup-intent.md). Det returnerer et setup intent med samme `client_secret`-form.

* `variant_id` er den variant, køberen køber. Send i stedet en inline `variant` for at opkræve et beløb, der endnu ikke er en gemt variant
* `confirmation_token` repræsenterer den betalingsmetode, elementerne har indsamlet
* `metadata` knytter betalingen til din egen ordre

### 2.3 Lever ud fra webhooket

Whop sender `payment.succeeded` til dit webhook-endpoint, når opkrævningen lykkes, uanset om køberen betalte direkte på siden eller kom tilbage fra et trin uden for siden. Verificér signaturen med SDK-hjælperen, og udfør derefter leveringsarbejdet: markér ordren som betalt, giv adgang, og send e-mailen.

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

## 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 en bankomdirigering, 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 `returnUrl` 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 uden for siden, ankommer til `returnUrl`, **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. Kortafvisninger når aldrig denne side, fordi `handleNextAction` rapporterer dem direkte. Retursiden er det eneste sted, hvor dit website ser en mislykket betaling 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 checkout. Alt andet betyder, at opkrævningen stadig afventer. Fortæl køberen, at du bekræfter via e-mail. De direkte forløb i formularen 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 — `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>}
		</>
	);
}
```

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

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

## Næste trin

* [Reference for betalingselementer](https://docs.whop.com/da/elements/latest/payments/overview): alle indstillinger, events og metoder på Payments-handlet.
* [Express checkout](https://docs.whop.com/da/developer/guides/express-checkout.md): tilføj Apple Pay og Google Pay med ét tryk ved siden af formularen.
* [Gem betalingsmetoder](https://docs.whop.com/da/developer/guides/save-payment-methods.md): gem en metode uden at opkræve den, og opkræv den senere fra din server.
* [Indlejr en checkout](https://docs.whop.com/da/developer/guides/embed-checkout.md): spring formularen over, og indsæt i stedet hele Whops checkout.
