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

# Démarrage rapide du chat

> Ajoutez le chat Whop à votre application web ou iOS, de la création d'une clé API à l'affichage de votre première conversation.

[Intégrer le chat Whop dans votre application](https://www.youtube.com/embed/MqgyFg9YyCw?rel=0)

1
Créer une clé API

Créez une clé API dans le [tableau de bord développeur Whop](https://whop.com/dashboard/developer) et enregistrez-la sur votre serveur sous le nom `WHOP_API_KEY`.

Cette clé vous permet d'effectuer des actions dans le contexte de votre compte. Conservez-la sur le serveur. Ne la placez jamais dans du code navigateur, mobile ou côté client.

2
Installer les paquets

Installez le SDK dans votre backend :

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

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

> [tab] cURL
>
> Vous pouvez aussi consulter [la référence de l'API](https://docs.whop.com/fr/developer/quickstart.md) si vous préférez effectuer les requêtes vous-même.

Installez les paquets d'éléments dans votre 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
>
> Ajoutez ce paquet Swift dans Xcode :
>
> ```text theme={null}
> https://github.com/whopio/whopsdk-elements-swift
> ```
>
> Le chat prend en charge les photos, les vidéos et les messages vocaux : ajoutez donc ces permissions au fichier `Info.plist` de votre application :
>
> ```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>
> ```

Toutes les classes, options et types exportés par les paquets web sont listés dans la [référence des paquets](https://docs.whop.com/fr/sdk/elements/overview.md).

3
Obtenir un ID utilisateur pour vos utilisateurs

Inscrivez vos propres utilisateurs en tant que sous-comptes avant de générer des jetons de chat. Cela crée un compte Whop que vous pouvez associer à l'utilisateur de votre plateforme.

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

Enregistrez de votre côté l'ID utilisateur Whop obtenu (`owner_user.id` dans la réponse) et transmettez-le comme `user_id` lorsque vous créez des jetons d'accès au chat.

Consultez les [profils spécifiques au compte](https://docs.whop.com/fr/developer/guides/chat/sync-users.md#2-set-an-account-specific-name-and-profile-picture) pour en savoir plus sur la mise à jour des avatars et des noms d'affichage des utilisateurs.

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

5
Créer ou récupérer un canal, un message privé ou un chat d'assistance

Tous les types de chat utilisent une messagerie en temps réel et peuvent s'afficher dans l'élément Chat. Choisissez le type selon vos besoins :

> [card] [Canaux](https://docs.whop.com/fr/developer/guides/chat/channels.md)
>
> Un chat partagé pour les conversations publiques ou en grand groupe. Des salons avec modération, options de lecture seule et sans limite fixe de membres.

> [card] [Messages privés](https://docs.whop.com/fr/developer/guides/chat/direct-messages.md)
>
> Une conversation privée entre utilisateurs. Ils apparaissent dans la liste des messages privés et peuvent compter jusqu'à 50 membres.

> [card] [Chat d'assistance](https://docs.whop.com/fr/developer/guides/chat/support-chats.md)
>
> Une conversation d'assistance individuelle entre un utilisateur et votre compte. Les clients les voient comme des messages privés. Les administrateurs les gèrent via une boîte de réception d'assistance plutôt que via la liste des messages privés.

Avant d'afficher le chat, obtenez l'ID du canal que vous souhaitez ouvrir.

* Les ID des [**canaux**](https://docs.whop.com/fr/developer/guides/chat/channels.md) commencent par `chat_feed_`.
* Les ID des [**messages privés**](https://docs.whop.com/fr/developer/guides/chat/direct-messages.md) et des [**chats d'assistance**](https://docs.whop.com/fr/developer/guides/chat/support-chats.md) commencent par `feed_`.

6
Afficher le chat dans votre application

Ce code utilise l'endpoint de jeton que vous avez créé pour récupérer un jeton et afficher l'élément de chat. Le SDK se charge de gérer le jeton et de le rafraîchir si nécessaire.

> [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: "")
>     }
>   }
> }
> ```

## Étapes suivantes

> [card] [Authentification](https://docs.whop.com/fr/developer/guides/chat/authentication.md)
>
> Choisissez entre les jetons limités à un compte et OAuth pour le chat intégré.

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

> [card] [Élément Chat](https://docs.whop.com/fr/developer/guides/chat/chat-element.md)
>
> Découvrez les props, événements, styles et options de liens profonds de l'interface de chat.

> [card] [Élément de liste des messages privés](https://docs.whop.com/fr/developer/guides/chat/dms-list-element.md)
>
> Affichez la liste des conversations privées d'un utilisateur.


## Related topics

- [Communautés et chat](https://docs.whop.com/fr/developer/communities/overview.md)
- [API Chat](https://docs.whop.com/fr/developer/guides/chat.md)
- [OAuth pour le chat](https://docs.whop.com/fr/developer/guides/chat/oauth.md)
