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

# Godkend brugere i Whop-apps

> Verificer den aktuelle bruger, og kontrollér vedkommendes adgangsniveau i din Whop-app.

Whop-apps vises i en iframe på `whop.com`. For at finde ud af, *hvem* der sender en forespørgsel til din app, sender Whop et kortlivet JSON Web Token (JWT) i `x-whop-user-token`-headeren på hver forespørgsel fra samme oprindelse. Du verificerer dette token med SDK'et for at få et bruger-ID og kontrollerer derefter, hvad brugeren kan se.

## Verificer iframe-brugertokenet

> [!WARNING]
>
> `verifyUserToken` er ikke tilgængelig i den nuværende `@whop/sdk`, så TypeScript-eksemplerne på denne side bevares som reference og vil ikke køre, som de står. Python er anderledes: `whop-sdk` leverer hjælpefunktionen som `whop_sdk.lib.verify_user_token`, som kræver, at PyJWT er installeret ved siden af (`pip install "pyjwt[crypto]"`). `whop_sdk`-gem'en leverer den også, men som en modulfunktion under et andet rod-namespace end klienten: `WhopSDK::Helpers::VerifyUserToken.verify_user_token!`, hvor klienten er `Whop_sdk::Client`. Det er ikke en metode på klienten, og gem'en afhænger allerede af `jwt`.

Kald `verifyUserToken` på hver forespørgsel. Den læser `x-whop-user-token`-headeren, validerer JWT-signaturen og udløbstiden og returnerer bruger-ID'et. Ugyldige tokens kaster som standard en fejl. TypeScript og Python tilbyder også en variant, der ikke kaster fejl:

| Sprog | Variant uden fejlkast |
| - | - |
| TypeScript | Angiv `{ dontThrow: true }` som andet argument |
| Python | Kald `try_verify_user_token`, som returnerer `None` i stedet for at kaste en fejl |
| Ruby | Ingen. `verify_user_token!` er det eneste indgangspunkt, så fang `StandardError`. |

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

Tokenet vedhæftes kun forespørgsler til din iframes `window.location.origin`. Eksempler:

* Relativ sidenavigation: `<a href="/da/sub_page">...</a>`
* Fetch-kald uden domæne: `await fetch("/api/quizzes")`

Disse peger på dit `App.base_url`-domæne.

> [accordion] API'et ligger på et andet domæne
>
> Hvis din frontend kører på `example.com`, men dit API kører på `api.example.com`, skal du sende API-forespørgsler gennem en reverse proxy via `example.com/api`, så de bærer `x-whop-user-token`-headeren.
>
> * **Cloudflare**: Opret en ["origin rule"](https://developers.cloudflare.com/rules/origin-rules/features/#dns-record) fra `/api` på `example.com`, der omskriver til `api.example.com/api`.
>
> * **Next.js**: Tilføj en [rewrite](https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites) i `next.config.mjs`.
>
> * **nginx / Caddy**: Brug rewrite-funktionen i din serverkonfiguration.
>
> > [!NOTE]
> >
> > Denne opsætning er nødvendig på grund af browsernes strenge cookiepolitikker på tværs af oprindelser.

## Lokal opsætning

Whop leverer en lokal reverse proxy, der efterligner iframe- og cookieadfærden i produktion, så den kode, du skriver, fungerer ens på `localhost` og i produktion. Se [guiden til udviklingsproxyen](https://docs.whop.com/da/developer/guides/dev-proxy.md) for opsætning.

## Kontrollér adgang

Nu hvor du ved, hvem der sender forespørgslen, skal du kontrollere, hvad vedkommende må se. Brug metoden [`checkAccess`](https://docs.whop.com/da/api-reference/users/check-user-access) til at verificere adgang til en Experience, en konto eller et produkt.

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

### Ressource-ID'er og adgangsniveauer

| `resource_id`-præfiks | Kontrollerer adgang til |
| - | - |
| `biz_xxxx` | Konto |
| `prod_xxxx` | Produkt |
| `exp_xxxx` | Experience |

Svarets `access_level` er en af følgende:

| Niveau | Betydning |
| - | - |
| `customer` | Brugeren har et gyldigt medlemskab. For en experience har vedkommende et medlemskab af et produkt, der er forbundet med den. For et produkt, af netop det produkt. For en konto, af et hvilket som helst produkt på den. |
| `admin` | Brugeren er teammedlem på kontoen (enhver rolle, inklusive moderator). |
| `no_access` | Brugeren har ingen adgang (`has_access` er `false`). |

### Kundeapp (experience-visning)

Kundeapps bør begrænse adgangen ud fra det `experienceId`, der sendes i stiparametrene. Returner `no_access`, eller omdiriger, hvis seeren ikke har et gyldigt medlemskab.

```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>;
}
```

Det samme mønster fungerer i en API-route. Udskift `headers()` med `request.headers`, og returner en `403 Response` i stedet for JSX.

### Dashboard-app (dashboard-visning)

Dashboard-apps bør begrænse adgangen ud fra `access_level === "admin"`, så kun kontoens teammedlemmer kan indlæse visningen.

```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>;
}
```

Samme mønster i en API-route. Udskift `headers()` med `request.headers`, og returner en `403 Response` i stedet for JSX.

## Næste trin

> [card] [Kør en lokal udviklingsproxy](https://docs.whop.com/da/developer/guides/dev-proxy.md)
>
> Efterlign iframe- og cookieopsætningen fra produktion på localhost.

> [card] [Anmod om tilladelser](https://docs.whop.com/da/developer/guides/permissions.md)
>
> Tilføj de scopes, din app har brug for, før du udgiver.

> [card] [Lyt til webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Modtag hændelser for betalinger, medlemskaber og tilmeldinger på din server.

> [card] [Byg en app-visning](https://docs.whop.com/da/developer/guides/app-views.md)
>
> Opsæt dashboard-visninger, experiences og discover-opslag.
