Novu

https://docs.novu.co/platform
Admin
Novu is an open-source notification infrastructure platform that simplifies the implementation and...
Tokens:254,783
Snippets:2,231
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Novu Go SDK

Source: https://docs.novu.co/platform/sdks/server/go

Use the go get command to add the Novu Go SDK to your project dependencies.

```go
go get github.com/novuhq/novu-go
```

--------------------------------

### Install the React SDK

Source: https://docs.novu.co/platform/inbox/headless-mode

Use npm to install the required Novu React package.

```bash
npm i @novu/react
```

--------------------------------

### Run the application

Source: https://docs.novu.co/platform/quickstart/angular

Start the development server to view the application.

```bash
npm run start
```

--------------------------------

### Install Novu React package

Source: https://docs.novu.co/platform/inbox/migration-guide

Install the required dependency to begin the migration.

```bash
npm install @novu/react
```

--------------------------------

### Install Novu SDK

Source: https://docs.novu.co/platform/quickstart/angular

Install the required @novu/js package via npm.

```bash
npm install @novu/js
```

--------------------------------

### Run development server

Source: https://docs.novu.co/platform/quickstart/nextjs

Start the local development server to view the changes.

```bash
npm run dev
```

--------------------------------

### Install Agent Toolkit

Source: https://docs.novu.co/platform/build-with-ai/agent-toolkit

Install the core toolkit package via npm.

```bash
npm install @novu/agent-toolkit
```

--------------------------------

### Install Novu Python SDK

Source: https://docs.novu.co/platform/sdks/server/python

Commands to install the SDK using common Python package managers.

```bash
pip install novu-py
```

```bash
poetry add novu-py
```

--------------------------------

### Install Novu SDK

Source: https://docs.novu.co/platform/sdks/server/typescript

Commands to install the @novu/api package using various package managers.

```bash
npm add @novu/api
```

```bash
pnpm add @novu/api
```

```bash
yarn add @novu/api zod@^3

## Note that Yarn does not install peer dependencies automatically. You will need

## to install zod as shown above.
```

```bash
bun add @novu/api
```

--------------------------------

### Install Novu Next.js SDK

Source: https://docs.novu.co/platform/quickstart/nextjs

Install the required package via npm to begin using Novu components.

```bash
npm install @novu/nextjs
```

--------------------------------

### Install Novu Inbox dependencies

Source: https://docs.novu.co/platform/inbox/setup-inbox

Install the required package for your specific framework.

```bash
npm install @novu/nextjs
```

```bash
npm install @novu/react
```

--------------------------------

### Install and Initialize Novu Inbox

Source: https://docs.novu.co/platform/build-with-ai/skills

Installation commands and basic initialization for the Novu Inbox component in different web environments.

```bash
npm install @novu/react
```

```tsx
import { Inbox } from "@novu/react";

function App() {
  return (
    <Inbox
      applicationIdentifier="YOUR_NOVU_APP_ID"
      subscriberId="subscriber-123"
      subscriberHash="HMAC_HASH"  // Required if HMAC encryption is enabled
    />
  );
}
```

```bash
npm install @novu/nextjs
```

```tsx
// components/NotificationInbox.tsx
"use client"; // Required for App Router

import { Inbox } from "@novu/nextjs";

export function NotificationInbox() {
  return (
    <Inbox
      applicationIdentifier={process.env.NEXT_PUBLIC_NOVU_APP_ID!}
      subscriberId="subscriber-123"
      subscriberHash="HMAC_HASH"
    />
  );
}
```

```bash
npm install @novu/js
```

```typescript
import { Novu } from "@novu/js";

const novu = new Novu({
  applicationIdentifier: "YOUR_NOVU_APP_ID",
  subscriberId: "subscriber-123",
});
```

--------------------------------

### Install Novu Ruby SDK

Source: https://docs.novu.co/platform/sdks/server/ruby

Use the gem command to install the Novu package in your Ruby environment.

```bash
gem install novu
```

--------------------------------

### Install Novu .NET SDK

Source: https://docs.novu.co/platform/sdks/server/dotnet

Use the dotnet CLI to add the Novu package to your project.

```csharp
dotnet add package Novu
```

--------------------------------

### Install Novu React Native SDK

Source: https://docs.novu.co/platform/sdks/react-native

Install the required package via npm.

```bash
npm install @novu/react-native
```

--------------------------------

### Install Novu Framework

Source: https://docs.novu.co/platform/workflow/add-and-configure-steps/code-steps

Install the framework as a development dependency to enable TypeScript type support for workflow components.

```bash
npm install --save-dev @novu/framework
```

--------------------------------

### Digest Count Summary Output Example

Source: https://docs.novu.co/platform/workflow/add-notification-content/personalize-content

Example output for the countSummary helper.

```text
5 notifications
```

--------------------------------

### Initialize React project with Vite

Source: https://docs.novu.co/platform/quickstart/react

Commands to scaffold a new React TypeScript project and install dependencies.

```bash
npm create vite@latest novu-inbox-react -- --template react-ts
cd novu-inbox-react
npm install
npm run dev
```

--------------------------------

### Configure Kannel integration credentials

Source: https://docs.novu.co/platform/integrations/sms/kannel

Example configuration snippet for setting up authentication and connection details for the Kannel gateway.

