Skip to main content
This guide helps you plan and execute a migration of your transactional notification flows from Braze to Courier. It covers how the two platforms compare, where Courier gives you more flexibility for developer-facing use cases, and a concrete step-by-step plan for moving things over.
Braze is a full marketing automation platform covering campaigns, analytics, and customer engagement. This guide focuses specifically on migrating transactional and product notification workflows; marketing campaign orchestration is outside Courier’s scope.

​
Mapping Braze Concepts to Courier

BrazeCourier
CampaignsTemplates + Send API
CanvasAutomations
SegmentsAudiences
User ProfilesUsers / Profiles
Subscription GroupsPreferences
Content CardsInbox
Connected Contentdata on send + Fetch Data node
CurrentsOutbound Webhooks
Liquid templatingHandlebars + Variables

​
Campaigns and Templates

Braze campaigns bundle content, audience targeting, scheduling, and delivery into a single resource. Courier separates these concerns: templates own the content, and the Send API or Automations handle delivery. This separation means your product team can update notification copy in the visual Designer without touching delivery logic, and engineers can adjust routing or timing without risk of breaking template content. Templates hold content for every channel (email, SMS, push, chat, inbox) in a single resource. You design them with drag-and-drop blocks or define them programmatically with Elemental JSON.

​
Canvas and Automations

Braze Canvas is a visual workflow builder for multi-step, multi-channel journeys. Courier Automations fill the same role for transactional flows: delays, conditions, branching, digests, and cancellation.
Canvas StepCourier Equivalent
Message stepSend node (references a template)
Delay stepDelay node
Decision splitCondition node
Action pathsBranching with conditions
Audience pathsAudience filtering + conditions
Build automations visually in the Automations Designer or define them through the Automations API.

​
Segments and Audiences

Braze segments use filters on user attributes, behaviors, and events. Courier Audiences provide similar dynamic grouping based on user profile attributes. Define filter rules once and Courier keeps the audience membership current as profiles change. For simpler use cases, you can also target users with Lists (static subscriber groups) or send to individual users directly.

​
Users and Profiles

Courier profiles store everything about a recipient: email, phone, push tokens, and any custom properties you need for personalization. Profiles accept nested JSON natively, so structured data like account tiers, team roles, or feature flags fits naturally. You can create profiles ahead of time through the API, or identify users inline at send time. If you pass a user_id that doesn’t exist yet, Courier creates the profile on the fly.

​
Subscription Groups and Preferences

Braze subscription groups manage opt-in/opt-out status per channel. Courier Preferences go further: users can opt out by channel, category, or specific notification topic, and Courier enforces these automatically at send time. On top of the API, Courier ships a hosted preference page you can deploy in minutes and embeddable React components for building a preference center directly into your app.

​
Content Cards and Inbox

Braze Content Cards deliver persistent in-app content. Courier Inbox serves a similar purpose as a real-time in-app notification center, with drop-in components for React, iOS, Android, and vanilla JS. Inbox runs on the same delivery pipeline as email, push, and SMS; 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.

​
Connected Content and Dynamic Data

Braze’s Connected Content pulls external data into templates at render time. In Courier, you pass all the data a template needs through the data field on the send request. For automation flows that need to fetch data mid-sequence, the Fetch Data node calls external APIs and passes the response into subsequent steps.

​
Templating Language

Braze uses Liquid for message personalization. Courier uses Handlebars with {{variable}} syntax. Both support conditionals, loops, and filters. Courier also provides built-in helpers for common operations like date formatting, string manipulation, and conditional rendering.

​
Why Courier

  • API-first for developers. Courier is built for transactional and product notifications. A single API call sends to any channel; no campaign setup required.
  • Content and logic stay separate. Templates and automations are independent resources. 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.
  • 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 your primary email provider goes down, traffic shifts to the backup without code changes.
  • 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 in Braze (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 Braze Content Cards for in-app messaging, enable Courier Inbox; no external provider needed.
3

Recreate templates

Braze campaigns bundle content and delivery config together. In Courier, start by extracting the content portion into templates:
  1. Create a new template for each transactional notification type
  2. Add content blocks for each channel (email, SMS, push, etc.)
  3. Convert Liquid variables ({{user.first_name}}) to Handlebars syntax ({{first_name}}); the data comes from the send request’s data field
  4. Publish the template to make it available for sending
If your Braze campaigns include multi-step Canvas flows, recreate the orchestration separately in Automations.
4

Migrate user data

Create user profiles in Courier with the same identifiers you use in Braze. 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.
5

Set up preferences

If you use Braze subscription groups, recreate your preference structure in Courier:
  1. Define subscription topics that map to your Braze subscription groups
  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.
6

Update your send calls

Replace Braze’s campaign trigger or Canvas trigger API calls with Courier’s Send API:
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.
7

Set up event streaming

If you use Braze Currents to stream delivery events, configure Courier Outbound Webhooks to forward message events (sent, delivered, opened, clicked) to your data warehouse or analytics pipeline.
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 Braze setup
  3. Switch your production code to use Courier’s Production API key
  4. Monitor Message Logs and Analytics for delivery confirmation

​
API Mapping

OperationBrazeCourier
Send a notificationPOST /messages/sendPOST /send
Trigger a workflowPOST /canvas/trigger/sendPOST /automations/invoke
Create/update a userPOST /users/trackPUT /profiles/:id
Get a userPOST /users/export/idsGET /profiles/:id
Manage subscriptionsPOST /subscription/status/setPUT /users/:id/preferences/:topic
Get message statusCampaign analytics endpointsGET /messages/:id
Bulk operationsPOST /users/track (batch)POST /bulk

​
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