Migrate from Braze

Plan and run a migration of your transactional notification flows from Braze to Courier.

Braze is a marketing automation platform: campaigns, analytics, and customer engagement. Only the transactional and product notification workflows move to Courier. Marketing campaign orchestration is outside its scope.

Map Braze concepts to Courier

Braze	Courier
Campaigns	+
Canvas
Segments
User Profiles
Subscription Groups
Content Cards
Connected Content	`data` on send +
Currents
Liquid templating

Campaigns and templates

Braze campaigns bundle content, audience targeting, scheduling, and delivery into one resource. Courier splits them: own the content, and the or handle delivery. Your product team updates copy in Design Studio without touching delivery logic. Engineers change routing or timing without breaking template content. One template holds content for every channel (email, SMS, push, chat, inbox). Build it with drag-and-drop blocks, or define it in JSON.

Canvas and Journeys

Braze Canvas is a visual builder for multi-step, multi-channel journeys. Courier do the same for transactional flows: , , , , and .

Canvas Step	Courier Equivalent
Message step	(references a template)
Delay step
Decision split
Action paths	with conditions
Audience paths	+ conditions on profile data

Canvas entry criteria become : an API invoke, an inbound webhook, a Segment event, or a user joining an audience. Build journeys or through the .

Segments and audiences

Braze segments filter on user attributes, behaviors, and events. Courier group users dynamically by profile attributes. Define the filter rules once and Courier keeps membership current as profiles change. You can also target a , a static subscriber group, or send to individual users.

Users and profiles

Courier store a recipient’s email, phone, push tokens, and any custom properties you personalize with. Profiles accept nested JSON, so structured data like account tiers, team roles, or feature flags fits 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.

Subscription groups and preferences

Braze subscription groups manage opt-in and opt-out per channel. Courier go further. Users opt out by channel, category, or notification topic, and Courier enforces that at send time. Courier also ships a and embeddable for a preference center inside your app.

Content Cards and Inbox

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

Connected content and dynamic data

Braze’s Connected Content pulls external data into templates at render time. In Courier, you pass the data a template needs in the data field on the send request. To fetch data mid-journey, the calls an external API and passes the response to later nodes.

Templating language

Braze uses Liquid to personalize messages. Courier uses and {{variable}} syntax. Both support conditionals, loops, and helpers for 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 journeys are independent resources. 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.
Built-in in-app channel. Courier Inbox works without a third-party provider. Drop in a React, iOS, or Android component and send on the same pipeline as email and push.
Automatic failover. Configure multiple providers per channel. If your primary email provider goes down, traffic shifts to the backup without a code change.
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 the rendered content.

Migrate step by step

Create your Courier workspace

and create a workspace. Test and Production have independent API keys, so you can migrate without touching live traffic.

Configure integrations

Go to Integrations in the Courier dashboard and connect the same providers you use in Braze (SendGrid, Twilio, FCM). Each provider maps to a channel type (email, SMS, push, chat). Configure multiple providers per channel for .If you use Braze Content Cards for in-app messaging, enable . No external provider needed.

Recreate templates

Braze campaigns bundle content and delivery config. Extract the content into in Design Studio:

Create a new template for each transactional notification type
Add content blocks for each channel (email, SMS, push, etc.)
Convert Liquid variables ({{user.first_name}}) to ({{first_name}}). The data comes from the send request’s data field
Publish the template to make it available for sending

Recreate multi-step Canvas flows separately in .

Migrate user data

Create profiles with the same identifiers you use in Braze, through 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 Braze subscription groups, recreate your preference structure in Courier:

Define that map to your Braze subscription groups
Configure default channel routing per topic
Migrate user preference selections via the

Courier also provides a , or for embedding preferences in your app.

Update your send calls

Replace Braze’s campaign trigger or Canvas trigger API 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.

Courier handles routing, preferences, and failover from your template and workspace configuration.

Set up event streaming

If you stream delivery events with Braze Currents, configure to forward message events (sent, delivered, opened, clicked) to your data warehouse or analytics pipeline.

Test and cut over

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

Migrate with an AI agent

Most of this migration is mechanical: read a campaign definition, create the equivalent Courier template, rewrite the call site. A coding agent handles that well. Three things to set up first:

