Novu vs Knock vs Courier: Notifications 2026

Notification Infrastructure Is a Real Category Now

Five years ago, "notification infrastructure" meant sendgrid + a cron job. Today, it's a distinct software category with its own market, tooling, and pricing models. The reason: product teams discovered that notification logic — routing rules, user preferences, digests, multi-channel fallback, in-app feeds — was taking months to build and was never quite right.

Three APIs dominate the developer-facing end of this market: Novu, Knock, and Courier. They share a common premise — abstract away the complexity of multi-channel notification delivery — but they approach it differently and price it differently enough that choosing wrong costs real money at scale.

TL;DR

Novu is the open-source default — self-host for free, cloud plan available, and the only option with a genuinely embeddable in-app notification center component out of the box. Knock has the most powerful workflow builder and best developer ergonomics, with per-event pricing that's predictable at scale. Courier is the best choice if your team needs a visual notification designer and routing logic that non-engineers can manage. All three beat building in-house for any team that sends multi-channel notifications.

Key Takeaways

Novu: ~30–35K GitHub stars; open source (MIT); self-host free forever; Cloud free tier 30K events/month; modern @novu/react SDK with <Inbox /> component
Knock: SaaS-only; free up to 10K monthly notifications; Starter $250/month (250K notifications); best workflow engine; in-app feed component
Courier: free tier 10K notifications/month; strong routing/brand management; best for marketing-engineering collaboration; Segment/Stripe integrations
In-app feed: All three have it — but Novu's is the most production-ready React component; Knock's is close; Courier's is newer
Pricing model: Knock is per-notification; Novu Cloud is per-event (1 trigger = 1 event regardless of channels); Courier is per-notification
Self-hosting: Only Novu offers a real self-hosted option (Docker Compose + MIT license); Knock and Courier are SaaS-only

Pricing Comparison

Feature	Novu	Knock	Courier
Free tier	30K events/month	10K notifications/month	10K notifications/month
Paid entry	$30/month (Pro, 30K events)	$250/month (Starter, 250K)	$99/month (Business)
In-app feed	✅ included	✅ included	✅ included
Self-host	✅ free (MIT)	❌	❌
Workflow builder	✅	✅ (superior)	✅
Preference center	✅	✅	✅
SOC 2	✅ (Cloud)	✅	✅

Novu Pricing

Novu's pricing has two tracks:

Self-hosted: Free forever, unlimited usage. You provide the infrastructure. Docker Compose is the standard deployment — a typical production setup runs on a $50-100/month VPS. Requires managing your own MongoDB, Redis, and the Novu API/worker/web containers.

Novu Cloud:

Free: 30,000 events/month; 1 workspace; community support
Pro ($30/month): 30,000 events/month; up to 3 team members; email support
Team ($250/month): 250,000 events/month; multiple workspaces; priority support; SLA
Enterprise: Custom; dedicated infrastructure; SSO; HIPAA

The event unit is the key billing concept — one event = one notification trigger, regardless of how many channels it fans out to. Sending a single notification to email + SMS + in-app = 1 event, not 3. This makes Novu's pricing unusually favorable for multi-channel workflows.

Knock Pricing

Knock bills per notification (not per event trigger):

Free (Developer): 10,000 notifications/month; all features included
Starter ($250/month): 250,000 notifications/month; priority support; branding removed
Enterprise: Custom volume; dedicated support; SLA guarantees

Knock's per-notification model means that if one event triggers email + SMS + push = 3 notifications billed. This is the opposite of Novu's model. At high volume with many channels, Knock can get expensive; at low-to-medium volume it's very competitive.

Courier Pricing

Free: 10,000 notifications/month; all features; 1 workspace
Business ($99/month): 50K notifications/month; $1.49/1K additional; multiple workspaces; custom branding
Enterprise: Custom; SAML SSO; dedicated IP; custom data retention

Courier bills per notification sent. $99/month for 50K notifications works out to $1.98/1K — comparable to Knock at similar volumes.

Architecture and Core Concepts

Novu's Model: Topics and Subscribers

Novu is built around subscribers (users who receive notifications) and topics (groups of subscribers). You trigger a notification workflow by sending an event to a subscriber or topic:

