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

# Chat API

> Verstuur en lees chatberichten in een Whop-community vanaf je server en beheer de kanalen ervan.

Gebruik de Chat API om berichten te versturen, kanalen te beheren, supportgesprekken te openen en reacties te lezen. Identificeer kanalen via `experience_id` of `channel_id`.

> [!TIP]
>
> Deze pagina behandelt de **server-side Chat API**, waarmee je Whop vanuit je backend aanroept om berichten te plaatsen, te lezen of te modereren. Wil je een live Whop-chat-UI in je eigen frontend weergeven, zie dan de [quickstart voor ingesloten chat](https://docs.whop.com/nl/developer/guides/chat/quickstart.md).

## De SDK initialiseren

```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")))
```

## Een bericht versturen

Berichten ondersteunen Markdown en optionele bijlagen die zijn geüpload via de [Files API](https://docs.whop.com/nl/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)
```

## Berichten lezen

Lijstbewerkingen pagineren automatisch. Itereer over de response en de SDK haalt extra pagina's voor je op.

```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
```

## Kanalen beheren

Gebruik [Update Channel](https://docs.whop.com/nl/api-reference/channels/update-channel.md) om de moderatie-instellingen van een communitykanaal te wijzigen: verboden woorden, wachttijden tussen berichten en wie mag posten of reageren. Gebruik [List Channels](https://docs.whop.com/nl/api-reference/channels/list-channels.md) met `kind` ingesteld op `community` om de chatkanalen van een account op te vragen.

```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` accepteert `everyone` of `admins`. `who_can_react` accepteert `everyone` of `no_one`. Account API-sleutels kunnen alleen communitykanalen bijwerken.

## Reageren op een bericht

```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)
}
```

## Supportkanalen

Supportkanalen zijn 1-op-1-threads tussen een klant en een account. Gebruik ze voor helpdesks of conciërgeflows. [Create Channel](https://docs.whop.com/nl/api-reference/channels/create-channel.md) met `kind` ingesteld op `support` retourneert het bestaande kanaal als er al een voor de klant bestaat. Om de supportinbox van je account op te vragen, roep je [List Channels](https://docs.whop.com/nl/api-reference/channels/list-channels.md) aan met `kind` ingesteld op `support` en `support_role` ingesteld op `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"
```

## Vereiste permissies

Voeg deze toe via de [gids voor permissies](https://docs.whop.com/nl/developer/guides/permissions.md) voordat je je app publiceert.

| Permissie | Nodig voor |
| - | - |
| `chat:read` | Berichten, kanalen en reacties lezen |
| `chat:message:create` | Berichten plaatsen |
| `chat:moderate` | Kanaalinstellingen bijwerken |
| `support_chat:create` | Supportkanalen openen |
| `support_chat:read` | Supportkanalen lezen |

> [accordion] Structuur van het berichtobject
>
> ```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 };
> }
> ```
>
> Volledig schema: zie de [API-referentie voor berichten](https://docs.whop.com/nl/api-reference/legacy/messages/message.md).

## Volgende stappen

> [card] [Naar events luisteren met webhooks](https://docs.whop.com/nl/developer/guides/webhooks.md)
>
> Ontvang chatevents op je server in plaats van te pollen.

> [card] [Meldingen versturen](https://docs.whop.com/nl/developer/guides/notifications.md)
>
> Stuur pushmeldingen naar gebruikers die niet live in de chat zijn.

> [card] [Bestanden uploaden](https://docs.whop.com/nl/developer/guides/upload-files.md)
>
> Voeg afbeeldingen en video's toe aan berichten.

> [card] [Chat insluiten in je app](https://docs.whop.com/nl/developer/guides/chat/quickstart.md)
>
> Kant-en-klare Whop-chat-UI voor je frontend (apart product).


## Related topics

- [API-versies](https://docs.whop.com/nl/developer/api/versioning.md)
- [AI-chat](https://docs.whop.com/nl/api-reference/legacy/ai-chats/ai-chat.md)
- [API-stabiliteit](https://docs.whop.com/nl/api-reference/stability.md)
