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

# Whop API Quickstart

> Foretag dit første Whop API-kald, opret en checkout, betal den med et testkort, og modtag webhooken – alt sammen i sandkassen. Skift derefter til produktion.

Denne quickstart kører i sandkassen, et separat Whop-miljø, hvor der aldrig flyttes penge. Du får en sandbox-API-nøgle, foretager dit første kald, opretter en checkout, betaler den med et testkort og modtager `payment.succeeded`-webhooken på din server. At gå live er det sidste trin, og det handler mest om at bytte nøgler.

> [!TIP]
>
> Hvis du bruger en kodeagent, så giv den denne side som Markdown, `https://docs.whop.com/developer/quickstart.md`, eller indsæt prompten fra [Oversigt](https://docs.whop.com/da/developer/start.md#build-with-your-coding-agent).

## Sandkasse og produktion

Whop kører to miljøer, der intet deler: ikke konti, ikke nøgler, ikke produkter, ikke webhooks. Du bygger i sandkassen og lancerer i produktion. Hver værdi nedenfor ændrer sig mellem dem.

| | Sandkasse: byg og test | Produktion: lancér |
| - | - | - |
| Penge | Flyttes aldrig | Rigtige |
| Dashboard | [sandbox.whop.com](https://sandbox.whop.com) | [whop.com](https://whop.com) |
| API-nøgler og webhooks | [sandbox.whop.com/dashboard/developer](https://sandbox.whop.com/dashboard/developer) | [whop.com/dashboard/developer](https://whop.com/dashboard/developer) |
| API-base-URL | `https://sandbox-api.whop.com/api/v1` | `https://api.whop.com/api/v1` |
| SDK-miljø | `Sandbox` | `Production`, SDK'ets standard |
| Checkout-sider | `sandbox.whop.com/checkout/...` | `whop.com/checkout/...` |
| `WHOP_ENVIRONMENT` | `sandbox` | `production` |

> [!WARNING]
>
> Sandbox- og produktions-API-nøgler ser identiske ud, så intet i en nøgle fortæller dig, hvilket miljø den hører til. Kodestykkerne på denne side vælger miljøet ud fra en `WHOP_ENVIRONMENT`-variabel i stedet for at hardcode det, så den samme kode kører i begge. [Whop MCP-serveren](https://docs.whop.com/da/developer/ai/overview.md#mcp-server) handler kun på produktionsdata.

## Få en sandbox-API-nøgle

**1. Tilmeld dig sandkassen**

Gå til [sandbox.whop.com](https://sandbox.whop.com), og opret en konto. Den er adskilt fra enhver konto, du har på whop.com. Tilmeldingsforløbet opretter din første virksomhed, som er den Account, der ejer API-nøgler, produkter, webhooks og betalinger.

**2. Opret en Account API-nøgle**

Åbn [sandbox.whop.com/dashboard/developer](https://sandbox.whop.com/dashboard/developer). Under **Account API Keys** skal du vælge **Create** og give nøglen et navn som `Local development`.

Brug Admin-rollen til denne quickstart. Før produktion skal du skifte til et brugerdefineret tilladelsessæt, der kun dækker de endpoints, du kalder.

**3. Gem nøglen på din server**

Kopiér nøglen, når Whop viser den, og læg den i din lokale `.env`-fil sammen med det miljø, den hører til:

```bash theme={null}
WHOP_ENVIRONMENT=sandbox
WHOP_API_KEY=your_sandbox_key
```

![Whop-dashboardets Account API Keys-sektion, der viser et nøglenavn, en maskeret værdi og en Create-knap](https://mintcdn.com/whop/xuW6TKFlagvnbmV0/images/developer-api-key-field.png?fit=max\&auto=format\&n=xuW6TKFlagvnbmV0\&q=85\&s=699bf36af18f7a12dfd855eb0684b38e)

> [!NOTE]
>
> Hold `WHOP_API_KEY` på din server. Læg ikke API-nøgler i browserkode, mobilapps eller offentlige repositories. Sandbox- og produktionsnøgler ser identiske ud, så navngiv dem, så du kan skelne dem fra hinanden.

En Account API-nøgle er det rette valg, når din server handler på vegne af din egen virksomhed. For at bygge en app, som andre virksomheder installerer, eller for at lade brugere logge ind med Whop, se [Godkendelse og API-nøgler](https://docs.whop.com/da/developer/guides/auth-scoping.md).

## Installér SDK'et

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

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

```bash Ruby theme={null}
gem install whop_sdk
```

> [!NOTE]
>
> Denne side kræver SDK 2.7.0 eller nyere. Tidligere versioner accepterer ikke den inline `variant` på checkout-konfigurationer.

## Foretag dit første kald

Peg klienten mod det miljø, der er angivet i `WHOP_ENVIRONMENT`, og hent kontoen bag din nøgle. Det bekræfter, at nøglen virker, og udskriver dit konto-ID, som starter med `biz_`.

```typescript TypeScript theme={null}
import { WhopClient, WhopEnvironment } from "@whop/sdk";

const apiKey = process.env.WHOP_API_KEY;

if (!apiKey) {
  throw new Error("Set WHOP_API_KEY");
}

const client = new WhopClient({
  token: apiKey,
  environment: process.env.WHOP_ENVIRONMENT === "production" ? WhopEnvironment.Production : WhopEnvironment.Sandbox,
});

const account = await client.accounts.me();

console.log(account.id);
```

```python Python theme={null}
import os
from whop_sdk import Whop, WhopEnvironment

client = Whop(
    token=os.environ["WHOP_API_KEY"],
    environment=WhopEnvironment.PRODUCTION if os.environ.get("WHOP_ENVIRONMENT") == "production" else WhopEnvironment.SANDBOX,
)

account = client.accounts.me()

print(account.id)
```

```ruby Ruby theme={null}
require "whop_sdk"

whop = Whop_sdk::Client.new(
  token: ENV.fetch("WHOP_API_KEY"),
  environment: ENV["WHOP_ENVIRONMENT"] == "production" ? Whop_sdk::Environment::PRODUCTION : Whop_sdk::Environment::SANDBOX,
)

account = whop.accounts.me

puts account.id
```

```bash curl (sandbox) theme={null}
curl https://sandbox-api.whop.com/api/v1/accounts/me \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Api-Version-Date: 2026-11-04-1"
```

```json Response (trimmed) theme={null}
{
	"id": "biz_XXXXXXXX",
	"title": "Acme Studio",
	"route": "acme-studio",
	"status": "active"
}
```

> [!TIP]
>
> Det er din sandbox-konto. Nøglen virker.

## Opret en checkout

Ét kald opretter en variant og returnerer en `purchase_url`, en checkout-side hostet på `sandbox.whop.com`.

```typescript TypeScript theme={null}
const checkout = await client.checkoutConfigurations.create({
	variant: {
		title: "Starter",
		billing_type: "one_time",
		initial_price: 10.0,
		currency: "usd",
	},
});

console.log(checkout.purchase_url);
```

```python Python theme={null}
checkout = client.checkout_configurations.create(
    variant={
        "title": "Starter",
        "billing_type": "one_time",
        "initial_price": 10.0,
        "currency": "usd",
    },
)

print(checkout.purchase_url)
```

```ruby Ruby theme={null}
checkout = whop.checkout_configurations.create(
  variant: {
    title: "Starter",
    billing_type: "one_time",
    initial_price: 10.0,
    currency: "usd",
  },
)

puts checkout.purchase_url
```

Du åbner denne URL i betalingstrinnet. Hvis du allerede har en variant, så send dens ID som `variant_id` i stedet for den inline `variant`. Du kan ikke sende begge. [Create Checkout Configuration](https://docs.whop.com/da/api-reference/checkout-configurations/create-a-checkout-configuration.md) viser alle muligheder, herunder tilbagevendende priser, prøveperioder og omdirigerings-URL'er.

## Lyt efter webhooken

Opsæt dit endpoint, før du betaler, så `payment.succeeded`-hændelsen har et sted at lande.

**1. Tilføj et endpoint**

Tilføj en `POST`-rute, der verificerer signaturen og logger hændelsen. Verificeringen kræver den rå request-body, så læs den før enhver JSON-parsing.

```typescript TypeScript + Next.js theme={null}
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest): Promise<Response> {
  const event = unwrapWebhook<{ type: string; data: { id: string } }>(await request.text(), {
    headers: Object.fromEntries(request.headers),
    key: process.env.WHOP_WEBHOOK_SECRET!,
  });

  console.log(event.type, event.data.id);

  return new Response("OK", { status: 200 });
}
```

```python Python + FastAPI theme={null}
import os

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

app = FastAPI()

@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request):
    event = unwrap(await request.body(), headers=dict(request.headers), key=os.environ["WHOP_WEBHOOK_SECRET"])

    print(event["type"], event["data"]["id"])

    return Response(status_code=200)
```

```ruby Ruby on Rails theme={null}
class Api::WebhooksController < ApplicationController
  skip_before_action :verify_authenticity_token

  def whop
    event = WhopSDK::Helpers::VerifyWebhook.unwrap(
      request.raw_post,
      headers: {
        "webhook-id" => request.headers["webhook-id"],
        "webhook-timestamp" => request.headers["webhook-timestamp"],
        "webhook-signature" => request.headers["webhook-signature"],
      },
      key: ENV.fetch("WHOP_WEBHOOK_SECRET"),
    )

    Rails.logger.info("#{event[:type]} #{event[:data][:id]}")

    head :ok
  end
end
```

Mens du udvikler, så eksponér ruten over HTTPS med ngrok, Cloudflare Tunnel eller en anden tunnel.

**2. Opret webhooken i sandbox-dashboardet**

Åbn **Developer > Webhooks** i sandbox-dashboardet, og vælg derefter **Create webhook**. Indsæt HTTPS-adressen på dit endpoint, behold API-versionen på `v1`, og vælg `payment.succeeded`.

![Formularen til oprettelse af webhook, der viser hændelsen payment\_succeeded valgt på hændelseslisten](https://mintcdn.com/whop/RLIxcN4GVU-CLB5B/images/create-webhook-select-events.png?fit=max\&auto=format\&n=RLIxcN4GVU-CLB5B\&q=85\&s=079887392e21e4680a82415244aeaea4)

**3. Gem signeringshemmeligheden**

Kopiér hemmeligheden fra webhookens **Secret**-kolonne, og tilføj den til `.env` præcis som vist, inklusive `ws_`-præfikset:

```bash theme={null}
WHOP_WEBHOOK_SECRET=ws_your_secret
```

Genstart din server, så den indlæser den nye værdi.

## Betal med et testkort

Åbn `purchase_url` fra checkout-trinnet, og betal med:

| Felt | Værdi |
| - | - |
| Kortnummer | `4242 4242 4242 4242` |
| Udløbsdato | En vilkårlig fremtidig dato, f.eks. `12/34` |
| CVC | Tre vilkårlige cifre, f.eks. `123` |
| Faktureringsadresse | En vilkårlig adresse |

Inden for få sekunder logger din server `payment.succeeded` og betalings-ID'et, som starter med `pay_`.

> [!TIP]
>
> Du har modtaget en betaling og håndteret dens webhook fra ende til anden. Der blev ikke trukket noget.

For at teste et afvist kort eller 3D Secure skal du bruge de andre numre i [Testkort](https://docs.whop.com/da/developer/guides/sandbox.md#test-cards). Hvis intet ankommer, så tjek leveringsloggen på webhooken i dashboardet og [Webhook-levering](https://docs.whop.com/da/developer/troubleshooting.md#webhook-delivery).

## Gå live

Sandkasse og produktion deler intet, så at gå live betyder, at du gentager opsætningen på whop.com med produktionsoplysninger. Din kode ændrer sig ikke. Kun værdierne i dit miljø gør.

**1. Opret en produktionsnøgle**

Log ind på [whop.com](https://whop.com/start), åbn [whop.com/dashboard/developer](https://whop.com/dashboard/developer), og opret en Account API-nøgle med kun de tilladelser, din integration bruger.

**2. Byt hver værdi ud med dens produktionsmodstykke**

I dit produktionsmiljø skal du sætte alle tre variabler til produktionsværdier. Genbrug aldrig en sandbox-nøgle eller -hemmelighed i produktion, eller omvendt.

```bash Sandbox theme={null}
WHOP_ENVIRONMENT=sandbox
WHOP_API_KEY=your_sandbox_key
WHOP_WEBHOOK_SECRET=ws_your_sandbox_secret
```

```bash Production theme={null}
WHOP_ENVIRONMENT=production
WHOP_API_KEY=your_production_key
WHOP_WEBHOOK_SECRET=ws_your_production_secret
```

Hvis du kalder API'et direkte, så skift base-URL'en til `https://api.whop.com/api/v1`.

**3. Genskab det, du lavede i sandkassen**

Produkter, varianter, checkout-konfigurationer og webhooks overføres ikke. Opret produktionswebhooken mod din produktions-URL, og gem dens nye signeringshemmelighed.

**4. Fastlås din API-version**

SDK'et sender den version, det blev bygget mod. Hvis du kalder API'et direkte, så send `Api-Version-Date` på hver anmodning, så senere ændringer ikke ændrer dine svar. Se [API-versionering](https://docs.whop.com/da/developer/api/versioning.md).

> [!WARNING]
>
> Checkout-links i produktion tager rigtige penge. Tjek, hvilken nøgle du har i hånden, før du kører noget, der opretter en opkrævning eller flytter en saldo.

## Byg nu det, du kom for

> [card] [Du sælger et abonnement eller et engangsprodukt](https://docs.whop.com/da/developer/guides/accept-payments.md)
>
> Checkout-links, Checkout-elementet, varianter og prøveperioder.

> [card] [Du skylder penge til andre end dig selv](https://docs.whop.com/da/developer/platforms/manual-payouts.md)
>
> Udbetalinger, overførsler, saldi og udbetalingsportalen.

> [card] [Du tager en andel af det, andre sælger](https://docs.whop.com/da/developer/platforms/quickstart.md)
>
> Underkonti, opkrævning på deres vegne og udbetaling til dem.

> [card] [Du vil have distribution, ikke kun infrastruktur](https://docs.whop.com/da/developer/guides/app-views.md)
>
> Apps, der kører inde i Whop, med godkendelse, visninger og CLI'en.

> [card] [Dit produkt kræver, at folk taler med hinanden](https://docs.whop.com/da/developer/guides/chat/quickstart.md)
>
> Chat, DM'er og fora, du kan indlejre.

> [card] [Du vil bare læse referencen](https://docs.whop.com/da/api-reference/overview.md)
>
> Alle ressourcer i Current API, med en playground på hvert endpoint.


## Related topics

- [Whop API-oversigt](https://docs.whop.com/da/api-reference/overview.md)
- [Kernebegreber i Whop API](https://docs.whop.com/da/developer/concepts.md)
- [Whop Partners API](https://docs.whop.com/da/developer/partners/overview.md)