```bash
  group = smsc
  smsc = smpp
  smsc-id = YourSMSCID
  host = SMSC_Hostname_or_IP
  port = SMSC_Port
  smsc-username = YourUsername
  smsc-password = YourPassword
  max-pending-submits = 10
  allow-ip = "127.0.0.1"
```

--------------------------------

### Install Novu Java SDK with Gradle

Source: https://docs.novu.co/platform/sdks/server/java

Add this implementation line to your build.gradle file.

```groovy
implementation 'co.novu:novu-java:LATEST'
```

--------------------------------

### Install Novu PHP SDK

Source: https://docs.novu.co/platform/sdks/server/php

Use Composer to add the Novu SDK as a dependency to your project.

```bash
composer require "novuhq/novu"
```

--------------------------------

### Digest Sentence Summary Output Example

Source: https://docs.novu.co/platform/workflow/add-notification-content/personalize-content

Example output for the sentenceSummary helper.

```text
Radek, Dima, and 5 others
```

--------------------------------

### Install Novu Kotlin SDK

Source: https://docs.novu.co/platform/sdks/server/kotlin

Add the Novu dependency to your project using Maven or Gradle.

```xml
<dependency>
    <groupId>co.novu</groupId>
    <artifactId>novu-kotlin</artifactId>
    <version>{use-latest-version}</version>
  </dependency>
```

```groovy
implementation 'co.novu:novu-kotlin:{use-latest-version}'
```

```kotlin
implementation("co.novu:novu-kotlin:{use-latest-version}")
```

--------------------------------

### Translation file structure

Source: https://docs.novu.co/platform/workflow/advanced-features/translations

Example directory layout for locale files.

```text
translations/
├── en_US.json
├── fr_FR.json
├── es_ES.json
└── de_DE.json
```

--------------------------------

### Start Kannel bearerbox

Source: https://docs.novu.co/platform/integrations/sms/kannel

Command to initiate the Kannel bearerbox process using a specific configuration file.

```bash
   bearerbox /path/to/kannel.conf
```

--------------------------------

### Translation JSON content example

Source: https://docs.novu.co/platform/workflow/advanced-features/translations

Format for individual translation files.

```json
{
  "workflows": {
    "welcome": {
      "subject": "Welcome to our platform!",
      "body": "Thank you for joining us."
    }
  }
}
```

--------------------------------

### Bulk create subscribers

Source: https://docs.novu.co/platform/build-with-ai/skills

Use these examples to create multiple subscribers in a single API request.

```java
novu.subscribers().createBulk().body(BulkSubscriberCreateDto.builder()
    .subscribers(List.of(
        CreateSubscriberRequestDto.builder().subscriberId("user-1").email("alice@example.com").firstName("Alice").build(),
        CreateSubscriberRequestDto.builder().subscriberId("user-2").email("bob@example.com").firstName("Bob").build()))
    .build()).call();
```

```bash
curl -X POST 'https://api.novu.co/v2/subscribers/bulk' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
  "subscribers": [
    { "subscriberId": "user-1", "email": "alice@example.com", "firstName": "Alice" },
    { "subscriberId": "user-2", "email": "bob@example.com", "firstName": "Bob" }
  ]
}'
```

--------------------------------

### Trigger Workflow

Source: https://docs.novu.co/platform/sdks/server/go

Trigger a workflow using the Novu Go SDK. The US region example uses the default configuration, while the EU region example requires a custom server URL.

```go
package main

import (
	"context"
	novugo "github.com/novuhq/novu-go"
	"github.com/novuhq/novu-go/models/components"
	"log"
	"os"
)

func main() {
ctx := context.Background()

    s := novugo.New(
    	novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")),
    )

    res, err := s.Trigger(ctx, components.TriggerEventRequestDto{
    	WorkflowID: "workflow_identifier",
    	Payload: map[string]any{
    		"comment_id": "string",
    		"post": map[string]any{
    			"text": "string",
    		},
    	},
    	Overrides: map[string]map[string]any{
    		"email": map[string]any{
    			"bcc": "no-reply@novu.co",
    		},
    	},
    	To: components.CreateToSubscriberPayloadDto(
    		components.SubscriberPayloadDto{
    			SubscriberID: "subscriber_uniuqe_identifier",
    			FirstName: "Albert",
    			LastName: "Einstein",
    			Email: "albert@einstein.com",
    		},
    	),
    }, nil)
    if err != nil {
    	log.Fatal(err)
    }
    if res.TriggerEventResponseDto != nil {
    	// handle response
    }

}
```

```go
package main

import (
	"context"
	novugo "github.com/novuhq/novu-go"
	"github.com/novuhq/novu-go/models/components"
	"log"
	"os"
)

func main() {
	ctx := context.Background()

	s := novugo.New(
		novugo.WithServerURL("https://eu.api.novu.co"),
		novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")),
	)

	res, err := s.Trigger(ctx, components.TriggerEventRequestDto{
		WorkflowID: "workflow_identifier",
		Payload: map[string]any{
			"comment_id": "string",
			"post": map[string]any{
				"text": "string",
			},
		},
		Overrides: map[string]map[string]any{
			"email": map[string]any{
				"bcc": "no-reply@novu.co",
			},
		},
		To: components.CreateToSubscriberPayloadDto(
			components.SubscriberPayloadDto{
				SubscriberID: "subscriber_uniuqe_identifier",
				FirstName: "Albert",
				LastName: "Einstein",
				Email: "albert@einstein.com",
			},
		),
	}, nil)
	if err != nil {
		log.Fatal(err)
	}
	if res.TriggerEventResponseDto != nil {
		// handle response
	}
}
```

