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

# Gebruikers authenticeren in Whop-apps

> Verifieer de huidige gebruiker en controleer diens toegangsniveau in je Whop-app.

Whop-apps worden weergegeven in een iframe op `whop.com`. Om te bepalen *wie* een request naar je app doet, geeft Whop bij elk same-origin-request een kortlevende JSON Web Token (JWT) mee in de header `x-whop-user-token`. Je verifieert dit token met de SDK om een gebruikers-ID te krijgen en controleert daarna wat die gebruiker mag zien.

## Het iframe-gebruikerstoken verifiëren

> [!WARNING]
>
> `verifyUserToken` is niet beschikbaar in de huidige `@whop/sdk`, dus de TypeScript-fragmenten op deze pagina zijn ter referentie bewaard en werken niet zoals ze er staan. Bij Python ligt dat anders: `whop-sdk` levert de helper als `whop_sdk.lib.verify_user_token`, waarvoor PyJWT ernaast geïnstalleerd moet zijn (`pip install "pyjwt[crypto]"`). De `whop_sdk`-gem levert hem ook, maar als modulefunctie onder een andere root-namespace dan de client: `WhopSDK::Helpers::VerifyUserToken.verify_user_token!`, terwijl de client `Whop_sdk::Client` is. Het is geen methode van de client, en de gem is al afhankelijk van `jwt`.

Roep `verifyUserToken` bij elk request aan. De functie leest de header `x-whop-user-token`, valideert de handtekening en vervaldatum van de JWT en retourneert de gebruikers-ID. Ongeldige tokens geven standaard een fout. TypeScript en Python bieden ook een variant die geen fout gooit:

| Taal | Variant zonder fout |
| - | - |
| TypeScript | Geef `{ dontThrow: true }` mee als tweede argument |
| Python | Roep `try_verify_user_token` aan, dat `None` retourneert in plaats van een fout te gooien |
| Ruby | Geen. `verify_user_token!` is het enige toegangspunt, dus vang `StandardError` af met rescue. |

```typescript JS/TS + NextJS theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function MyServerRenderedPage() {
	const { userId } = await whopsdk.verifyUserToken(await headers());

    // ... the rest of your component / api route etc...
}
```

```javascript JS/TS + ExpressJS theme={null}
import express from "express";
import { whopsdk } from "./lib/whop-sdk";

const app = express();

app.get("/my-route", async (req, res) => {
    const { userId } = await whopsdk.verifyUserToken(req.headers);

    // ... the rest of your route handler
});
```

```python Python + FastAPI theme={null}
from fastapi import FastAPI, Request
from whop_sdk.lib.verify_user_token import verify_user_token

app = FastAPI()

@app.get("/my-route")
async def my_route(request: Request):
    # Synchronous, and app_id is required: it is checked against the token's audience.
    result = verify_user_token(request.headers, app_id="app_xxxxxxxxxxxxx")
    user_id = result.user_id

    # ... the rest of your route handler
```

```ruby Ruby on Rails theme={null}
class MyController < ApplicationController
  def my_action
    # Give the helper a token string or a plain Hash, not an ActionDispatch headers object.
    # app_id is optional in Ruby. Pass it to check the token's audience.
    auth_result = WhopSDK::Helpers::VerifyUserToken.verify_user_token!(
      request.headers["x-whop-user-token"],
      app_id: "app_xxxxxxxxxxxxx",
    )
    user_id = auth_result.user_id

    # ... the rest of your controller action
  end
end
```

Het token wordt alleen meegestuurd met requests naar de `window.location.origin` van je iframe. Voorbeelden:

* Relatieve paginanavigatie: `<a href="/nl/sub_page">...</a>`
* Fetches zonder domein: `await fetch("/api/quizzes")`

Deze worden herleid naar je `App.base_url`-domein.

