Skip to main content
This guide helps you plan and execute a migration from SuprSend to Courier. It covers how the two platforms compare, where Courier gives you more flexibility, and a concrete step-by-step plan for moving everything over.

​
Mapping SuprSend Concepts to Courier

SuprSendCourier
WorkflowsAutomations
TemplatesTemplates
VendorsIntegrations
Smart Channel RoutingChannel Priority + Failover
BatchingDigest
SubscribersUsers / Profiles
PreferencesPreferences
InboxInbox
TenantsTenants

​
Workflows and Automations

SuprSend workflows use four node types (trigger, function, branch, delivery) to orchestrate notification logic. Courier Automations give you the same capabilities with a visual designer and a programmatic API.
SuprSend NodeCourier Equivalent
Trigger nodeAutomation trigger (API invoke, webhook, or schedule)
Delay (function node)Delay node
Batch (function node)Digest node
Branch nodeCondition node
Delivery nodeSend node (references a template + routing)
The important difference: automations and templates are separate resources in Courier. A send node references a template by ID, so your product team can change what a notification says without opening the workflow, and engineers can adjust timing and conditions without touching copy. Build automations visually in the Automations Designer or define them through the Automations API.

​
Templates

SuprSend organizes notification content in template groups, with separate templates per channel. Courier templates take a unified approach: a single resource holds content for every channel (email, SMS, push, chat, inbox), so you design all channel variants in one place. The visual Designer uses drag-and-drop content blocks, and there’s a code-first path through Elemental JSON if you prefer to define content programmatically. Both support {{variable}} Handlebars-style personalization, channel-specific overrides, and localization. Because templates live in the Designer, your product team can update copy, layout, and branding without writing code or waiting for a deploy. Publish when ready and it’s live immediately.

​
Integrations

What SuprSend calls vendors, Courier calls Integrations. These are the provider connections (SendGrid, Twilio, FCM, Slack, etc.) that handle actual message delivery. Courier supports 50+ providers. You can wire up multiple providers for the same channel type, and Courier fails over between them automatically. If your primary email provider goes down, traffic shifts to the backup without any code changes or manual intervention.

​
Routing

Courier’s single routing method replicates SuprSend’s smart channel routing: channels are tried in the order you specify, and delivery stops at the first success. For situations where you want to reach users everywhere at once, the all method broadcasts to every listed channel simultaneously. Routing is configured per send request or per template, and you can layer provider-level failover on top; so you get fallback at both the channel and provider layers.

​
Digests and Batching

Courier’s Digest node works the same way as SuprSend’s batch function: collect matching events over a configurable time window, then send a single summary notification. Your template gets access to the full list of digested events, so you can render rich summaries across email, push, or in-app.

​
Users and Profiles

Courier profiles store recipient data: email, phone, push tokens, and any custom properties you need. Profiles accept nested JSON natively, which is useful for structured data like subscription tiers, team roles, or feature flags. Profiles can be created ahead of time through the API or identified inline at send time. Pass a user_id that doesn’t exist yet and Courier creates the profile automatically.

​
Preferences

SuprSend’s preference system supports global channel opt-outs, category-level controls, and per-category overrides. Courier Preferences support the same hierarchy and enforce them automatically at send time, so you don’t need conditional logic in your code. On top of the API, Courier ships a hosted preference page you can deploy in minutes and embeddable React components for in-app preference centers. No custom UI work required.

​
In-App Notifications

Courier Inbox is a real-time in-app notification center with drop-in components for React, iOS, Android, and vanilla JS. It runs on the same delivery pipeline as email, push, and SMS, so there’s no separate provider to configure. Out of the box you get read/unread state, archiving, per-user history, toast notifications, and tab-based organization.

​
Tenants

Tenants work similarly across both platforms. You scope branding, preference defaults, and notification feeds to individual customer organizations. Pass a tenant_id at send time and Courier applies per-tenant branding and preferences automatically. Branding lives directly on the Tenant resource rather than as a separate object.