--------------------------------

### Create a context via API

Source: https://docs.novu.co/platform/workflow/advanced-features/contexts/manage-contexts

Examples for creating a new context using different programming languages and the Novu API.

```ts
import { Novu } from "@novu/api"

const novu = new Novu({ secretKey: "<YOUR_SECRET_KEY_HERE>" });

await novu.contexts.create({
  type: "tenant",
  id: "acme-corp",
  data: {
    name: "Acme Corporation",
    plan: "enterprise",
  },
});
```

```python
import os
from novu_py import Novu

with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
    novu.contexts.create(create_context_request_dto={
        "type": "tenant",
        "id": "acme-corp",
        "data": {
            "name": "Acme Corporation",
            "plan": "enterprise",
        },
    })
```

```go
import (
    "context"
    "os"

    novugo "github.com/novuhq/novu-go"
    "github.com/novuhq/novu-go/models/components"
)

s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

res, err := s.Contexts.Create(context.Background(), components.CreateContextRequestDto{
    Type: "tenant",
    ID:   "acme-corp",
    Data: map[string]any{
        "name": "Acme Corporation",
        "plan": "enterprise",
    },
}, nil)
```

```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<YOUR_SECRET_KEY_HERE>')
    ->build();

$sdk->contexts->create(
    createContextRequestDto: new Components\CreateContextRequestDto(
        type: 'tenant',
        id: 'acme-corp',
        data: [
            'name' => 'Acme Corporation',
            'plan' => 'enterprise',
        ],
    ),
);
```

```csharp
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;

var sdk = new NovuSDK(secretKey: "<YOUR_SECRET_KEY_HERE>");

await sdk.Contexts.CreateAsync(createContextRequestDto: new CreateContextRequestDto() {
    Type = "tenant",
    Id = "acme-corp",
    Data = new Dictionary<string, object>() {
        { "name", "Acme Corporation" },
        { "plan", "enterprise" },
    },
});
```

```java
import co.novu.Novu;
import co.novu.models.components.CreateContextRequestDto;
import java.util.Map;

Novu novu = Novu.builder()
    .secretKey("<YOUR_SECRET_KEY_HERE>")
    .build();

novu.contexts().create()
    .body(CreateContextRequestDto.builder()
        .type("tenant")
        .id("acme-corp")
        .data(Map.ofEntries(
            Map.entry("name", "Acme Corporation"),
            Map.entry("plan", "enterprise")))
        .build())
    .call();
```

```bash
curl -L -g -X POST 'https://api.novu.co/v2/contexts' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
    "type": "tenant",
    "id": "acme-corp",
    "data": {
        "name": "Acme Corporation",
        "plan": "enterprise"
    }
}'
```

--------------------------------

### Create a Tool Webhook Endpoint

Source: https://docs.novu.co/platform/integrations/tool/webhook

Use these examples to register a new tool webhook endpoint for a subscriber.

```java
import co.novu.Novu;
import co.novu.models.components.*;

Novu novu = Novu.builder().secretKey("<NOVU_SECRET_KEY>").build();

novu.channelEndpoints().create()
    .body(CreateToolWebhookEndpointDto.builder()
        .type("tool_webhook")
        .integrationIdentifier("tool-webhook")
        .subscriberId("<SUBSCRIBER_ID>")
        .createSubscriberIfMissing(true)
        .endpoint(ToolWebhookEndpointDto.builder()
            .url("https://customer.example.com/hooks/novu")
            .headers(Map.of("Authorization", "Bearer subscriber-token"))
            .method("POST")
            .build())
        .build())
    .call();
```

```bash
curl -L -X POST 'https://api.novu.co/v1/channel-endpoints' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
  "type": "tool_webhook",
  "integrationIdentifier": "tool-webhook",
  "subscriberId": "<SUBSCRIBER_ID>",
  "createSubscriberIfMissing": true,
  "endpoint": {
    "url": "https://customer.example.com/hooks/novu",
    "headers": {
      "Authorization": "Bearer subscriber-token"
    },
    "method": "POST"
  }
}'
```

--------------------------------

### GET /v1/inbox/topics/{topicKey}/subscriptions/{identifier}

Source: https://docs.novu.co/platform/subscription/manage-topic-subscriptions

Get details for a specific subscription via the Inbox API.

```APIDOC
## GET /v1/inbox/topics/{topicKey}/subscriptions/{identifier}

### Description
Get one subscription.

### Method
GET

### Endpoint
/v1/inbox/topics/{topicKey}/subscriptions/{identifier}

### Parameters
#### Path Parameters
- **topicKey** (string) - Required - The unique identifier of the topic.
- **identifier** (string) - Required - The unique identifier of the subscription.
```

--------------------------------

### Install Novu Laravel SDK

Source: https://docs.novu.co/platform/sdks/server/laravel

Use Composer to add the Novu Laravel package to your project dependencies.

```php
composer require novu/novu-laravel
```

--------------------------------

### Trigger Email with Attachments

Source: https://docs.novu.co/platform/integrations/email

Examples for sending email attachments using different programming languages.

