Knock

Name: Knock
Brand: Knock
Price: 0250 USD

Notification infrastructure your engineers build once and your PM edits forever

Knock is a notification infrastructure platform that sits between your application and your delivery providers, handling workflow orchestration, batching, delays, cross-channel routing, user preference centers, and multi-tenancy through a single API, so product teams can ship in-app feeds, email, push, SMS, Slack, and Microsoft Teams notifications without building and maintaining that logic themselves.

Visit website

Overview

Knock exists because of a specific engineering failure that repeats at every SaaS company. Notifications start as one line of code that sends an email. Then someone asks for an in-app feed, then a digest so people are not emailed nine times an hour, then a preference center so they can turn categories off, then Slack delivery for the customers who live there, then per-tenant branding. Eighteen months later a team owns a notification service nobody wanted to build, and every product change means an engineering ticket. Knock takes that entire layer as a product.

The founders, Sam Seely and Chris Bell, hit exactly this problem as product and engineering leaders at Frame.io before starting the company in 2021. Knock raised a $12M Series A led by Craft Ventures in February 2024, taking total funding to $18M, with David Sacks joining the board. The customer list skews toward developer-facing products: Webflow, Vercel, Vidyard, and Amplitude are all cited, which is the right kind of validation for a piece of infrastructure.

The important thing for a buyer in this category is what Knock is not. It is not a marketing automation platform. There is no contact database you upload, no campaign calendar, no deliverability practice, and no ESP. You bring your own providers (SendGrid, Postmark, Twilio, APNs, Firebase, Slack) and Knock orchestrates across them. It is entirely event-driven off your product data stream, which means a company with no engineering resource cannot use it at all, and a company with engineers gets a layer that a product manager can then operate without filing tickets.

Pricing is the sharpest edge. The Developer tier is free and unusually generous: 10,000 messages a month, unlimited workflows, unlimited channels, unlimited team members, batching, delays, and multi-tenancy. The next step is Starter at $250 a month for 50,000 prepaid messages. There is nothing in between, so a company that outgrows the free tier faces a hard jump from $0 to $250, which is the single most common complaint from small teams evaluating it.

Best for

Product and engineering teams at SaaS companies who need real product notifications (in-app feed, digests, preference centers, per-tenant configuration) and want the workflow logic owned by a platform a PM can edit rather than by application code an engineer has to redeploy.

Not the right fit for

Marketing teams without engineering support; there is no contact upload, no campaign calendar, and nothing happens until a developer wires the trigger, so a marketer alone cannot use Knock at all.
Newsletter and broadcast senders; Knock has broadcasts but it is not an ESP, it does not manage deliverability, and it will never be the right home for a weekly send to a purchased list.
Ecommerce brands; there is no product catalog, no cart abandonment recipe, no revenue attribution, and nothing about the pricing model rewards a high-volume promotional sender.
Small teams whose volume sits just above the free tier; the step from free to $250 a month with no intermediate plan is brutal for a company sending 15,000 messages a month.
Anyone who wants sending included; you bring and pay for your own SendGrid, Twilio, and push providers on top of the Knock bill, so the total cost is always higher than the sticker price.

How it works

1
You define workflows in Knock, either in the dashboard or as code through the CLI. A workflow describes what happens when a given event occurs in your product: which channels fire, in what order, with what delays, batched over what window, and subject to which conditions. Workflows are versioned, testable in non-production environments, and roll back with a click.
2
Your application calls the Knock API to trigger a workflow, passing a recipient and a data payload. That is usually the only Knock-specific code in your codebase. Everything downstream (which channel, what template, whether to batch, whether the user has opted out) is decided by Knock rather than by your application logic, which is precisely what makes the layer worth having.
3
Knock delivers through channels you configure with your own provider credentials. Email goes out through your SendGrid or Postmark account, SMS through your Twilio account, push through APNs and Firebase, chat through Slack and Microsoft Teams, and in-app through Knock's own feed and Guides components. You own the sending reputation because you own the provider account.
4
For the surfaces users touch, Knock ships components: an in-app notification feed, a preference center where users choose categories and channels, and Guides for in-product paywalls, dialogs, and nudges that use your own front-end components with copy and targeting editable in the Knock dashboard. Data comes in from warehouses, CDPs, reverse ETL tools, and webhooks, so audiences and segments can be built from data you already have rather than re-instrumented.

