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

# Foros

> Crea publicaciones en foros, obtén hilos y añade comentarios o reacciones en cualquier comunidad de Whop.

Usa la Forums API para publicar posts, comentar en hilos existentes y reaccionar a publicaciones dentro de la experiencia de foro de una comunidad de Whop. El `experience_id` delimita el contenido del foro, así que cada tile de foro en la barra lateral de una comunidad es una experiencia independiente.

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

## Crea una publicación

Las publicaciones admiten Markdown. Los campos opcionales te permiten fijar la publicación, ponerla tras un paywall o marcarla como mención.

```typescript TypeScript theme={null}
const post = await client.forumPosts.create({
  experience_id: "exp_xxxxxxxxxxxxx",
  content: "This is the post body in **Markdown**.",
  title: "Optional title for paywalled posts",
  pinned: false,
  is_mention: false,
  paywall_amount: 0, // cents; 500 = $5.00
});
```

```python Python theme={null}
post = client.forum_posts.create(
    experience_id="exp_xxxxxxxxxxxxx",
    content="This is the post body in **Markdown**.",
    title="Optional title for paywalled posts",
    pinned=False,
    is_mention=False,
    paywall_amount=0,
)
```

```rust Rust theme={null}
let post = client
    .forum_posts
    .create(
        &CreateForumPostsRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            content: Some("This is the post body in **Markdown**.".to_string()),
            title: Some("Optional title for paywalled posts".to_string()),
            pinned: Some(false),
            is_mention: Some(false),
            paywall_amount: Some(0.0), // cents; 500 = $5.00
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
post, err := client.ForumPosts.Create(context.TODO(), &whopsdk.CreateForumPostsRequest{
    ExperienceID:  "exp_xxxxxxxxxxxxx",
    Content:       whopsdk.String("This is the post body in **Markdown**."),
    Title:         whopsdk.String("Optional title for paywalled posts"),
    Pinned:        whopsdk.Bool(false),
    IsMention:     whopsdk.Bool(false),
    PaywallAmount: whopsdk.Float64(0), // cents; 500 = $5.00
})
if err != nil {
    log.Fatal(err)
}
_ = post
```

## Lee publicaciones

Las operaciones de listado se paginan automáticamente.

```typescript TypeScript theme={null}
const posts = await client.forumPosts.list({
  experience_id: "exp_xxxxxxxxxxxxx",
  first: 10,
});

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

const post = await client.forumPosts.retrieve({ id: "post_xxxxxxxxxxxxx" });
```

```python Python theme={null}
for item in client.forum_posts.list(
    experience_id="exp_xxxxxxxxxxxxx",
    first=10,
):
    print(item)

post = client.forum_posts.retrieve("post_xxxxxxxxxxxxx")
```

```rust Rust theme={null}
let posts = client
    .forum_posts
    .list(
        &ForumPostsListQueryRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            first: Some(10),
            ..Default::default()
        },
        None,
    )
    .await?;

for item in posts.data {
    println!("{item:?}");
}

let post = client
    .forum_posts
    .retrieve(&"post_xxxxxxxxxxxxx".to_string(), None)
    .await?;
```

```go Go theme={null}
page, err := client.ForumPosts.List(context.TODO(), &whopsdk.ListForumPostsRequest{
    ExperienceID: "exp_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)
}

post, err := client.ForumPosts.Retrieve(context.TODO(), &whopsdk.RetrieveForumPostsRequest{
    ID: "post_xxxxxxxxxxxxx",
})
if err != nil {
    log.Fatal(err)
}
_ = post
```

## Comenta en una publicación

Los comentarios son publicaciones con un `parent_id`. Obtenlos pasando el ID de la publicación padre a `list`.

```typescript TypeScript theme={null}
const comment = await client.forumPosts.create({
  experience_id: "exp_xxxxxxxxxxxxx",
  content: "Great post!",
  parent_id: "post_xxxxxxxxxxxxx",
});

const comments = await client.forumPosts.list({
  experience_id: "exp_xxxxxxxxxxxxx",
  parent_id: "post_xxxxxxxxxxxxx",
  first: 10,
});

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

```python Python theme={null}
comment = client.forum_posts.create(
    experience_id="exp_xxxxxxxxxxxxx",
    content="Great post!",
    parent_id="post_xxxxxxxxxxxxx",
)