```php
$sdk->trigger(
    triggerEventRequestDto: new Components\TriggerEventRequestDto(
        workflowId: 'workflowId',
        to: new Components\SubscriberPayloadDto(subscriberId: 'subscriberId'),
        payload: [
            'attachments' => [
                [
                    'file' => 'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNkYPhfz0AEYBxVSF+FAP5FDvcfRYWgAAAAAElFTkSuQmCC',
                    'name' => 'blue.png',
                    'mime' => 'image/png',
                ],
                [
                    'file' => 'iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII',
                    'name' => 'transparent.png',
                    'mime' => 'image/png',
                ],
            ],
        ],
    ),
);
```

```csharp
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;

var sdk = new NovuSDK(secretKey: "<NOVU_SECRET_KEY>");

await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
    WorkflowId = "workflowId",
    To = To.CreateSubscriberPayloadDto(new SubscriberPayloadDto() {
        SubscriberId = "subscriberId",
    }),
    Payload = new Dictionary<string, object>() {
        { "attachments", new List<Dictionary<string, object>>() {
            new Dictionary<string, object>() {
                { "file", "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNkYPhfz0AEYBxVSF+FAP5FDvcfRYWgAAAAAElFTkSuQmCC" },
                { "name", "blue.png" },
                { "mime", "image/png" },
            },
            new Dictionary<string, object>() {
                { "file", "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII" },
                { "name", "transparent.png" },
                { "mime", "image/png" },
            },
        } },
    },
});
```

```java
import co.novu.Novu;
import co.novu.models.components.*;
import java.util.List;
import java.util.Map;

Novu novu = Novu.builder()
    .secretKey("<NOVU_SECRET_KEY>")
    .build();

novu.trigger()
    .body(TriggerEventRequestDto.builder()
        .workflowId("workflowId")
        .to(To2.of(SubscriberPayloadDto.builder()
            .subscriberId("subscriberId")
            .build()))
        .payload(Map.of(
            "attachments", List.of(
                Map.of(
                    "file", "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNkYPhfz0AEYBxVSF+FAP5FDvcfRYWgAAAAAElFTkSuQmCC",
                    "name", "blue.png",
                    "mime", "image/png"),
                Map.of(
                    "file", "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII",
                    "name", "transparent.png",
                    "mime", "image/png"))))
        .build())
    .call();
```

```bash
curl -L -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: ApiKey <SECRET_KEY>' \
--data-raw '{
    "name": "workflow_trigger_identifier",
    "to": [
        {
            "subscriberId": "subscriber_id",
            "email": "email_address"
        }
    ],
    "payload": {
        "attachments": [
            {
                "file": "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII",
                "name": "transparent.png",
                "mime": "image/png"
            },
            {
                "file": "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNkYPhfz0AEYBxVSF+FAP5FDvcfRYWgAAAAAElFTkSuQmCC",
                "name": "blue.png",
                "mime": "image/png"
            }
        ]
    }
}'
```

--------------------------------

### Define Context Data Structure

Source: https://docs.novu.co/platform/workflow/advanced-features/contexts/contexts-in-workflows

Example JSON structure for a context object containing tenant information.

```json
{
  "context": {
    "tenant": {
      "id": "acme-corp",
      "data": {
        "name": "Acme Corporation",
        "plan": "enterprise"
      } 
    }
  }
}
```

--------------------------------

### Install Novu Java SDK with Maven

Source: https://docs.novu.co/platform/sdks/server/java

Add this dependency to your pom.xml file to include the Novu SDK in your project.

```xml
<dependency>
    <groupId>co.novu</groupId>
    <artifactId>novu-java</artifactId>
    <version>LATEST</version>
</dependency>
```

--------------------------------

### Create a subscriber profile

Source: https://docs.novu.co/platform/concepts/subscribers

Use these examples to programmatically create or update a subscriber profile in your Novu account.

```ts
import { Novu } from "@novu/api";

const novu = new Novu({ secretKey: "<YOUR_SECRET_KEY_HERE>" });

await novu.subscribers.create({
  subscriberId: "subscriber_unique_identifier",
  firstName: "Albert",
  lastName: "Einstein",
  email: "albert@einstein.com",
  phone: "+1234567890",
  data: {
    address: "123 Main St, Anytown, USA",
    membershipLevel: "Gold",
    preferredTopics: ["News", "Sports"],
  },
});
```

```python
import os
from novu_py import Novu

with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
    novu.subscribers.create(create_subscriber_request_dto={
        "subscriber_id": "subscriber_unique_identifier",
        "first_name": "Albert",
        "last_name": "Einstein",
        "email": "albert@einstein.com",
        "phone": "+1234567890",
        "data": {
            "address": "123 Main St, Anytown, USA",
            "membershipLevel": "Gold",
            "preferredTopics": ["News", "Sports"],
        },
    })
```

```go
import (
    "context"
    "os"

    novugo "github.com/novuhq/novu-go"
    "github.com/novuhq/novu-go/models/components"
)

s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

res, err := s.Subscribers.Create(context.Background(), components.CreateSubscriberRequestDto{
    SubscriberID: "subscriber_unique_identifier",
    FirstName:    "Albert",
    LastName:     "Einstein",
    Email:        "albert@einstein.com",
    Phone:        "+1234567890",
    Data: map[string]any{
        "address":         "123 Main St, Anytown, USA",
        "membershipLevel": "Gold",
        "preferredTopics": []string{"News", "Sports"},
    },
}, nil, nil)
```