Feature breakdown

24 features in 5 modules

Workflow orchestration

The core engine: what happens when an event fires, decided outside your application code.

Visual and code-defined workflows: Build workflows in the dashboard or define them as code through the CLI and check them into version control, with CI validation so a bad workflow fails a build rather than a customer's inbox.
Batching and digests: Collapse many events into one notification over a window you define, which is the feature most teams build badly themselves and the reason many buyers arrive at Knock in the first place.
Delays and waits: Time-based steps and wait-for-condition steps so a workflow can pause, check whether the user has already acted, and skip the reminder if so.
Conditional branching: Route on recipient attributes, tenant configuration, or payload data so one workflow serves several customer segments without duplicating it.
Cross-channel fallback: Send in-app first, fall back to email if unseen, fall back to SMS if still unseen, all as workflow configuration rather than application logic.
Environments and rollback: Test changes in non-production environments, promote them deliberately, and roll a workflow version back with a click when something goes wrong.

Channels and providers

Bring your own delivery, keep your own sending reputation.

Unlimited channels on every plan: Channel count is not a pricing lever at any tier, including the free one, which is unusual and removes a common upgrade trap.
In-app notification feed: A drop-in feed component with real-time updates, read and seen state, and archiving, which is the piece teams most often want and least want to build.
Email through your own provider: Configure SendGrid, Postmark, Resend, or similar with your own credentials. Knock composes and orchestrates; your provider sends and owns the reputation.
SMS and push: Twilio and similar for SMS, APNs and Firebase for mobile push, configured with your own accounts and billed by those providers separately.
Slack and Microsoft Teams: First-class chat delivery including the OAuth flow for connecting a customer's workspace, which is a meaningful amount of work to build and a common requirement in B2B SaaS.

User-facing controls

The surfaces that stop notifications becoming a support problem.

Preference centers: Category and channel level opt-outs backed by a preferences API, so users control what they receive and where without you building a settings screen from scratch.
Sending windows and frequency limits: Quiet hours and rate controls that keep a chatty product from training users to ignore it.
Guides: In-product paywalls, dialogs, and nudges rendered with your own front-end components, with copy and targeting editable in the Knock dashboard by a non-engineer. Billed separately as Guide active users.
Multi-tenancy: Tenant-aware configuration and isolation so a B2B product can give each customer organization its own notification settings, and on Enterprise its own branding.

Data and audiences

How Knock knows who to message and what to say.

Warehouse, CDP, and reverse ETL ingestion: Pull user attributes and events from your warehouse, CDP, or a reverse ETL tool rather than maintaining a second copy of your customer data inside Knock.
Dynamic segments: Build audiences from attributes, events, and relationships, and trigger workflows on segment entry as well as on direct API calls.
Custom objects: Model non-user entities (a project, a document, a workspace) and personalize or target against them, which matters for products where notifications are about things rather than about people.
Broadcasts: One-off sends to a segment, included on every plan including free, for the announcements that do not warrant a workflow.

Developer experience

The part that decides whether the integration actually lands.

SDKs across eight languages: Node, Python, Ruby, Go, Java, .NET, Elixir, and PHP server SDKs, plus front-end components for the feed and preference center.
Agent toolkit and MCP server: Knock positions itself as operable entirely from Cursor or Claude Code, with an MCP server and CLI so workflows can be authored and modified by an AI coding assistant against your repository.
AI email generation: Template generation that produces client-safe email HTML in your layout and branding, which removes the worst hour of any notification project.
Observability and debugging: Per-message execution traces showing exactly which steps ran and why, with log streaming to external monitoring on Enterprise.
99.99% uptime commitment: Production reliability commitments appropriate to a system sitting in the critical path of your product's communication.

Use cases

4 documented

Series A SaaS company with a notification service nobody owns

Comments, mentions, and assignments each send an immediate email, users are complaining about volume, and building a digest plus a preference center is a quarter of engineering work nobody has budgeted.

Batching, preference centers, and the in-app feed come as configuration. The engineering team ships the trigger calls in a sprint, deletes the homegrown service, and the PM adjusts digest windows afterwards without a deploy.

B2B product whose customers live in Slack

