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

# OAuth

> Tilføj "Sign in with Whop" til dit website med OAuth 2.1 og Proof Key for Code Exchange (PKCE).

Brug OAuth 2.1 + PKCE med OpenID Connect (OIDC) til at lade brugere logge ind med Whop på dit website eller i din app. De returnerede adgangstokens giver dig adgang til data og lader dig handle på vegne af disse brugere.

> [!NOTE]
>
> OAuth-endpoints findes på `https://api.whop.com/oauth/`.

## Trin 1: Opret din OAuth-app

> [!WARNING]
>
> `App`-objektet, som `apps.create` returnerer i den nuværende `@whop/sdk`, eksponerer ikke et `client_secret`-felt. Kopiér i stedet klienthemmeligheden fra fanen Dashboard.

> [tab] API
>
> Brug endpointet [Create App](https://docs.whop.com/da/api-reference/apps/create-app.md) til at oprette en OAuth-app programmatisk:
>
> ```typescript theme={null}
> import { WhopClient } from "@whop/sdk";
>
> const client = new WhopClient({ token: process.env.WHOP_API_KEY });
>
> const app = await client.apps.create({
>   name: "My App",
>   redirect_uris: [
>     "http://localhost:3000/api/auth/callback/whop",
>     "https://myapp.com/api/auth/callback/whop"
>   ],
> });
>
> console.log(app.id);            // NEXT_PUBLIC_WHOP_APP_ID
> console.log(app.client_secret); // WHOP_CLIENT_SECRET
> ```
>
> Opdater redirect-URI'er senere med endpointet [Update App](https://docs.whop.com/da/api-reference/apps/update-app.md).

> [tab] Dashboard
>
> **1. Opret eller vælg din app**
>
> Gå til [Developer Dashboard](https://whop.com/dashboard/developer), og opret en ny app, eller vælg en eksisterende.
>
> **2. Tilføj redirect-URI'er**
>
> Tilføj i OAuth-sektionen alle de redirect-URI'er, du planlægger at bruge (skal matche præcist).
>
> **3. Kopiér legitimationsoplysninger**
>
> Kopiér dit `client_id` (ligner `app_xxxxx`) og `client_secret`.
>
> **4. Vælg dine scopes**
>
> Vælg dine tilgængelige OAuth-scopes via knappen "View available scopes", og vælg kun dem, du har brug for.

## Trin 2: Send brugere til godkendelse

Brug PKCE i din web- eller mobilklient til sikkert at omdirigere brugere til Whops OAuth-forløb.

```typescript expandable theme={null}
const STORAGE_KEY = "whop_oauth_pkce";

function base64url(bytes: Uint8Array) {
	return btoa(String.fromCharCode(...bytes)).replace(
		/[+/=]/g,
		(c) => ({ "+": "-", "/": "_", "=": "" })[c]!,
	);
}

function randomString(len: number) {
	return base64url(crypto.getRandomValues(new Uint8Array(len)));
}

async function sha256(str: string) {
	return base64url(
		new Uint8Array(
			await crypto.subtle.digest("SHA-256", new TextEncoder().encode(str)),
		),
	);
}

async function startWhopOAuth(
	clientId: string,
	redirectUri: string,
	scope = "openid profile email",
	accountId?: string,
) {
	const pkce = {
		codeVerifier: randomString(32),
		state: randomString(16),
		nonce: randomString(16),
	};
	sessionStorage.setItem(STORAGE_KEY, JSON.stringify(pkce));

	const params = new URLSearchParams({
		response_type: "code",
		client_id: clientId,
		redirect_uri: redirectUri,
		scope,
		state: pkce.state,
		nonce: pkce.nonce,
		code_challenge: await sha256(pkce.codeVerifier),
		code_challenge_method: "S256",
		...(accountId && { company_id: accountId }),
	});

	window.location.href = `https://api.whop.com/oauth/authorize?${params}`;
}
```

Kald `startWhopOAuth` for at omdirigere brugeren:

```typescript theme={null}
await startWhopOAuth(
	"app_xxxxxxxxx",
	"https://yourapp.com/oauth/callback",
	"openid profile email", // optionally specify more custom scopes here
	"biz_xxxxx", // optionally specify a scoped account id here
);
```

Hvis brugeren ikke er logget ind, beder Whop om login og viser derefter samtykkeskærmen.
Hvis brugeren allerede har godkendt din applikation til de anmodede scopes,
omdirigeres vedkommende automatisk tilbage uden at skulle bekræfte to gange.

> [!NOTE]
>
> Hvis du sender et konto-ID som `company_id`, er tokens afgrænset til den konto
> for brugeren. Du kan kun få adgang til de ressourcer, som brugeren kan styre på
> den Whop-konto.

## Trin 3: Håndter callbacket, og byt koden

Whop omdirigerer tilbage til din `redirect_uri` med `code` og `state`. Brug denne funktion til at verificere state, bytte koden til tokens og hente legitimationsoplysninger:

```typescript expandable theme={null}
const STORAGE_KEY = "whop_oauth_pkce";

interface WhopTokens {
	access_token: string;
	refresh_token: string;
	id_token?: string; // only present if "openid" scope was requested
	token_type: string;
	expires_in: number;
	obtained_at: number; // we add this client-side for refresh logic
}

async function handleWhopCallback(
	clientId: string,
	redirectUri: string,
): Promise<WhopTokens> {
	const params = new URLSearchParams(window.location.search);
	const [code, returnedState, error] = [
		params.get("code"),
		params.get("state"),
		params.get("error"),
	];
	if (error)
		throw new Error(
			`OAuth error: ${error} - ${params.get("error_description") || ""}`,
		);

	const stored = JSON.parse(sessionStorage.getItem(STORAGE_KEY) || "null");
	sessionStorage.removeItem(STORAGE_KEY);
	if (!stored || returnedState !== stored.state)
		throw new Error("Invalid state - possible CSRF");

	const res = await fetch("https://api.whop.com/oauth/token", {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify({
			grant_type: "authorization_code",
			code,
			redirect_uri: redirectUri,
			client_id: clientId,
			code_verifier: stored.codeVerifier,
		}),
	});

	if (!res.ok) {
		const err = await res.json().catch(() => ({}));
		throw new Error(
			`Token exchange failed: ${err.error_description || res.status}`,
		);
	}

	const tokens = await res.json();
	return { ...tokens, obtained_at: Date.now() };
}

function storeTokens(tokens: WhopTokens) {
	document.cookie = `whop_tokens=${encodeURIComponent(JSON.stringify(tokens))}; path=/; max-age=${60 * 60 * 24 * 30}; secure; samesite=strict`;
}

function getTokens(): WhopTokens | null {
	const match = document.cookie.match(/whop_tokens=([^;]+)/);
	return match ? JSON.parse(decodeURIComponent(match[1])) : null;
}

function clearTokens() {
	document.cookie = "whop_tokens=; path=/; max-age=0";
}
```

På din callback-side:

```typescript theme={null}
const tokens = await handleWhopCallback(
	"app_xxxxxxxxx",
	"https://yourapp.com/oauth/callback",
);
storeTokens(tokens);
```

## Trin 4: Brug tokens

Initialiser Whop SDK'et med brugerens adgangstoken:

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

const tokens = getTokens();

const client = new WhopClient({
	token: tokens.access_token,
});
```

Se [API-referencen](https://docs.whop.com/da/api-reference/overview.md) for alle tilgængelige endpoints.

## Trin 5: Forny tokens

Adgangstokens udløber efter 1 time. Brug refresh-tokenet til at få nye legitimationsoplysninger:

```typescript expandable theme={null}
async function refreshTokens(
	clientId: string,
	accountId?: string,
): Promise<WhopTokens> {
	const tokens = getTokens();
	if (!tokens?.refresh_token) throw new Error("No refresh token available");

	const res = await fetch("https://api.whop.com/oauth/token", {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify({
			grant_type: "refresh_token",
			refresh_token: tokens.refresh_token,
			client_id: clientId,
			...(accountId && { company_id: accountId }),
		}),
	});

	if (!res.ok) {
		const error = await res.json().catch(() => ({}));
		if (res.status === 401 || error.error === "invalid_grant") {
			clearTokens();
			throw new Error("Session expired - please log in again");
		}
		throw new Error(
			`Token refresh failed: ${error.error_description || res.status}`,
		);
	}

	const newTokens = await res.json();
	const stored = { ...newTokens, obtained_at: Date.now() };
	storeTokens(stored);
	return stored;
}

async function getValidAccessToken(clientId: string): Promise<string> {
	const tokens = getTokens();
	if (!tokens) throw new Error("Not logged in");

	const expiresAt = tokens.obtained_at + tokens.expires_in * 1000;
	const needsRefresh = Date.now() > expiresAt - 5 * 60 * 1000; // 5 min buffer

	if (needsRefresh) {
		const refreshed = await refreshTokens(clientId);
		return refreshed.access_token;
	}

	return tokens.access_token;
}
```

Brug:

```typescript theme={null}
const accessToken = await getValidAccessToken("app_xxxxxxxxx");
```

> [!NOTE]
>
> Refresh-tokens roteres ved hver brug. Gem altid de nye tokens, der returneres fra
> refresh-endpointet. Hvis du angav `company_id` under godkendelsen, skal du
> angive det samme `company_id`, når du fornyer.

## Trin 6: Userinfo og tilbagekaldelse

### Hent brugeroplysninger

Hent den godkendte brugers profil via userinfo-endpointet:

```typescript theme={null}
interface WhopUserInfo {
	sub: string; // user tag (e.g. "user_xxxxx")
	name?: string; // requires "profile" scope
	preferred_username?: string; // requires "profile" scope
	picture?: string; // requires "profile" scope
	email?: string; // requires "email" scope
	email_verified?: boolean; // requires "email" scope
}

async function getUserInfo(accessToken: string): Promise<WhopUserInfo> {
	const res = await fetch("https://api.whop.com/oauth/userinfo", {
		headers: { Authorization: `Bearer ${accessToken}` },
	});
	if (!res.ok) throw new Error(`Failed to fetch user info: ${res.status}`);
	return res.json();
}
```

> [!NOTE]
>
> De returnerede felter afhænger af de givne scopes. `openid` er påkrævet,
> `profile` tilføjer navn/brugernavn/billede, `email` tilføjer e-mailfelter.

### Tilbagekald tokens ved logout

Når en bruger logger ud, skal du tilbagekalde vedkommendes refresh-token. Adgangstokens udløber efter 1 time og kan ikke tilbagekaldes på serveren.

```typescript theme={null}
async function logout(clientId: string) {
	const tokens = getTokens();
	if (tokens?.refresh_token) {
		await fetch("https://api.whop.com/oauth/revoke", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({
				token: tokens.refresh_token,
				client_id: clientId,
			}),
		});
	}
	clearTokens();
}
```

> [!WARNING]
>
> Tilbagekald altid tokens, når brugere logger ud. Det ugyldiggør refresh-tokenet
> med det samme og forhindrer uautoriseret adgang, selv hvis tokenet er kompromitteret.

## Fejlhåndtering

OAuth-fejl følger standardformatet:

```json theme={null}
{
	"error": "invalid_grant",
	"error_description": "Authorization code has expired"
}
```

Almindelige fejlkoder:

* `invalid_request`: manglende eller ugyldig parameter.
* `invalid_grant`: kode eller token er udløbet eller tilbagekaldt.
* `invalid_client`: ukendt `client_id`.
* `insufficient_scope`: tokenet har ikke det påkrævede scope.
* `rate_limit_exceeded`: for mange requests (tjek headeren `Retry-After`).

## Næste trin

> [card] [API-reference](https://docs.whop.com/da/api-reference.md)
>
> Alle endpoints, et givet adgangstoken kan kalde.

> [card] [Modtag betalinger](https://docs.whop.com/da/developer/guides/accept-payments.md)
>
> Kombiner login med checkout for komplette købsforløb.

> [card] [Lyt til webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Reager på events for betalinger, medlemskaber og tilmeldinger på serversiden.

> [card] [Anmod om tilladelser](https://docs.whop.com/da/developer/guides/permissions.md)
>
> Konfigurer de OAuth-scopes, din app rent faktisk har brug for.


## Related topics

- [Godkendelse til chat](https://docs.whop.com/da/developer/guides/chat/authentication.md)
- [List OAuth Grants](https://docs.whop.com/da/api-reference/users/list-oauth-grants.md)
- [OAuth til chat](https://docs.whop.com/da/developer/guides/chat/oauth.md)