```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<YOUR_SECRET_KEY_HERE>')
    ->build();

$sdk->subscribers->create(
    createSubscriberRequestDto: new Components\CreateSubscriberRequestDto(
        subscriberId: 'subscriber_unique_identifier',
        firstName: 'Albert',
        lastName: 'Einstein',
        email: 'albert@einstein.com',
        phone: '+1234567890',
        data: [
            'address' => '123 Main St, Anytown, USA',
            'membershipLevel' => 'Gold',
            'preferredTopics' => ['News', 'Sports'],
        ],
    ),
);
```

```csharp
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;

var sdk = new NovuSDK(secretKey: "<YOUR_SECRET_KEY_HERE>");

await sdk.Subscribers.CreateAsync(createSubscriberRequestDto: new CreateSubscriberRequestDto() {
    SubscriberId = "subscriber_unique_identifier",
    FirstName = "Albert",
    LastName = "Einstein",
    Email = "albert@einstein.com",
    Phone = "+1234567890",
    Data = new Dictionary<string, object>() {
        { "address", "123 Main St, Anytown, USA" },
        { "membershipLevel", "Gold" },
        { "preferredTopics", new List<string> { "News", "Sports" } },
    },
});
```

```java
import co.novu.Novu;
import co.novu.models.components.CreateSubscriberRequestDto;
import java.util.List;
import java.util.Map;

Novu novu = Novu.builder()
    .secretKey("<YOUR_SECRET_KEY_HERE>")
    .build();

novu.subscribers().create()
    .body(CreateSubscriberRequestDto.builder()
        .subscriberId("subscriber_unique_identifier")
        .firstName("Albert")
        .lastName("Einstein")
        .email("albert@einstein.com")
        .phone("+1234567890")
        .data(Map.ofEntries(
            Map.entry("address", "123 Main St, Anytown, USA"),
            Map.entry("membershipLevel", "Gold"),
            Map.entry("preferredTopics", List.of("News", "Sports"))))
        .build())
    .call();
```

--------------------------------

### Define Tenant Context Objects

Source: https://docs.novu.co/platform/inbox/advanced-features/multi-tenancy

Examples of passing a simple tenant ID string or a rich tenant object containing metadata.

```jsx
// Simple tenant ID

context: {
  tenant: 'acme-corp' 
}

// Rich tenant object

context: {
  tenant: {
    id: 'acme-corp',
    data: {
      name: 'Acme Corporation',
      logo: 'https://cdn.acme.com/logo.png'
    }
  }
}
```

--------------------------------

### GET /v2/topics/{topicKey}/subscriptions

Source: https://docs.novu.co/platform/subscription/manage-topic-subscriptions

List all subscriptions associated with a specific topic.

```APIDOC
## GET /v2/topics/{topicKey}/subscriptions

### Description
List subscriptions on a topic.

### Method
GET

### Endpoint
/v2/topics/{topicKey}/subscriptions

### Parameters
#### Path Parameters
- **topicKey** (string) - Required - The unique identifier of the topic.
```

--------------------------------

### Bulk Import Subscribers

Source: https://docs.novu.co/platform/concepts/subscribers

Examples of how to import multiple subscribers at once using different programming languages and the REST API.

```csharp
await sdk.Subscribers.CreateBulkAsync(bulkSubscriberCreateDto: new BulkSubscriberCreateDto() {
    Subscribers = new List<CreateSubscriberRequestDto> {
        new CreateSubscriberRequestDto() {
            SubscriberId = "subscriber_unique_identifier_1",
            FirstName = "Albert",
            LastName = "Einstein",
            Email = "albert@einstein.com",
            Phone = "+1234567890",
        },
        new CreateSubscriberRequestDto() {
            SubscriberId = "subscriber_unique_identifier_2",
            FirstName = "Isaac",
            LastName = "Newton",
            Email = "isaac@newton.com",
            Phone = "+1234567891",
        },
    },
});
```

```java
import co.novu.Novu;
import co.novu.models.components.BulkSubscriberCreateDto;
import co.novu.models.components.CreateSubscriberRequestDto;
import java.util.List;

Novu novu = Novu.builder()
    .secretKey("<YOUR_SECRET_KEY_HERE>")
    .build();

novu.subscribers().createBulk()
    .body(BulkSubscriberCreateDto.builder()
        .subscribers(List.of(
            CreateSubscriberRequestDto.builder()
                .subscriberId("subscriber_unique_identifier_1")
                .firstName("Albert")
                .lastName("Einstein")
                .email("albert@einstein.com")
                .phone("+1234567890")
                .build(),
            CreateSubscriberRequestDto.builder()
                .subscriberId("subscriber_unique_identifier_2")
                .firstName("Isaac")
                .lastName("Newton")
                .email("isaac@newton.com")
                .phone("+1234567891")
                .build()))
        .build())
    .call();
```

```bash
curl -L -g -X POST 'https://api.novu.co/v1/subscribers/bulk' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
    "subscribers": [
        {
            "subscriberId": "subscriber_unique_identifier_1",
            "firstName": "Albert",
            "lastName": "Einstein",
            "email": "albert@einstein.com",
            "phone": "+1234567890"
        },
        {
            "subscriberId": "subscriber_unique_identifier_2",
            "firstName": "Isaac",
            "lastName": "Newton",
            "email": "isaac@newton.com",
            "phone": "+1234567891"
        }
    ]
}'
```