Enterprise accounts want notifications in their own Slack workspace, which means building an OAuth flow and per-tenant token storage.

Knock ships the Slack and Microsoft Teams connection flow and stores tenant configuration, so chat delivery becomes a channel in an existing workflow rather than a project.

Product manager who cannot ship copy changes

Every wording tweak to an onboarding notification requires an engineer, a pull request, and a release.

Templates, timing, and targeting live in the Knock dashboard with environment promotion and rollback, so the PM owns the message and engineering owns the trigger.

Team hitting the free tier ceiling

10,000 free messages a month covered the beta, but the product now sends 40,000 and the bill jumps to $250.

Starter's 50,000 prepaid messages at $250 works out to $0.005 a message with $0.005 overage after, which is defensible against the cost of maintaining the equivalent internally but a real step change for a small budget.

Pricing

from $0 (Developer), then $250 per month (Starter)

Usage-based on messages sent, with a separate meter for Guide active users and AI agent credits, plus a large free tier and a single published paid plan before enterprise contracts.

Plan	Price	Includes
Developer	$0 per month	10,000 messages per month included 500 Guide active users and 500 AI agent credits Unlimited workflows, channels, and team members Batching, delays, broadcasts, and multi-tenancy Google SSO One of the most generous free tiers in developer tooling. Multi-tenancy on a free plan is close to unheard of.
Starter	$250 per month	50,000 prepaid messages, then $0.005 per message 2,500 prepaid Guide active users, then $0.05 per user 2,000 AI agent credits, then $0.01 per credit Knock branding removed Email client previews The jump from $0 to $250 with nothing in between is the plan structure's weakest point.
Enterprise	Custom annual contract	Volume-based or monthly-notified-user pricing with annual commit discounts Custom roles and permissions, SCIM directory sync, SAML 2.0 SSO Per-customer branding and internationalization Data warehouse analytics integration and Datadog observability Enterprise SLAs and HIPAA with a BAA

Plan

Price

Includes

Developer

per month

10,000 messages per month included
500 Guide active users and 500 AI agent credits
Unlimited workflows, channels, and team members
Batching, delays, broadcasts, and multi-tenancy
Google SSO

One of the most generous free tiers in developer tooling. Multi-tenancy on a free plan is close to unheard of.

Starter

$250

per month

50,000 prepaid messages, then $0.005 per message
2,500 prepaid Guide active users, then $0.05 per user
2,000 AI agent credits, then $0.01 per credit
Knock branding removed
Email client previews

The jump from $0 to $250 with nothing in between is the plan structure's weakest point.

Enterprise

Custom

annual contract

Volume-based or monthly-notified-user pricing with annual commit discounts
Custom roles and permissions, SCIM directory sync, SAML 2.0 SSO
Per-customer branding and internationalization
Data warehouse analytics integration and Datadog observability
Enterprise SLAs and HIPAA with a BAA

Add-ons

Messages beyond the included allowance ($0.005 per message): Applies on Starter after the 50,000 prepaid messages.
Guide active users ($0.05 per user): After the 2,500 prepaid on Starter or the 500 included on Developer.
AI agent credits ($0.01 per credit): Consumed by the AI workflow and template generation features.

Billing notes

The meter is messages sent, not profiles stored, so a large user base that rarely gets notified is cheap here in a way it is not on Customer.io or Ortto.
Guides are a second meter entirely, billed on monthly active users who see a guide, so an in-product nudge programme costs separately from your notification volume.
You pay your own delivery providers on top. Budget SendGrid, Twilio, and push costs separately; the Knock line item is the orchestration layer only.
At the equivalent of 5,000 lightly notified users the Developer plan is often genuinely sufficient, which means a real cost of $0 plus provider fees.
At 50,000 users generating say 400,000 messages a month, Starter's 50,000 prepaid plus 350,000 overage at $0.005 comes to roughly $2,000 a month, at which point the Enterprise volume conversation is the rational move.
There is no intermediate plan between free and $250, so growth from 10,000 to 12,000 messages a month costs a company $3,000 a year.