> [accordion] De API staat op een ander domein
>
> Als je frontend op `example.com` draait maar je API op `api.example.com`, stuur API-requests dan via een reverse proxy door `example.com/api`, zodat ze de header `x-whop-user-token` bevatten.
>
> * **Cloudflare**: maak een ["origin rule"](https://developers.cloudflare.com/rules/origin-rules/features/#dns-record) die `/api` op `example.com` herschrijft naar `api.example.com/api`.
>
> * **Next.js**: voeg een [rewrite](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites) toe in `next.config.mjs`.
>
> * **nginx / Caddy**: gebruik de rewrite-functie in je serverconfiguratie.
>
> > [!NOTE]
> >
> > Deze setup is nodig vanwege het strikte cross-origin-cookiebeleid van browsers.

## Lokale setup

Whop levert een lokale reverse proxy die het iframe- en cookiegedrag van productie nabootst, zodat de code die je schrijft precies hetzelfde werkt op `localhost` als in productie. Zie de [gids voor de development proxy](https://docs.whop.com/nl/developer/guides/dev-proxy.md) voor de setup.

## Toegang controleren

Nu je weet wie het request doet, controleer je wat die persoon mag zien. Gebruik de methode [`checkAccess`](https://docs.whop.com/nl/api-reference/users/check-user-access) om de toegang tot een Experience, Account of Product te verifiëren.

```typescript JS/TS theme={null}
import { whopsdk } from "@/lib/whop-sdk";

const response = await whopsdk.users.checkAccess({
    id: "user_xxxxxxxxxxxxx",
    resource_id: "resource_id",
});

// Response:
// {
//   "has_access": true,
//   "access_level": "customer"
// }
```

```python Python theme={null}
response = whopsdk.users.check_access(
    resource_id="resource_id",
    id="user_xxxxxxxxxxxxx",
)

# Response:
# {
#   "has_access": True,
#   "access_level": "customer"
# }
```

```ruby Ruby theme={null}
response = whopsdk.users.check_access(
  resource_id: "resource_id",
  id: "user_xxxxxxxxxxxxx",
)

# Response:
# {
#   "has_access": true,
#   "access_level": "customer"
# }
```

```rust Rust theme={null}
let response = client
    .users
    .check_access(&"user_xxxxxxxxxxxxx".to_string(), &"resource_id".to_string(), None)
    .await?;

println!("{} {}", response.has_access, response.access_level);
// has_access => true, access_level => "customer"
```

```go Go theme={null}
response, err := client.Users.CheckAccess(context.TODO(), &whopsdk.CheckAccessUsersRequest{
    ID:         "user_xxxxxxxxxxxxx",
    ResourceID: "resource_id",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(response.HasAccess, response.AccessLevel)
// has_access => true, access_level => "customer"
```

```bash cURL theme={null}
curl --request GET \
  --url https://api.whop.com/api/v1/users/{id}/access/{resource_id} \
  --header 'Authorization: Bearer <token>'
```

### Resource-ID's en toegangsniveaus

| Voorvoegsel `resource_id` | Controleert toegang tot |
| - | - |
| `biz_xxxx` | Account |
| `prod_xxxx` | Product |
| `exp_xxxx` | Experience |

De `access_level` in de response is een van de volgende:

| Niveau | Betekenis |
| - | - |
| `customer` | De gebruiker heeft een geldig lidmaatschap. Bij een experience heeft de gebruiker een lidmaatschap voor een product dat eraan is gekoppeld. Bij een product voor dat specifieke product. Bij een account voor een product binnen dat account. |
| `admin` | De gebruiker is teamlid van het account (elke rol, inclusief moderator). |
| `no_access` | De gebruiker heeft geen toegang (`has_access` is `false`). |

### Klantapp (experience-weergave)

Klantapps moeten de toegang afschermen op basis van de `experienceId` die in de padparameters wordt meegegeven. Retourneer `no_access` of stuur door als de bezoeker geen geldig lidmaatschap heeft.

```typescript theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function ExperiencePage({
    params,
}: {
    params: Promise<{ experienceId: string }>;
}) {
    const { experienceId } = await params;
    const { userId } = await whopsdk.verifyUserToken(await headers());

    const access = await whopsdk.users.checkAccess({
        id: userId,
        resource_id: experienceId,
    });

    if (!access.has_access) {
        return <div>Access denied</div>;
    }

    return <div>Welcome to the experience!</div>;
}
```

Hetzelfde patroon werkt in een API-route. Vervang `headers()` door `request.headers` en retourneer een `403 Response` in plaats van JSX.

### Dashboardapp (dashboardweergave)

Dashboardapps moeten de toegang afschermen op `access_level === "admin"`, zodat alleen teamleden van het account de weergave kunnen laden.

```typescript theme={null}
import { headers } from "next/headers";
import { whopsdk } from "@/lib/whop-sdk";

export default async function DashboardPage({
    params,
}: {
    params: Promise<{ companyId: string }>;
}) {
    const { companyId } = await params;
    const { userId } = await whopsdk.verifyUserToken(await headers());

    const access = await whopsdk.users.checkAccess({
        id: userId,
        resource_id: companyId,
    });

    if (access.access_level !== "admin") {
        return <div>Admin access required</div>;
    }

    return <div>Welcome to the dashboard!</div>;
}
```

Hetzelfde patroon in een API-route. Vervang `headers()` door `request.headers` en retourneer een `403 Response` in plaats van JSX.

## Volgende stappen

> [card] [Een lokale development proxy draaien](https://docs.whop.com/nl/developer/guides/dev-proxy.md)
>
> Boots de iframe- en cookiesetup van productie na op localhost.

> [card] [Permissies aanvragen](https://docs.whop.com/nl/developer/guides/permissions.md)
>
> Voeg de scopes toe die je app nodig heeft voordat je publiceert.

> [card] [Naar webhooks luisteren](https://docs.whop.com/nl/developer/guides/webhooks.md)
>
> Ontvang events voor betalingen, lidmaatschappen en entries op je server.

> [card] [Een app-weergave bouwen](https://docs.whop.com/nl/developer/guides/app-views.md)
>
> Stel dashboardweergaven, experiences en Discover-vermeldingen in.


## Related topics

- [Whop-apps bouwen](https://docs.whop.com/nl/developer/apps/overview.md)
- [Whop-apps bouwen met React Native](https://docs.whop.com/nl/developer/guides/react-native.md)
- [App-weergaven](https://docs.whop.com/nl/developer/guides/app-views.md)