// Trigger a notification in Novu
import { Novu } from '@novu/node'

const novu = new Novu(process.env.NOVU_API_KEY)

await novu.trigger('order-confirmation', {
  to: {
    subscriberId: 'user-123',
    email: 'user@example.com',
    phone: '+15551234567'
  },
  payload: {
    orderId: 'ORD-456',
    total: '$89.99',
    estimatedDelivery: '2026-03-20'
  }
})

The workflow (email template, SMS template, in-app message, send conditions) is defined in Novu's UI or via code. You can define digest windows, delays, and multi-step sequences.

Novu's in-app notification center is its clearest differentiator. A pre-built React component that renders a notification bell with a feed, mark-as-read, infinite scroll, and real-time delivery via WebSocket.

Novu now has two React packages. The newer @novu/react is recommended for new projects:

// Modern approach: @novu/react (recommended)
import { NovuProvider, Inbox, Bell } from '@novu/react'

function App() {
  return (
    <NovuProvider
      subscriberId="user-123"
      applicationIdentifier={process.env.NOVU_APP_ID}
    >
      <Bell />       {/* Notification bell with unread count */}
      <Inbox />      {/* Full notification inbox/feed */}
    </NovuProvider>
  )
}

The legacy @novu/notification-center package (with PopoverNotificationCenter / NotificationBell) still works but is in maintenance mode. For new projects, use @novu/react.

Drop either in and you have a working notification center in ~10 minutes, including real-time WebSocket updates.

Knock's Model: Workflows and Actors

Knock centers on workflows (sequences of notification steps with conditions, delays, and batching) and users (recipients). The workflow builder in Knock's UI is the most powerful of the three — you can build sophisticated multi-step sequences with branching logic, digest windows, and per-step channel conditions without code.

// Trigger in Knock
import Knock from '@knocklabs/node'

const knock = new Knock(process.env.KNOCK_SECRET_KEY)

await knock.workflows.trigger('new-comment', {
  recipients: ['user-123'],
  actor: 'user-456', // who triggered the action
  data: {
    commentId: 'comment-789',
    message: 'Great article!',
    postTitle: 'Building Better APIs'
  }
})

Knock's workflow builder supports:

Batch/digest: Collect notifications over a window (e.g., "send one email per hour instead of one per comment")
Delays: "Wait 30 minutes before sending push notification"
Channel conditions: "Only send SMS if user hasn't opened the email within 2 hours"
Per-recipient preferences: Users can mute specific channels per workflow

The batch/digest support is Knock's strongest feature — it's more flexible and easier to configure than Novu's equivalent.

Courier's Model: Routing and Brands

Courier's core concept is routing — defining rules for how notifications should be delivered across channels based on user data, provider availability, and business logic. A notification might say "send to email unless user prefers SMS, then fall back to push":

// Send via Courier
import { CourierClient } from '@trycourier/courier'

const courier = CourierClient({ authorizationToken: process.env.COURIER_AUTH_TOKEN })

const { requestId } = await courier.send({
  message: {
    to: { user_id: 'user-123' },
    template: 'ORDER_CONFIRMATION',
    data: {
      orderId: 'ORD-456',
      total: '$89.99'
    }
  }
})

Courier's Designer — a drag-and-drop notification template builder — is aimed at product and marketing teams who don't want to touch code for template changes. This is a real advantage in companies where marketing owns notification copy.

Brand management in Courier lets you define global brand assets (logo, colors, fonts) that apply across all notification templates. Template updates propagate automatically. For companies managing notifications across multiple brands or white-label products, this is significant.

Feature Comparison

Feature	Novu	Knock	Courier
Email	✅	✅	✅
SMS	✅	✅	✅
Push (FCM/APNs)	✅	✅	✅
In-app feed	✅ (React component)	✅ (React + Vue)	✅
Slack/Teams/Discord	✅	✅	✅
WhatsApp	✅	⚠️ limited	✅
Digest/batch	✅	✅ (superior)	✅
Workflow builder	✅	✅ (superior)	✅
User preferences	✅	✅	✅
Template designer	✅	⚠️ basic	✅ (superior)
Brand management	⚠️ basic	❌	✅
Self-host	✅	❌	❌
Open source	✅	❌	❌
BYOP (bring your own provider)	✅	✅	✅

