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

# API de chat

> Envía y lee mensajes de chat en una comunidad de Whop desde tu servidor y gestiona sus canales.

Usa la API de chat para enviar mensajes, gestionar canales, abrir conversaciones de soporte y leer reacciones. Identifica los canales por `experience_id` o `channel_id`.

> [!TIP]
>
> Esta página cubre la **API de chat del lado del servidor**, para llamar a Whop desde tu backend y publicar, leer o moderar mensajes. Si quieres mostrar una interfaz de chat de Whop en vivo dentro de tu propio frontend, consulta el [inicio rápido del chat incrustado](https://docs.whop.com/es/developer/guides/chat/quickstart.md).

## Inicializar el SDK

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

const client = new WhopClient({
  token: process.env.WHOP_API_KEY,
});
```

```python Python theme={null}
import os
from whop_sdk import Whop

client = Whop(
    token=os.environ["WHOP_API_KEY"],
)
```

```rust Rust theme={null}
use whop_sdk::prelude::*;

let config = ClientConfig {
    token: Some(std::env::var("WHOP_API_KEY").unwrap()),
    ..Default::default()
};
let client = Whop::new(config).expect("Failed to build client");
```

```go Go theme={null}
import (
    "os"

    "github.com/whopio/whopsdk-go/v2/client"
    "github.com/whopio/whopsdk-go/v2/option"
)

client := client.NewWhop(option.WithToken(os.Getenv("WHOP_API_KEY")))
```

## Enviar un mensaje

Los mensajes admiten Markdown y archivos adjuntos opcionales subidos mediante la [API de archivos](https://docs.whop.com/es/developer/guides/upload-files.md).

```typescript TypeScript theme={null}
const message = await client.messages.create({
  channel_id: "chat_feed_xxxxxxxxxxxxx", // or an experience_id
  content: "Hello! **Markdown** is supported.",
  attachments: [
    { id: "file_xxxxxxxxxxxxx" }, // upload via the Files API first
  ],
});
```

```python Python theme={null}
message = client.messages.create(
    channel_id="chat_feed_xxxxxxxxxxxxx",
    content="Hello! **Markdown** is supported.",
    attachments=[
        {"id": "file_xxxxxxxxxxxxx"},
    ],
)
```

```rust Rust theme={null}
let message = client
    .messages
    .create(
        &CreateMessagesRequest {
            channel_id: "chat_feed_xxxxxxxxxxxxx".to_string(), // or an experience_id
            content: "Hello! **Markdown** is supported.".to_string(),
            attachments: Some(vec![CreateMessagesRequestAttachmentsItem {
                id: "file_xxxxxxxxxxxxx".to_string(), // upload via the Files API first
            }]),
            ..Default::default()
        },
        None,
    )
    .await?;

println!("{}", message.id);
```

```go Go theme={null}
message, err := client.Messages.Create(context.TODO(), &whopsdk.CreateMessagesRequest{
    ChannelID: "chat_feed_xxxxxxxxxxxxx", // or an experience_id
    Content:   "Hello! **Markdown** is supported.",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(message.ID)
```

## Leer mensajes

Las operaciones de listado se paginan automáticamente. Itera la respuesta y el SDK obtiene las páginas adicionales por ti.

```typescript TypeScript theme={null}
const messages = await client.messages.list({
  channel_id: "chat_feed_xxxxxxxxxxxxx",
  direction: "desc",
  first: 20,
});

for await (const message of messages) {
  console.log(message);
}

const single = await client.messages.retrieve({ id: "msg_xxxxxxxxxxxxx" });
```

```python Python theme={null}
for message in client.messages.list(
    channel_id="chat_feed_xxxxxxxxxxxxx",
    direction="desc",
    first=20,
):
    print(message)

single = client.messages.retrieve("msg_xxxxxxxxxxxxx")
```

```rust Rust theme={null}
let messages = client
    .messages
    .list(
        &MessagesListQueryRequest {
            channel_id: "chat_feed_xxxxxxxxxxxxx".to_string(),
            direction: Some(Direction::Desc),
            first: Some(20),
            ..Default::default()
        },
        None,
    )
    .await?;

for message in messages.data {
    println!("{message:?}");
}

let single = client
    .messages
    .retrieve(&"msg_xxxxxxxxxxxxx".to_string(), None)
    .await?;
```

```go Go theme={null}
page, err := client.Messages.List(context.TODO(), &whopsdk.ListMessagesRequest{
    ChannelID: "chat_feed_xxxxxxxxxxxxx",
    Direction: whopsdk.DirectionDesc.Ptr(),
    First:     whopsdk.Int(20),
})
if err != nil {
    log.Fatal(err)
}

iter := page.Iterator()
for iter.Next(context.TODO()) {
    fmt.Println(iter.Current())
}
if err := iter.Err(); err != nil {
    log.Fatal(err)
}

single, err := client.Messages.Retrieve(context.TODO(), &whopsdk.RetrieveMessagesRequest{
    ID: "msg_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
_ = single
```

## Gestionar canales

Usa [Update Channel](https://docs.whop.com/es/api-reference/channels/update-channel.md) para cambiar los ajustes de moderación de un canal de la comunidad: palabras prohibidas, tiempos de espera entre publicaciones y quién puede publicar o reaccionar. Usa [List Channels](https://docs.whop.com/es/api-reference/channels/list-channels.md) con `kind` establecido en `community` para listar los canales de chat de una cuenta.

```typescript TypeScript theme={null}
const channel = await client.channels.update({
  id: "chat_feed_xxxxxxxxxxxxx",
  moderation: {
    ban_media: false,
    ban_urls: false,
    banned_words: ["spam", "scam"],
    user_posts_cooldown_seconds: 10,
    who_can_post: "admins",
    who_can_react: "everyone",
  },
});

const channels = await client.channels.list({
  kind: "community",
  account_id: "biz_xxxxxxxxxxxxx",
  first: 10,
});

for await (const item of channels) {
  console.log(item);
}
```

```python Python theme={null}
channel = client.channels.update(
    "chat_feed_xxxxxxxxxxxxx",
    moderation={
        "ban_media": False,
        "ban_urls": False,
        "banned_words": ["spam", "scam"],
        "user_posts_cooldown_seconds": 10,
        "who_can_post": "admins",
        "who_can_react": "everyone",
    },
)

for item in client.channels.list(
    kind="community",
    account_id="biz_xxxxxxxxxxxxx",
    first=10,
):
    print(item)
```

```go Go theme={null}
channel, err := client.Channels.Update(context.TODO(), &whopsdk.UpdateChannelsRequest{
    ID: "chat_feed_xxxxxxxxxxxxx",
    Moderation: &whopsdk.UpdateChannelsRequestModeration{
        BanMedia:                 whopsdk.Bool(false),
        BanURLs:                  whopsdk.Bool(false),
        BannedWords:              []string{"spam", "scam"},
        UserPostsCooldownSeconds: whopsdk.Int(10),
        WhoCanPost:               whopsdk.UpdateChannelsRequestModerationWhoCanPostAdmins.Ptr(),
        WhoCanReact:              whopsdk.UpdateChannelsRequestModerationWhoCanReactEveryone.Ptr(),
    },
})
if err != nil {
    log.Fatal(err)
}
_ = channel

page, err := client.Channels.List(context.TODO(), &whopsdk.ListChannelsRequest{
    Kind:      []*whopsdk.ListChannelsRequestKindItem{whopsdk.ListChannelsRequestKindItemCommunity.Ptr()},
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxx"),
    First:     whopsdk.Int(10),
})
if err != nil {
    log.Fatal(err)
}

iter := page.Iterator()
for iter.Next(context.TODO()) {
    fmt.Println(iter.Current())
}
if err := iter.Err(); err != nil {
    log.Fatal(err)
}
```

```bash cURL theme={null}
curl -X PATCH https://api.whop.com/api/v1/channels/chat_feed_xxxxxxxxxxxxx \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "moderation": {
      "ban_media": false,
      "ban_urls": false,
      "banned_words": ["spam", "scam"],
      "user_posts_cooldown_seconds": 10,
      "who_can_post": "admins",
      "who_can_react": "everyone"
    }
  }'

curl -G https://api.whop.com/api/v1/channels \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  --data-urlencode "kind=community" \
  --data-urlencode "account_id=biz_xxxxxxxxxxxxx" \
  --data-urlencode "first=10"
```

`who_can_post` acepta `everyone` o `admins`. `who_can_react` acepta `everyone` o `no_one`. Las claves de API de cuenta solo pueden actualizar canales de la comunidad.

## Reaccionar a un mensaje

```typescript TypeScript theme={null}
await client.reactions.create({
  resource_id: "msg_xxxxxxxxxxxxx",
  emoji: "😀", // Unicode or ':heart:' shortcode
});
```

```python Python theme={null}
client.reactions.create(
    resource_id="msg_xxxxxxxxxxxxx",
    emoji="😀",
)
```

```rust Rust theme={null}
client
    .reactions
    .create(
        &CreateReactionsRequest {
            resource_id: "msg_xxxxxxxxxxxxx".to_string(),
            emoji: Some("😀".to_string()), // Unicode or ':heart:' shortcode
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Reactions.Create(context.TODO(), &whopsdk.CreateReactionsRequest{
    ResourceID: "msg_xxxxxxxxxxxxx",
    Emoji:      whopsdk.String("😀"), // Unicode or ':heart:' shortcode
})
if err != nil {
    log.Fatal(err)
}
```

## Canales de soporte

Los canales de soporte son hilos 1:1 entre un cliente y una cuenta. Úsalos para servicios de ayuda o flujos de atención personalizada. [Create Channel](https://docs.whop.com/es/api-reference/channels/create-channel.md) con `kind` establecido en `support` devuelve el canal existente si ya hay uno para el cliente. Para listar la bandeja de soporte de tu cuenta, llama a [List Channels](https://docs.whop.com/es/api-reference/channels/list-channels.md) con `kind` establecido en `support` y `support_role` establecido en `staff`.

```typescript TypeScript theme={null}
const support = await client.channels.create({
  kind: "support",
  account_id: "biz_xxxxxxxxxxxxx",
  customer_user_id: "user_xxxxxxxxxxxxx",
});

const supportChannels = await client.channels.list({
  kind: "support",
  support_role: "staff",
  account_id: "biz_xxxxxxxxxxxxx",
  status: "unresolved",
  order: "last_message_at",
  direction: "desc",
  first: 10,
});

for await (const item of supportChannels) {
  console.log(item);
}
```

```python Python theme={null}
support = client.channels.create(
    kind="support",
    account_id="biz_xxxxxxxxxxxxx",
    customer_user_id="user_xxxxxxxxxxxxx",
)

for item in client.channels.list(
    kind="support",
    support_role="staff",
    account_id="biz_xxxxxxxxxxxxx",
    status="unresolved",
    order="last_message_at",
    direction="desc",
    first=10,
):
    print(item)
```

```go Go theme={null}
support, err := client.Channels.Create(context.TODO(), &whopsdk.CreateChannelsRequest{
    Kind:           whopsdk.CreateChannelsRequestKindSupport,
    AccountID:      whopsdk.String("biz_xxxxxxxxxxxxx"),
    CustomerUserID: whopsdk.String("user_xxxxxxxxxxxxx"),
})
if err != nil {
    log.Fatal(err)
}
_ = support

page, err := client.Channels.List(context.TODO(), &whopsdk.ListChannelsRequest{
    Kind:        []*whopsdk.ListChannelsRequestKindItem{whopsdk.ListChannelsRequestKindItemSupport.Ptr()},
    SupportRole: whopsdk.ListChannelsRequestSupportRoleStaff.Ptr(),
    AccountID:   whopsdk.String("biz_xxxxxxxxxxxxx"),
    Status:      whopsdk.ListChannelsRequestStatusUnresolved.Ptr(),
    Order:       whopsdk.ListChannelsRequestOrderLastMessageAt.Ptr(),
    Direction:   whopsdk.ListChannelsRequestDirectionDesc.Ptr(),
    First:       whopsdk.Int(10),
})
if err != nil {
    log.Fatal(err)
}

iter := page.Iterator()
for iter.Next(context.TODO()) {
    fmt.Println(iter.Current())
}
if err := iter.Err(); err != nil {
    log.Fatal(err)
}
```

```bash cURL theme={null}
curl -X POST https://api.whop.com/api/v1/channels \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "support",
    "account_id": "biz_xxxxxxxxxxxxx",
    "customer_user_id": "user_xxxxxxxxxxxxx"
  }'

curl -G https://api.whop.com/api/v1/channels \
  -H "Authorization: Bearer $WHOP_API_KEY" \
  --data-urlencode "kind=support" \
  --data-urlencode "support_role=staff" \
  --data-urlencode "account_id=biz_xxxxxxxxxxxxx" \
  --data-urlencode "status=unresolved" \
  --data-urlencode "order=last_message_at" \
  --data-urlencode "direction=desc" \
  --data-urlencode "first=10"
```

## Permisos necesarios

Añádelos desde la [guía de permisos](https://docs.whop.com/es/developer/guides/permissions.md) antes de publicar tu app.

| Permiso | Necesario para |
| - | - |
| `chat:read` | Leer mensajes, canales y reacciones |
| `chat:message:create` | Publicar mensajes |
| `chat:moderate` | Actualizar los ajustes de los canales |
| `support_chat:create` | Abrir canales de soporte |
| `support_chat:read` | Leer canales de soporte |

> [accordion] Estructura del objeto de mensaje
>
> ```typescript theme={null}
> {
>   id: string;
>   content: string | null;
>   created_at: string;
>   is_edited: boolean;
>   is_pinned: boolean;
>   message_type: "text" | "image" | "video" | "poll";
>   poll: { options: Array<{ id: string; text: string }> | null } | null;
>   poll_votes: Array<{ count: number; option_id: string | null }>;
>   reaction_counts: Array<{ count: number; emoji: string | null }>;
>   replying_to_message_id: string | null;
>   updated_at: string;
>   user: { id: string; name: string | null; username: string };
> }
> ```
>
> Esquema completo: consulta la [referencia de la API de mensajes](https://docs.whop.com/es/api-reference/legacy/messages/message.md).

## Próximos pasos

> [card] [Escuchar eventos con webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Recibe eventos del chat en tu servidor en lugar de consultar periódicamente.

> [card] [Enviar notificaciones](https://docs.whop.com/es/developer/guides/notifications.md)
>
> Envía notificaciones push a los usuarios que no están conectados al chat.

> [card] [Subir archivos](https://docs.whop.com/es/developer/guides/upload-files.md)
>
> Adjunta imágenes y vídeos a los mensajes.

> [card] [Incrustar el chat en tu app](https://docs.whop.com/es/developer/guides/chat/quickstart.md)
>
> Interfaz de chat de Whop lista para usar en tu frontend (producto independiente).


## Related topics

- [Versiones de la API](https://docs.whop.com/es/developer/api/versioning.md)
- [Mapa de la plataforma](https://docs.whop.com/es/developer/platform-map.md)
- [Chat de IA](https://docs.whop.com/es/api-reference/legacy/ai-chats/ai-chat.md)
