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	(references a template + routing)

The important difference: journeys and templates are separate resources in Courier. A send node references a template by ID. Your product team changes what a notification says without opening the journey. Engineers change timing and conditions without touching copy. Build journeys visually or define them through the .

Templates

SuprSend splits notification content into template groups, one template per channel. A Courier is a single resource holding content for every channel: email, SMS, push, chat, and inbox. uses drag-and-drop content blocks. JSON is the code-first path. Both support Handlebars-style personalization, channel-specific overrides, and . Your product team updates copy, layout, and branding in Design Studio without code or a deploy. Publish and it goes live immediately.

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 matching events over a window you configure, then releases them as one payload for a single summary notification. Your template gets the full list of collected events, so you can render summaries across email, push, or in-app. For summaries that release on a fixed schedule the user controls, use the .

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. You write no conditional logic. Courier also ships a you can deploy in minutes and embeddable for in-app preference centers. No custom UI required.

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. Pass a tenant_id at send time and Courier applies that tenant’s branding and preferences. Branding lives on the Tenant resource rather than a separate object.

Why Courier

Content and logic stay separate. Templates and journeys are independent. Your product team updates copy in Design Studio while engineers tune journey timing.
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). Configure multiple providers per channel for automatic failover at the provider level too.
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. No custom UI required.
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, enable . No external provider needed.

Recreate templates

SuprSend template groups contain per-channel templates. In Courier, a single holds content for all channels:

Create a new template for each notification type
Add channel-specific content blocks (email body, SMS text, push title/body, etc.)
Use {{variable}} syntax for dynamic data. Both platforms use Handlebars-style variables
Publish the template to make it available for sending

Recreate workflows as journeys

Recreate SuprSend workflows that use delays, batching, or branching in . 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
Migrate user preference selections via the

Courier also provides a you can deploy immediately, or for embedding preferences in your app.

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. The same pattern as SuprSend’s smart channel routing.

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 /subscriber`
Get a user	`GET /subscriber/:id`
Set user preferences	`POST /subscriber/:id/category/:cat/preference`
Get message status	`GET /event/:id`
Create/update tenant	Tenant API

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