Value assessment: Knock is priced as infrastructure, and the honest comparison is not against Mailchimp but against the salary cost of the engineer who would otherwise own your notification service. On that basis the free tier is remarkable value and Starter at $250 is fair, since 50,000 messages with batching, preference centers, in-app feed, and multi-tenancy is a quarter of engineering work you no longer do. The weakness is the plan gap: a team sending 15,000 messages a month is paying $250 for capability it barely uses, and the separate Guides meter means the sticker price understates the cost of using the whole product. Add your own provider bills on top and Knock is never the cheapest line on the invoice, but it is usually the one that saves the most.

Strengths & limitations

Strengths

Batching, digests, preference centers, and multi-tenancy are all first-class, and they are exactly the four things engineering teams build worst when they build them in-house.
The free Developer tier is extraordinarily generous, including unlimited workflows, unlimited channels, unlimited team members, and multi-tenancy at $0.
Bring-your-own-provider means you keep your sending reputation, your existing SendGrid or Twilio contracts, and your negotiated rates.
Workflows as code with CLI, version control, CI validation, environments, and one-click rollback, which makes notification changes a normal part of the software lifecycle instead of a risk.
The agent toolkit and MCP server are a genuine differentiator: workflows can be authored and edited from Cursor or Claude Code against your own repository.
Strong compliance posture for a company this size, with SOC 2, GDPR, CCPA, HIPAA with a BAA on Enterprise, and a 99.99% uptime commitment.
The division of labour is right: engineers own triggers, product owns messages, and neither blocks the other after the initial integration.

Limitations

Completely unusable without engineering; there is no path where a marketer signs up and gets value, because nothing happens until code calls the API.
The pricing cliff from $0 to $250 a month with no intermediate plan penalizes exactly the small companies the free tier attracted.
Guides are metered separately on active users, so the in-product messaging feature has its own cost curve that is easy to miss when budgeting.
You still pay for delivery separately, and you still own deliverability, list hygiene, and domain authentication yourself.
No marketing surface at all: no campaign calendar, no A/B testing of the sort a growth team expects, no revenue attribution, no ecommerce anything.
At $18M raised and a small team, Knock is a young company holding a critical path position in your product, which is a real if manageable concentration risk.

Head-to-head comparisons

5 alternatives

Knock vs Courier

from $0 (Developer, 10,000 sends per month), then $0.005 per send

The closest comparison in the batch: both are bring-your-own-provider notification infrastructure with in-app inboxes, preference centers, and multi-channel workflows. Courier is metered purely per send at $0.005 with 10,000 free, and leans harder into the visual template designer for non-developers. Knock has the stronger free tier, deeper multi-tenancy, workflows as code, and Guides. Pick Courier for simpler linear pricing and a friendlier design surface; pick Knock for B2B products with tenant-level configuration and teams who want notification logic in version control.

Full Knock vs Courier comparison

Knock vs Novu

from $0 (Free or self-hosted), then $30 per month (Pro)

Novu is the open-source answer to the same problem: workflows, inbox component, digests, and preferences, metered by workflow runs from $30 a month, with a self-hostable core. Knock is closed source, more expensive, and more mature on multi-tenancy, environments, and enterprise controls. Choose Novu when self-hosting or budget matters most, or when $30 versus $250 decides it; choose Knock when the notification layer is critical path and you want a vendor with SLAs behind it.

Full Knock vs Novu comparison

Knock vs OneSignal

from $0 (Free), then $19 per month plus usage (Growth)

OneSignal is a growth team's tool with push as its deepest channel and delivery included, free for unlimited mobile push. Knock is an engineering team's tool with no delivery of its own and no marketing surface. If the question is how to reach users on their phone with a campaign, OneSignal. If the question is how to stop our product emailing people nine times an hour, Knock.

Full Knock vs OneSignal comparison

Knock vs Dittofeed

from $0 self-hosted; $75/mo Cloud Pro

Both are developer-friendly and both let you keep control, but Dittofeed is open-source marketing automation (journeys, segments, templates, bring your own ESP) aimed at lifecycle campaigns, self-hostable free or cloud from $75 a month. Knock is product notification infrastructure aimed at in-app feeds and transactional workflows. A team wanting to run onboarding email campaigns should take Dittofeed; a team wanting a notification feed with digests and preferences should take Knock.

Full Knock vs Dittofeed comparison

Knock vs Customer.io

from $100/mo (Essentials)