--------------------------------

### Trigger a workflow for a topic

Source: https://docs.novu.co/platform/build-with-ai/skills

Use these examples to send a notification to all subscribers associated with a specific topic key.

```typescript
await novu.trigger({
  workflowId: "project-update",
  to: [{ type: "Topic", topicKey: "project-alpha-watchers" }],
  payload: { update: "New release deployed" },
});
```

```python
novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
    workflow_id="project-update",
    to=[{"type": "Topic", "topic_key": "project-alpha-watchers"}],
    payload={"update": "New release deployed"},
))
```

```go
_, err := s.Trigger(ctx, components.TriggerEventRequestDto{
    WorkflowID: "project-update",
    To: components.CreateToArrayOfTo1([]components.To1{
        components.CreateTo1TopicPayloadDto(components.TopicPayloadDto{
            Type: components.TriggerRecipientsTypeEnumTopic, TopicKey: "project-alpha-watchers",
        }),
    }),
    Payload: map[string]any{"update": "New release deployed"},
}, nil)
```

```php
$sdk->trigger(triggerEventRequestDto: new Components\TriggerEventRequestDto(
    workflowId: 'project-update',
    to: [new Components\TopicPayloadDto(
        topicKey: 'project-alpha-watchers',
        type: Components\TriggerRecipientsTypeEnum::Topic,
    )],
    payload: ['update' => 'New release deployed'],
));
```

```csharp
await sdk.TriggerAsync(new TriggerEventRequestDto {
    WorkflowId = "project-update",
    To = To.CreateArrayOfTo1(new List<To1> {
        To1.CreateTopicPayloadDto(new TopicPayloadDto {
            Type = TriggerRecipientsTypeEnum.Topic,
            TopicKey = "project-alpha-watchers",
        }),
    }),
    Payload = new Dictionary<string, object>() { { "update", "New release deployed" } },
});
```

```java
novu.trigger().body(TriggerEventRequestDto.builder()
    .workflowId("project-update")
    .to(To2.of(List.of(To1.of(TopicPayloadDto.builder()
        .type(TriggerRecipientsTypeEnum.TOPIC)
        .topicKey("project-alpha-watchers")
        .build()))))
    .payload(Map.of("update", "New release deployed"))
    .build()).call();
```

```bash
curl -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
  "name": "project-update",
  "to": [{ "type": "Topic", "topicKey": "project-alpha-watchers" }],
  "payload": { "update": "New release deployed" }
}'
```

--------------------------------

### GET /v2/subscribers/{subscriberId}/subscriptions

Source: https://docs.novu.co/platform/subscription/manage-topic-subscriptions

List all topic subscriptions for a specific subscriber.

```APIDOC
## GET /v2/subscribers/{subscriberId}/subscriptions

### Description
List all topic subscriptions for a subscriber.

### Method
GET

### Endpoint
/v2/subscribers/{subscriberId}/subscriptions

### Parameters
#### Path Parameters
- **subscriberId** (string) - Required - The unique identifier of the subscriber.
```

--------------------------------

### Create a Remix application

Source: https://docs.novu.co/platform/quickstart/remix

Initialize a new Remix project using the create-remix CLI.

```bash
npx create-remix@latest
```

--------------------------------

### Trigger Workflow to Multiple Topics

Source: https://docs.novu.co/platform/workflow/trigger-workflow

Examples for triggering a workflow to multiple topics using different SDKs and cURL.

```javascript
await novu.trigger({
  workflowId: "workflow_identifier",
  to: [
    { type: "Topic", topicKey: "topic_key_1" }, 
    { type: "Topic", topicKey: "topic_key_2" }
  ]
});
```

```python
import os
import novu_py
from novu_py import Novu

with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
    novu.trigger(trigger_event_request_dto=novu_py.TriggerEventRequestDto(
        workflow_id="workflow_identifier",
        to=[
            {"type": "Topic", "topic_key": "topic_key_1"},
            {"type": "Topic", "topic_key": "topic_key_2"},
        ],
    ))
```

```go
import (
    "context"
    "os"

    novugo "github.com/novuhq/novu-go"
    "github.com/novuhq/novu-go/models/components"
)

s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

res, err := s.Trigger(context.Background(), components.TriggerEventRequestDto{
    WorkflowID: "workflow_identifier",
    To: components.CreateToArrayOfTo1([]components.To1{
        components.CreateTo1TopicPayloadDto(components.TopicPayloadDto{
            Type:     components.TriggerRecipientsTypeEnumTopic,
            TopicKey: "topic_key_1",
        }),
        components.CreateTo1TopicPayloadDto(components.TopicPayloadDto{
            Type:     components.TriggerRecipientsTypeEnumTopic,
            TopicKey: "topic_key_2",
        }),
    }),
}, nil)
```

```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<YOUR_SECRET_KEY_HERE>')
    ->build();

$sdk->trigger(
    triggerEventRequestDto: new Components\TriggerEventRequestDto(
        workflowId: 'workflow_identifier',
        to: [
            new Components\TopicPayloadDto(
                topicKey: 'topic_key_1',
                type: Components\TriggerRecipientsTypeEnum::Topic,
            ),
            new Components\TopicPayloadDto(
                topicKey: 'topic_key_2',
                type: Components\TriggerRecipientsTypeEnum::Topic,
            ),
        ],
    ),
);
```

