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

> Verkoop je software op Whop. Scherm een webapp af door de toegang van elke gebruiker te controleren, of scherm downloadbare software af met licentiesleutels.

Whop verzorgt de checkout, facturering en het abonnementsbeheer voor je software. Voordat je app iemand toelaat, controleert die bij Whop of de klant op dat moment toegang heeft. Deze pagina laat de twee manieren zien om die controle uit te voeren.

## Kies je integratie

| | Toegangscontrole | Licentiesleutels |
| - | - | - |
| **Het meest geschikt voor** | Een webapp waarin gebruikers zich op je site aanmelden | Desktop-apps, scripts en tools die gebruikers downloaden |
| **Waarmee de klant wordt geïdentificeerd** | Diens Whop-gebruikers-ID, opgeslagen in je gebruikersrecord | Een licentiesleutel die Whop bij elke aankoop uitgeeft |
| **Wat je server aanroept** | `users.checkAccess` | `memberships.retrieve` en `memberships.update` |
| **Beperken tot één apparaat** | Nee | Ja, met een hardware-ID in de metadata van het lidmaatschap |

Beide routes delen dezelfde configuratie.

## Instellen

### 1. Maak je whop en een product aan

Begin op [whop.com/sell](https://whop.com/dashboard/start/) om je whop een naam te geven en de URL te kiezen. Ga daarna naar **Products** in je dashboard en voeg een product toe met de prijs die je klanten betalen. Kopieer de product-ID (`prod_`) en de bijbehorende plan-ID (`plan_`). Je hebt ze hieronder allebei nodig.

### 2. Maak een API-sleutel aan

Ga in je dashboard naar **Developer → API keys** en maak een account-API-sleutel aan. Die handelt namens je bedrijf, dus houd hem op je server en lever hem nooit mee in clientcode of een downloadbare app. Sla hem op als `WHOP_API_KEY`.

### 3. Installeer de SDK

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

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

Maak één client aan en gebruik die opnieuw. De voorbeelden op deze pagina noemen hem `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"])
```

## Integratie met e-mailaanmelding

Gebruik deze route wanneer klanten zich aanmelden bij je eigen webapp. Sla de Whop-gebruikers-ID van elke klant op in je gebruikersrecord en controleer daarmee de toegang voordat je betaalde functies aanbiedt.

### 1. Voeg Whop-kolommen toe aan je gebruikerstabel

| Kolom | Type | Beschrijving |
| - | - | - |
| `whop_user_id` | string | De Whop-gebruikers-ID van de klant, met het voorvoegsel `user_`. |
| `whop_username` | string | Optioneel. De Whop-gebruikersnaam van de klant. Toon die in je UI en logs. |

### 2. Stuur aangemelde gebruikers naar de checkout

Maak vanaf je server een checkoutconfiguratie aan en zet je eigen gebruikers-ID in `metadata`. Whop kopieert die metadata naar het lidmaatschap, en zo koppelt de volgende stap de aankoop terug aan je gebruiker. Stuur de gebruiker daarna door naar `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
```

Wil je kopers liever op je eigen pagina houden, [sluit dan het Checkout-element in](https://docs.whop.com/nl/developer/guides/embed-checkout.md) en geef dezelfde `metadata` mee op de handle. [Betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md) vergelijkt alle checkoutopties.

### 3. Sla de Whop-gebruikers-ID op vanuit de webhook

Open het [tabblad Developer in je dashboard](https://whop.com/dashboard/developer), selecteer **Create webhook**, abonneer je op `membership.activated` en sla het ondertekeningsgeheim op als `WHOP_WEBHOOK_SECRET`. De `data` van het event is het lidmaatschap, met de `user_id` van de koper en de `metadata` die je bij de checkout hebt ingesteld.

```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` wordt ook bij verlengingen verstuurd, dus zorg dat het wegschrijven veilig herhaald kan worden. [Webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md) behandelt nieuwe pogingen en testen.

### 4. Controleer de toegang voordat je betaalde functies aanbiedt

Vraag Whop of de gebruiker toegang heeft tot je product. Het antwoord houdt rekening met verlengingen, opzeggingen en terugbetalingen, dus je hoeft de factureringsstatus niet zelf bij te houden.

```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` in hetzelfde antwoord is `customer`, `admin` of `no_access`.

### 5. Laat klanten hun facturering beheren

Verwijs klanten naar hun [Whop-bestellingen](https://whop.com/@me/settings/orders) om hun betaalmethode bij te werken of op te zeggen. Ze melden zich aan met het e-mailadres waarmee ze hebben gekocht.

## Integratie met licentiesleutels

Gebruik deze route voor software die op het apparaat van de klant draait. Bij elke aankoop hoort een unieke licentiesleutel. Je software vraagt om de sleutel, en je server controleert die bij Whop.

### 1. Voeg de app Software toe aan je product

[Installeer de app Software](https://whop.com/apps/app_jHH5YT7jHYQANi/install/) in je whop, open die en voeg de naam en downloadlink van je software toe. Kopers zien dan hun licentiesleutel en de download in hun bestellingen. De API retourneert de `license_key` van een lidmaatschap alleen wanneer het product deze app bevat.

### 2. Valideer sleutels vanaf je server

Controleer sleutels vanaf je eigen server, nooit vanuit de software die je levert. Je API-sleutel kan elk lidmaatschap in je bedrijf lezen en wijzigen, dus sluit hem nooit in een desktop-app of script in dat gebruikers downloaden. Je software stuurt de licentiesleutel en een apparaat-ID naar je server, en je server controleert die bij Whop.

Om elke sleutel tot één apparaat te beperken, sla je een hardware-ID op in de metadata van het lidmaatschap wanneer iemand de sleutel voor het eerst gebruikt, en vergelijk je die bij elke volgende controle:

* **De sleutel is nog niet gekoppeld** (geen `hwid` in de metadata): sla de `hwid` van het apparaat op en verleen toegang.
* **De opgeslagen `hwid` komt overeen:** verleen toegang.
* **De opgeslagen `hwid` is anders:** weiger toegang. De sleutel is in gebruik op een ander apparaat totdat de klant hem reset.

```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. Reset een licentiesleutel

Klanten kunnen hun sleutel resetten vanuit hun bestellingen. Om hem vanaf je server te resetten, [werk je het lidmaatschap bij](https://docs.whop.com/nl/api-reference/memberships/update-membership.md) met een leeg metadata-object (`metadata: {}`). De volgende controle vanaf een willekeurig apparaat koppelt de sleutel opnieuw.

## Ontwerp je winkelpagina

Op je winkelpagina komen mensen meer te weten over je software voordat ze kopen. Selecteer de naam van je whop linksboven en selecteer daarna **Design store page** om de editor te openen. Selecteer **Edit details** om het volgende aan te passen:

* **Naam en kopregel:** vertel wat de software doet en voor wie die is.
* **Beschrijving:** focus op het probleem dat de software oplost en wat kopers krijgen, zoals updates, support of een community.
* **Logo:** voeg een strak, eenvoudig logo toe.
* **Galerijafbeeldingen of video:** laat de software in gebruik zien. Een korte demovideo helpt kopers een beslissing te nemen.
* **Categorie:** kies de categorie waarmee mensen je software vinden wanneer ze op Whop rondkijken.

## Volgende stappen

> [card] [Betalingen accepteren](https://docs.whop.com/nl/developer/guides/accept-payments.md)
>
> Vergelijk checkoutlinks, het Checkout-element en payment elements.

> [card] [Webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md)
>
> Verifieer handtekeningen, handel nieuwe pogingen af en test events.

> [card] [Lidmaatschappen beheren](https://docs.whop.com/nl/developer/guides/memberships.md)
>
> Zeg lidmaatschappen op, pauzeer, verleng en werk ze bij vanaf je server.

> [card] [Aanmelden met Whop](https://docs.whop.com/nl/developer/guides/oauth.md)
>
> Laat klanten zich aanmelden met hun Whop-account in plaats van met een wachtwoord.


## Related topics

- [Aan de slag met Whop](https://docs.whop.com/nl/get-started.md)
- [Wat zijn Whop-apps](https://docs.whop.com/nl/whop-apps/what-are-whop-apps.md)