teaches the agent Courier’s real APIs and patterns so it stops guessing at endpoints:
npx skills add trycourier/courier-skills
In Claude Code, install it as a plugin instead. The plugin self-updates and ships the Courier docs MCP server.
gives the agent direct access to your workspace: create templates, build journeys, upsert users, and read send logs. See for setup in Claude Code, Cursor, Codex, and VS Code.
Docs for agents. Point it at llms-full.txt when it needs API detail beyond this page.

Then start it with a prompt like this one. Fill in the bracketed parts.

Help me migrate our notifications from Braze to Courier.

Read first:
- https://www.courier.com/docs/guides/migrate/from-braze
  (concept mapping and the migration steps you should follow)
- https://www.courier.com/docs/llms-full.txt
  (full Courier docs, for API detail as you need it)

Our setup:
- Codebase: [path]
- Braze API credentials: [env var]
- Courier: connected through the Courier MCP server

Work in this order. Stop after step 3 and wait for my review
before you create anything in Courier.

0. Setup. Install Courier Skills so you build against Courier's real
   APIs and patterns rather than guessing:
   npx skills add trycourier/courier-skills
   Then confirm the Courier MCP server is connected. If either one is
   missing, stop and tell me before going further.

1. Inventory. Use the Braze REST API to list every active campaign
   and Canvas. For each, record: name, entry trigger (API-triggered,
   scheduled, or action-based), channels, target segment, and whether
   it is a single send or a multi-step flow.

2. Classify each as:
   - transactional (an action in our product must produce it)
   - marketing (campaign or lifecycle)
   - in-app guidance (Content Cards, in-app messages)

3. Find the send sites. Grep the codebase for Braze
   POST /messages/send, POST /campaigns/trigger/send, and
   POST /canvas/trigger/send calls, plus POST /users/track calls that
   only exist to set an attribute a campaign triggers on. Map each to
   the campaign or Canvas it fires.

   Report the inventory, the classification, and the send-site list.
   Then wait.

4. Transactional first. For each transactional campaign: create the
   Courier template with the channels it needs, convert its Liquid
   personalization to Courier variables, then rewrite the call site to
   a Courier /send that names the template and passes data. Leave the
   Braze call in place behind a flag so we can run both and compare.

5. Canvases become journeys. Recreate each multi-step Canvas through
   the Courier journeys API. Delay steps become delay nodes, decision
   splits become branch nodes, message steps become send nodes, and
   exit criteria become cancel nodes.

6. Preferences. Map each Braze subscription group to a Courier
   subscription topic and import the opt-out state before any
   marketing send.

Rules:
- Never send to a real user. Use a test profile in the Test
  environment for every verification send.
- Never pause, disable, or delete anything in Braze. That is my call.
- If something in Braze has no Courier equivalent, say so in your
  report rather than approximating it.

Review the Liquid conversion in step 4 closely. Braze resolves {{user.*}} against its own user store. Each one becomes either a Profile attribute you sync or a value you pass in data. Decide that before the Templates exist, not after.

Map the API

Operation	Braze	Courier
Send a notification	`POST /messages/send`
Trigger a workflow	`POST /canvas/trigger/send`
Create/update a user	`POST /users/track`
Get a user	`POST /users/export/ids`
Manage subscriptions	`POST /subscription/status/set`
Get message status	Campaign analytics endpoints
Bulk operations	`POST /users/track` (batch)

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 Braze

Map Braze concepts to Courier

Campaigns and templates

Canvas and Journeys

Segments and audiences

Users and profiles

Subscription groups and preferences

Content Cards and Inbox

Connected content and dynamic data

Templating language

Why Courier

Migrate step by step

Migrate with an AI agent

Map the API

​Map Braze concepts to Courier

​Campaigns and templates

​Canvas and Journeys

​Segments and audiences

​Users and profiles

​Subscription groups and preferences

​Content Cards and Inbox

​Connected content and dynamic data

​Templating language

​Why Courier

​Migrate step by step

​Migrate with an AI agent

​Map the API

Map Braze concepts to Courier

Campaigns and templates

Canvas and Journeys

Segments and audiences

Users and profiles

Subscription groups and preferences

Content Cards and Inbox

Connected content and dynamic data

Templating language

Why Courier

Migrate step by step

Migrate with an AI agent

Map the API