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

# SaaS

> Sælg din software på Whop. Beskyt en webapp ved at tjekke hver brugers adgang, eller beskyt software, der kan downloades, med licensnøgler.

Whop håndterer checkout, fakturering og abonnementsstyring for din software. Før din app lukker nogen ind, tjekker den hos Whop, at kunden har adgang lige nu. Denne side viser de to måder at udføre det tjek på.

## Vælg din integration

| | Adgangstjek | Licensnøgler |
| - | - | - |
| **Bedst til** | En webapp, hvor brugerne logger ind på dit website | Desktopapps, scripts og værktøjer, som brugerne downloader |
| **Hvad identificerer kunden** | Deres Whop-bruger-ID, gemt på din brugerpost | En licensnøgle, som Whop udsteder ved hvert køb |
| **Hvad din server kalder** | `users.checkAccess` | `memberships.retrieve` og `memberships.update` |
| **Begræns til én maskine** | Nej | Ja, med et hardware-ID i medlemskabets metadata |

Begge veje deler den samme opsætning.

## Opsætning

### 1. Opret din whop og et produkt

Start på [whop.com/sell](https://whop.com/dashboard/start/) for at give din whop et navn og vælge dens URL. Gå derefter til **Products** i dit dashboard, og tilføj et produkt med den pris, dine kunder betaler. Kopiér produkt-ID'et (`prod_`) og dets plan-ID (`plan_`). Du skal bruge begge nedenfor.

### 2. Opret en API-nøgle

I dit dashboard skal du gå til **Developer → API keys** og oprette en API-nøgle til kontoen. Den handler på vegne af din virksomhed, så hold den på din server, og send den aldrig med i klientkode eller en app, der kan downloades. Gem den som `WHOP_API_KEY`.

### 3. Installér SDK'et

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

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

Opret én klient, og genbrug den. Eksemplerne på denne side kalder den `client`.

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

export const client = new WhopClient({ token: process.env.WHOP_API_KEY });
```

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

from whop_sdk import Whop

client = Whop(token=os.environ["WHOP_API_KEY"])
```

## Integration med e-mail-login

Brug denne vej, når kunderne logger ind på din egen webapp. Gem hver kundes Whop-bruger-ID på din brugerpost, og tjek derefter adgangen med det, før du leverer betalte funktioner.

### 1. Tilføj Whop-kolonner til din brugertabel

| Kolonne | Type | Beskrivelse |
| - | - | - |
| `whop_user_id` | string | Kundens Whop-bruger-ID med præfikset `user_`. |
| `whop_username` | string | Valgfrit. Kundens Whop-brugernavn. Vis det i din brugerflade og dine logs. |

### 2. Send indloggede brugere til checkout

Opret en checkout-konfiguration fra din server, og læg dit eget bruger-ID i `metadata`. Whop kopierer disse metadata over på medlemskabet, og det er sådan, næste trin knytter købet til din bruger. Omdirigér derefter brugeren til `purchase_url`.

```typescript TypeScript theme={null}
export async function startCheckout(userId: string) {
  const checkout = await client.checkoutConfigurations.create({
    variant_id: process.env.WHOP_VARIANT_ID!,
    metadata: { customer_id: userId },
    redirect_url: "https://yourapp.com/billing/return",
  });

  return checkout.purchase_url;
}
```

```python Python theme={null}
def start_checkout(user_id: str) -> str:
    checkout = client.checkout_configurations.create(
        variant_id=os.environ["WHOP_VARIANT_ID"],
        metadata={"customer_id": user_id},
        redirect_url="https://yourapp.com/billing/return",
    )

    return checkout.purchase_url
```

For i stedet at holde køberne på din egen side kan du [indlejre Checkout-elementet](https://docs.whop.com/da/developer/guides/embed-checkout.md) og sende de samme `metadata` med på dets handle. [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md) sammenligner alle checkout-muligheder.

### 3. Gem Whop-bruger-ID'et fra webhooket

Åbn [fanen Developer i dit dashboard](https://whop.com/dashboard/developer), vælg **Create webhook**, abonnér på `membership.activated`, og gem signeringshemmeligheden som `WHOP_WEBHOOK_SECRET`. Hændelsens `data` er medlemskabet med køberens `user_id` og de `metadata`, du angav ved checkout.

```typescript TypeScript theme={null}
// app/api/webhooks/whop/route.ts
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
  // Verify the raw body. Parsing it first changes the bytes and the signature check fails.
  const event = unwrapWebhook(await request.text(), {
    headers: Object.fromEntries(request.headers),
    key: process.env.WHOP_WEBHOOK_SECRET!,
  });

  if (event.type === "membership.activated") {
    const customerId = event.data.metadata?.customer_id;
    if (customerId && event.data.user_id) {
      await db.users.update(customerId, { whop_user_id: event.data.user_id });
    }
  }

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

```python Python 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):
    # Verify the raw body. Parsing it first changes the bytes and the signature check fails.
    event = unwrap(await request.body(), dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "membership.activated":
        membership = event["data"]
        customer_id = (membership.get("metadata") or {}).get("customer_id")
        if customer_id and membership.get("user_id"):
            db.users.update(customer_id, whop_user_id=membership["user_id"])

    return Response(status_code=200)
```

`membership.activated` udløses også ved fornyelser, så sørg for, at skrivningen er sikker at gentage. [Webhooks](https://docs.whop.com/da/developer/guides/webhooks.md) dækker genforsøg og test.

### 4. Tjek adgang, før du leverer betalte funktioner

Spørg Whop, om brugeren har adgang til dit produkt. Svaret følger fornyelser, opsigelser og refusioner, så du ikke selv behøver at holde styr på faktureringsstatus.

```typescript TypeScript theme={null}
export async function hasAccess(whopUserId: string) {
  const access = await client.users.checkAccess({
    id: whopUserId,
    resource_id: process.env.WHOP_PRODUCT_ID!,
  });

  return access.has_access;
}
```

```python Python theme={null}
def has_access(whop_user_id: str) -> bool:
    access = client.users.check_access(
        resource_id=os.environ["WHOP_PRODUCT_ID"],
        id=whop_user_id,
    )

    return access.has_access
```

`access_level` i det samme svar er `customer`, `admin` eller `no_access`.

### 5. Lad kunderne administrere fakturering

Link kunderne til deres [Whop-ordrer](https://whop.com/@me/settings/orders), så de kan opdatere deres betalingsmetode eller opsige. De logger ind med den e-mail, de købte med.

## Integration med licensnøgler

Brug denne vej til software, der kører på kundens maskine. Hvert køb leveres med en unik licensnøgle. Din software beder om nøglen, og din server tjekker den hos Whop.

### 1. Tilføj appen Software til dit produkt

[Installér appen Software](https://whop.com/apps/app_jHH5YT7jHYQANi/install/) på din whop, åbn den, og tilføj din softwares navn og downloadlink. Køberne ser derefter deres licensnøgle og downloaden i deres ordrer. API'et returnerer kun et medlemskabs `license_key`, når dets produkt indeholder denne app.

### 2. Validér nøgler fra din server

Tjek nøgler fra din egen server, aldrig fra den software, du udgiver. Din API-nøgle kan læse og ændre alle medlemskaber i din virksomhed, så indlejr den aldrig i en desktopapp eller et script, som brugerne downloader. Din software sender licensnøglen og en maskinidentifikator til din server, og din server tjekker den hos Whop.

For at begrænse hver nøgle til én maskine skal du gemme et hardware-ID i medlemskabets metadata, første gang nogen bruger nøglen, og derefter sammenligne det ved hvert senere tjek:

* **Nøglen er ikke bundet endnu** (intet `hwid` i dens metadata): gem maskinens `hwid`, og giv adgang.
* **Det gemte `hwid` matcher:** giv adgang.
* **Det gemte `hwid` er anderledes:** afvis adgang. Nøglen er i brug på en anden maskine, indtil kunden nulstiller den.

```typescript TypeScript theme={null}
// Add "past_due" if you let customers keep access while Whop retries a failed renewal.
const VALID_STATUSES = ["active", "trialing", "completed"];

export async function validateLicense(licenseKey: string, hwid: string) {
  // Retrieve accepts a license key in place of a membership ID. An unknown key throws a 404 error.
  const membership = await client.memberships.retrieve({ id: licenseKey });

  if (!VALID_STATUSES.includes(membership.status)) {
    return { valid: false, reason: "membership_inactive" };
  }

  const boundHwid = membership.metadata?.hwid;

  if (!boundHwid) {
    // Update merges these keys into the existing metadata.
    await client.memberships.update({ id: membership.id, metadata: { hwid } });
    return { valid: true };
  }

  if (boundHwid !== hwid) {
    return { valid: false, reason: "bound_to_another_machine" };
  }

  return { valid: true };
}
```

```python Python theme={null}
# Add "past_due" if you let customers keep access while Whop retries a failed renewal.
VALID_STATUSES = {"active", "trialing", "completed"}


def validate_license(license_key: str, hwid: str) -> dict:
    # Retrieve accepts a license key in place of a membership ID. An unknown key raises a 404 error.
    membership = client.memberships.retrieve(license_key)

    if membership.status not in VALID_STATUSES:
        return {"valid": False, "reason": "membership_inactive"}

    bound_hwid = (membership.metadata or {}).get("hwid")

    if not bound_hwid:
        # Update merges these keys into the existing metadata.
        client.memberships.update(membership.id, metadata={"hwid": hwid})
        return {"valid": True}

    if bound_hwid != hwid:
        return {"valid": False, "reason": "bound_to_another_machine"}

    return {"valid": True}
```

### 3. Nulstil en licensnøgle

Kunderne kan nulstille deres nøgle fra deres ordrer. For at nulstille den fra din server skal du [opdatere medlemskabet](https://docs.whop.com/da/api-reference/memberships/update-membership.md) med et tomt metadata-objekt (`metadata: {}`). Det næste tjek fra en hvilken som helst maskine binder nøglen igen.

## Design din butiksside

Din butiksside er der, hvor folk lærer om din software, før de køber. Vælg navnet på din whop øverst til venstre, og vælg derefter **Design store page** for at åbne editoren. Vælg **Edit details** for at tilpasse:

* **Navn og overskrift:** fortæl, hvad softwaren gør, og hvem den er til.
* **Beskrivelse:** fokuser på det problem, den løser, og hvad køberne får, såsom opdateringer, support eller et fællesskab.
* **Logo:** tilføj et rent, simpelt logo.
* **Galleribilleder eller video:** vis softwaren i brug. En kort demovideo hjælper køberne med at beslutte sig.
* **Kategori:** vælg den kategori, der hjælper folk med at finde din software, når de gennemser Whop.

## Næste trin

> [card] [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
>
> Sammenlign checkout-links, Checkout-elementet og betalingselementer.

> [card] [Webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Verificér signaturer, håndtér genforsøg, og test hændelser.

> [card] [Administrer medlemskaber](https://docs.whop.com/da/developer/guides/memberships.md)
>
> Opsig, sæt på pause, forlæng og opdater medlemskaber fra din server.

> [card] [Log ind med Whop](https://docs.whop.com/da/developer/guides/oauth.md)
>
> Lad kunderne logge ind med deres Whop-konto i stedet for en adgangskode.


## Related topics

- [Kom i gang med Whop](https://docs.whop.com/da/get-started.md)
- [Hvad er Whop-apps](https://docs.whop.com/da/whop-apps/what-are-whop-apps.md)
