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

# Notificaciones push

> Envía notificaciones push a los usuarios de tu app, limitadas por experiencia o por cuenta.

Envía notificaciones push a los usuarios de tu app. Las notificaciones aparecen en la app móvil y en la interfaz web de Whop.

## Elige tu tipo de notificación

| | Notificación de experiencia | Notificación de cuenta |
| - | - | - |
| **Audiencia** | Usuarios con acceso a una experiencia | Miembros del equipo de una cuenta |
| **Ideal para** | Apps orientadas a clientes (alertas, redes sociales, fitness) | Apps de panel (acciones de administración, informes, alertas) |
| **Campo clave obligatorio** | `experience_id` | `account_id` |
| **Filtrar a usuarios específicos** | `user_ids` (deben tener acceso a la experiencia) | `user_ids` (deben ser miembros del equipo) |

> [!NOTE]
>
> Enviar notificaciones requiere el permiso `notification:create`. Añádelo siguiendo la [guía de permisos](https://docs.whop.com/es/developer/guides/permissions.md). La experiencia debe pertenecer a tu app, o la cuenta debe tener tu app instalada.

## Envía a todos los usuarios de una experiencia

Envía notificaciones a todos los usuarios con acceso a una experiencia:

```typescript TypeScript theme={null}
const result = await client.notifications.create({
  experience_id: 'exp_xxxxxxxxxxxxxx',
  title: 'New Feature Available',
  subtitle: 'Check it out now',
  content: 'We just released a new feature that helps you track your progress better.',
});

console.log(result.success); // true

```

```python Python theme={null}
result = client.notifications.create(
    experience_id="exp_xxxxxxxxxxxxxx",
    title="New Feature Available",
    subtitle="Check it out now",
    content="We just released a new feature that helps you track your progress better.",
)

print(result.success)  # True
```

```ruby Ruby theme={null}
result = client.notifications.create(
  experience_id: "exp_xxxxxxxxxxxxxx",
  title: "New Feature Available",
  subtitle: "Check it out now",
  content: "We just released a new feature that helps you track your progress better."
)

puts result.success  # true
```

```rust Rust theme={null}
let result = client
    .notifications
    .create(
        &CreateNotificationsRequest {
            experience_id: Some("exp_xxxxxxxxxxxxxx".to_string()),
            title: "New Feature Available".to_string(),
            subtitle: Some("Check it out now".to_string()),
            content: "We just released a new feature that helps you track your progress better."
                .to_string(),
            ..Default::default()
        },
        None,
    )
    .await?;

println!("{}", result.success); // true
```

```go Go theme={null}
result, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    ExperienceID: whopsdk.String("exp_xxxxxxxxxxxxxx"),
    Title:        "New Feature Available",
    Subtitle:     whopsdk.String("Check it out now"),
    Content:      "We just released a new feature that helps you track your progress better.",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(result.Success) // true
```

> [!NOTE]
>
> **Caso de uso de ejemplo:** si estás creando una app de seguimiento de fitness, podrías
> enviar una notificación a todos cuando se publique un nuevo programa de entrenamiento. También
> podrías enviar notificaciones dirigidas a los usuarios que completaron una racha de 7 días
> para celebrar su logro.

## Envía a usuarios específicos

Usa el parámetro `user_ids` para enviar notificaciones solo a usuarios específicos. Estos usuarios también deben tener acceso a la experiencia.

```typescript TypeScript theme={null}
const result = await client.notifications.create({
  experience_id: 'exp_xxxxxxxxxxxxxx',
  title: 'Complete your daily workout',
  content: 'You\'re 50% of the way to your goal. Finish strong!',
  user_ids: ['user_abc123', 'user_def456'],
});
```

```python Python theme={null}
result = client.notifications.create(
    experience_id="exp_xxxxxxxxxxxxxx",
    title="Complete your daily workout",
    content="You're 50% of the way to your goal. Finish strong!",
    user_ids=["user_abc123", "user_def456"],
)
```

```ruby Ruby theme={null}
result = client.notifications.create(
  experience_id: "exp_xxxxxxxxxxxxxx",
  title: "Complete your daily workout",
  content: "You're 50% of the way to your goal. Finish strong!",
  user_ids: ["user_abc123", "user_def456"]
)
```

```rust Rust theme={null}
client
    .notifications
    .create(
        &CreateNotificationsRequest {
            experience_id: Some("exp_xxxxxxxxxxxxxx".to_string()),
            title: "Complete your daily workout".to_string(),
            content: "You're 50% of the way to your goal. Finish strong!".to_string(),
            user_ids: Some(vec!["user_abc123".to_string(), "user_def456".to_string()]),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    ExperienceID: whopsdk.String("exp_xxxxxxxxxxxxxx"),
    Title:        "Complete your daily workout",
    Content:      "You're 50% of the way to your goal. Finish strong!",
    UserIDs:      []string{"user_abc123", "user_def456"},
})
if err != nil {
    log.Fatal(err)
}
```

## Envía a los miembros del equipo de una cuenta

Envía notificaciones a todos los miembros del equipo de una cuenta (usuarios de apps de panel):

```typescript TypeScript theme={null}
const result = await client.notifications.create({
  account_id: 'biz_xxxxxxxxxxxxxx',
  title: 'Monthly Report Ready',
  subtitle: 'October 2024',
  content: 'Your monthly analytics report has been generated and is ready to view.',
});
```

```python Python theme={null}
result = client.notifications.create(
    account_id="biz_xxxxxxxxxxxxxx",
    title="Monthly Report Ready",
    subtitle="October 2024",
    content="Your monthly analytics report has been generated and is ready to view.",
)
```

```ruby Ruby theme={null}
result = client.notifications.create(
  account_id: "biz_xxxxxxxxxxxxxx",
  title: "Monthly Report Ready",
  subtitle: "October 2024",
  content: "Your monthly analytics report has been generated and is ready to view."
)
```

```rust Rust theme={null}
let result = client
    .notifications
    .create(
        &CreateNotificationsRequest {
            account_id: Some("biz_xxxxxxxxxxxxxx".to_string()),
            title: "Monthly Report Ready".to_string(),
            subtitle: Some("October 2024".to_string()),
            content: "Your monthly analytics report has been generated and is ready to view."
                .to_string(),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxxx"),
    Title:     "Monthly Report Ready",
    Subtitle:  whopsdk.String("October 2024"),
    Content:   "Your monthly analytics report has been generated and is ready to view.",
})
if err != nil {
    log.Fatal(err)
}
```

> [!NOTE]
>
> **Caso de uso de ejemplo:** si estás creando un panel de declaración de impuestos, podrías
> enviar notificaciones a todos los miembros del equipo cuando se acerque una fecha límite de presentación.
> También podrías enviar recordatorios dirigidos a usuarios específicos que aún deban
> completar pasos del proceso de presentación.

## Envía a miembros específicos del equipo

Usa el parámetro `user_ids` para enviar notificaciones solo a miembros específicos del equipo. Estos usuarios también deben ser miembros del equipo de la cuenta.

```typescript TypeScript theme={null}
const result = await client.notifications.create({
  account_id: 'biz_xxxxxxxxxxxxxx',
  title: 'Action Required',
  content: 'Please review and approve the pending invoices.',
  user_ids: ['user_manager1', 'user_manager2'],
});
```

```python Python theme={null}
result = client.notifications.create(
    account_id="biz_xxxxxxxxxxxxxx",
    title="Action Required",
    content="Please review and approve the pending invoices.",
    user_ids=["user_manager1", "user_manager2"],
)
```

```ruby Ruby theme={null}
result = client.notifications.create(
  account_id: "biz_xxxxxxxxxxxxxx",
  title: "Action Required",
  content: "Please review and approve the pending invoices.",
  user_ids: ["user_manager1", "user_manager2"]
)
```

```rust Rust theme={null}
client
    .notifications
    .create(
        &CreateNotificationsRequest {
            account_id: Some("biz_xxxxxxxxxxxxxx".to_string()),
            title: "Action Required".to_string(),
            content: "Please review and approve the pending invoices.".to_string(),
            user_ids: Some(vec!["user_manager1".to_string(), "user_manager2".to_string()]),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxxx"),
    Title:     "Action Required",
    Content:   "Please review and approve the pending invoices.",
    UserIDs:   []string{"user_manager1", "user_manager2"},
})
if err != nil {
    log.Fatal(err)
}
```

## Enlaces profundos con rest\_path

Dirige a los usuarios a páginas específicas de tu app cuando toquen una notificación usando el parámetro `rest_path`.

## Configura la ruta de tu app

Primero, configura la ruta de tu app en el panel para que gestione el parámetro de ruta dinámica:

1. Ve a la configuración de tu app en el [panel de desarrollador](https://whop.com/dashboard/developer)
2. En la sección de hosting, actualiza tu "App path" para que incluya `[restPath]`

**Para apps de experiencia:**

```
/experiences/[experienceId]/[restPath]
```

**Para apps de panel:**

```
/companies/[companyId]/[restPath]
```

## Envía notificaciones con enlaces profundos

Añade el parámetro `rest_path` a tu notificación. Whop lo agrega a la URL base de tu app.

```typescript TypeScript theme={null}
// Experience app: Direct to a specific workout
await client.notifications.create({
  experience_id: 'exp_xxxxxxxxxxxxxx',
  title: 'Today\'s Recommended Workout',
  content: 'Based on your progress, we recommend this HIIT session.',
  rest_path: '/workouts/hiit-advanced-1',
});

// Dashboard app: Direct to a specific report
await client.notifications.create({
  account_id: 'biz_xxxxxxxxxxxxxx',
  title: 'Unusual Activity Detected',
  content: 'Review the flagged transactions in your dashboard.',
  rest_path: '/reports/flagged-transactions',
});

```

```python Python theme={null}
# Experience app: Direct to a specific workout
client.notifications.create(
    experience_id="exp_xxxxxxxxxxxxxx",
    title="Today's Recommended Workout",
    content="Based on your progress, we recommend this HIIT session.",
    rest_path="/workouts/hiit-advanced-1",
)

# Dashboard app: Direct to a specific report
client.notifications.create(
    account_id="biz_xxxxxxxxxxxxxx",
    title="Unusual Activity Detected",
    content="Review the flagged transactions in your dashboard.",
    rest_path="/reports/flagged-transactions",
)
```

```ruby Ruby theme={null}
# Experience app: Direct to a specific workout
client.notifications.create(
  experience_id: "exp_xxxxxxxxxxxxxx",
  title: "Today's Recommended Workout",
  content: "Based on your progress, we recommend this HIIT session.",
  rest_path: "/workouts/hiit-advanced-1"
)

# Dashboard app: Direct to a specific report
client.notifications.create(
  account_id: "biz_xxxxxxxxxxxxxx",
  title: "Unusual Activity Detected",
  content: "Review the flagged transactions in your dashboard.",
  rest_path: "/reports/flagged-transactions"
)
```

```rust Rust theme={null}
// Experience app: Direct to a specific workout
client
    .notifications
    .create(
        &CreateNotificationsRequest {
            experience_id: Some("exp_xxxxxxxxxxxxxx".to_string()),
            title: "Today's Recommended Workout".to_string(),
            content: "Based on your progress, we recommend this HIIT session.".to_string(),
            rest_path: Some("/workouts/hiit-advanced-1".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;

// Dashboard app: Direct to a specific report
client
    .notifications
    .create(
        &CreateNotificationsRequest {
            account_id: Some("biz_xxxxxxxxxxxxxx".to_string()),
            title: "Unusual Activity Detected".to_string(),
            content: "Review the flagged transactions in your dashboard.".to_string(),
            rest_path: Some("/reports/flagged-transactions".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
// Experience app: Direct to a specific workout
_, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    ExperienceID: whopsdk.String("exp_xxxxxxxxxxxxxx"),
    Title:        "Today's Recommended Workout",
    Content:      "Based on your progress, we recommend this HIIT session.",
    RestPath:     whopsdk.String("/workouts/hiit-advanced-1"),
})
if err != nil {
    log.Fatal(err)
}

// Dashboard app: Direct to a specific report
_, err = client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    AccountID: whopsdk.String("biz_xxxxxxxxxxxxxx"),
    Title:     "Unusual Activity Detected",
    Content:   "Review the flagged transactions in your dashboard.",
    RestPath:  whopsdk.String("/reports/flagged-transactions"),
})
if err != nil {
    log.Fatal(err)
}
```

## Gestiona la ruta en tu app

Cuando un usuario toca la notificación, Whop lo dirige a la URL completa construida a partir de la ruta de tu app y el `rest_path`.

**Ejemplo para una app de experiencia:**

Si alojas tu app en `https://your-app.com` y envías:

```typescript theme={null}
rest_path: "/posts/post_123";
```

El usuario abrirá:

```
https://your-app.com/experiences/exp_xxxxxxxxxxxxxx/posts/post_123
```

**En Next.js**, crea un archivo en:

```
app/experiences/[experienceId]/posts/[postId]/page.tsx
```

**En Express**, gestiona la ruta:

```typescript theme={null}
app.get("/experiences/:experienceId/posts/:postId", (req, res) => {
	// Handle the notification deep link
});
```

También puedes usar parámetros de consulta:

```typescript theme={null}
rest_path: "?action=review&id=123";
```

## Iconos de notificación personalizados

De forma predeterminada, las notificaciones muestran el avatar de tu experiencia, el avatar de tu cuenta o ambos. Personaliza el icono proporcionando el ID de usuario de Whop cuya foto de perfil quieres usar.

```typescript TypeScript theme={null}
await client.notifications.create({
  experience_id: 'exp_xxxxxxxxxxxxxx',
  title: 'New Comment',
  content: 'Sarah replied to your post: "Great progress!"',
  icon_user_id: 'user_xxxxxxxxxxxxx',
  rest_path: '/posts/my-post-123',
});
```

```python Python theme={null}
client.notifications.create(
    experience_id="exp_xxxxxxxxxxxxxx",
    title="New Comment",
    content='Sarah replied to your post: "Great progress!"',
    icon_user_id="user_xxxxxxxxxxxxx",
    rest_path="/posts/my-post-123",
)
```

```ruby Ruby theme={null}
client.notifications.create(
  experience_id: "exp_xxxxxxxxxxxxxx",
  title: "New Comment",
  content: 'Sarah replied to your post: "Great progress!"',
  icon_user_id: "user_xxxxxxxxxxxxx",
  rest_path: "/posts/my-post-123"
)
```

```rust Rust theme={null}
client
    .notifications
    .create(
        &CreateNotificationsRequest {
            experience_id: Some("exp_xxxxxxxxxxxxxx".to_string()),
            title: "New Comment".to_string(),
            content: "Sarah replied to your post: \"Great progress!\"".to_string(),
            icon_user_id: Some("user_sarah123".to_string()),
            rest_path: Some("/posts/my-post-123".to_string()),
            ..Default::default()
        },
        None,
    )
    .await?;
```

```go Go theme={null}
_, err := client.Notifications.Create(context.TODO(), &whopsdk.CreateNotificationsRequest{
    ExperienceID: whopsdk.String("exp_xxxxxxxxxxxxxx"),
    Title:        "New Comment",
    Content:      `Sarah replied to your post: "Great progress!"`,
    IconUserID:   whopsdk.String("user_sarah123"),
    RestPath:     whopsdk.String("/posts/my-post-123"),
})
if err != nil {
    log.Fatal(err)
}
```

Esto es útil para funciones sociales en las que quieres mostrar quién realizó una acción (comentó, dio me gusta, siguió, etc.).

## Próximos pasos

> [card] [Crea un chatbot](https://docs.whop.com/es/developer/guides/chat.md)
>
> Combina las notificaciones con mensajes dentro de la app para que los usuarios reciban avisos estén donde estén.

> [card] [Escucha webhooks](https://docs.whop.com/es/developer/guides/webhooks.md)
>
> Dispara notificaciones a partir de `payment.succeeded`, `membership.activated` y otros eventos del servidor.

> [card] [Foros](https://docs.whop.com/es/developer/guides/forums.md)
>
> Avisa a los usuarios cuando lleguen nuevas publicaciones o comentarios a tu experiencia de foro.

> [card] [Solicita permisos](https://docs.whop.com/es/developer/guides/permissions.md)
>
> Confirma la configuración de permisos de tu app para que las notificaciones se envíen correctamente.


## Related topics

- [Comunidades y chat](https://docs.whop.com/es/developer/communities/overview.md)
- [API de chat](https://docs.whop.com/es/developer/guides/chat.md)
- [Retrieve Notification](https://docs.whop.com/es/api-reference/notifications/retrieve-notification.md)
