Migrate from SuprSend

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

Map SuprSend concepts to Courier

SuprSend	Courier
Workflows
Templates
Vendors
Smart Channel Routing	+
Batching
Subscribers
Preferences
Inbox
Tenants

Workflows and Journeys

SuprSend workflows orchestrate notifications with four node types: trigger, function, branch, and delivery. Courier do the same with a visual builder and an API.

SuprSend node	Courier equivalent
Trigger node	(API invoke, inbound webhook, Segment event, or audience membership)
Delay (function node)
Batch (function node)
Branch node
Delivery node	, one per channel

Each delivers one channel with its own journey template. Your product team edits that content in Design Studio while engineers change triggers, timing, and conditions on the same journey. To send email and in-app from a journey, add a Send node for each. Build journeys visually or define them through the .

Templates

A SuprSend template holds an editor per channel and is referenced by slug. A Courier works the same way for direct sends: one resource with content for every channel (email, SMS, push, chat, and inbox), sent through the . Content inside a journey lives in that journey’s Send nodes. uses drag-and-drop content blocks. JSON is the code-first path. Both support , channel-specific overrides, and . In Design Studio every variable names its source: {{data.order_id}} for send data, {{profile.first_name}} for the user’s profile.

Integrations

SuprSend vendors are Courier : the provider connections that deliver messages, such as SendGrid, Twilio, FCM, and Slack. Courier supports providers on every channel. Wire up multiple providers for the same channel type and Courier between them automatically. If your primary email provider goes down, traffic shifts to the backup with no code change and no manual step.

Routing

Courier’s single replicates SuprSend’s smart channel routing. Courier tries channels in the order you specify and stops at the first success. The all method sends to every listed channel at once. Set routing per send request or per template. Provider-level layers on top, so you get fallback at both the channel and provider layers.

Digests and batching

Courier’s works like SuprSend’s batch function. 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 schedule the user picks, like a daily or weekly digest, use .

Users and profiles

Courier store recipient data: email, phone, push tokens, and any custom properties. Profiles accept nested JSON, which suits structured data like subscription tiers, team roles, or feature flags. Create profiles ahead of time through the API, or inline at send time. Pass a user_id that doesn’t exist yet and Courier creates the profile.

Preferences

SuprSend’s preference system supports global channel opt-outs, category-level controls, and per-category overrides. Courier support the same hierarchy and enforce it at send time. Courier also ships a you can deploy in minutes and embeddable for in-app preference centers.

In-app notifications

Courier is a real-time in-app notification center with drop-in components for , , , and . It runs on the same delivery pipeline as email, push, and SMS, so there’s no separate provider to configure. You get read/unread state, archiving, per-user history, , and .

Tenants

work much the same on both platforms. You scope branding, preference defaults, and notification feeds to a customer organization. Set message.context.tenant_id on a send and Courier applies that tenant’s brand and preferences. A tenant points to a with brand_id.

Why Courier

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.
Routing you control. Priority-based fallback (single) or broadcast to all channels (all).
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.
Hosted preferences out of the box. Ship a user-facing preference center with a single config, or embed React components 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 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 as SuprSend vendors (SendGrid, Twilio, FCM, etc.). Each provider maps to a channel type (email, SMS, push, chat). Configure multiple providers per channel for .If you use SuprSend’s inbox, is already set up in production and test. No external provider needed.

Recreate templates

For each SuprSend template you send directly, create a Courier with the same channels:

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

Recreate workflows as journeys

Recreate SuprSend workflows that use delays, batching, or branching in , with a Send node per channel. Build them visually or define them through the .For notification types that need no orchestration (no delays, no batching), skip journeys and send directly via the .

Migrate user data

Create Courier profiles with the same identifiers you use in SuprSend. Use the , or create them 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 SuprSend’s preference system, recreate your structure in Courier:

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

Update your send calls

Replace SuprSend’s workflow trigger calls with Courier’s . A basic send looks like this:

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.

Courier applies routing, preferences, and failover from your template and workspace configuration. For multi-channel sends, set the routing field:

const { requestId } = await courier.send.message({
  message: {
    to: {
      user_id: "user_123",
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    routing: {
      method: "single",
      channels: [
        "push",
        "email",
        "sms",
      ],
    },
  },
});

response = client.send.message(
    message={
        "to": {
            "user_id": "user_123",
        },
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "routing": {
            "method": "single",
            "channels": [
                "push",
                "email",
                "sms",
            ],
        },
    },
)

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",
      "routing": {
        "method": "single",
        "channels": [
          "push",
          "email",
          "sms"
        ]
      }
    }
  }'

response = courier.send_.message(
  message: {
    to: {
      user_id: "user_123"
    },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    routing: {
      method: "single",
      channels: [
        "push",
        "email",
        "sms"
      ]
    }
  }
)

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"),
		Routing: courier.SendMessageParamsMessageRouting{
			Channels: []shared.MessageRoutingChannelUnionParam{
				{OfString: courier.String("push")},
				{OfString: courier.String("email")},
				{OfString: courier.String("sms")},
			},
			Method: "single",
		},
	},
})

SendMessageParams params = SendMessageParams.builder()
    .message(SendMessageParams.Message.builder()
        .to(UserRecipient.builder().userId("user_123").build())
        .template("nt_01kx4h2jdafq8bk9aftxak4b40")
        .routing(SendMessageParams.Message.Routing.builder()
            .addChannel("push")
            .addChannel("email")
            .addChannel("sms")
            .method(SendMessageParams.Message.Routing.Method.SINGLE)
            .build())
        .build())
    .build();
SendMessageResponse response = client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => [
      'user_id' => 'user_123',
    ],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'routing' => [
      'method' => 'single',
      'channels' => [
        'push',
        'email',
        'sms',
      ],
    ],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Routing = new() { Channels = ["push", "email", "sms"], Method = Send::Method.Single },
    },
};

var response = await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message.to '{"user_id": "user_123"}' \
  --message.template nt_01kx4h2jdafq8bk9aftxak4b40 \
  --message.routing '{"method": "single", "channels": ["push", "email", "sms"]}'

With Courier MCP, send my nt_01kx4h2jdafq8bk9aftxak4b40 template to user_123 over email and push.

This tries push first, then email, then SMS.

Test and cut over

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

Map the API

Operation	SuprSend	Courier
Send a notification	`POST /trigger/`
Create/update a user	`POST /v1/user/{distinct_id}/`
Get a user	`GET /v1/user/{distinct_id}/`
Set user preferences	`PATCH /v1/user/{distinct_id}/preference/category/{category_slug}/`
Get message status	`GET /v1/message/` (list and filter)
Create/update tenant	`POST /v1/tenant/{tenant_id}/`

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 SuprSend

Map SuprSend concepts to Courier

Workflows and Journeys

Templates

Integrations

Routing

Digests and batching

Users and profiles

Preferences

In-app notifications

Tenants

Why Courier

Migrate step by step

Map the API

​Map SuprSend concepts to Courier

​Workflows and Journeys

​Templates

​Integrations

​Routing

​Digests and batching

​Users and profiles

​Preferences

​In-app notifications

​Tenants

​Why Courier

​Migrate step by step

​Map the API

Map SuprSend concepts to Courier

Workflows and Journeys

Templates

Integrations

Routing

Digests and batching

Users and profiles

Preferences

In-app notifications

Tenants

Why Courier

Migrate step by step

Map the API