Migrate from Knock

Plan and run a migration from Knock to Courier.

Map Knock concepts to Courier

Knock	Courier
Channels
Workflows	+
Recipients / Users
Objects	+ `data` on send
Subscriptions
Preferences
Tenants
Feeds (in-app)
Commits	Publish (draft/live)

Integrations

Knock Channels map to Courier , where you configure providers like SendGrid, Twilio, and FCM. Add several providers to one channel type and Courier between them. If your primary email provider is down, the backup takes over with no code changes. Courier supports providers across email, SMS, push, chat, and webhooks. Provider config lives in the dashboard, so adding or swapping one never needs a deploy.

Templates and Journeys

Knock bundles content and delivery logic into one Workflow. Courier splits them into two resources. This is the biggest difference between the platforms. own the content. Design them visually in Design Studio, with drag-and-drop blocks for email, SMS, push, and chat. Or define them in code with JSON. Either way, your product team ships copy changes without an engineering cycle. own the orchestration: , , , , and . A journey’s references a template by ID, so the two evolve independently. A journey starts from a : an API invoke, an inbound webhook, a Segment event, or a user joining an audience. Those are the same entry points as Knock workflow triggers.

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 feature flags, team roles, or subscription tiers fits. 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.

Objects and subscriptions

Knock Objects are non-user entities people subscribe to, like a document or a project. That splits into two things in Courier, and they move separately. The subscriber set becomes a list. A list_id is a dotted namespace, so document.doc_a1b2.watchers names the watchers of one document. Subscribing a user creates the list, so there is no object to register first, and list_pattern reaches every entity of a kind in one send. walks the whole pattern. The entity’s own attributes become data. Whatever the template renders about the document, such as its title or URL, goes in data on the send. So a Knock object that is both a subscriber set and a bag of attributes maps to a list plus data, rather than to one resource.

Preferences

Knock’s PreferenceSet maps to Courier . Users opt out by channel, category, or notification topic, and Courier enforces that at send time. Your code needs no conditional logic. Courier also ships a you can deploy in minutes. Embeddable put a preference center inside your app.

Tenants

in Courier work like Tenants in Knock. Scope branding, preference defaults, and notification feeds to a customer organization, workspace, or account. Pass a tenant_id at send time and Courier applies that tenant’s branding and preference defaults. One difference: Courier stores branding attributes on the Tenant resource, not as a separate Brands object.

In-app notifications

Knock’s Feeds map to Courier , a real-time notification center with drop-in components for , , , and . Inbox runs on the same pipeline as your other channels, so there’s no extra provider to configure. You get read/unread state, archiving, per-user history, and .

Versioning

Knock uses a git-style commit model to version dashboard changes. Courier uses draft and published states. Edit templates and journeys in draft, preview them, and publish when ready. Published versions are immutable, so you always have a snapshot of what’s live.

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.
Built-in in-app channel. Courier Inbox needs no third-party provider. Drop in a React, iOS, or Android component and deliver on the same pipeline as email and push.
Automatic failover. Configure multiple providers per channel. If SendGrid goes down, your email goes out through the backup.
Hosted preferences. Ship a user-facing preference center with one 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.
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. 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 in Knock (SendGrid, Twilio, FCM, etc.). Each provider maps to a channel type (email, SMS, push, chat). Configure multiple providers per channel for .If you use Knock’s in-app feed, enable . No external provider needed.

Recreate templates

Knock workflows combine content and logic. In Courier, recreate the content as in Design Studio:

Create a new template for each notification type
Add content blocks for each channel (email, SMS, push, etc.)
Use syntax for dynamic data. Courier supports the same Handlebars-style variables
Publish the template to make it available for sending

If your Knock workflows include orchestration logic (delays, conditions, batching), recreate that in .

Migrate user data

Create user profiles in Courier with the same identifiers you use in Knock. Use the , or identify users 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 Knock’s PreferenceSet, recreate that structure in Courier:

Define that map to your Knock categories
Configure default channel routing per topic
Migrate user preference selections via the

Courier also provides a you can deploy immediately, or to embed preferences in your app.

Update your send calls

Replace Knock’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: {
      name: 'Sarah Bennett',
      action_url: 'https://app.example.com',
    },
  },
});

response = client.send.message(
    message={
        "to": {"user_id": "user_123"},
        "template": "nt_01kx4h2jdafq8bk9aftxak4b40",
        "data": {
            "name": "Sarah Bennett",
            "action_url": "https://app.example.com",
        },
    },
)

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": {
        "name": "Sarah Bennett",
        "action_url": "https://app.example.com"
      }
    }
  }'

response = courier.send_.message(
  message: {
    to: { user_id: "user_123" },
    template: "nt_01kx4h2jdafq8bk9aftxak4b40",
    data: { name: "Sarah Bennett", action_url: "https://app.example.com" }
  }
)

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{
			"name": "Sarah Bennett",
			"action_url": "https://app.example.com",
		},
	},
})

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(
            "name", "Sarah Bennett",
            "action_url", "https://app.example.com")))
        .build())
    .build();
client.send().message(params);

$response = $client->send->message(
  message: [
    'to' => ['userID' => 'user_123'],
    'template' => 'nt_01kx4h2jdafq8bk9aftxak4b40',
    'data' => ['name' => 'Sarah Bennett', 'action_url' => 'https://app.example.com'],
  ],
);

SendMessageParams parameters = new()
{
    Message = new()
    {
        To = new UserRecipient { UserID = "user_123" },
        Template = "nt_01kx4h2jdafq8bk9aftxak4b40",
        Data = new Dictionary<string, JsonElement>()
        {
            { "name", JsonSerializer.SerializeToElement("Sarah Bennett") },
            { "action_url", JsonSerializer.SerializeToElement("https://app.example.com") },
        },
    },
};

await client.Send.Message(parameters);

courier send message \
  --api-key "$COURIER_API_KEY" \
  --message '{"to":{"user_id":"user_123"},"template":"nt_01kx4h2jdafq8bk9aftxak4b40","data":{"name":"Sarah Bennett","action_url":"https://app.example.com"}}'

With Courier MCP, send my nt_01kx4h2jdafq8bk9aftxak4b40 template to user_123 with their name.

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

Test and cut over

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

Map the API

Operation	Knock	Courier
Send a notification	`POST /workflows/:key/trigger`
Create/update a user	`PUT /users/:id`
Get a user	`GET /users/:id`
Set user preferences	`PUT /users/:id/preferences/:set_id`
Get message status	`GET /messages/:id`
List messages	`GET /messages`
Create/update tenant	`PUT /tenants/: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 Knock

Map Knock concepts to Courier

Integrations

Templates and Journeys

Users and profiles

Objects and subscriptions

Preferences

Tenants

In-app notifications

Versioning

Why Courier

Migrate step by step

Map the API

​Map Knock concepts to Courier

​Integrations

​Templates and Journeys

​Users and profiles

​Objects and subscriptions

​Preferences

​Tenants

​In-app notifications

​Versioning

​Why Courier

​Migrate step by step

​Map the API

Map Knock concepts to Courier

Integrations

Templates and Journeys

Users and profiles

Objects and subscriptions

Preferences

Tenants

In-app notifications

Versioning

Why Courier

Migrate step by step

Map the API