All three support "bring your own provider" — you connect your existing SendGrid, Twilio, or Mailgun account and route through their platform. None of them are notification delivery networks themselves.

Developer Experience

Novu has the most SDKs and widest ecosystem (Node.js, Python, PHP, .NET, Go, Java, Ruby). The self-hosted setup requires more ops knowledge, but the Docker Compose path is well-documented. The workflow editor has improved significantly in v1 (2024) and the TypeScript SDK is solid.

Knock has the best developer ergonomics. Their API design is clean, documentation is excellent, and the workflow builder UI is genuinely intuitive. TypeScript SDK is first-class. The actor/recipient model maps naturally to how product engineers think about notification events. Knock also supports a "preview" mode where you can test a workflow with specific user data before sending.

Courier has the most visual tooling. The notification designer is the best in class for non-engineers. However, the API is more complex than Knock's and the developer documentation is less polished. The routing DSL takes time to learn.

Real-Time In-App Notifications Deep Dive

All three use WebSocket or SSE for real-time in-app delivery, but the implementation quality varies:

Novu ships @novu/react with <Inbox />, <Bell />, and a <Preferences /> component. WebSocket updates are managed automatically — reconnection, optimistic UI, pagination, and mark-as-read all handled. Saves 2–3 weeks of frontend work. (Legacy @novu/notification-center still works but is in maintenance mode.)

Knock ships @knocklabs/react with KnockFeedProvider, NotificationIconButton, NotificationFeedPopover, and a useNotifications hook for custom UIs. Quality is comparable to Novu's. Real-time delivery via persistent WebSocket connection.

Courier fully rebuilt its Inbox in 2025 with a new architecture. Ships CourierInboxPopupMenu and CourierInbox components, plus a drop-in Preferences component that automatically enforces user channel preferences without additional code. WebSocket-powered with single connection per tab and real-time sync across views.

Cost Scenarios at Scale

Scenario 1: SaaS app — 10K MAU, 5 notifications/user/month (50K events/notifications)

Platform	Monthly Cost
Novu Cloud	50K events → $30/month (Pro tier; 30K included + 20K overage)
Novu Self-hosted	~$30/month (small VPS)
Knock	50K notifications → $250/month (Starter plan)
Courier	50K notifications → $99/month (Business)

Scenario 2: Growth-stage app — 100K MAU, 10 notifications/user/month = 1M/month

Platform	Monthly Cost
Novu Cloud (Team)	~$250/month (250K events included; significant overages at 1M)
Novu Self-hosted	~$100–150/month (larger VPS + Redis)
Knock	1M notifications → Starter ($250) + $4,750 overages ≈ $5,000/month (Enterprise pricing needed)
Courier	1M notifications: Business + overages ≈ $1,450/month

At meaningful scale, self-hosted Novu wins on cost decisively. Knock's per-notification model is affordable at lower volumes but gets expensive fast with high-frequency multi-channel notification workflows. Courier sits in the middle.

When to Choose Each

Choose Novu if:

Data residency or privacy requirements make SaaS a non-starter (self-host)
You want an open-source notification stack you can fork and customize
You need the pre-built React in-app notification center component fastest
You're cost-sensitive at high volume and can manage your own infra
You're building for markets where keeping data on-premise is critical (healthcare, finance, EU GDPR-sensitive)

Choose Knock if:

You need a complex multi-step workflow with batching, delays, and channel fallbacks
Developer experience is a priority — Knock's API and docs are the cleanest
You want per-notification pricing (predictable at scale vs per-seat or per-event)
Your notification logic is complex and changes frequently (the workflow builder shines here)

Choose Courier if:

Non-technical team members (product, marketing) need to edit notification templates without engineer involvement
You need strong brand management across multiple notification templates
Your routing logic is complex (A/B test notification channels, fallback chains)
Segment or Stripe integrations are important for your use case

Compare notification APIs, pricing, and uptime at APIScout.

Comments