Migrate from Novu

This guide maps Novu concepts to Courier and gives you a step-by-step migration plan.

Map Novu concepts to Courier

Novu	Courier
Workflows	+
Subscribers
Topics
Integrations
Digest	+ nodes
Delay
Preferences
Inbox
Tenants

Workflows, templates, and Journeys

Novu workflows combine content, channel routing, and orchestration logic (digest, delay, conditions) in one resource. Courier gives content and orchestration each their own tools. That’s the biggest difference between the two. own the content layer. Design them visually in Design Studio (drag-and-drop blocks for email, SMS, push, and chat) or in code with JSON. Either way, your product team ships copy changes without an engineering cycle. own the orchestration layer: , , , , and . Each journey delivers one channel with its own journey template. For sends with no orchestration, a workspace template holds every channel and goes out through the .

Novu step type	Courier equivalent
Channel step (email, SMS, push, chat)	, one per channel
Digest step	(window-based) or node (schedule-based)
Delay step
Custom step	or logic

A journey starts from a : an API invoke, an inbound webhook, a Segment event, or a user joining an audience. Build journeys visually or through the .

Subscribers and users

Novu subscribers map to Courier . Both store email, phone, push tokens, locale, and custom properties. Courier profiles accept nested JSON, so account tiers, team roles, and feature flags fit as-is. Create profiles ahead of time through the API, or identify users inline at send time. Pass a user_id that doesn’t exist yet and Courier creates the profile.

Topics and subscription topics

Novu topics group subscribers for bulk delivery. The Courier equivalent depends on your use case:

For notification categories (letting users opt in/out of types of notifications): use within Preferences
For bulk delivery to groups: use or

Integrations

Novu and Courier both call provider connections “integrations.” Courier supports providers across email, SMS, push, chat, and webhooks. Wire up multiple providers for one channel type and Courier between them automatically, with no code changes.

Digest and delay

Courier’s covers Novu’s digest step. It collects a user’s events and releases them as one summary when it hits a maximum item count, a quiet period with no new events, or a maximum wait. The first event’s run continues to the summary send, and the rest end at the Batch node.

Setting	Example	What it does
Max items	100	Release when 100 events arrive
Wait period	5 minutes	Release after 5 minutes with no new event
Max wait period	1 hour	Release within an hour of the first event, even if events keep coming
Include event data	First 5	Keep the 5 most recent events (up to 25) for the template. `First` keeps the newest and `Last` the earliest

In the summary template, {{batch.count}} is the total and data.batch.items holds the kept events. A summary costs one send, however many events it rolls up. For summaries that release on a fixed schedule the user controls (a daily activity email, a weekly report), use the node instead. works like Novu’s delay step. Specify a duration and the journey pauses before the next node.

Preferences

Novu’s preference system supports global and per-workflow channel controls. Courier support the same hierarchy (global, per-topic, per-channel) and enforce it at send time. Courier also ships a you can deploy in minutes, plus embeddable for in-app preference centers.

In-app notifications

Novu’s Inbox component handles in-app notifications. Courier does the same, with drop-in components for , , , and . Courier Inbox runs on the same delivery pipeline as email, push, and SMS. There’s no separate service to manage. You get read/unread state, archiving, per-user history, , and .

Tenants

Courier work like Novu tenants. Scope branding, preference defaults, and notification feeds to one customer organization. Set message.context.tenant_id on a send and Courier applies that tenant’s brand and preferences.

Why Courier

Fully managed infrastructure. No self-hosting to maintain, no bridge endpoints to deploy. Courier handles orchestration, delivery, retries, and scaling.
Design Studio. Build email, SMS, push, and chat content with drag-and-drop blocks. Preview across channels, personalize with variables, and publish without deploying code.
Built-in in-app channel. Courier Inbox works without a third-party provider. Drop in a React, iOS, or Android component and deliver in-app notifications on the same pipeline as email and push.
Automatic failover. Configure multiple providers per channel and Courier fails over automatically. If SendGrid goes down, your email still goes out through your backup provider.
Hosted preferences out of the box. Ship a user-facing preference center with a single config, or embed React components directly in your app.
The providers you already use. Email, SMS, push, chat, webhooks, CDPs, and observability tools. Switch providers without changing your send code.
Full delivery observability. track every message from API request to provider delivery with a detailed timeline, error details, and rendered content inspection.

Migrate step by step

Create your Courier workspace

and create a workspace. Courier gives you separate Test and Production with their own API keys, so you can migrate without touching live traffic.

Configure integrations

Go to Integrations in your Courier dashboard and connect the same providers you use in Novu (SendGrid, Twilio, FCM, etc.). Each provider maps to a channel type (email, SMS, push, chat). Configure multiple providers per channel for .If you use Novu’s inbox component, is already set up in production and test. No external provider needed.

Recreate templates

