Twilio Notify EOL: Migrating to Knock

Twilio Notify was Twilio's multi-channel messaging API that let developers deliver push notifications, SMS, and other notifications through a single interface. It supported device registrations through bindings, user targeting through identities and tags, and flexible delivery options like time-to-live (TTL) and priority settings.

However, Twilio announced in 2022 that Notify would be deprecated, and the service is now officially reaching its end-of-life on December 31, 2025. After this date, the Notify API will no longer function.

If you're still relying on Twilio Notify, it's important to plan your migration now to avoid service interruptions. In this post, we'll walk through how to move your notification infrastructure to Knock, complete with:

• Feature-by-feature mapping
• API code samples
• A suggested cutover schedule

Let's dive in.

Why migrate to Knock?

The Twilio Notify service unified SMS, push, and email into a single API—but it had limitations: no in-app support, basic preference management, and limited workflow logic. While it did eliminate some manual work for teams who needed cross-channel engagement, it fell short of providing a fully-featured notification system that an entire organization could rely on.

Notifications for the entire organization

In comparison, Knock provides product and marketing teams flexibility in how they send notifications, covering both transactional and promotional use cases. With Knock, you can send customer or product messaging through the following methods:

• Transactional, event-based messaging using API triggers directly from your product using Workflows
• One-time, promotional journeys using Broadcasts that are triggered from the dashboard
• Audience-based notifications when a user enters a particular audience segment
• Native in-product messaging using Guides
• Event-based messaging using triggers from a CDP like Segment or Rudderstack

In addition to flexibility around sending messages, Knock also provides key functionality to complete the 'notification layer' of your technology stack:

• First-class support for SMS, email, push, in-app, and chat (Slack, MS Teams)

• Workflow builder with delays, batching, throttling, and branching

• User preferences that are automatically evaluted when sending

• Developer-first SDKs, in-app components, and observability

• Visual template management using a Notion-like template editor

• Translation management tools that scale with your product

Mapping concepts from Notify to Knock

Any successful migration depends on mapping concepts from your source system to your destination system in a clear way. This allows you to better compare the functionality of both systems to understand where there are feature gaps or where you'll be able to take advantage of new functionality.

Users and identities

Twilio Notify used concepts like bindings and identities to manage how and where users received messages. A binding linked a user identity to a specific channel and address, like an SMS number or push token.

In Knock, this is represented more directly:

• Identities map to Knock user ID — typically something stable like a database ID or UUID, and these users are commonly referred to as recipients in Knock.

• Bindings map to channel data or properties on a Knock user. Properties like phone_number or email are reserved in Knock and tell Knock where to send particular messages. For token-based communication methods, like push or Slack, channel_data allows you to store a number of different tokens for use with a particular channel.

In addition to providing you the data model to manage the tokens and email addresses, Knock also provides you with SDKs and drop-in components that make it easier to acquire tokens for channels like push or Slack.

Adding user properties and channel data in Knock

// In Knock:
 
await knock.users.update("user-123", {
  phone_number: "+15551234567",
 
  channel_data: {
    APNS_CHANNEL_ID: {
      tokens: ["apns-push-token"],
    },
  },
});

Code comparison: Notify vs. Knock

The method of sending notifications slightly differs between Twilio Notify and Knock, but there are also a lot of similarities.

Twilio Notify (push via identity)

When sending a notification with Twilio Notify, you need to directly specify the service, either SMS or push, that you want to use to send the notification, as well as pass either an identity or a binding to correctly route the notification to the right user and device.

const client = require("twilio")(accountSid, authToken);
 
client.notify.services(serviceSid).notifications.create({
  identity: "user-123",
 
  body: "You have a new alert!",
});

Triggering a Knock Workflow

In contrast, Knock uses a concept called workflows to encapsulate different notifications channels and any corresponding logic. When you trigger a workflow for a particular recipient, Knock handles resolving any necessary channel data or user properties and will execute sends across all orchestrated channels.

import { Knock } from "@knocklabs/node";
 
const knock = new Knock(process.env.KNOCK_API_KEY);
 
await knock.workflows.trigger("new-alert", {
  recipients: ["user-123"],
 
  data: { message: "You have a new alert!" },
});

Notify tags vs. Knock Objects and Subscriptions

In Notify, you can use tags to group users under labels and send messages to everyone associated with a tag.

client.notify.services(serviceSid).notifications.create({
  tag: "team:abc",
 
  body: "Your team has a new message!",
});

In Knock, you model groups using objects, and connect users to them via subscriptions:

//Objects in Knock live in a collection, have a unique id, and store properties
 
await knock.objects.set("teams", "team:abc", { name: "Team ABC" });
 
await knock.objects.addSubscriptions("teams", "team:abc", {
  recipients: ["user-123"],
});
 
await knock.workflows.trigger("team-update", {
  recipients: [{ collection: "subscriptions", id: "team:abc" }],
 
  data: { message: "Your team has a new message!" },
});

Mapping summary

In comparison to Twilio Notify, Knock's system provides more structure and visibility into relationships, enabling richer targeting logic.

Setup a plan for migration

Channels

Since Knock supports more channels and providers than Twilio Notify, it's possible to add additional channels to your notification system for orchestration. At a minimum, you'll need to set up channels in Knock for each type of Notify output you use in your existing system:

• SMS: via Twilio

• Push: via FCM or APNs

• Email: via SendGrid

• In-app: via Knock's realtime infrastructure

Workflows

Rebuild Notify message flows in Knock's workflow builder with:

• Message steps (customizable per channel)

• Batching, branching, delay, or throttling logic

• Preferences and send windows

Cutover plan

Implementing user preferences

Knock allows fine-grained control over what messages users receive and where they receive them. These granular controls make it less likely that a user unsubscribes from an entire channel.

// Opt user out of SMS for 'marketing' notifications
 
await knock.users.setPreferences("user-123", {
  channel_types: { sms: false },
  workflows: {
    "new-comment": {
      channel_types: {
        email: true,
        push: false,
      },
    },
    categories: {
      marketing: {
        channel_types: {
          sms: false,
          email: true,
        },
      },
    },
  },
});

Final thoughts

Twilio Notify's end-of-life doesn't have to be a setback. It's a chance to upgrade your notification stack. Knock offers a flexible, developer-friendly platform for multi-channel delivery, with full observability and control.

With the Knock MCP server, you can speed up your migration by creating workflows and templates directly from your IDE. Check out this video series to learn more.

Start now, and you'll be ready well ahead of December 31, 2025.

Want help?

Check out:

• Knock Docs

• Knock's Twilio SMS integration guide

• Or reach out to the Knock team directly