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

# Autenticación del chat

> Autentica a los usuarios del chat incrustado con tokens con alcance de cuenta u OAuth

> [card] [Tipos de credenciales de Whop](https://docs.whop.com/es/developer/guides/auth-scoping.md)
>
> Consulta Autenticación y claves de API para ver los cuatro tipos de credenciales de Whop, cuándo usar cada uno y cómo limitar el alcance de un token a las acciones que necesita.

Antes de usar el SDK de chat, necesitas autenticar a los usuarios. Elige uno de estos dos enfoques:

| Enfoque | Ideal para |
| - | - |
| **[Tokens de usuario con alcance de cuenta](#account-scoped-user-tokens)** | Apps que ya tienen sus propios usuarios. Tu servidor genera tokens de Whop para ellos sin un paso de inicio de sesión. |
| **[OAuth](https://docs.whop.com/es/developer/guides/chat/oauth.md)** | Apps que quieren que los usuarios inicien sesión en Whop por sí mismos mediante una página de inicio de sesión o un webview. |

## Tokens de usuario con alcance de cuenta

Usa este enfoque si **tu app ya tiene sus propios usuarios** (mediante tu propio sistema de autenticación o sesiones). Mantienes tu flujo de inicio de sesión actual y generas un token de Whop para el usuario que tenga la sesión iniciada, sin ningún paso de inicio de sesión adicional.

Tu servidor intercambia tu clave de API de Whop por un token de usuario de corta duración cuando lo necesita y lo devuelve al cliente. Tú decides para qué usuario es el token.

### Reúne tus credenciales

Necesitarás tres cosas:

1. **Clave de API**: crea una en el [panel de desarrollador de Whop](https://whop.com/dashboard/developer). Trátala como una contraseña y guárdala solo en tu servidor.
2. **ID de cuenta**. Lo encontrarás en la URL de tu panel: `whop.com/dashboard/biz_XXXXXXXXX/`.
3. **ID de usuario**: el usuario que quieres autenticar. En producción, obtenlo de tu propio sistema de autenticación o sesiones.

> [!NOTE]
>
> Para el chat incrustado, `account_id` y `user_id` son obligatorios a la vez al generar un token.

### Crea un endpoint de token en tu servidor

Añade un endpoint que llame a `POST https://api.whop.com/api/v1/access_tokens` con tu clave de API y devuelva el token resultante al cliente.

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

### Obtén el token desde tu app

Proporciona al SDK una función de callback de token que lo obtenga de tu endpoint. Los elementos de chat la llaman siempre que necesitan autenticarse, y de nuevo automáticamente cuando el token caduca.

> [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: "")
>         }
>     }
> }
> ```
>
> Pasa el proveedor de tokens al SDK al iniciar la app:
>
> ```swift theme={null}
> .task {
>     await WhopSDK.configure(tokenProvider: WhopAPITokenProvider())
> }
> ```

### Alcances necesarios

Solicita estos alcances al crear el token:

| Alcance | Propósito |
| - | - |
| `chat:message:create`, `chat:read` | Canales |
| `dms:read`, `dms:message:manage`, `dms:channel:manage` | Mensajes directos |
| `support_chat:read`, `support_chat:message:create` | Chats de soporte |

> [!NOTE]
>
> Si tu app es propietaria de las cuentas de usuario y genera tokens de chat con alcance de cuenta, sincroniza esos usuarios antes de pasar su `user_id` aquí. La sincronización de usuarios no forma parte de OAuth.

> [card] [Sincroniza tus usuarios](https://docs.whop.com/es/developer/guides/chat/sync-users.md)
>
> Crea o asigna usuarios de Whop antes de generar tokens de chat con alcance de cuenta.

## OAuth

OAuth tiene su propia página para que esta guía pueda centrarse en los tokens de usuario con alcance de cuenta.

Usa OAuth cuando tu app quiera que los usuarios inicien sesión en Whop por sí mismos mediante una página de inicio de sesión o un webview de iOS. Es la opción adecuada cuando tu app necesita acceder a una cuenta de Whop propiedad del usuario, o cuando no quieres que tu backend genere tokens de usuario de Whop.

> [card] [OAuth](https://docs.whop.com/es/developer/guides/chat/oauth.md)
>
> Configura los alcances de OAuth, las URI de redirección, los endpoints de token web y el OAuth gestionado por el SDK en iOS.


## Related topics

- [Canales del chat incrustado](https://docs.whop.com/es/developer/guides/chat/channels.md)
- [OAuth del chat](https://docs.whop.com/es/developer/guides/chat/oauth.md)
- [Inicio rápido del chat](https://docs.whop.com/es/developer/guides/chat/quickstart.md)
