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

# Authentification du chat

> Authentifiez les utilisateurs du chat intégré avec des jetons limités à un compte ou avec OAuth

> [card] [Types d'identifiants Whop](https://docs.whop.com/fr/developer/guides/auth-scoping.md)
>
> Consultez Authentification et clés API pour découvrir les quatre types d'identifiants Whop, quand utiliser chacun d'eux et comment restreindre un jeton aux seules actions dont il a besoin.

Avant d'utiliser le SDK de chat, vous devez authentifier les utilisateurs. Choisissez l'une des deux approches :

| Approche | Idéale pour |
| - | - |
| **[Jetons utilisateur limités à un compte](#account-scoped-user-tokens)** | Les applications qui ont déjà leurs propres utilisateurs. Votre serveur génère des jetons Whop pour eux sans étape de connexion. |
| **[OAuth](https://docs.whop.com/fr/developer/guides/chat/oauth.md)** | Les applications qui souhaitent que les utilisateurs se connectent eux-mêmes à Whop via une page de connexion ou une webview. |

## Jetons utilisateur limités à un compte

Utilisez cette approche si **votre application a déjà ses propres utilisateurs** (via votre propre système d'authentification / de session). Vous conservez votre flux de connexion existant et générez un jeton Whop pour l'utilisateur actuellement connecté — sans étape de connexion supplémentaire.

Votre serveur échange votre clé API Whop contre un jeton utilisateur de courte durée à la demande, puis le renvoie au client. C'est vous qui décidez à quel utilisateur le jeton est destiné.

### Rassembler vos identifiants

Vous aurez besoin de trois éléments :

1. **Clé API** — créez-en une dans le [tableau de bord développeur Whop](https://whop.com/dashboard/developer). Traitez-la comme un mot de passe et conservez-la uniquement sur votre serveur.
2. **ID du compte**. Vous le trouverez dans l'URL de votre tableau de bord : `whop.com/dashboard/biz_XXXXXXXXX/`.
3. **ID utilisateur** — l'utilisateur que vous souhaitez authentifier. En production, déduisez-le de votre propre système d'authentification / de session.

> [!NOTE]
>
> Pour le chat intégré, `account_id` et `user_id` sont tous deux obligatoires lors de la génération d'un jeton.

### Créer un endpoint de jeton sur votre serveur

Ajoutez un endpoint qui appelle `POST https://api.whop.com/api/v1/access_tokens` avec votre clé API et renvoie le jeton obtenu au client.

> [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"
>     ]
>   }'
> ```

### Récupérer le jeton depuis votre application

Fournissez au SDK une fonction de rappel qui récupère le jeton depuis votre endpoint. Les éléments de chat l'appellent chaque fois qu'ils doivent s'authentifier, puis à nouveau automatiquement lorsque le jeton expire.

> [tab] React
>
> ```typescript theme={null}
> async function getToken() {
>   const response = await fetch("/api/chat/token", { method: "POST" });
>   const data = await response.json();
>   return data.token;
> }
> ```

> [tab] Vanilla JS
>
> ```typescript theme={null}
> async function getToken() {
>   const response = await fetch("/api/chat/token", { method: "POST" });
>   const data = await response.json();
>   return data.token;
> }
> ```

> [tab] Swift
>
> ```swift theme={null}
> import WhopElements
>
> class WhopAPITokenProvider: WhopTokenProvider {
>     private let serverURL = URL(string: "https://your-server.com")!
>
>     func getToken() async -> WhopTokenResponse {
>         do {
>             var req = URLRequest(url: serverURL.appendingPathComponent("api/chat/token"))
>             req.httpMethod = "POST"
>
>             let (data, _) = try await URLSession.shared.data(for: req)
>             let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
>             return WhopTokenResponse(accessToken: json["token"] as? String ?? "")
>         } catch {
>             return WhopTokenResponse(accessToken: "")
>         }
>     }
> }
> ```
>
> Transmettez le fournisseur de jetons au SDK au lancement de l'application :
>
> ```swift theme={null}
> .task {
>     await WhopSDK.configure(tokenProvider: WhopAPITokenProvider())
> }
> ```

### Scopes requis

Demandez ces scopes lors de la création du jeton :

| Scope | Usage |
| - | - |
| `chat:message:create`, `chat:read` | Canaux |
| `dms:read`, `dms:message:manage`, `dms:channel:manage` | Messages privés |
| `support_chat:read`, `support_chat:message:create` | Chats d'assistance |

> [!NOTE]
>
> Si votre application gère les comptes utilisateur et génère des jetons de chat limités à un compte, synchronisez ces utilisateurs avant de transmettre leur `user_id` ici. La synchronisation des utilisateurs ne fait pas partie d'OAuth.

> [card] [Synchroniser vos utilisateurs](https://docs.whop.com/fr/developer/guides/chat/sync-users.md)
>
> Créez ou associez des utilisateurs Whop avant de générer des jetons de chat limités à un compte.

## OAuth

OAuth est traité sur sa propre page afin que ce guide reste centré sur les jetons utilisateur limités à un compte.

Utilisez OAuth lorsque votre application souhaite que les utilisateurs se connectent eux-mêmes à Whop via une page de connexion ou une webview iOS. C'est le bon choix lorsque votre application a besoin d'accéder à un compte Whop appartenant à un utilisateur, ou lorsque vous ne souhaitez pas que votre backend génère des jetons utilisateur Whop.

> [card] [OAuth](https://docs.whop.com/fr/developer/guides/chat/oauth.md)
>
> Configurez les scopes OAuth, les URI de redirection, les endpoints de jeton web et OAuth géré par le SDK sur iOS.


## Related topics

- [Canaux du chat intégré](https://docs.whop.com/fr/developer/guides/chat/channels.md)
- [Démarrage rapide du chat](https://docs.whop.com/fr/developer/guides/chat/quickstart.md)
- [Bac à sable du chat intégré](https://docs.whop.com/fr/developer/guides/chat/playground.md)