​
Why Courier

  • Content and logic stay separate. Templates and automations are independent. Your product team updates copy in the Designer while engineers tune workflow timing; neither blocks the other.
  • Visual template designer. Build email, SMS, push, and chat content with drag-and-drop blocks. Preview across channels, personalize with variables, and publish without deploying code.
  • Flexible routing. 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 directly in your app. No custom UI required.
  • 50+ integrations. Email, SMS, push, chat, webhooks, CDPs, and observability tools. Switch providers without changing your send code.
  • Full delivery observability. Message Logs track every message from API request to provider delivery with a detailed timeline, error details, and rendered content inspection.

​
Migration Steps

1

Create your Courier workspace

Sign up and create a workspace. Courier gives you separate Test and Production environments with independent API keys, so you can migrate safely without affecting live traffic.
2

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). You can configure multiple providers per channel for failover.If you use SuprSend’s inbox, enable Courier Inbox; no external provider needed.
3

Recreate templates

SuprSend template groups contain per-channel templates. In Courier, a single template holds content for all channels:
  1. Create a new template for each notification type
  2. Add channel-specific content blocks (email body, SMS text, push title/body, etc.)
  3. Use {{variable}} syntax for dynamic data; both platforms use the same Handlebars-style approach
  4. Publish the template to make it available for sending
4

Recreate workflows as automations

If you use SuprSend workflows with delays, batching, or branching, recreate them in Automations. You can build automations visually in the Automations Designer or define them programmatically via the Automations API.For simple notification types that don’t need orchestration (no delays, no digests), you can skip automations entirely and send directly via the Send API.
5

Migrate user data

Create user profiles in Courier with the same identifiers you use in SuprSend. You can create profiles via the Profiles API or inline at send time.
{
  "user_id": "user_123",
  "profile": {
    "email": "user@example.com",
    "phone_number": "+15551234567",
    "custom": {
      "name": "Jane Doe",
      "plan": "enterprise"
    }
  }
}
For bulk migration, use the Bulk API to upsert users in batches.
6

Set up preferences

If you use SuprSend’s preference system, recreate your structure in Courier:
  1. Define subscription topics that map to your SuprSend categories
  2. Configure default channel routing per topic
  3. Migrate user preference selections via the Preferences API
Courier also provides a hosted preference page you can deploy immediately, or React components for embedding preferences in your app.
7

Update your send calls

Replace SuprSend’s workflow trigger calls with Courier’s Send API. A basic send looks like this:
curl -X POST https://api.courier.com/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message": {
      "to": { "user_id": "user_123" },
      "template": "order-confirmation",
      "data": {
        "order_id": "ORD-456",
        "total": "$79.99"
      }
    }
  }'
Courier handles routing, preferences, and failover automatically based on your template and workspace configuration. For multi-channel sends, set the routing field:
{
  "message": {
    "to": { "user_id": "user_123" },
    "template": "order-confirmation",
    "routing": {
      "method": "single",
      "channels": ["push", "email", "sms"]
    }
  }
}
This tries push first, then email, then SMS; the same pattern as SuprSend’s smart channel routing.
8

Test and cut over

  1. Send test messages in your Test environment and verify delivery in Message Logs
  2. Validate that preferences, routing, and template rendering match your SuprSend setup
  3. Switch your production code to use Courier’s Production API key
  4. Monitor Message Logs and Analytics for delivery confirmation

​
API Mapping

OperationSuprSendCourier
Send a notificationPOST /triggerPOST /send
Create/update a userPOST /subscriberPUT /profiles/:id
Get a userGET /subscriber/:idGET /profiles/:id
Set user preferencesPOST /subscriber/:id/category/:cat/preferencePUT /users/:id/preferences/:topic
Get message statusGET /event/:idGET /messages/:id
Bulk operationsBatch APIPOST /bulk
Create/update tenantTenant APIPUT /tenants/:id

​
What’s Next

Quickstart

Send your first notification in under 2 minutes

Template Designer

Build notification content with the visual editor

Automations

Add delays, conditions, digests, and branching to your notification workflows

Preferences

Let users control which notifications they receive