<!-- APIScout AI-readable guide source -->
<!-- Canonical: https://apiscout.dev/guides/novu-vs-knock-vs-courier-notification-api-2026 -->
<!-- Raw Markdown: https://apiscout.dev/guides/novu-vs-knock-vs-courier-notification-api-2026/raw.md -->
<!-- Source path: content/guides/novu-vs-knock-vs-courier-notification-api-2026.mdx -->

---
og_image: "/images/guides/novu-vs-knock-vs-courier-notification-api-2026.webp"
title: "Novu vs Knock vs Courier: Notifications 2026"
description: "Novu: open source with self-host. Knock: powerful workflow engine. Courier: best routing logic. Compare notification infrastructure APIs for 2026 now."
date: "2026-03-16"
author: "APIScout Team"
tags: ["novu", "knock", "courier", "notification-api", "in-app-notifications", "api-comparison", "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:

```typescript
// 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:

```tsx
// 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.

```typescript
// 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":

```typescript
// 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](https://apiscout.dev).*

*Related: [Twilio vs Plivo vs Telnyx: SMS APIs 2026](/blog/twilio-vs-plivo-vs-telnyx-sms-voice-api-2026) · [Best Free APIs for Developers 2026](/blog/best-free-apis-2026), [Best In-App Notification APIs 2026](/blog/best-in-app-notification-apis-2026), [Best Push Notification APIs in 2026](/blog/best-push-notification-apis-2026), [How to Add Push Notifications to a Web App](/blog/how-to-add-push-notifications-web-app-2026)*