Novu workflows contain inline content per channel step. In Courier, extract the content into :

Create a new template for each notification type
Add content blocks for each channel (email body, SMS text, push title/body, etc.)
Bring over your Handlebars variables with a source prefix: {{data.order_id}} for trigger payload data, {{profile.first_name}} for subscriber fields
Publish the template to make it available for sending

Recreate workflows as journeys

If your Novu workflows include digest, delay, or conditional logic, recreate them in , with a Send node per channel. Build journeys visually or programmatically via the .For notification types that need no orchestration (no delays, no digests), skip journeys and send directly via the .

Migrate subscriber data

Create user profiles in Courier with the same identifiers you use in Novu, via the or inline at send time.

{
  "user_id": "user_123",
  "profile": {
    "email": "sarah@acme-corp.com",
    "phone_number": "+15551234567",
    "custom": {
      "name": "Sarah Bennett",
      "plan": "enterprise"
    }
  }
}

Set up preferences

If you use Novu’s subscriber preferences, recreate your structure in Courier:

Define that map to your Novu workflow categories
Configure default channel routing per topic
Import each subscriber’s choices through the , before any optional notification sends from Courier

Update your trigger calls

Replace Novu’s workflow trigger calls with Courier’s :

const { requestId } = await client.send.message({
  message: {
    to: { user_id: 'user_123' },
    template: 'nt_01kx4h2jdafq8bk9aftxak4b40',
    data: {
      order_id: 'ORD-456',
      total: 79.99,
    },
  },
});

response = client.send.message(
    message={
        "to": {"user_id": "user_123"},
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "data": {
            "order_id": "ORD-456",
            "total": 79.99,
        },
    },
)

curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer $COURIER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": { "user_id": "user_123" },
      "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
      "data": {
        "order_id": "ORD-456",
        "total": 79.99
      }
    }
  }'

response = courier.send_.message(
  message: {
    to: { user_id: "user_123" },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    data: { order_id: "ORD-456", total: 79.99 }
  }
)

response, err := client.Send.Message(context.TODO(), courier.SendMessageParams{
	Message: courier.SendMessageParamsMessage{
		To: courier.SendMessageParamsMessageToUnion{
			OfUserRecipient: &shared.UserRecipientParam{
				UserID: courier.String("user_123"),
			},
		},
		Template: courier.String("nt_01kx4h2jdafq8bk9aftxak4b40"),
		Data: map[string]any{
			"order_id": "ORD-456",
			"total": 79.99,
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(JsonValue.from(java.util.Map.of("user_id", "user_123")))
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .data(JsonValue.from(java.util.Map.of(
            "order_id", "ORD-456",
            "total", 79.99)))
        .build())
    .build();
client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => ['userID' => 'user_123'],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'data' => ['order_id' => 'ORD-456', 'total' => 79.99],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Data = new Dictionary<string, JsonElement>()
        {
            { "order_id", JsonSerializer.SerializeToElement("ORD-456") },
            { "total", JsonSerializer.SerializeToElement(79.99) },
        },
    },
};

await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message '{"to":{"user_id":"user_123"},"template":"nt_01kx4h2jdafq8bk9aftxak4b40","data":{"order_id":"ORD-456","total":79.99}}'

With Courier MCP, send my nt_01kx4h2jdafq8bk9aftxak4b40 template to user_123 with the order details.

Test and cut over

Send test messages in your Test environment and verify delivery in
Validate that preferences, routing, and template rendering match your Novu setup
Switch your production code to use Courier’s Production API key
Monitor and for delivery confirmation

Map the API

Operation	Novu	Courier
Send a notification	`POST /v1/events/trigger`
Create/update a subscriber	`POST /v2/subscribers` or `PATCH /v2/subscribers/:id`
Get a subscriber	`GET /v2/subscribers/:id`
Set preferences	`PATCH /v2/subscribers/:id/preferences`
Get message status	`GET /v1/messages` (list and filter)
List messages	`GET /v1/messages`
Manage topics	`POST /v2/topics`

Get started

Send your first message

Build a notification

Send to many people

Send when something happens

Let users choose

Go live

Move to Courier

Migrate from Novu

Map Novu concepts to Courier

Workflows, templates, and Journeys

Subscribers and users

Topics and subscription topics

Integrations

Digest and delay

Preferences

In-app notifications

Tenants

Why Courier

Migrate step by step

Map the API

​Map Novu concepts to Courier

​Workflows, templates, and Journeys

​Subscribers and users

​Topics and subscription topics

​Integrations

​Digest and delay

​Preferences

​In-app notifications

​Tenants

​Why Courier

​Migrate step by step

​Map the API

Map Novu concepts to Courier

Workflows, templates, and Journeys

Subscribers and users

Topics and subscription topics

Integrations

Digest and delay

Preferences

In-app notifications

Tenants

Why Courier

Migrate step by step

Map the API