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

# Push-notifikationer

> Send push-notifikationer til brugere i din app, afgrænset efter experience eller konto.

Send push-notifikationer til brugere i din app. Notifikationer vises i Whops mobilapp og webgrænseflade.

## Vælg din notifikationstype

| | Experience-notifikation | Kontonotifikation |
| - | - | - |
| **Målgruppe** | Brugere med adgang til en experience | Teammedlemmer på en konto |
| **Bedst til** | Kundevendte apps (advarsler, socialt, fitness) | Dashboard-apps (administrationshandlinger, rapporter, advarsler) |
| **Påkrævet nøglefelt** | `experience_id` | `account_id` |
| **Filtrer til bestemte brugere** | `user_ids` (skal have adgang til experiencen) | `user_ids` (skal være teammedlemmer) |

> [!NOTE]
>
> Afsendelse af notifikationer kræver tilladelsen `notification:create`. Tilføj den via [guiden til tilladelser](https://docs.whop.com/da/developer/guides/permissions.md). Experiencen skal tilhøre din app, eller kontoen skal have din app installeret.

## Send til alle i en experience

Send notifikationer til alle brugere med adgang til en experience:

```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]
>
> **Eksempel på brug:** Hvis du bygger en app til fitnesssporing, kan du
> sende en notifikation til alle, når et nyt træningsprogram udkommer. Du
> kan også sende målrettede notifikationer til brugere, der har gennemført en
> 7-dages stime, for at fejre deres præstation.

## Send til bestemte brugere

Brug parameteren `user_ids` til kun at sende notifikationer til bestemte brugere. Disse brugere skal også have adgang til experiencen.

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

## Send til en kontos teammedlemmer

Send notifikationer til alle teammedlemmer på en konto (brugere af dashboard-apps):

```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]
>
> **Eksempel på brug:** Hvis du bygger et dashboard til selvangivelser, kan du
> sende notifikationer til alle teammedlemmer, når en indleveringsfrist nærmer sig.
> Du kan også sende målrettede påmindelser til bestemte brugere, der stadig mangler
> at gennemføre trin i indleveringsprocessen.

## Send til bestemte teammedlemmer

Brug parameteren `user_ids` til kun at sende notifikationer til bestemte teammedlemmer. Disse brugere skal også være teammedlemmer på kontoen.

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

## Deep link med rest\_path

Send brugere til bestemte sider i din app, når de trykker på en notifikation, ved hjælp af parameteren `rest_path`.

## Opsætning af din app-sti

Konfigurer først din app-sti i dashboardet, så den håndterer den dynamiske ruteparameter:

1. Gå til dine appindstillinger i [developer dashboard](https://whop.com/dashboard/developer)
2. Opdater i hosting-sektionen din "App path", så den indeholder `[restPath]`

**For experience-apps:**

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

**For dashboard-apps:**

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

## Afsendelse af notifikationer med deep links

Tilføj parameteren `rest_path` til din notifikation. Whop tilføjer den til din apps basis-URL.

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

## Håndtering af ruten i din app

Når en bruger trykker på notifikationen, sender Whop vedkommende til den fulde URL, der er sammensat af din app-sti og `rest_path`.

**Eksempel for experience-app:**

Hvis du hoster din app på `https://your-app.com` og sender:

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

Åbner brugeren:

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

**I Next.js** opretter du en fil her:

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

**I Express** håndterer du ruten:

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

Du kan også bruge query-parametre:

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

## Brugerdefinerede notifikationsikoner

Som standard viser notifikationer din experience-avatar, din konto-avatar eller begge. Tilpas ikonet ved at angive Whop-bruger-ID'et for det profilbillede, du vil bruge.

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

Det er nyttigt til sociale funktioner, hvor du vil vise, hvem der udførte en handling (kommenterede, likede, fulgte osv.).

## Næste trin

> [card] [Byg en chatbot](https://docs.whop.com/da/developer/guides/chat.md)
>
> Kombiner notifikationer med beskeder i appen, så brugere får besked, uanset hvor de er.

> [card] [Lyt til webhooks](https://docs.whop.com/da/developer/guides/webhooks.md)
>
> Udløs notifikationer ud fra `payment.succeeded`, `membership.activated` og andre server-events.

> [card] [Fora](https://docs.whop.com/da/developer/guides/forums.md)
>
> Giv brugere besked, når nye opslag eller kommentarer lander i din forum-experience.

> [card] [Anmod om tilladelser](https://docs.whop.com/da/developer/guides/permissions.md)
>
> Bekræft din apps opsætning af tilladelser, så notifikationer sendes korrekt.