Customer.io is a full marketing automation platform with its own delivery, a CDP, campaign tooling, and a $100 monthly floor billed on profile count. Knock is the plumbing under your product's own notifications, with no campaign layer and no sending. Many companies eventually run both: Customer.io for lifecycle marketing, Knock for the in-product feed and transactional workflows. If you can only have one and you are a marketing-led business, take Customer.io.

Full Knock vs Customer.io comparison

Implementation & onboarding

Setup time: A day to a first workflow in production for a competent backend engineer, and one to three sprints to migrate an existing homegrown notification service. The in-app feed component is typically the fastest visible win.
Learning curve: Low for engineers, moderate for product people. The concepts (workflows, recipients, tenants, channels, preferences) are clean, but the mental model of moving decision logic out of application code into a workflow platform takes a team a couple of weeks to internalize.
Onboarding: Self-serve on Developer and Starter, with documentation and quickstarts carrying the load. Enterprise adds guided implementation. The CLI and MCP server mean an AI coding assistant can do much of the scaffolding.
Migration notes: Migration from a homegrown service is the common path and it is incremental: point one notification type at Knock, verify, then move the rest. Because you keep your existing delivery providers, there is no sending reputation to rebuild and no domain warmup. Preferences are the awkward part, since existing opt-out state has to be imported into the Knock preferences API before you cut over or you will message people who already unsubscribed.

Platform, API & security

Platforms: Web dashboardREST APICLIReact and JavaScript componentsiOS, Android, React Native, and Flutter clientsMCP server
API: REST API with server SDKs for Node, Python, Ruby, Go, Java, .NET, Elixir, and PHP, plus front-end SDKs for the notification feed and preference center, a CLI for workflows as code, and an MCP server for AI assistants.
Compliance: SOC 2GDPRCCPAHIPAA with a BAA on Enterprise
Data residency: US-hosted by default; EU or other regional arrangements are handled through Enterprise contracts.
SSO: Google SSO on every plan including free; SAML 2.0 and SCIM directory sync on Enterprise.
Security notes: Tenant isolation is a product feature rather than an afterthought, environments separate production from test, custom roles and permissions are available on Enterprise, and a 99.99% uptime commitment backs production use. Log streaming to Datadog and warehouse analytics integration are Enterprise capabilities.

Support & resources

Channels: Email supportIn-app supportDedicated Slack channel on EnterpriseEnterprise SLAs
Documentation: Thorough documentation at docs.knock.app covering workflows, channels, preferences, tenants, the CLI, every SDK, and the MCP server, with quickstarts per language.
Community: Active developer community and public changelog; the company publishes a fair amount of technical writing on notification system design.

Company

Founded: 2021
Headquarters: New York, New York, United States
Ownership: Venture-backed
Founders: Sam Seely, Chris Bell
Employees: Not disclosed; small team
Funding: $18M raised in total, including a $12M Series A led by Craft Ventures in February 2024.

Funding history

Round	Amount	Year	Notes
Seed	$6M	2022	Backed by Afore Capital, Preface Capital, and angels including Guillermo Rauch of Vercel.
Series A	$12M	2024	Led by Craft Ventures with Afore Capital and Preface Capital participating; David Sacks joined the board.

Timeline

2021Founded by Sam Seely and Chris Bell, who had run into the notification infrastructure problem as product and engineering leaders at Frame.io.
2022Raises a $6M seed round from Afore Capital, Preface Capital, and angels including Vercel's Guillermo Rauch.
2024Announces a $12M Series A led by Craft Ventures, bringing total funding to $18M, with David Sacks joining the board. More than 200 companies including Webflow, Vercel, Vidyard, and Amplitude are cited as customers.
2025Ships Guides for in-product paywalls, dialogs, and nudges rendered with the customer's own front-end components.
2026Repositions around AI-native authoring, with an agent toolkit and MCP server that let workflows be built and edited from Cursor or Claude Code, plus AI email template generation.

Integrations

SendGrid, Postmark, Resend, and other email providers
Twilio and other SMS providers
Apple Push Notification service and Firebase Cloud Messaging
Slack
Microsoft Teams
Snowflake, BigQuery, and other data warehouses
Segment and other CDPs
Hightouch, Census, and other reverse ETL tools
Datadog (Enterprise observability)
Cursor, Claude Code, and other MCP clients