```csharp
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;

var sdk = new NovuSDK(secretKey: "<YOUR_SECRET_KEY_HERE>");

await sdk.TriggerAsync(triggerEventRequestDto: new TriggerEventRequestDto() {
    WorkflowId = "workflow_identifier",
    To = To.CreateArrayOfTo1(new List<To1> {
        To1.CreateTopicPayloadDto(new TopicPayloadDto() {
            Type = TriggerRecipientsTypeEnum.Topic,
            TopicKey = "topic_key_1",
        }),
        To1.CreateTopicPayloadDto(new TopicPayloadDto() {
            Type = TriggerRecipientsTypeEnum.Topic,
            TopicKey = "topic_key_2",
        }),
    }),
});
```

```java
import co.novu.Novu;
import co.novu.models.components.*;
import java.util.List;

Novu novu = Novu.builder()
    .secretKey("<YOUR_SECRET_KEY_HERE>")
    .build();

novu.trigger()
    .body(TriggerEventRequestDto.builder()
        .workflowId("workflow_identifier")
        .to(To2.of(List.of(
            To1.of(TopicPayloadDto.builder()
                .type(TriggerRecipientsTypeEnum.TOPIC)
                .topicKey("topic_key_1")
                .build()),
            To1.of(TopicPayloadDto.builder()
                .type(TriggerRecipientsTypeEnum.TOPIC)
                .topicKey("topic_key_2")
                .build()))))
        .build())
    .call();
```

```bash
curl -X POST 'https://api.novu.co/v1/events/trigger' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
    "name": "workflow_identifier",
    "to": [
      {
          "type": "Topic",
          "topicKey": "topic_key_1"
      },
      {
          "type": "Topic",
          "topicKey": "topic_key_2"
      }
    ]
}'
```

--------------------------------

### Configure App layout with NovuInbox

Source: https://docs.novu.co/platform/quickstart/react

Example of integrating the NovuInbox component into a React Router layout structure.

```tsx
function Layout({ children }: { children: React.ReactNode }) {
  return (
    <div>
      <nav>
        <NovuInbox />
      </nav>
      {children}
    </div>
  );
}

function Home() {
  return <div>Welcome to the Home page!</div>;
}

function App() {
  return (
    <Router>
      <Layout>
        <Routes>
          <Route path="/" element={<Home />} />
          {/* Add your routes here */}
        </Routes>
      </Layout>
    </Router>
  );
}

export default App;
```

--------------------------------

### GET /v1/inbox/topics/{topicKey}/subscriptions

Source: https://docs.novu.co/platform/subscription/manage-topic-subscriptions

List the authenticated subscriber's subscriptions on a topic.

```APIDOC
## GET /v1/inbox/topics/{topicKey}/subscriptions

### Description
List the subscriber's subscriptions on a topic.

### Method
GET

### Endpoint
/v1/inbox/topics/{topicKey}/subscriptions

### Parameters
#### Path Parameters
- **topicKey** (string) - Required - The unique identifier of the topic.
```

--------------------------------

### Install Novu Skills via CLI

Source: https://docs.novu.co/platform/build-with-ai/skills

Use the skills CLI to add Novu skills to your project, making them accessible to AI coding assistants.

```bash
npx skills add novuhq/skills
```

--------------------------------

### Create a Vue application

Source: https://docs.novu.co/platform/quickstart/vue

Initialize a new Vue project using the latest version.

```bash
npm create vue@latest novu-inbox-vue
```

--------------------------------

### Create Slack channel endpoint

Source: https://docs.novu.co/platform/integrations/chat/slack

Use these examples to register a Slack user endpoint for a subscriber. Ensure the integration identifier and connection identifier are correctly specified.

```go
res, err := s.ChannelEndpoints.Create(context.Background(), operations.CreateChannelEndpointsControllerCreateChannelEndpointRequestBodySlackUser(
                components.CreateSlackUserEndpointDto{
                    SubscriberID: "user-123",
                    IntegrationIdentifier: "slack",
                    ConnectionIdentifier: novugo.String("conn_slack_acme"),
                    Context: map[string]any{
                        "tenant": "acme",
                    },
                    Type: components.CreateSlackUserEndpointDtoTypeSlackUser,
                    Endpoint: components.SlackUserEndpointDto{UserID: "U01234567"},
                },
            ), nil)
```

```php
use novu;
            use novu\Models\Components;

            $sdk = novu\Novu::builder()->setSecurity('<NOVU_SECRET_KEY>')->build();
            $sdk->channelEndpoints->create(
                requestBody: new Components\CreateSlackUserEndpointDto(
                    subscriberId: 'user-123',
                    integrationIdentifier: 'slack',
                    connectionIdentifier: 'conn_slack_acme',
                    context: [
                        'tenant' => 'acme',
                    ],
                    type: Components\CreateSlackUserEndpointDtoType::SlackUser,
                    endpoint: new Components\SlackUserEndpointDto(userId: 'U01234567'),
                ),
            );
```

