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

# Notifications push

> Envoyez des notifications push aux utilisateurs de votre app, ciblées par expérience ou par compte.

Envoyez des notifications push aux utilisateurs de votre app. Les notifications apparaissent dans l'app mobile Whop et dans l'interface web.

## Choisir votre type de notification

| | Notification d'expérience | Notification de compte |
| - | - | - |
| **Audience** | Utilisateurs ayant accès à une expérience | Membres de l'équipe d'un compte |
| **Idéal pour** | Apps destinées aux clients (alertes, social, fitness) | Apps de tableau de bord (actions d'administration, rapports, alertes) |
| **Champ de ciblage requis** | `experience_id` | `account_id` |
| **Filtrer sur des utilisateurs précis** | `user_ids` (doivent avoir accès à l'expérience) | `user_ids` (doivent être membres de l'équipe) |

> [!NOTE]
>
> L'envoi de notifications nécessite l'autorisation `notification:create`. Ajoutez-la en suivant le [guide des autorisations](https://docs.whop.com/fr/developer/guides/permissions.md). L'expérience doit appartenir à votre app, ou votre app doit être installée sur le compte.

## Envoyer à tous les utilisateurs d'une expérience

Envoyez des notifications à tous les utilisateurs ayant accès à une expérience :

```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]
>
> **Exemple de cas d'usage :** si vous créez une app de suivi sportif, vous pourriez
> envoyer une notification à tout le monde lors de la sortie d'un nouveau programme d'entraînement. Vous
> pourriez aussi envoyer des notifications ciblées aux utilisateurs ayant atteint une série de 7 jours
> pour célébrer leur réussite.

## Envoyer à des utilisateurs précis

Utilisez le paramètre `user_ids` pour n'envoyer des notifications qu'à certains utilisateurs. Ces utilisateurs doivent également avoir accès à l'expérience.

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

## Envoyer aux membres de l'équipe d'un compte

Envoyez des notifications à tous les membres de l'équipe d'un compte (utilisateurs d'apps de tableau de bord) :

```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]
>
> **Exemple de cas d'usage :** si vous créez un tableau de bord de déclaration fiscale, vous pourriez
> envoyer des notifications à tous les membres de l'équipe à l'approche d'une échéance de déclaration.
> Vous pourriez aussi envoyer des rappels ciblés aux utilisateurs qui doivent encore
> terminer certaines étapes de la déclaration.

## Envoyer à des membres précis de l'équipe

Utilisez le paramètre `user_ids` pour n'envoyer des notifications qu'à certains membres de l'équipe. Ces utilisateurs doivent également être membres de l'équipe du compte.

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

## Liens profonds avec rest\_path

Redirigez les utilisateurs vers des pages précises de votre app lorsqu'ils appuient sur une notification, grâce au paramètre `rest_path`.

## Configurer le chemin de votre app

Commencez par configurer le chemin de votre app dans le tableau de bord pour gérer le paramètre de route dynamique :

1. Accédez aux paramètres de votre app dans le [tableau de bord développeur](https://whop.com/dashboard/developer)
2. Dans la section d'hébergement, modifiez votre « App path » pour inclure `[restPath]`

**Pour les apps d'expérience :**

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

**Pour les apps de tableau de bord :**

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

## Envoyer des notifications avec des liens profonds

Ajoutez le paramètre `rest_path` à votre notification. Whop l'ajoute à l'URL de base de votre 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)
}
```

## Gérer la route dans votre app

Lorsqu'un utilisateur appuie sur la notification, Whop le redirige vers l'URL complète construite à partir du chemin de votre app et du `rest_path`.

**Exemple pour une app d'expérience :**

Si vous hébergez votre app à l'adresse `https://your-app.com` et envoyez :

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

L'utilisateur ouvrira :

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

**Avec Next.js**, créez un fichier à l'emplacement :

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

**Avec Express**, gérez la route :

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

Vous pouvez aussi utiliser des paramètres de requête :

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

## Icônes de notification personnalisées

Par défaut, les notifications affichent l'avatar de votre expérience, celui de votre compte, ou les deux. Personnalisez l'icône en fournissant l'ID utilisateur Whop dont vous voulez utiliser la photo de profil.

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

C'est utile pour les fonctionnalités sociales où vous voulez montrer qui a effectué une action (commentaire, j'aime, abonnement, etc.).

## Étapes suivantes

> [card] [Créer un chatbot](https://docs.whop.com/fr/developer/guides/chat.md)
>
> Associez les notifications aux messages in-app pour que les utilisateurs soient prévenus où qu'ils se trouvent.

> [card] [Écouter les webhooks](https://docs.whop.com/fr/developer/guides/webhooks.md)
>
> Déclenchez des notifications à partir de `payment.succeeded`, `membership.activated` et d'autres événements serveur.

> [card] [Forums](https://docs.whop.com/fr/developer/guides/forums.md)
>
> Prévenez les utilisateurs lorsque de nouveaux posts ou commentaires arrivent dans votre expérience de forum.

> [card] [Demander des autorisations](https://docs.whop.com/fr/developer/guides/permissions.md)
>
> Vérifiez la configuration des autorisations de votre app pour que les notifications soient bien envoyées.
