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

# Quickstart til chat

> Tilføj Whop-chat til din web- eller iOS-app, fra oprettelse af en API-nøgle til visning af din første samtale.

[Indlejr Whop-chat i din app](https://www.youtube.com/embed/MqgyFg9YyCw?rel=0)

1
Opret en API-nøgle

Opret en API-nøgle i [Whop Developer Dashboard](https://whop.com/dashboard/developer), og gem den på din server som `WHOP_API_KEY`.

Denne nøgle lader dig udføre handlinger i din kontos kontekst. Hold den på serveren. Læg den aldrig i browser-, mobil- eller klientkode.

2
Installer pakker

Installer SDK'et i din backend:

> [tab] Next.js
>
> ```bash theme={null}
> pnpm add @whop/sdk
> ```

> [tab] Express
>
> ```bash theme={null}
> pnpm add @whop/sdk
> ```

> [tab] cURL
>
> Du kan også se [API-referencen](https://docs.whop.com/da/developer/quickstart.md), hvis du foretrækker selv at sende forespørgslerne.

Installer elements-pakkerne i din frontend:

> [tab] React
>
> ```bash theme={null}
> pnpm add @whop/embedded-components-react-js @whop/embedded-components-vanilla-js
> ```

> [tab] HTML
>
> ```html theme={null}
> <script src="https://apollo.elements.whop.com/release/elements.js"></script>
> ```

> [tab] iOS
>
> Tilføj denne Swift-pakke i Xcode:
>
> ```text theme={null}
> https://github.com/whopio/whopsdk-elements-swift
> ```
>
> Chat understøtter fotos, videoer og talebeskeder, så tilføj disse tilladelser til din apps `Info.plist`:
>
> ```xml Info.plist theme={null}
> <key>NSCameraUsageDescription</key>
> <string>Allow camera access to take photos and videos in chat</string>
> <key>NSMicrophoneUsageDescription</key>
> <string>Allow microphone access to record voice messages in chat</string>
> <key>NSPhotoLibraryUsageDescription</key>
> <string>Allow photo library access to share photos and videos in chat</string>
> ```

Alle klasser, indstillinger og typer, som webpakkerne eksporterer, er listet i [pakkereferencen](https://docs.whop.com/da/sdk/elements/overview.md).

3
Få et bruger-ID til dine brugere

Tilmeld dine egne brugere som underkonti, før du udsteder chattokens. Det opretter en Whop-konto, som du kan knytte tilbage til din platformbruger.

> [tab] Next.js
>
> ```typescript theme={null}
> import { WhopClient } from "@whop/sdk";
>
> const client = new WhopClient({ token: process.env.WHOP_API_KEY });
>
> const account = await client.accounts.create({
>   email: "user@example.com",
>   title: "Jane Doe",
>   external_id: "user_12345", // your platform's user ID
> });
> ```

> [tab] Express
>
> ```typescript theme={null}
> import { WhopClient } from "@whop/sdk";
>
> const client = new WhopClient({ token: process.env.WHOP_API_KEY });
>
> const account = await client.accounts.create({
>   email: "user@example.com",
>   title: "Jane Doe",
>   external_id: "user_12345", // your platform's user ID
> });
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl -X POST https://api.whop.com/api/v1/accounts \
>   -H "Authorization: Bearer $WHOP_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "email": "user@example.com",
>     "title": "Jane Doe",
>     "external_id": "user_12345"
>   }'
> ```

Gem det resulterende Whop-bruger-ID (`owner_user.id` i svaret) hos dig selv, og angiv det som `user_id`, når du opretter adgangstokens til chat.

Se [kontospecifikke profiler](https://docs.whop.com/da/developer/guides/chat/sync-users.md#2-set-an-account-specific-name-and-profile-picture) for flere detaljer om, hvordan du opdaterer brugernes avatarer og visningsnavne.

4
Opret et token-endpoint på din server

Tilføj et endpoint, der kalder `POST https://api.whop.com/api/v1/access_tokens` med din API-nøgle og returnerer det resulterende token til klienten.

> [tab] Next.js
>
> ```typescript app/api/chat/token/route.ts theme={null}
> import { NextResponse } from "next/server";
> import { WhopClient } from "@whop/sdk";
>
> const client = new WhopClient({ token: process.env.WHOP_API_KEY });
>
> export async function POST() {
>   // Derive these from your own auth / session in production.
>   const user_id = "user_XXXXXXXXXXXX";
>   const account_id = "biz_XXXXXXXXXXXXX";
>
>   const { token } = await client.accessTokens.create({
>     account_id,
>     user_id,
>     scoped_actions: [
>       "chat:message:create",
>       "chat:read",
>       "dms:read",
>       "dms:message:manage",
>       "dms:channel:manage",
>       "support_chat:read",
>       "support_chat:message:create",
>     ],
>   });
>
>   return NextResponse.json({ token });
> }
> ```

> [tab] Express
>
> ```typescript server.ts theme={null}
> import express from "express";
> import { WhopClient } from "@whop/sdk";
>
> const app = express();
> app.use(express.json());
>
> const client = new WhopClient({ token: process.env.WHOP_API_KEY });
>
> app.post("/api/chat/token", async (_req, res) => {
>   // Derive these from your own auth / session in production.
>   const user_id = "user_XXXXXXXXXXXX";
>   const account_id = "biz_XXXXXXXXXXXXX";
>
>   const { token } = await client.accessTokens.create({
>     account_id,
>     user_id,
>     scoped_actions: [
>       "chat:message:create",
>       "chat:read",
>       "dms:read",
>       "dms:message:manage",
>       "dms:channel:manage",
>       "support_chat:read",
>       "support_chat:message:create",
>     ],
>   });
>
>   res.json({ token });
> });
>
> app.listen(3000);
> ```

> [tab] cURL
>
> ```bash theme={null}
> curl -X POST https://api.whop.com/api/v1/access_tokens \
>   -H "Authorization: Bearer $WHOP_API_KEY" \
>   -H "Content-Type: application/json" \
>   -d '{
>     "account_id": "biz_XXXXXXXXXXXXX",
>     "user_id": "user_XXXXXXXXXXXX",
>     "scoped_actions": [
>       "chat:message:create",
>       "chat:read",
>       "dms:read",
>       "dms:message:manage",
>       "dms:channel:manage",
>       "support_chat:read",
>       "support_chat:message:create"
>     ]
>   }'
> ```

5
Opret eller hent en kanal, en DM eller en supportchat

Alle chattyper bruger beskeder i realtid og kan vises i Chat-elementet. Vælg typen ud fra dine behov:

> [card] [Kanaler](https://docs.whop.com/da/developer/guides/chat/channels.md)
>
> En delt chat til offentlige samtaler eller samtaler i store grupper. Rum med moderation, skrivebeskyttede muligheder og ingen fast grænse for antal medlemmer.

> [card] [Direkte beskeder](https://docs.whop.com/da/developer/guides/chat/direct-messages.md)
>
> En privat samtale mellem brugere. De vises på DM-listen og kan have op til 50 medlemmer.

> [card] [Supportchat](https://docs.whop.com/da/developer/guides/chat/support-chats.md)
>
> En supportsamtale én-til-én mellem en bruger og din konto. Kunder ser dem som DM'er. Administratorer håndterer dem via en supportindbakke i stedet for DM-listen.

Før du viser chatten, skal du hente ID'et på den kanal, du vil åbne.

* ID'er for [**kanaler**](https://docs.whop.com/da/developer/guides/chat/channels.md) starter med `chat_feed_`.
* ID'er for [**DM'er**](https://docs.whop.com/da/developer/guides/chat/direct-messages.md) og [**supportchats**](https://docs.whop.com/da/developer/guides/chat/support-chats.md) starter med `feed_`.

6
Vis chat i din app

Dette bruger det token-endpoint, du har oprettet, til at hente et token og vise chat-elementet. SDK'et står for at administrere tokenet og forny det, når det er nødvendigt.

> [tab] React
>
> ```tsx theme={null}
> "use client";
>
> import {
>   ChatElement,
>   ChatSession,
>   Elements,
> } from "@whop/embedded-components-react-js";
> import { loadWhopElements } from "@whop/embedded-components-vanilla-js";
>
> const elements = loadWhopElements();
>
> async function getToken() {
>   const res = await fetch("https://your-server.com/api/chat/token", { method: "POST" });
>   const data = await res.json();
>   return data.token;
> }
>
> export function Chat() {
>   return (
>     <Elements elements={elements}>
>       <ChatSession token={getToken}>
>         <ChatElement
>           options={{ channelId: "chat_feed_XXXXXXXXXXXXXX" }}
>           style={{ height: "100dvh", width: "100%" }}
>         />
>       </ChatSession>
>     </Elements>
>   );
> }
> ```

> [tab] HTML
>
> ```html theme={null}
> <div id="chat" style="height: 100vh"></div>
>
> <script>
>   const elements = new WhopElements();
>
>   async function getToken() {
>     const res = await fetch("https://your-server.com/api/chat/token", { method: "POST" });
>     const data = await res.json();
>     return data.token;
>   }
>
>   const session = elements.createChatSession({ token: getToken });
>   const chat = session.createElement("chat-element", {
>     channelId: "chat_feed_XXXXXXXXXXXXXX",
>   });
>
>   chat.mount("#chat");
> </script>
> ```

> [tab] iOS
>
> ```swift theme={null}
> import SwiftUI
> import WhopElements
>
> struct ContentView: View {
>   var body: some View {
>     WhopChatView(
>       channelId: "chat_feed_XXXXXXXXXXXXXX",
>       style: .imessage
>     )
>     // This should be done as soon as you know your user is authenticated so its
>     // prepared and ready to use without delays.
>     .task {
>       await WhopSDK.configure(tokenProvider: WhopAPITokenProvider())
>     }
>   }
> }
>
> class WhopAPITokenProvider: WhopTokenProvider {
>   func getToken() async -> WhopTokenResponse {
>     let url = URL(string: "https://your-server.com/api/chat/token")!
>     var request = URLRequest(url: url)
>     request.httpMethod = "POST"
>
>     do {
>       let (data, _) = try await URLSession.shared.data(for: request)
>       let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
>       return WhopTokenResponse(accessToken: json["token"] as? String ?? "")
>     } catch {
>       return WhopTokenResponse(accessToken: "")
>     }
>   }
> }
> ```

## Næste trin

> [card] [Godkendelse](https://docs.whop.com/da/developer/guides/chat/authentication.md)
>
> Vælg mellem kontoafgrænsede tokens og OAuth til indlejret chat.

> [card] [Synkroniser dine brugere](https://docs.whop.com/da/developer/guides/chat/sync-users.md)
>
> Opret eller tilknyt Whop-brugere, før du udsteder kontoafgrænsede chattokens.

> [card] [Chat-element](https://docs.whop.com/da/developer/guides/chat/chat-element.md)
>
> Lær om props, hændelser, stilarter og muligheder for direkte links i chat-brugerfladen.

> [card] [DM-listeelement](https://docs.whop.com/da/developer/guides/chat/dms-list-element.md)
>
> Vis en liste over en brugers samtaler med direkte beskeder.


## Related topics

- [OAuth til chat](https://docs.whop.com/da/developer/guides/chat/oauth.md)
- [Godkendelse til chat](https://docs.whop.com/da/developer/guides/chat/authentication.md)
- [Playground til indlejret chat](https://docs.whop.com/da/developer/guides/chat/playground.md)