```csharp
using Novu;
            using Novu.Models.Components;

            var sdk = new NovuSDK(secretKey: "<NOVU_SECRET_KEY>");
            await sdk.ChannelEndpoints.CreateAsync(
                requestBody: CreateSlackUserEndpointDto.CreateSlackUser(
                    new CreateSlackUserEndpointDto() {
                        SubscriberId = "user-123",
                        IntegrationIdentifier = "slack",
                        ConnectionIdentifier = "conn_slack_acme",
                        Context = new Dictionary<string, object> {
                            { "tenant", "acme" },
                        },
                        Type = CreateSlackUserEndpointDtoType.SlackUser,
                        Endpoint = new SlackUserEndpointDto() { UserId = "U01234567" },
                    }));
```

```java
import co.novu.Novu;
            import co.novu.models.components.*;

            Novu novu = Novu.builder().secretKey("<NOVU_SECRET_KEY>").build();
            novu.channelEndpoints().create()
                .requestBody(CreateSlackUserEndpointDto.builder()
                    .subscriberId("user-123")
                    .integrationIdentifier("slack")
                    .connectionIdentifier("conn_slack_acme")
                    .context(java.util.Map.of("tenant", "acme"))
                    .type(CreateSlackUserEndpointDtoType.SLACK_USER)
                    .endpoint(SlackUserEndpointDto.builder().userId("U01234567").build())
                    .build())
                .call();
```

```bash
curl -L -X POST 'https://api.novu.co/v1/channel-endpoints' \
            -H 'Content-Type: application/json' \
            -H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
            -d '{
              "type": "slack_user",
              "subscriberId": "user-123",
              "integrationIdentifier": "slack",
              "connectionIdentifier": "conn_slack_acme",
              "context": {
                "tenant": "acme"
              },
              "endpoint": {
                "userId": "U01234567"
              }
            }'
```

--------------------------------

### Initialize Novu SDK in PHP

Source: https://docs.novu.co/platform/integrations/email

Shows the builder pattern for initializing the Novu SDK in PHP.

```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<NOVU_SECRET_KEY>')
    ->build();
```

--------------------------------

### Update Subscriber Credentials

Source: https://docs.novu.co/platform/integrations/push

Use these examples to add device tokens to a subscriber's profile before triggering a workflow.

```typescript
import { Novu } from '@novu/api';
import { ChatOrPushProviderEnum } from "@novu/api/models/components";

const novu = new Novu({ secretKey: "YOUR_SECRET_KEY_HERE" });

const result = await novu.subscribers.credentials.update({
  providerId: ChatOrPushProviderEnum.Fcm,
  credentials: {
    deviceTokens: [
      "token1",
      "token2",
    ],
  },
}, "subscriberId");
```

```python
import os
import novu_py
from novu_py import Novu

with Novu(secret_key=os.getenv("NOVU_SECRET_KEY", "")) as novu:
    novu.subscribers.credentials.update(
        subscriber_id="subscriberId",
        update_subscriber_channel_request_dto={
            "provider_id": novu_py.ChatOrPushProviderEnum.FCM,
            "credentials": {
                "device_tokens": ["token1", "token2"],
            },
        },
    )
```

```go
import (
    "context"
    "os"

    novugo "github.com/novuhq/novu-go"
    "github.com/novuhq/novu-go/models/components"
)

s := novugo.New(novugo.WithSecurity(os.Getenv("NOVU_SECRET_KEY")))

_, err := s.Subscribers.Credentials.Update(context.Background(), "subscriberId", components.UpdateSubscriberChannelRequestDto{
    ProviderID: components.ChatOrPushProviderEnumFcm,
    Credentials: components.ChannelCredentials{
        DeviceTokens: []string{"token1", "token2"},
    },
}, nil)
```

```php
use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity('<NOVU_SECRET_KEY>')
    ->build();

$sdk->subscribers->updateCredentials(
    subscriberId: 'subscriberId',
    updateSubscriberChannelRequestDto: new Components\UpdateSubscriberChannelRequestDto(
        providerId: Components\ChatOrPushProviderEnum::Fcm,
        credentials: new Components\ChannelCredentials(
            deviceTokens: ['token1', 'token2'],
        ),
    ),
);
```

```csharp
using Novu;
using Novu.Models.Components;
using System.Collections.Generic;

var sdk = new NovuSDK(secretKey: "<NOVU_SECRET_KEY>");

await sdk.Subscribers.UpdateCredentialsAsync(
    subscriberId: "subscriberId",
    updateSubscriberChannelRequestDto: new UpdateSubscriberChannelRequestDto() {
        ProviderId = ChatOrPushProviderEnum.Fcm,
        Credentials = new ChannelCredentials() {
            DeviceTokens = new List<string>() { "token1", "token2" },
        },
    }
);
```

```java
import co.novu.Novu;
import co.novu.models.components.*;
import java.util.List;

Novu novu = Novu.builder()
    .secretKey("<NOVU_SECRET_KEY>")
    .build();

novu.subscribers().updateCredentials()
    .subscriberId("subscriberId")
    .body(UpdateSubscriberChannelRequestDto.builder()
        .providerId(ChatOrPushProviderEnum.FCM)
        .credentials(ChannelCredentials.builder()
            .deviceTokens(List.of("token1", "token2"))
            .build())
        .build())
    .call();
```

```bash
curl -L -X PUT 'https://api.novu.co/v1/subscribers/<SUBSCRIBER_ID>/credentials' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
  "providerId": "fcm",
  "credentials": {
    "deviceTokens" : [
      "token1",
      "token2"
    ]
  }
}'
```
Tokens:
Raw