for item in client.forum_posts.list(
    experience_id="exp_xxxxxxxxxxxxx",
    parent_id="post_xxxxxxxxxxxxx",
    first=10,
):
    print(item)
```

```rust Rust theme={null}
let comment = client
    .forum_posts
    .create(
        &CreateForumPostsRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            content: Some("Great post!".to_string()),
            parent_id: Some("post_xxxxxxxxxxxxx".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

let comments = client
    .forum_posts
    .list(
        &ForumPostsListQueryRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            parent_id: Some("post_xxxxxxxxxxxxx".to_string()),
            first: Some(10),
            ..Default::default()
        },
        None,
    )
    .await?;

for item in comments.data {
    println!("{item:?}");
}
```

```go Go theme={null}
comment, err := client.ForumPosts.Create(context.TODO(), &whopsdk.CreateForumPostsRequest{
    ExperienceID: "exp_xxxxxxxxxxxxx",
    Content:      whopsdk.String("Great post!"),
    ParentID:     whopsdk.String("post_xxxxxxxxxxxxx"),
})
if err != nil {
    log.Fatal(err)
}
_ = comment

page, err := client.ForumPosts.List(context.TODO(), &whopsdk.ListForumPostsRequest{
    ExperienceID: "exp_xxxxxxxxxxxxx",
    ParentID:     whopsdk.String("post_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)
}
```

## Dale me gusta a una publicación

> [!NOTE]
>
> Las reacciones en los foros siempre son `:heart:`. Los mensajes de chat aceptan cualquier emoji, pero las reacciones de foro ignoran otros valores.

```typescript TypeScript theme={null}
await client.reactions.create({
  resource_id: "post_xxxxxxxxxxxxx",
  emoji: ":heart:",
});
```

```python Python theme={null}
client.reactions.create(
    resource_id="post_xxxxxxxxxxxxx",
    emoji=":heart:",
)
```

```rust Rust theme={null}
client
    .reactions
    .create(
        &CreateReactionsRequest {
            resource_id: "post_xxxxxxxxxxxxx".to_string(),
            emoji: Some(":heart:".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;
```

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

## Funciones avanzadas

### Publicaciones fijadas

Las publicaciones fijadas aparecen en la parte superior del feed. Usa `pinned: true` al crear una publicación.

```typescript TypeScript theme={null}
await client.forumPosts.create({
  experience_id: "exp_xxxxxxxxxxxxx",
  content: "Important announcement!",
  pinned: true,
});
```

```python Python theme={null}
client.forum_posts.create(
    experience_id="exp_xxxxxxxxxxxxx",
    content="Important announcement!",
    pinned=True,
)
```

```rust Rust theme={null}
client
    .forum_posts
    .create(
        &CreateForumPostsRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            content: Some("Important announcement!".to_string()),
            pinned: Some(true),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.ForumPosts.Create(context.TODO(), &whopsdk.CreateForumPostsRequest{
    ExperienceID: "exp_xxxxxxxxxxxxx",
    Content:      whopsdk.String("Important announcement!"),
    Pinned:       whopsdk.Bool(true),
})
if err != nil {
    log.Fatal(err)
}
```

### Menciona a usuarios

Usa `<@username>` en línea. Los usuarios mencionados reciben una notificación.

```typescript TypeScript theme={null}
await client.forumPosts.create({
  experience_id: "exp_xxxxxxxxxxxxx",
  content: "Hey <@username> check this out!",
});
```

```python Python theme={null}
client.forum_posts.create(
    experience_id="exp_xxxxxxxxxxxxx",
    content="Hey <@username> check this out!",
)
```

```rust Rust theme={null}
client
    .forum_posts
    .create(
        &CreateForumPostsRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            content: Some("Hey <@username> check this out!".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.ForumPosts.Create(context.TODO(), &whopsdk.CreateForumPostsRequest{
    ExperienceID: "exp_xxxxxxxxxxxxx",
    Content:      whopsdk.String("Hey <@username> check this out!"),
})
if err != nil {
    log.Fatal(err)
}
```

### Publicaciones con paywall

`paywall_amount` se expresa en centavos. Los lectores deben pagar para ver el contenido completo.

```typescript TypeScript theme={null}
await client.forumPosts.create({
  experience_id: "exp_xxxxxxxxxxxxx",
  title: "Premium post",
  content: "Exclusive content here",
  paywall_amount: 500, // $5.00
});
```

```python Python theme={null}
client.forum_posts.create(
    experience_id="exp_xxxxxxxxxxxxx",
    title="Premium post",
    content="Exclusive content here",
    paywall_amount=500,
)
```

```rust Rust theme={null}
client
    .forum_posts
    .create(
        &CreateForumPostsRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            title: Some("Premium post".to_string()),
            content: Some("Exclusive content here".to_string()),
            paywall_amount: Some(500.0), // $5.00
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.ForumPosts.Create(context.TODO(), &whopsdk.CreateForumPostsRequest{
    ExperienceID:  "exp_xxxxxxxxxxxxx",
    Title:         whopsdk.String("Premium post"),
    Content:       whopsdk.String("Exclusive content here"),
    PaywallAmount: whopsdk.Float64(500), // $5.00
})
if err != nil {
    log.Fatal(err)
}
```

### Paginación con cursores

Además de la paginación automática, puedes recorrer las páginas manualmente usando el `end_cursor` del `page_info` de la respuesta.

```typescript TypeScript theme={null}
const firstPage = await client.forumPosts.list({
  experience_id: "exp_xxxxxxxxxxxxx",
  first: 10,
});

const next = await client.forumPosts.list({
  experience_id: "exp_xxxxxxxxxxxxx",
  first: 10,
  after: firstPage.response.page_info.end_cursor ?? undefined,
});
```

```python Python theme={null}
first = client.forum_posts.list(
    experience_id="exp_xxxxxxxxxxxxx",
    first=10,
)

next_page = client.forum_posts.list(
    experience_id="exp_xxxxxxxxxxxxx",
    first=10,
    after=first.response.page_info.end_cursor,
)
```

```rust Rust theme={null}
let first_page = client
    .forum_posts
    .list(
        &ForumPostsListQueryRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            first: Some(10),
            ..Default::default()
        },
        None,
    )
    .await?;

let next = client
    .forum_posts
    .list(
        &ForumPostsListQueryRequest {
            experience_id: "exp_xxxxxxxxxxxxx".to_string(),
            first: Some(10),
            after: first_page.page_info.end_cursor.clone(),
            ..Default::default()
        },
        None,
    )
    .await?;

for item in next.data {
    println!("{item:?}");
}
```

```go Go theme={null}
firstPage, err := client.ForumPosts.List(context.TODO(), &whopsdk.ListForumPostsRequest{
    ExperienceID: "exp_xxxxxxxxxxxxx",
    First:        whopsdk.Int(10),
})
if err != nil {
    log.Fatal(err)
}

// Step to the next page manually
nextPage, err := firstPage.GetNextPage(context.TODO())
if err != nil {
    log.Fatal(err)
}
_ = nextPage
```

## Permisos necesarios

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

| Permiso | Necesario para |
| - | - |
| `forum:read` | Leer publicaciones y comentarios |
| `forum:post:create` | Crear publicaciones y comentarios |
| `chat:read` | Crear y leer reacciones |

> [accordion] Estructura del objeto de publicación
>
> ```typescript theme={null}
> {
>   id: string;
>   comment_count: number;
>   content: string | null;
>   is_edited: boolean;
>   is_pinned: boolean;
>   is_poster_admin: boolean;
>   like_count: number | null;
>   parent_id: string | null; // null = top-level, set = comment
>   title: string | null;
>   view_count: number | null;
>   user: { id: string; name: string | null; username: string };
> }
> ```
>
> Esquema completo: consulta la [referencia de la API de forum posts](https://docs.whop.com/es/api-reference/legacy/forum-posts/forum-post.md).

## Próximos pasos

> [card] [Crea un chatbot](https://docs.whop.com/es/developer/guides/chat.md)
>
> Combina publicaciones del foro con mensajes de chat en vivo en la misma comunidad.

> [card] [Escucha eventos con webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Reacciona en tiempo real en tu servidor a publicaciones y comentarios del foro.

> [card] [Envía notificaciones](https://docs.whop.com/es/developer/guides/notifications.md)
>
> Haz que los usuarios vuelvan a tu foro cuando haya algo nuevo.

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


## Related topics

- [Foro](https://docs.whop.com/es/api-reference/legacy/forums/forum.md)
- [Publicación del foro](https://docs.whop.com/es/api-reference/legacy/forum-posts/forum-post.md)
- [Migra desde versiones anteriores](https://docs.whop.com/es/developer/api/migrate-from-previous-versions.md)