Frequently asked questions

10 questions

What is Knock?

Knock is notification infrastructure. It sits between your application and your delivery providers and owns the logic that most teams end up building badly themselves: workflow orchestration, batching and digests, delays, cross-channel routing, user preference centers, and per-tenant configuration. You trigger a workflow with one API call and Knock decides what gets sent, where, and whether the user wanted it.

Is Knock event-driven or list-driven?

Entirely event-driven. There is no contact list you upload and no campaign you schedule against a static audience. Workflows fire when your product calls the API or when a user enters a segment built from ingested data. That is why a company without engineering resource cannot use Knock, and why a company with engineers gets something a list tool can never do.

How much does Knock cost?

The Developer plan is free forever and includes 10,000 messages a month, 500 Guide active users, unlimited workflows, unlimited channels, unlimited team members, batching, delays, and multi-tenancy. Starter is $250 a month for 50,000 prepaid messages, then $0.005 per message. Enterprise is a quoted annual contract. There is no plan between free and $250, which is the structure's weakest point.

Do I need my own email or SMS provider?

Yes. Knock does not send anything itself. You configure your own SendGrid, Postmark, Twilio, APNs, Firebase, or Slack credentials and Knock orchestrates across them. You keep your sending reputation and your negotiated provider rates, and you pay those providers separately, so the Knock line item is never your whole notification cost.

Who owns deliverability with Knock?

You do, entirely. Domain authentication, SPF and DKIM records, list hygiene, bounce handling, and reputation all sit with you and your email provider. Knock's responsibility ends at handing a correctly composed message to your provider. This is a real difference from Customer.io, Ortto, or Drip, where the vendor runs the sending infrastructure and shares the deliverability problem with you.

Can a product manager operate Knock after the engineering work is done?

Yes, and that is the main argument for buying it. Once triggers are wired, templates, timing, batching windows, branching conditions, and Guide copy are all editable in the dashboard, with environment promotion and one-click rollback. Engineers own the trigger and the payload; product owns everything downstream.

What are Guides and why are they billed separately?

Guides are in-product messages: paywalls, dialogs, and nudges rendered with your own front-end components, with copy and targeting editable in Knock. They are metered on Guide active users (500 included free, 2,500 on Starter, then $0.05 per user) because the cost driver is how many people see a guide rather than how many messages you send. Budget it as a second line item.

How does Knock compare to building notifications in-house?

That is the real comparison. Batching, preference centers, in-app feeds, Slack OAuth flows, per-tenant configuration, and delivery observability are each a few weeks of engineering, and once built they need an owner forever. At $250 a month, Starter is cheaper than the maintenance, let alone the build. The free tier covers a surprising amount of production usage before that decision is even due.

Does Knock support self-hosting?

No. Knock is a hosted service only. Teams whose requirement is self-hosting or data residency control should look at Novu, which is open source and self-hostable, or at Dittofeed for the marketing automation equivalent. Knock's answer to data control is Enterprise contracts with regional arrangements, HIPAA with a BAA, and warehouse analytics integration.

Who founded Knock and how is it funded?

Knock was founded in 2021 by Sam Seely and Chris Bell, who hit the problem as product and engineering leaders at Frame.io. It is headquartered in New York and has raised $18M in total, including a $12M Series A led by Craft Ventures in February 2024, with David Sacks joining the board. Customers cited include Webflow, Vercel, Vidyard, and Amplitude.

Editorial verdict

Knock is the right purchase when your notification problem is a product problem rather than a marketing problem. If people are complaining about email volume, if a preference center keeps slipping down the roadmap, if enterprise customers want Slack delivery, or if an engineer already owns a homegrown notification service they resent, this is the layer to buy and the free Developer tier is generous enough to prove it in a weekend. The reasons to walk away are equally clear: there is no marketing surface, nothing works without engineering, you still pay your own providers, and the leap from $0 to $250 a month with nothing in between is genuinely painful for a small team. For a five-person startup, Knock is the first thing to reach for only if you are shipping a product with an in-app notification feed. If your immediate need is onboarding emails and lifecycle campaigns, start with Customer.io, Bento, or Dittofeed and add Knock later when the product notifications become their own problem.

Written by the SaaSTracker editorial team. Awards, when shown, are judged against the published criteria in our methodology.