Before this release, reusable requests provided a template, but teams still needed to know which variable names were expected and which fields were required. With input schemas, teams that add a reusable step to a workflow can see the required payload and map the right workflow data into it.

Define reusable request inputs

For example, a reusable request like "Get latest articles" may need data like this:

{
  "number_of_articles": 3,
  "category": "product updates",
  "user_id": "user_123"
}

With input schemas, engineering teams can define that required structure once:

{
  "properties": {
    "number_of_articles": { "type": "number" },
    "category": { "type": "string" },
    "user_id": { "type": "string" }
  }
}

When someone adds that reusable request into a workflow, Knock shows them exactly what data to pass through.

This makes reusable steps more flexible and helps teams standardize workflow logic without rebuilding the same request again and again.

Map workflow data with less guesswork

To start using input schemas, open a reusable request and define the inputs it should expect. Add each field, choose its type, and mark any required fields so other teams know what data the request needs before they use it in a workflow.

<ImageModal src="/assets/changelog/reusable-request-input-schemas/fetch-inputs-1.png" alt="Defining inputs for a reusable request"

Those mapped inputs are available as parameters in the reusable request template. Reference them in the request URL, headers, or body to keep the request configuration reusable while each workflow passes in its own values.

<ImageModal src="/assets/changelog/reusable-request-input-schemas/fetch-inputs-4.webp" alt="Using values in the request template"

Once the schema is defined, add the reusable request to a workflow. Knock shows the required inputs in the fetch step, so the person building the workflow can see what data they need to provide.

<ImageModal src="/assets/changelog/reusable-request-input-schemas/fetch-inputs-2.webp" alt="Add reusable request to a workflow fetch step"

Get started

Input schemas for reusable requests are available today for all Knock customers. Learn more in our documentation.

For the past few months, we've seen beta customers build dynamic audiences and use them to trigger workflows, target broadcasts and guides, and create exclusion lists, all without needing to wrangle data themselves.

While dynamic audiences are a familiar concept across customer engagement solutions, we built Knock's version to go further than most. Here's how.

Create real-time user segments

Dynamic audiences allow you to query user properties to create segments of users that update in real time.

Reference properties like plan_tier to build a list of paying users, signup_date to check the number of signups over the last 90 days, or last_active_timestamp to build a target audience for a re-engagement campaign.

<ImageModal src="/assets/changelog/introducing-dynamic-audiences/free-plan-audience-details.png" alt="Using audience membership to trigger guides, broadcasts, and workflows"

As your data changes, users will enter or exit dynamic audiences based on their eligibility. Each entrance or exit is recorded as a membership event, which you can use to trigger workflows. No cron job, webhook, or hand-rolled event handler required.

You can use membership status to trigger guides, target broadcasts, or as part of true-false conditions.

<ImageModal src="/assets/blog/introducing-data-functions/audience-membership-guide-trigger.png" alt="Using audience membership to trigger guides, broadcasts, and workflows"

Audiences with version control

Most customer engagement platforms have some version of dynamic audiences, but they don't have a way to verify or preview audience changes before you make updates.

When you have a highly-automated messaging system, this can cause large-scale mistakes that are hard to fix retroactively.

With Knock dynamic audiences, we planned for this.

Dynamic audiences are versioned and promoted between environments, the same way you'd promote any other Knock resource. You draft a change in development, preview it against live user data, and promote it to production only when you're sure it does what you think it does. Membership is evaluated in real time once changes are promoted, not before.

<ImageModal src="/assets/changelog/introducing-dynamic-audiences/commit-audience-changes.png" alt="Building a dynamic audience with a live member preview"

This matters because small changes to an audience that triggers actual workflows can have real consequences. Editing a simple condition (i.e. flipping an operator or adjusting a threshold) can mistakenly push thousands of users into a sequence you didn't mean to run.

Versioning makes it easy to test changes and reduce mistakes. No more audience targeting held together with tape and glue.

Build audiences with AI

Instead of building lists manually, you can now describe the audience you want and let AI generate the conditions for you.

From the dashboard. While building a dynamic audience, use the "Generate" button turn a natural-language prompt into audience filters. This is useful for when you know the audience you want but don't want to search for and build each condition from scratch.

With Knock agent. Use the Knock agent in the dashboard to create or refine an audience with a prompt. Turn an idea like "active free users who signed up this quarter" into a reviewable dynamic audience using the data available in Knock.

From your AI editor. Point your favorite coding agent at the Knock MCP server to create, edit, and update audiences from your IDE, then use the Knock CLI to pull, review, and promote those changes across environments. Good for bulk edits, refactors, and the kind of tedious segmentation work you'd otherwise put off.

<ImageModal src="/assets/changelog/introducing-dynamic-audiences/dynamic-audiences-code-editor.png" alt="Promoting an audience version from development to production"

All three approaches produce the same versioned resource. Start with a prompt, review the generated audience, and promote it when you're sure it targets the right users.

Get started

Dynamic audiences officially bring user segmentation to Knock. Everything works the way you'd expect, with real-time evaluation, membership events, environment promotion, full API coverage, and first-class integration with workflows.

Dynamic audiences is available for all customers today. Open Audiences in the Knock dashboard and click "Create audience" to try it out. Learn more in our documentation.

If you're a lifecycle marketer drafting emails, you probably run through the same checklist every time: proofread the copy, verify links aren't broken, and confirm you're following deliverability best practices like alt text on images. Skills let you wrap that checklist into a command like /review-email and run it on demand.

How skills work

A skill is a named set of instructions you define once and reuse across your team. When you invoke a skill in the Knock agent, it runs through the steps you defined, asks for input when it needs something from you, and applies changes in place.

Skills can be used for things like:

• Reviewing copy for typos and style guide compliance.
• Checking that links in your emails resolve and aren't broken.
• Auditing emails for deliverability best practices, like alt text on images.
• Any other repeatable workflow you run across your messaging.

<ImageModal src="/assets/changelog/agent-skills/create-skill.png" alt="Creating a new skill in the Knock agent"

Running a skill

Once you've created a skill, you can run it by typing / in the Knock agent and selecting it from the menu. The agent takes it from there, working through each task in your skill and pausing to ask for your input when it needs a decision, like how to fix a broken link.

When the agent finishes, you get a summary of what changed and what still needs your attention.

Get started

Skills are available today for all Knock customers. Head to the Knock agent in your dashboard to create your first skill, or read more in our documentation.

Improved layout management

Layout management now has a consistent, three-pane experience, making layouts, workflows, and templates feel like one cohesive system.

Each layout page now has a "Used in" tab to see which workflows and broadcasts are using it. This makes it much easier to understand the impact of a change before you make it, which is especially useful for layouts used across many templates.

<ImageModal src="/assets/blog/layouts-2-0/layouts-used-in-closeup.png" alt="Close-up of the 'Used in' data on the layouts page"

More layout controls while editing

When editing emails, we've made the layout selector more prominent, so assigning or swapping a layout no longer requires digging through settings.

<ImageModal src="/assets/blog/layouts-2-0/layouts-editor-closeup.png" alt="Close-up of the layout selector in the email template editor"

Additionally, you can now apply branding overrides at the layout level, giving teams that manage multiple brands or tenants more flexibility, without duplicating templates.

Dark mode support

Knock's email layouts now support dark mode out of the box. You can now upload dark mode assets and set dark mode branding variables that we'll automatically be rendered for users that use dark mode in their email client.

<ImageModal src="/assets/blog/layouts-2-0/layouts-dark-mode.png" alt="Editing a layout's dark mode assets"

Get started

The new layouts experience is available for all customers today. Learn more in our documentation.

What it solves

Building in-app messages shouldn't require guessing why they do or don't appear for a given user.

The toolbar closes the gap between configuring an in-app message and confirming it works. Whether you're launching a new onboarding tour, a feature announcement, or a contextual nudge, you can validate the full experience before it reaches a single end user.

How it works

The guides toolbar allows you to:

• See what your users see. Toggle between all guides, active guides, and eligible guides to understand how your targeting rules play out in context. No more guessing whether a guide fired or why it didn't.
• Test in your real product environment. Force any guide to display on the current page so you can preview it exactly as your users will experience it within your actual UI, not a simulation.
• Inspect targeting in real time. View the parameters being evaluated for the current user and page so you can diagnose issues and fine-tune your audience rules with confidence.

Testing best practices

Before launching your guides to users, always test them thoroughly to ensure they work as expected. Focus on these key areas:

• Page targeting. Verify your guides appear on the correct pages by testing different URLs and path patterns in your activation rules.
• User targeting. Confirm your targeting conditions work correctly by testing with users who should and shouldn't see the guide based on your eligibility criteria.
• Engagement tracking events. Interact with your guides and verify that engagement status updates appear as expected in the dashboard (seen, interacted, archived).
• User interactions. Click all links, buttons, and interactive elements to ensure they work as expected and navigate to the correct destinations.

Getting started

The guides toolbar is available today for all Knock customers. For more information, read the documentation.

When events occur in your other services—like a new user in Clerk, a payment in Stripe, or a directory sync event in WorkOS—you can send that event data to Knock to create users, trigger workflows, and update audiences. Knock ingests, verifies, and transforms the event data for you to take action on.

Pre-built sources

We're shipping five pre-configured data sources: Stripe, Supabase, PostHog, Clerk, and WorkOS. For each, we've handled verification schemes and created pre-configured action mappings so you can get set up with a few clicks.

<ImageModal src="/assets/blog/introducing-data-sources/pre-built-integrations.png" alt="Pre-built data source integrations"

Build your own source

For any other providers, use our custom data source to map any event to an action in Knock. Custom sources include a flexible JavaScript scripting framework to process, validate, and transform incoming requests.

<ImageModal src="/assets/blog/introducing-data-sources/adding-custom-source.png" alt="Configuring a custom data source in Knock"

This function runs whenever an event is received and before any actions are processed, enabling you to write your own logic to verify a payload and transform properties to better match how they're used in Knock messaging.

async function main(ctx) {
  const { headers, rawBody, body, vars } = ctx;
  const verified = await verifyHmacSha256({
    secret: vars["SERVICE_SIGNING_SECRET"],
    signature: headers["x-webhook-signature"],
    payload: body,
  });
  const full_name = `${body.first_name} ${body.last_name}`;
  return {
    verified,
    full_name,
  };
}

Get started

Data sources are available today for all Knock customers. Head to "Settings > Sources" in the dashboard, or read more in our documentation.

This function gives teams a way to build modular customer journeys and launch more sophisticated messaging campaigns. Instead of rebuilding the same logic in multiple places, you can create reusable workflow building blocks and trigger them whenever they are needed.

That means faster experimentation, easier maintenance, and more consistent customer experiences as your messaging strategy grows.

The trigger workflow step functions similarly to a standard workflow trigger, executing a specified workflow with a specified payload. The payload is constructed based on the configuration settings defined in the step.

The trigger workflow function is available today for all Knock customers. Learn more about it in our documentation.

Built directly into the dashboard, the Knock agent has full context of your Knock account and assists with everything from answering questions to executing day-to-day tasks.

How it works

The agent is designed to work how you work. With every prompt, it references your existing setup to ensure outputs match your branding and writing style, make sense in the context of messaging, and leverage existing templates and components.

Create and manage resources

The Knock agent can be started from anywhere in the dashboard to create and manage any Knock resources, such as workflows, broadcasts, guides, and more.

Generate beautiful emails

Gone are the days of building emails from scratch. Just describe what you want, upload a screenshot of an email you like, or send it a URL to pull content from. The agent builds a client-safe email using your layout and branding.

Build audience segments

You can also build user segments from scratch using the Knock agent. Describe the users you want to target, and the agent will pull together the right filters to create a dynamic audience, ready to use.

Get started

The Knock agent is now available in public beta for all teams. Agent use is included on all Knock plans at no additional cost during the beta period as we refine the experience and expand capabilities.

Log in or sign up for Knock to give it a try. You can learn more in our documentation.

You can use MJML for both email layouts and email templates:

• Layouts work much like HTML layouts: they must include a root tag, {{ content }} inserts the template body, and {{ footer_links }} inserts footer links when configured.
• Templates can be written fully in MJML or built in the visual editor, where blocks render as MJML components when the template or layout uses MJML. When using a layout, both the layout and template must be MJML.

Knock also supports mixing in plain HTML by wrapping it in automatically, so existing HTML snippets can still render correctly within MJML.

Learn more about MJML support in our documentation.

The new data functions available include:

• Update audience. Add or remove a user to or from a static audience. For example, when users hit a usage milestone, you can add them to a "Power users" audience, or remove them if they churn.
• Update user. Modify the recipient's properties or preferences. For example, you can mark the completed_onboarding user property as "true" when a user finishes the onboarding workflow.
• Update tenant. Modify a company's properties. For example, when a workspace upgrades their plan, you can update the tenant's plan_tier property to "Pro."
• Update object. Modify properties on any object in your environment (e.g. projects, orders, or tasks). For example, when a task is completed, you can update the project's completed_tasks_count so a summary notification shows the right total.
• Modify workflow. Add or update a property in your workflow's data scope. This allows you to compute a value in an early step (e.g. a personalized recommendation) and use it in later branch or message steps.

Data functions help you turn real-time behavior into structured, reliable data from within a workflow. This ensures records stay enriched and up to date, powers better segmentation and personalization, and enables you to make users eligible to receive other messaging, including guides, broadcasts, or other workflows.

Data functions are available today for all Knock customers. Read more about designing workflows.

How it works

The AI agent function sends a prompt to an AI model of your choice and makes the response available in your workflow state. You can use it to enrich data, personalize messaging, and bring context into your messaging flows.

Common use cases include:

• Running research to enrich and store user and company data.
• Personalizing messaging to drive higher conversion rates.
• Summarizing batch content into concise digests.

AI can help you generate a comprehensive prompt from scratch, or you can choose from one our prompt templates. You can structure your response format using a JSON schema, so your response comes back clean, typed, and ready to use downstream.

When the agent returns a response, it becomes available in workflow run data and can be referenced in subsequent steps and templates. This allows you to store data in Knock or use it to personalize your messaging.

Agent pricing

The AI agent function uses a credit model. Agent usage consumes credits according to your selected model and the number of tokens consumed by your agent.

All Knock plans come with an included amount of credits, after which you can pre-purchase top ups, configure auto-replenishment rules, and set max spend limits for your account.

Get started

The AI agent function is now available for all non-enterprise customers. Developer plans include 500 free credits per month and starter plans include 2,000.

If you are an enterprise customer and want access, please get in touch.

You can learn more in our agent function docs.

To get started, add the server to your MCP client configuration:

{
  "mcpServers": {
    "knock": {
      "url": "https://mcp.knock.app/mcp"
    }
  }
}

When you first use a Knock tool, you'll be prompted to sign in with your Knock account. Full setup instructions are available for Cursor, Claude Desktop, and Claude Code.

OAuth authentication

Previously, connecting to the Knock MCP server required a service token. Service tokens grant broad access to your Knock account and don't distinguish between individual users, which makes it difficult to audit who made changes and to enforce the principle of least privilege.

The MCP server now authenticates through your Knock account via OAuth. Your credentials are managed through the standard sign-in flow, and role-based permissions are automatically applied based on your user profile. This means each team member operates with the appropriate level of access without needing to share or rotate service tokens.

New and updated tools

We've also shipped a set of improvements to the tools available through the MCP server:

• More granular workflow step tools. All workflow tools now accept environment and channel_key parameters, giving you explicit control over which environment and channel a step targets when creating or updating workflows.
• Message debugging. Added get_message_delivery_logs and get_message_events tools so you can inspect delivery attempts and the full event timeline for any message. We also fixed an issue with get_user_messages.
• Email layout tools. Added list_email_layouts and get_email_layout to enable you to discover and inspect email layouts when building email steps.

See the full tools reference for a complete list of available tools.

The experiment function enables you to split recipients into randomized cohorts within your workflows or broadcasts, routing each recipient down a specific branch based on a percentage-based distribution.

This is useful for:

• A/B testing. Split recipients into two or more cohorts and compare the results of each. You can test different message formatting, copy, images, and more to measure what performs better.
• Gradual rollouts. Roll out a new notification strategy to a small percentage of recipients before expanding to all users.
• Channel experimentation. Test messaging through different channels in parallel to see which drive more engagement from your audience.

How it works

When a workflow executes an experiment function, Knock randomly assigns the recipient to a cohort using the following process:

• Configuring cohorts. Each experiment starts with two cohorts by default, split 50/50. You can adjust the percentage distribution to control the distribution of recipients or add additional cohorts. The total across all cohorts must equal 100%.
• Branch execution. Once assigned, the recipient proceeds through the steps defined in their cohort's branch.
• Observability. Like all Knock workflow functions, you get full visibility into execution through our debugging tools. You'll be able to see exactly which experiment cohort was chosen for each recipient.

The experiment function also supports custom cohort keys. You can assign a cohort key to produce a deterministic assignment, such as ensuring all users within the same tenant follow the same branch. The cohort key defaults to the recipient ID.

Note: Dedicated experiment analytics are coming soon.

The experiment function is available now for all customers. Read more in the documentation.

Available skills

The package ships with two skills today:

• knock-cli. Enables your agent to work with the Knock CLI to pull, push, and validate workflows, email layouts, guides, and partials. It covers CLI installation and authentication, the Knock directory structure, workflow templates (visual blocks and HTML mode), and building reusable email components with partials.
• notification-best-practices. Comprehensive guidelines for designing and writing effective notifications across all channels, including email, push, SMS, in-app, and chat. It covers channel-specific formatting, copy best practices, system implementation patterns, and template examples for common use cases like signups, payments, collaboration, and alerts.

Installation

You can install the entire skills package with a single command:

npx skills add knocklabs/skills

Or you can can install specific skills by passing a flag:

npx skills add knocklabs/skills --skill knock-cli
npx skills add knocklabs/skills --skill notification-best-practices

Once installed, skills are automatically available to your agent and activated when relevant tasks are detected.

The skills package is open source and available on GitHub.

Knock sources enable you to integrate platforms like Segment, RudderStack, Hightouch, and Census to trigger workflows, identify users, and automate actions.

The new design is available today on the Sources page in the main dashboard sidebar. Here's what's new:

New source setup experience

Connecting a source to Knock is now only two steps.

Improved field mapping experience

A new interface makes it easy to map incoming event data to actions in Knock. You can now view the past events for an event type and connect the action fields directly.

Improved event observability

An improved logs page makes it easy to see events streaming in, how Knock handles them, and the actions taken as a result.

Workflow mapping improvements

We also upgraded source event trigger steps: view past event shapes, validate mappings inline, and send test events to preview how workflows will run.

These changes are available today for all Knock customers.

Read more about Knock event ingestion through integration sources in our docs.

The timestamp operators ("is a timestamp before," "is a timestamp on or after," and "is a timestamp between") accept timestamp arguments in three formats:

• Relative. A time relative to when the condition is evaluated. Relative timestamps include a value, a unit (minutes, hours, days, or weeks), and a modifier ("from now" or "ago"). For example, "7 days ago" or "3 days from now".
• Absolute. A fixed date and time. In JSON, this is represented in ISO 8601 format (e.g., "2025-06-15T14:30:00Z").
• Dynamic. A Liquid template variable that resolves to a timestamp at runtime (e.g., {{ recipient.subscription_ends_at }}). Dynamic timestamp arguments are available in workflows, broadcasts, and guides.

With these datetime conditions, you can now:

• Trigger a reminder workflow when {{ recipient.appointment_date }} is a timestamp on or after 24 hours from now, so users get a reminder email one day before their appointment.
• Send a CVE alert only when {{ tenant.created_at }} is a timestamp between 2026-01-01T09:00:00Z and 2026-01-15T09:00:00Z, so only tenants onboarded during the affected window receive a sensitive notice.
• Trigger a trial survey when {{ recipient.trial_ends_at }} is a timestamp on or after 14 days ago, so you only reach out at the right moment.

These operators are available today for all Knock customers. Read more about datetime conditions in the docs.

Here's what’s new:

• Custom brand attributes. Define brand colors and attributes using vars.branding.* variables. Update your design system in one place and have changes propagate across all templates.
• Schemas for partial inputs. Partials now support optional input schemas for field types, labels, descriptions, and required flags, so editors can move faster without breaking brand or content guidelines. Schemas are versioned with the partial, making it easy to manage changes over time.
• JSON object support for partial inputs. Partials now accept JSON objects through markdown inputs. This enables passing complex data like objects and lists instead of only strings.
• Isolated CSS styles. HTML partials now support isolated <style> tags that inject into the email <head> only when the partial is used. Styles are deduplicated and pollute your root stylesheet.
• Improved discoverability in the visual editor. All partials are now visible directly in the block editor, with search support to quickly find components.
• Configurable editor experience. Default blocks (buttons, text, images, etc.) can now be disabled at the account level, limiting editors to use partials to enforce brand consistency.

These improvements are available today for all Knock customers. Read the documentation to learn more about building reusable email components with partials.

Previously, delivery status checks in Knock were only possible via a sophisticated polling mechanism. At high message volumes, this polling had the potential to run into API rate limits imposed by messaging providers. Now, with delivery status webhooks, providers push delivery status changes back to Knock via webhooks. This makes the system more reliable as a whole and not susceptible to rate limits.

With delivery status webhooks enabled for your channels, you can:

• Track successful deliveries. See when messages are delivered to the recipient's mail server or carrier.
• Monitor bounces. Get notified when emails bounce due to invalid recipients or domains.
• Better debugging. Understand delivery issues in real-time to troubleshoot notification problems.

We currently support delivery status webhooks for the following providers:

• Email. AWS SES, Resend, Postmark, SendGrid, and Mailgun
• SMS. Twilio

To get started, configure the webhook endpoint in your provider's dashboard to point to Knock. Each provider has specific setup instructions in our documentation.

Delivery status webhooks are available today for all Knock customers. Read the documentation to learn more about setting up delivery status webhooks for your channels.

This feature is enabled by default for all new customers. If you're an existing customer, production write access is an opt-in setting. To enable production write access, navigate to the Permissions page under the Admin section of your account settings.

When you enable production write access in your account:

1. All roles with edit permissions can edit resources in any environment. Owner, admin, and member roles can create and edit content resources (like workflows and guides) directly in production.

2. The Production-only Member role becomes available. This role gives a user access to the production environment, and no others. It enables non-technical team members to work in production without touching any resources that are managed in development. Learn more about the Production-only Member role.

3. Content resources can only be edited in the environment in which they were created. This means that any content resources you want to follow your environment lifecycle (create in development, promote to production) are only editable in development. For use cases that don't need the governance of environment promotion, you can create directly in production.

Production write access keeps production-critical resources (like high-volume transactional workflows) version controlled by the development environment, while enabling marketing and product teams to work in a simpler, production-only way for lifecycle journeys and product announcements.

With asset management, you can now:

• Store assets directly in Knock. Upload and store images like logos, icons, and graphics in your Knock account without needing external hosting.
• Reuse assets across templates. Browse and insert uploaded assets into any message template with a single click. No more copying and pasting URLs.
• Centralized control. Assets live in one place and are referenced everywhere, so you can update visuals across messages without touching templates, making it easier to keep your brand assets consistent.

Currently, only image files are supported, including PNG, JPEG, GIF, and SVG. In the future, we may support additional asset types.

Asset management is available today for all Knock customers. Navigate to Content > Assets to upload and manage your assets, or read the documentation to learn more.

Previously, each environment in Knock had a single public and secret API key pair. This meant all of your integrations shared the same credentials, which made it difficult to rotate keys or limit access for specific use cases.

With API key management, you can now:

• Create multiple API keys. Generate as many public and secret key pairs as you need per environment, enabling you to use dedicated keys for different services, integrations, or team members.
• Revoke keys instantly. If a key is compromised or no longer needed, you can revoke it directly from the dashboard without affecting your other integrations.
• Better security practices. Rotate keys on your own schedule and scope credentials to specific parts of your infrastructure.

API key management is available today for all Knock customers. You can manage your API keys from the Settings > API keys page in the dashboard, or read the documentation to learn more.

Today, we're thrilled to launch the 1.0 release of the CLI, with a whole host of new features and improvements to make working with Knock locally and in your CI/CD pipeline even easier.

With the 1.0 release of the CLI you can now:

• Login to the CLI using your Knock account, without needing a service token via knock login
• Initialize a central knock.json file for your project, and use that for all pull and push commands without specifying where your Knock directory is located
• Work with all versioned resources in Knock (workflows, templates, guides, layouts, translations), commit and promote changes, list environments and channels, and much more
• Create new resources directly without going to the Knock dashboard, or from our new template repository via knock workflow new

We've also included JSON schemas for all of your resource definitions, providing an editing assist and type hints in your IDE for you and your favorite coding agent like Cursor, Copilot, or Claude Code.

CLI 1.0 is also fully compatible with our new branching beta. Using the CLI you can create branches, push and pull changes on those branches, and merge changes from your branch back into main when complete.

If you're interested in trying out the 1.0 release of the CLI, you can get started by running npm install -g @knocklabs/cli or brew install knocklabs/tap/knock. You can also read the documentation to get started.

Previously, all changes to versioned content in Knock had to be made in your development environment. That meant if you had multiple developers using Knock, changes needed to be carefully coordinated.

With branching, each developer can make changes in an isolated branch. Once changes are complete, the branch can be safely merged back into the development environment.

Branch management is deeply integrated into our management API and CLI, allowing you to use branching as a part of your everyday developer workflow or automate branches with your CI/CD pipeline. In addition, branching makes it possible to use Knock in preview environments, like those used by Vercel or Netlify. That means your team can test notification workflows end to end alongside other feature changes.

Branching unlocks an even better developer workflow within Knock, and we're excited to make it available today to all customers. If you're interested in trying out branching, you can request access from the dashboard on the Settings > Branches page. You can learn more in our documentation.

Dynamic audiences are segments of users you can use to trigger workflows, target guides, or build broadcast lists. You can also use dynamic audiences in your workflow conditions and branches to check if a user is in an audience and route them accordingly.

Here are a few use cases you can power with dynamic audiences:

• Target a guide announcing an enterprise plan feature to your enterprise admin audience
• Trigger your new user onboarding workflow when a user enters your new signups audience
• Send a re-engagement broadcast to your "has not logged in for 30 days" broadcast

Dynamic audiences run on the user data you already manage in Knock and are updated in real-time. We built dynamic audiences to be fast and ready to work at the scale of our largest customers.

As of today's release, our segmentation engine works with users and user properties. We'll be adding support for source events and object/tenant data next.

If you're interested in trying out dynamic audiences, let us know and we'll get you set up. You can learn more about dynamic audiences in our documentation.

This allow you to use domains you own—rather than an auto-generated URL like e1.knock.app—for all tracked links in your messages. Aligning your tracking domains with your sending domain reduces the likelihood of spam filters flagging your messages and increases trust from users who expect links to come from you, not a third party.

Custom domains support granular configuration per message type and per environment. That means you can set up specific domains for specific purposes, such as one domain for short SMS links and another for long-form email URLs.

Custom domains are available today for all Knock customers. You can find out more in our documentation.

1. Recipient always selected. When you open a workflow or broadcast, a recipient is now automatically selected so you can preview recipient data in your workflow.
2. Object recipients. You can now toggle the recipient or actor field to “object” and select the object you want to use while building and previewing your workflow.
3. Inline-identify from the recipient selector. You can now add a new user or object directly from the recipient selector, without needing to navigate away.
4. Edit users and objects. A new “Edit” button lets you make changes to user or object properties without leaving the workflow builder.

These improvements also extend to the test runner, where you're now able to inline-identify and edit user data.

Fixes and improvements

• 👀 [Dashboard] You can now view a diff of uncommitted changes that have been made to versioned resources in the "Changes" tab.
• 🐛 [Dashboard] We fixed an issue where writing liquid within a JSON template would fail validation.
• 🐛 [Notification engine] We now validate all chat channel data before processing a chat channel step. Missing data will now show an error.
• 👀 [Notification engine] We now send a Knock specific User-Agent header for all webhook channel and outbound webhook requests.
• 🐛 [Dashboard] We fixed an issue where request signing could not be set on reusable requests.
• 🐛 [Dashboard] We fixed an issue where toggling preferences with conditions would fail via the dashboard.
• 👀 [API] We now pass through the Slack retry-after ratelimit headers with all Slack requests.

Here's how it works:

• Using the per-device locale you can localize push notification content to what your user's device has configured, taking precedence from the locale stored on the user. That means if your device is set to en-GB but your user has en-US on their user properties, any push notifications sent to the device will be generated in British english.
• Similarly, using the per-device timezone you can control the precise send windows for when a particular device for a user should receive a push notification. This per-device value takes precedence over the user property.

Our client-side mobile SDKs have been updated with the ability automatically set this data for each device, or if you're using our API directly, you can replace the call to set tokens with a list of devices.

{
  "devices": [
    {
      "token": "user_device_token_1",
      "locale": "en-US",
      "timezone": "America/New_York"
    }
  ]
}

Push device metadata is available today for all customers. You can read more in our documentation.

Fixes and improvements

• 👀 [Dashboard/mAPI/CLI] You can now opt into a private beta of branching. Head to your "Settings > Branches" page to request access.
• 👀 [Dashboard] We added the ability to see all subscriptions that a user has from the users detail page.
• 🐛 [Notification engine] We fixed an issue with our workflow trigger function where some child workflows were not running.
• 👀 [API] We now expose a channel attached to each message produced from the API and sent via webhooks.
• 👀 [mAPI] You can now filter commits by one or more resource_type (like workflow) to show all commits associated to that type of resource.
• 👀 [Notification engine] We added a new compare_versions liquid filter.
• 👀 [Notification engine] We now send workflow_category as a tag to Datadog and NewRelic when reporting metrics.
• 👀 [Dashboard] You can now see the "Last login at" for the members of your account.

While we've always had channel type preferences that let you control preferences for all messages sent for that channel type (like email), there were situations where you might have needed to be more granular with exactly what a user is opting out of.

As an example, if you're using our webhook channel to send messages in your workflow to both "PagerDuty" and "Incident.io", you would have no way in our existing preference model to set a preference for each of these channels, as both would be represented under the http channel type.

Now, using per-channel preferences, you can control exactly which channel a user should or should not receive messages from.

{
  "channels": {
    // The PagerDuty channel
    "145a7412-2e9a-4ae4-ae2d-cbca4f5308fe": true,
    // The Incident.io channel
    "8b3c9f21-7d4a-4e1b-9c8e-f2a1b5d6c3e9": false
  }
}

Channel-level preferences work just like channel type preferences in that you can nest them under workflows or categories. They can even be mixed with channel_types.

{
  "workflows": {
    "new-incident": {
      "channels": {
        // PagerDuty channel is OFF
        "145a7412-2e9a-4ae4-ae2d-cbca4f5308fe": false
      },
      "channel_types": {
        // All emails
        "email": true
      }
    }
  }
}

Channel-level preferences are available today for all customers. You can read more in our documentation.

Fixes and improvements

• 👀 [CLI] All resources pulled by the CLI now have $schema fields attached, making it possible to get an editing assist when working with your schemas locally.
• 👀 [mAPI] We've introduced new per-channel step level schemas in our OpenAPI spec to aid with editing. Instead of WorkflowChannelStep there's now WorkflowEmailStep, WorkflowInAppFeedStep etc.
• 👀 [Dashboard] We've made some large performance improvements to the template editor within the dashboard. Previously, large documents with frequent saves were causing the performance of the editor to regress. Now things should be silky smooth!
• 🐛 [Dashboard] We fixed an issue with the toolbar commands in our template editor.
• 🐛 [Dashboard] We fixed an issue where autocompleting objects in liquid would show an empty value.
• 🐛 [Notification engine] We fixed an issue where using a null actor on the workflow trigger step could cause it to fail.

With Guides, you use your own components to power in-app messages that drive activation and upsells. Legacy in-app messaging vendors use external JavaScript libraries that bloat performance and degrade your design. Our component-first infrastructure keeps your app fast and your messaging on-brand.

Component-first in-app messaging

Guides are managed from the Knock dashboard. Once you hook a component into Knock, it's available for product managers and marketers to draft and preview content for that component, as well as target the audience for the guide and where it should render in your application.

Guide prioritization and throttling

You can manage guide prioritization and throttling to ensure users see the highest priority guides first and aren't flooded with messages when they log in to your product.

Observability and analytics

Knock Guides use the same powerful observability and analytics engine as the rest of Knock. Every guide records per-user events so you understand when users see, interact with, and archive your guides.

All of that data is available for debugging and analysis within the Knock dashboard, and will automatically flow through any extensions you've set up with Knock, like our data warehouse syncs or message event webhooks.

Key benefits

• Composable primitives to build what you want. The guides toolkit provides React components, React hooks, lower-level JavaScript APIs, socket infrastructure so your engineers can build the in-product experience they want.
• No performance tax. No external scripts to load, no performance tax. Your in-app messaging code runs through the same build process as the rest of your app.
• Actual inline components. Complete control over your render lifecycle so you can ship truly embedded messaging without content layout shift, UI jank, or CSS conflicts.

Get started

Guides are available for all Knock customers starting today. You can get started by reading our documentation.

Save reusable requests

In the dashboard sidebar, you'll see a new "Reusable requests" section. Here you can create and manage your reusable requests that can be used in any fetch step across your workflows.

Once saved, these requests can then be applied to any workflow fetch step, making it easy to maintain consistent configurations across your messaging infrastructure.

Apply reusable requests to workflow fetch steps

Within a workflow fetch step, you'll see a new "Apply template" button. Here you can select a reusable fetch step to instantly inherit its properties. While linked, the fetch step will continue to inherit any changes made to the reusable request's configuration.

AI-generate reusable request configurations

We've also added the ability to generate reusable request configurations. This can be done by clicking the "Generate" button in the reusable request editor either during creation or when editing an existing request. This will use the prompt to auto-populate the request configuration.

More Information

To learn more about reusable requests, check out the documentation: Reusable fetch functions.

Fixes and improvements

• 👀 [Dashboard] Added realtime input validation in the content editor
• 👀 [Liquid] Added support for partial ISO dates across all of our date helpers
• 👀 [Dashboard] Added message previews to the Guide message log
• 👀 [Dashboard] Fixed performance issues in Guide content editor
• 👀 [SDKs] Added optimistic updates when archiving a message
• 🐛 [API] Fixed a bug with creating schedules with a null ending_at field
• 👀 [Dashboard] Added interacted metadata to the guide message log timeline
• 🐛 [Dashboard] Fixed the width of the HTTP channel button in the workflow step pane
• 🐛 [Dashboard] Fixed the callout UI within Deactivate workflow modal

Previously, in order to use the CLI, you would have to use a service token to authenticate. Service tokens are great for non-local, shared environments, like when using Knock inside your CICD pipeline. However, for engineers who want to work with their Knock resources locally, requiring them to create a service token was an unnecessary extra step.

Now, Knock users can simply knock login to gain access to the CLI and get started managing their Knock workflows, templates, and more in code. You'll be redirected from the CLI to your browser to authenticate and grant access to your Knock account. Users who have authenticated with the CLI will then be granted the same permissions they have in the dashboard.

We’re excited to make it even easier for you and the engineers in your organization to work with Knock locally via our CLI. You can read more and get started today via the docs.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue where resetting a variable could set the variable to an empty string, causing the default to not be applied.
• 🐛 [Dashboard] We fixed an issue with casing of custom fields during CSV upload mapping.
• 👀 [SDK] We've added the ability to opt out of inline-identify in the JS and React SDKs.

Now, with our support for Amazon SNS you can route push notifications from Knock through Amazon's SNS infrastructure. Our SNS integration even has support for automated deregistration should the user's device token no longer be valid.

You can read more in our integration documentation, or can get started today using Amazon SNS by creating and configuring it as a channel within your Knock account.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue where the "Request access" button for the APNS + FCM channel group was causing an error.
• 🐛 [Dashboard] We fixed an issue where accessing the conditions builder could cause the application to error in certain situations.
• 🐛 [Dashboard] We fixed an error where the template changes toast message would appear erroneously when expanding or collapsing variables in the state pane.

Using the new Knock-powered email channel, you'll be able to send up to 100 emails from your Knock account per-month for free, perfect for testing or for small side projects. The limit is per-account, so includes both your development and production environments. Once the monthly limit is reached your messages will stop being delivered until it's reset on the first of the month.

You'll find the new Knock-powered default email channel waiting for you once you create a new Knock account. From there, you can select the channel as you're building your workflows or broadcasts to start sending emails to your users.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue with broadcasts where if your broadcast contained channel steps under a branch, the broadcast would be marked as invalid.
• 🐛 [Dashboard] We fixed an issue where the tenant in the autocomplete in the template editor would not display any custom properties.
• 🐛 [API] We fixed an issue where a schedule couldn't be created for a tenant.
• 🐛 [Notification engine] We fixed an issue where SMS to overrides were not being respected.
• 🐛 [SDKs] We fixed an issue where some fields on the Message schema were not correctly marked as required.

With our new, reworked information architecture, we’ve made it easier than ever to find what you need in the Knock dashboard, and to move across the environments you have configured within Knock.

We’ve also gone ahead and moved a few items into the “Settings” page, so they’re better classified as what they are. You’ll find that we also gave the sidebar within the setting section on your account an overhaul to better logically group different areas.

All of these changes have rolled out to all users today.

New sidebar with sections

The new sidebar groups related areas into clear sections and keeps primary actions in reach. Workflows, Broadcasts, and Commits sit at the top for quick access, while Content, Recipients, Observability, and Platform organize the rest. You can collapse sections to reduce noise and stay focused.

Top-level environment switcher

The environment switcher now lives at the top of the dashboard, visible on every page with a new, refreshed look.

New settings page

Settings have a new left sidebar that groups controls by account, version control, integrations, and admin. Channels, Integrations, and Sources now live here under integrations, so provider setup and data connections sit alongside the rest of your workspace settings.

New account dropdown

The account menu is streamlined with quick access to your settings, channels and sources page, accounts, and sign out. Organization switching is easier to see and faster to use.

New help menu

The help menu provides quick links to docs, API reference, and our Slack community. You can also share feedback and contact support in one click.

Fixes and improvements

• 🐛 [Dashboard] We fixed a variety of small issues that would cause the dashboard to error.
• 🐛 [SDK] We fixed token signing in Cloudflare Workers.
• 👀 [Dashboard] When creating new channel step, the selection will default to your email channel when there is only one.
• 🐛 [SDK] We fixed a bug when listing users in the Node SDK.
• 👀 [Dashboard] We added filters to the Broadcast messages log.
• 👀 [Dashboard] The CMD+DEL shortcut no longer deletes the entire block in the template editor.
• 🐛 [Dashboard] We fixed a bug when trying to select a different webhook channel.
• 👀 [SDK] Microsoft recently deprecated multi-tenant bot registration, so we now support sending notifications as Microsoft Teams bots registered with Azure as single-tenant.

Lightning-fast uploads with instant feedback

We've rebuilt the CSV uploader from the ground up with performance in mind. The uploader now opens instantly and processes uploads in seconds, giving you real-time feedback as users are added to your broadcast or audience. You'll see the user count update live as your file is processed, making it easy to track progress and confirm your upload is working as expected.

Streamlined column mapping with full control

The new mapping interface gives you complete control over your data. You can easily add new columns, rename incoming columns, or skip unnecessary ones. This flexibility means you can work with any CSV structure without having to modify your files beforehand.

Per-recipient broadcast data

Here's the game-changer: when uploading users for a broadcast, you can now categorize CSV fields as either "user data" or "broadcast data". User data gets saved to your user schema as usual, but broadcast data is used only for that specific broadcast.

This is perfect for including one-time information like:

• Promotional discount codes unique to each recipient but not necessary to reuse
• Event-specific details like seat numbers or session times
• Usage metrics relevant only to that broadcast

Previously, if you wanted to include this type of data in your broadcasts, you'd have to store it permanently on your user records with no easy way to clean it up later. Now you can keep your user schema clean while still personalizing broadcasts with rich, contextual data.

Save uploaded users as reusable audiences

When uploading users to a broadcast, you still have the option to save them as a new audience that can be reused for future broadcasts. This makes it easy to build and maintain audience segments without having to re-upload the same users repeatedly.

Fixes and improvements

• 🐛 [In app feed] We fixed an issue where the realtime feed didn't update after marking all archived.
• 🐛 [CLI] We fixed a regression with the push all command in the CLI.
• 🐛 [Dashboard] We fixed an issue where searching for a source event with a space would return no results.
• 🐛 [Dashboard] We fixed an issue where setting user preferences in the UI would fail even though setting via the API worked for the same payload.
• 🐛 [Dashboard] We fixed an issue where workflow categories with spaces would break.

New tab for resource-specific version control

On versionable resource pages, we introduced a new tab titled "Changes". This tab gives you a more detailed view of the changes you've made to your resource. You can see the changes you've made, the commits that need promoting, and a history of when your resource was last promoted.

You'll also be able to see the historical commits for that resource, enabling full visibility into the changes that have been made to your resource over time.

Commit and promote changes directly from any resource

We've added the ability to commit and promote changes directly from any resource. This means you can now make changes to a workflow, email layout, or any other versionable resource and commit those changes without leaving the page. The new commit flow provides a clear summary of your changes and lets you add a descriptive message before committing.

Once committed, you can promote those changes to the next environment too, right from the resource page. This streamlines the process of moving changes through your environments.

View changes across environments

The new changes tab also enables you to view the overall status of your resource across environments. Previously, it was difficult to know when a resource had unpromoted commits in other environments. Now, we have a special indicator that introduces a visual cue to help you identify when a resource has uncommitted changes or unpromoted commits in other environments.

And when a resource is synchronized across all environments and in production, you'll see a green checkmark to indicate that the resource in its current state is live in production and the same across all environments.

Fixes and improvements

• 🐛 [MCP] We fixed an issue where creating a new partial from the MCP server crashes partials list.
• 👀 [Dashboard] We added filtering for messages under users/tenants/objects.
• 👀 [Dashboard] We improved the translation editing experience.
• 👀 [Dashboard] Introduced breadcrumb navigation for the dashboard.
• 🐛 [Dashboard] We fixed an issue where previewing a message would mark it as "read" inadvertently.
• 👀 [Docs] We added Guides tooling to the Agent Toolkit docs.
• 👀 [SDK] We added a usePreferences hook to the React SDK.
• 🐛 [API] We fixed an issue with plaintext link parsing.

Our @knocklabs/react package now has support for React Sever Components. This unlocks full compatibility with Next.js App Router and other frameworks, allowing you to use the SDK in both server and client components.

We migrated our internal store from zustand to @tanstack/store. This means finer control over state updates, better TypeScript support, and a smaller overall bundle size. It also unifies store logic across packages, reducing the surface area for bugs and improving long-term maintainability.

Finally, we’ve revamped our release pipeline to support canary and release candidate (RC) versions. Teams can now opt into early versions of our SDKs, test upcoming changes, and provide feedback before a stable release. With this change, we will now ship fixes and features more confidently, with a clear and gradual path to general availability.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue where the "Alerts" workflow template was broken.
• 🐛 [Dashboard] We fixed an issue with the search input when interacting with it from the Command+K menu.
• 🐛 [Dashboard] We fixed an issue where the "Discard changes" button didn’t work in the translations editor.
• 🐛 [Dashboard] We fixed an issue where the diff viewer was cut off in Safari.

With guides scheduling, you can now control exactly when your guides activate and deactivate. This is perfect for time-sensitive announcements, seasonal promotions, and other in-product messaging.

We've also added an analytics summary for guides, giving you visibility into how your in-product messages are performing. The summary shows total potential audience size and the number of users who have seen, interacted with, and archived a guide. You can view these metrics as either raw numbers or as percentages of the total audience.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue where breadcrumbs were not displaying correctly on some pages.
• 🐛 [Dashboard] We fixed an issue where updates to brand settings did not live update the branding preview.
• 🐛 [Dashboard] We fixed an issue where opening links in a message preview would break the preview.
• 🐛 [Dashboard] We fixed an issue where the template editor could crash when selecting a source event trigger for API-triggered workflows.
• 🐛 [Dashboard] We fixed an issue related to drag & drop and the trigger workflow step.
• 👀 [Dashboard] We moved email template settings like from address directly into the template editor to simplify email editing.
• 👀 [Dashboard] We shipped a number of other miscellaneous UI and bug fixes.

Getting started with generating types is incredibly easy. You first describe your workflow trigger schema (or generate it using AI), then you can pull workflow type definitions from the Knock CLI:

knock workflow generate-types --output-file=./knock-workflow-types.ts

Next, within your application, you can import your types and annotate your Knock workflow triggers:

import { Knock } from "@knocklabs/node";
import { CommentCreatedData } from "./knock-workflow-types";

const knock = new Knock({ apiKey: process.env.KNOCK_API_KEY });

const triggerData: CommentCreatedData = {
  comment_id: "comment_123",
  comment_text: "Great work on this!",
  document_id: "doc_456",
  document_name: "Project Proposal",
  priority: "medium",
  metadata: {
    source: "web_app",
    version: 1,
  },
};

await knock.workflows.trigger("comment-created", {
  recipients: ["user_789"],
  data: triggerData, // ✅ Type-safe!
});

Your application's compilation will now fail if required data is missing or invalid data types are passed. This ensures that the data your workflow expects is provided.

The Knock CLI currently supports generating types for TypeScript, Go, Python, and Ruby. We may add other languages in the future. Please get in touch if there's a language you need that we don't currently support.

You can learn more in our guide on type safety and in the CLI documentation.

Other CLI improvements

We've also added support for two new commands in the Knock CLI:

• knock pull: Pulls down all versionable resources from your Knock account into the specified directory. Using this command, all resources will be pulled under their own directories (like workflows, layouts, partials).
• knock push: Pushes all resources in your Knock directory up to Knock in a single command, where you can optionally supply a commit message to pass along to commit and push at the same time.

Fixes and improvements

• 🐛 [Dashboard] We fixed an issue where the discard changes button for setting trigger data did not always work
• 🐛 [Dashboard] We fixed an issue where opening an email preview could have marked a message as "opened" inadvertently
• 👀 [Dashboard] We improved the categories filter on workflows to be a typeahead
• 👀 [Notification engine] We added support for a new format_date_in_locale liquid helper
• 🐛 [API] We fixed an issue with our OpenAPI spec where the set tenant endpoint listed that it accepted preferences
• 🐛 [SDK] We fixed an issue in the React SDK where the useNotifications hook could cause a memory leak
• 🐛 [Agent toolkit] We fixed an issue where some models would report issues with the tools provided by the MCP server
• 👀 [Agent toolkit] We added support for updating as well as creating workflow steps
• 👀 [Agent toolkit] We added support for upserting email layouts

Previously to see how your email notifications would render you would have to use a combination of our in browser preview, sending tests to yourself via the test runner, and using an external tool, like Litmus. Now, with email client previews, you can see exactly how your email will render on a variety of email clients by just navigating to the "Client previews" tab.

You can access email client previews by going to the "Client previews" tab in the template editor. There you will see a selection of popular email clients, showing a snapshot of how your template will render on each client. Each image can be enlarged, and you can easily navigate between different email client previews by using the keyboard.

Email client previews is available today for all enterprise plan customers. You can read more in the documentation.

Fixes and improvements

• 🐛 [API] We fixed an issue where using the bulk create schedules endpoint with a non-existent recipient could cause the process to fail.
• 🐛 [Dashboard] We fixed an issue where service tokens could not be deleted or renamed.
• 🐛 [Dashboard] We fixed an issue with archiving email layouts.
• 🐛 [Dashboard] We fixed an issue where opening the template settings modal on email templates would show an errant error for the JSON overrides field.
• 🐛 [Dashboard] We fixed some performance issues with the new template editor, leading to slow typing speeds.

Guides enable you to power in-product messaging, everything from paywalls and badges, to one-time announcements and banners, using your own native components.

With guides, your engineering team gets complete control over in-product messages and how they’re rendered in your product, while your product and marketing teams get the ability to draft, A/B test, and manage all your native in-product content.

Native, self-serve, and observable

Here are a few reasons why we think guides will help product and engineering teams:

• Goodbye <script/>. Hello <Component/>: Unlike legacy in-app messaging tools that inject JavaScript agents and slow down your app, Knock guides integrate directly with your React, Vue.js, or Angular components. No performance penalties. No UI janking. Complete design system compliance.
• Self-service for PMs and marketers: With guides, product and marketing teams get the ability to draft content, target recipients, and configure message activation in a self-service way, without needing to worry about introducing breaking changes in the frontend.
• Built-in analytics and observability: Guides automatically track delivery and engagement metrics. You can understand how many users are seeing, interacting with, and archiving your in-app guides. We make it easy to deliver that data where you need it, whether that's your data warehouse or CDPs such as Segment or Amplitude.

We believe in a future for the internet where software teams can ship in-app messaging that powers adoption, growth, and retention, without having to compromise on performance, web vitals, and content layout shift.

Check out a walkthrough here.

Read the full announcement.

A brand new docs experience

We first shipped our docs site four years ago along with the initial launch of Knock. Since then, the design hasn’t changed, despite us shipping a lot of new content.

We’ve reorganized our content, rebuilt our “building in-app UI” section, and refreshed our API and management API references using the OpenAPI spec.

We have also added support for all your LLM needs, with llms.txt and llms-full.txt, markdown pages, and a new RAG API endpoint for our MCP server.

If you’re interested in peeking behind the curtains for these changes, our docs are open source and available here.

New SDKs for Node, Go, Python, and Ruby

Today, we’re proud to release the 1.0 versions of our SDKs in Node (Typescript), Go, Python, and Ruby. These new SDKs are richly typed and include all resources across our API. They are a joy to use. In addition to typing, they include retries, auto-pagination, customizable logging, and configurable timeouts.

If you’re a current SDK user, our migration guides will provide information on how to migrate to the 1.0 releases of our SDKs. We’re also anticipating that our PHP and .NET SDKs will follow the same generated treatment in the second half of this year.

Check out a walkthrough here.

Read the full announcement.

Whether you’re announcing a new feature, alerting users about system maintenance, or driving new feature adoption, broadcasts let you create thoughtful cross-channel messaging sequences that reach users where they are.

Unlike traditional workflows in Knock that trigger based on events, broadcasts are scheduled to run once for an audience. And, because broadcasts use our workflow engine under the hood, you can easily build sophisticated cross-channel one-time messaging.

Audiences, preferences, and analytics

Along with broadcasts, we are also releasing:

• Audiences: You can now create an audience in Knock using CSV upload, through our rETL integrations with Census and Hightouch and via our API.
• Commercial preferences and 1-click unsubscribe: To stay compliant with regulations like CAN -SPAM and CASL, you can set a broadcast (or a workflow) as commercial, which give users the ability to one-click opt-out of any future commercial messaging sent with Knock.
• Observability and analytics: The messages sent by broadcasts are just like any other messages in Knock. You get visibility into all of the same observability and analytics data we provide for trigger-based workflows.

Read the full announcement.

Check out a demo here.

Read the full announcement.

This is our biggest update yet to building and designing cross-channel messaging in Knock. We redesigned our template editor and our workflow canvas with a renewed focus on:

• Speed. All updates are optimistic. You will never see a loading spinner. You can now use keyboard shortcuts for everything.
• Ease of use. Writing an email in Knock is as easy as writing a doc in Notion.
• Quality control. We’ve overhauled error handling and introduced AI powered auto-fix suggestions to debug more complex issues

Check out a demo here.

Knock Agent Toolkit

Agent Toolkit is a set of tools that enables your agents to send messaging across channels such as in-app, email, push, SMS, and chat apps (Slack, Microsoft Teams.) All messaging sent by the agent works within the guardrails of the messaging workflows and templates you configure in Knock.

const toolkit = await createAgentToolkit({
  permissions: {
    workflows: {
      trigger: ["comment-created", "task-completed", "welcome-user"],
    },
  },
});

Human-in-the-loop

An important part of building agents is enabling them to go to humans to provide input, verify work, and approve outputs. Agent Toolkit exposes a set of helper methods that make it easy to wrap your tool calls in asynchronous human approvals or inputs.

import { createToolkit } from "@knocklabs/agent-toolkit/ai-sdk";

const toolkit = createToolkit();

const classifyToolRequiringInput = toolkit.requireHumanInput(classifyWork, {
  workflow: "approve-classification",
  recipients: ["user_123"],
});

Our toolkit comes with built-in support for major agent frameworks and SDKs including Vercel AI SDK, LangChain, and OpenAI.

Knock MCP server

Anything you can do in the Knock dashboard you can now do using natural language.

We’re shipping a local MCP server that wraps Agent Toolkit and exposes the tools via the Model Context Protocol. The MCP server can be installed in any MCP-compatible client, including AI coding tools such as Cursor, Windsurf, or Claude Code.

We’re giving foundation models and tools like Cursor the ability to set up workflows, design emails, interact with Knock observability data, and much more.

Get started

You can get started today with Agent Toolkit and our MCP server by reading the documentation and installing the package via npm (@knocklabs/agent-toolkit).

The future is agentic. At Knock we’re thrilled to get the opportunity to partner with our customers and define how agents and humans work together.

To learn more, read the full announcement.

Last year we shipped our workflow trigger data schema validation, which allows you to use a JSON schema to describe the data that's expected as part of your workflow trigger. However, getting started here required you to write out a full JSON schema from scratch.

Now, using AI, you can click the "Generate schema" button to automatically generate a trigger data JSON schema from data available to your workflow. It's like magic.

Fixes and improvements

• 👀 [Dashboard] We added a new "Commits" tab to the workflow page where you can see all commits on that workflow and promote changes.
• 👀 [SDKs] We now support a containerStyle prop for the React Native and Expo SDK's NotificationFeed component.
• 👀 [SDKs] fetchNextPage in the JavaScript SDK FeedClient now supports FetchFeedOptions.
• 🐛 [SDKs] Trigger data filtering now supports boolean values in the JavaScript and React SDK.

Commit log filtering is available for all users on the "Commits" page, within the "Commit log" and "Unpromoted" tabs. Select a workflow from the filter dropdown to see all commits related to that workflow.

Fixes and improvements

• 🐛 [Notification engine] We fixed an issue where MS Teams webhooks would unexpectedly retry a sent notification.
• 👀 [API] We added support for datetime filtering to the user feed endpoint.
• 👀 [API] We added support for listing recipients with their preference sets loaded.
• 👀 [Notification engine] We added support for a new from_markdown Liquid helper to convert Markdown to HTML.

Teams operating customer engagement at scale know the difficulty of managing multiple changes across several teams and channels. With all of the moving parts, it's easy to lose track of what's been changed and when.

Knock enables teams to collaborate effectively with a powerful commit and environment model. But we recently identified a need to enhance the commits page UI to be even more useful. That's why we've redesigned our commits page with a focus on clarity and usability, making it easier for growing teams to manage changes to their notifications.

The new design is available today to all users under the "Commits" tab in the sidebar.

Fixes and improvements

• 👀 [Dashboard] We added support for the "markdown" Liquid filter to allow MarkDown input -> HTML conversion
• 👀 [Dashboard] Rolled out trigger event improvements
• 🐛 [Dashboard] We fixed an issue with Menu Buttons firing multiple times
• 🐛 [Dashboard] We deployed a fix for an email template rendering issue
• 🐛 [SDK] We addressed an issue in the Go SDK where some user properties were incorrectly marked as required

Today we're releasing support for React 19 in our web JavaScript SDKs. This will enable projects with React 19 as a dependency to use our SDKs without any additional configuration. Projects using React 18 or below can safely upgrade to the latest SDK versions without any code changes, as this update maintains full backwards compatibility. All code changes can be found in the GitHub pull request here.

To upgrade, set the package versions in your package.json to the latest version listed below, then reinstall.

Here are the latest versions of our SDKs:

• @knocklabs/client: v0.12.0
• @knocklabs/react: v0.6.0
• @knocklabs/react-core: v0.5.0

With these updates, our web SDKs now support React versions 16, 17, 18, and 19.

A note on the react-native and expo packages:

The react-native and expo packages do not yet support React 19.

React 19 recently became available on React Native, however, some of the internal dependencies need time to catch up and support these changes before we can update our own packages.

Since the underlying dependency on @knocklabs/client was updated, we released a new version for these packages as well.

• @knocklabs/react-native: v0.6.0
• @knocklabs/expo: v0.3.0

React 19 support in our Telegraph components

In addition to the JavaScript SDKs, we've also updated our Telegraph components to support React 19. As a dependency of our JavaScript SDKs, this means that you can now use our in-app notification components and hooks with React 19 without any additional configuration.

You can read more about using our React components to build in-app notifications in the docs here.

Fixes and improvements

• 🐛 [Dashboard] We fixed a bug where users were able to create variables without setting a value

Today we’re introducing email-based user ID resolution for Slack, simplifying the steps needed to send direct messages via Slack to your Knock users.

Previously, if you wanted to send a direct message via Slack to one of your users, you needed to update your Knock user’s channel data to include their Slack user ID. This ID is typically found by making a request to the users.lookupByEmail endpoint of the Slack API using your Knock user’s email address.

Now, Knock can automatically make this API request on your behalf before sending a message. When the request succeeds, Knock will automatically add the Slack user ID to the user’s channel data.

You can read more about enabling email-based user ID resolution for Slack in our documentation.

• 👀 [Dashboard] We made it possible to see who created a workflow, in addition to who last edited a workflow.
• 🐛 [Notification engine] We fixed a bug in which temporary failures from Mailgun were treated as undelivered.
• 🐛 [Dashboard] We fixed a bug in which a cloned workflow would default to the inactive state.
• 👀 [SDK] We updated our SDKs to include ending_at for scheduled workflows.

Today we're introducing the ability to filter for messages by a workflow run ID or a workflow recipient run ID.

Before, if you wanted to find all of the messages produced for a single workflow trigger call you needed to attach your own identifier to your messages and use our trigger data filtering. Now, with our new filtering capabilities, you can filter for messages by the workflow run ID returned from a trigger request, or an individual workflow recipient run ID.

We've introduced these new filters into the messages API, and also to the dashboard, making it easier than ever to track down specific messages produced from a single workflow run, or for multiple workflow runs from a single trigger request.

Fixes and improvements

• 🐛 [Notification engine] We fixed an issue with our SMTP sender where including a from name could cause some email providers to fail.
• 👀 [Dashboard] We added support for better surfacing inline errors in our code editor for Liquid, JSON, and Markdown.
• 👀 [Dashboard] We now show the total number of members in a workspace in the members list.
• 🐛 [Dashboard] We fixed an issue with our fetch step where in certain cases it could fail to send a test with a hard crash.
• 🐛 [Dashboard] We added support for being able to use message conditions on push notification steps.
• 🐛 [Dashboard] We fixed a small bug where descriptions longer than 255 characters for variables would fail to save.
• 🐛 [Dashboard] We fixed a minor issue with our commit log viewer where long lines were not wrapping.

Today we're releasing an extension to our workflow trigger API: the ability to supply per-recipient trigger data. Previously, the data field supplied to your workflow trigger was shared across all recipients, meaning that if you wanted to supply recipient-specific data, you had to do so by either triggering a workflow per-recipient, or by stuffing data onto the user's profile.

Now, with the introduction of per-recipient trigger data, you can supply recipient-specific trigger data for up to 1000 recipients at a time via the workflow trigger API. The per-recipient trigger data will be merged onto the base workflow trigger data, making it easy to still supply shared data to all recipients of your workflow while providing anything recipient-specific.

Here's an example, where we're supplying a recipient-specific dashboard URL to the workflow. In this example, when the workflow runs for esattler, it will merge the contents of their trigger data onto the base data, so the dashboard_url will be https://dashboard.jurassic.park/esattler.

{
  "data": {
    "dashboard_url": "https://dashboard.jurassic.park",
    "alert_type": "dinos-roaming",
    "alert_id": "1234567890"
  },
  "recipients": [
    {
      "id": "esattler",
      "$trigger_data": {
        "dashboard_url": "https://dashboard.jurassic.park/esattler"
      }
    }
  ]
}

Fixes and improvements

• 🐛 [API] We fixed an issue where the user deletion API could sometimes respond with an inconsistent status code.
• 🐛 [SDK] We fixed an issue where the Python SDK would not correctly handle JSON errors from particular versions of the requests library.

Behind the scenes, TeamsKit:

• manages your OAuth connection and tokens.
• helps your customers select which channels they will receive notifications in.
• integrates seamlessly with the rest of Knock, so you can easily send notifications to Teams alongside any other channel.

Shipping a Teams integration has never been easier.

Read the full announcement ->

As a nice quality of life improvement, we've added a new ending_at field to Schedules. The ending at field allows you to schedule a workflow to repeat for a recipient until a specific date, making it easy to build schedules that run for a limited time.

You can read more about scheduling workflows with an ending date in our documentation.

Fixes and improvements

• 👀 [Dashboard] We added support for setting an empty layout for email templates in a workflow.
• 👀 [mAPI] We added support for a null layout_key for email templates in a workflow.
• 🐛 [Dashboard] We fixed an issue where previewing an email template with an invalid set of JSON overrides would fail.
• 🐛 [Dashboard] We fixed an issue where changing a step title or description would not save correctly when typing quickly.
• 🐛 [Dashboard] We fixed an issue where partials could not be used when they use system key names like primary-button.

We've added a new endpoint to the Knock Management API to preview workflow templates. This is useful if you're looking to integrate Knock into your own application and need a way to preview templates with user supplied data, like when building a template customization experience.

To use the preview endpoint, you pass it a channel step on a workflow, and provide the recipient, actor, tenant, and data parameters to render the template with. The API will then return a JSON object with the rendered template across all channel types, or a detailed error response if the template could not be rendered.

You can read more about the preview endpoint in our documentation.

Fixes and improvements

• 👀 [Dashboard] We added pagination to the source events list.
• 🐛 [Dashboard] We fixed an issue where the "Previous" button on user, object, and tenants lists would always return you to the first page.
• 🐛 [Dashboard] We fixed an issue where the count at the bottom of some table views would always only show the number of items returned on that page, not the total number of items.
• 🐛 [Dashboard] We fixed an issue where creating a workflow from a template with a category would fail.
• 🐛 [Notification engine] We fixed an issue where SMS links over 255 characters would not be shortened.
• 🐛 [API] We fixed an issue with paginating users, objects, and tenants with a before cursor.

Today we're announcing support for overriding the recipient of an SMS message. This is useful if you want to send an SMS to a different user than the one that triggered the workflow.

With the new SMS recipient override, you can now specify either a static or dynamic value via Liquid for the recipient of an SMS. For example, you might be sending an SMS to the user, but be sending it to the new phone number they entered and stored on the recipient profile as recipient.new_phone_number.

You can read more about SMS overrides in our documentation.

Fixes and improvements

• 👀 [Dashboard] You can now see environment.merged_latest changes in the audit logs.
• 🐛 [API] We fixed an issue where hourly schedules with an interval > 1 would be enqueued at the wrong time.
• 🐛 [Dashboard] We fixed an issue where the workflow builder would show an incorrect tooltip when adding steps.
• 🐛 [Dashboard] We fixed an issue where after adding an integration, you would need to refresh the page to see it show up in the workflow builder.
• 🐛 [SDK] You can now safely mount the <KnockProvider> in the React SDK with a null or undefined userId.

Today we're announcing support for referencing objects, users, and tenants dynamically in templates. While we've always exposed properties on the template such as the recipient, actor, and tenant, if you needed to reference other object or user data stored within your Knock environment, you had no access to that within your workflow scope.

Now, with template references, you can load arbitrary objects, users, and tenants into your template context. This allows you to reference any data stored within your Knock environment, such as a different user's profile, a tenant's settings, or an object's properties. Using template references brings access to any kind of third-party object data that you might want to store in Knock, without needing to pass it into your workflow data.

Here's an example. Let's say you're a collaboration product, and you want to show the current project's most up to date title and description in an update email for things happening on that project. With template references, you can load the project object dynamically at execution time by passing in a project_id into your workflow trigger, and then loading the project object into your template context.

{% assign project = data.project_id | object: "projects" %}

# {{ project.title }}: new updates

> {{ project.description }}

There have been {{ total_activities }} updates on this project in the last 24 hours.

This feature is available now to all Knock customers. You can read more about the feature in our template references documentation.

Fixes and improvements

• 🐛 We fixed an issue with the workflow canvas where it would no longer center correctly.
• 🐛 We fixed an issue with channel steps in the workflow builder, where it appeared you could change the selected channel in non-development environments.
• 🐛 We fixed an issue where cleaning up message history on the deletion of a user would sometimes fail.

Today we're adding support for overriding the recipient of an email generated in Knock. Previously, emails were always sent to the email address associated with the recipient.

With the new to email override, you can now specify either a static or dynamic value via liquid for the recipient of an email. For example, you might be sending a change email confirmation to the user, but be sending it to the new email address they entered and stored on the recipient profile as recipient.new_email.

You can read more about the feature in our email overrides documentation.

Today we're excited to extend our batch step with support for immediately flushing the first item in the batch. Previously, our batch step would collect all triggers across the batch window, and flush those as a single batch once the window closed.

With immediate flushing, your batch will always flush the first item before accumulating subsequent triggers across the batch window. If you're a developer, you might be familiar with this concept as a "leading debounce". This can be useful when you want to immediately notify your users about some action occurring, while still batching any additional information across a window of time to reduce the number of notifications your users receive.

You'll find the option to immediately flush the first item in the batch under the advanced options in the batch step settings. You can read more about the feature in our batch step documentation.

Fixes and improvements

• 👀 We added support for sending multiple tags to Mailgun via overrides.
• 🐛 We moved our OneSignal integration to use the v11.6 API.
• 🐛 We added a role="none" attribute to any open tracking pixels included in emails.
• 🐛 We fixed an issue where identify events sent to Segment would override properties set on the user being identified.

Today we're excited to announce that we've added support to our Microsoft Teams integration for sending notifications via bots through the Microsoft Bot Framework. While we've previously had support for Microsoft Teams as a provider in Knock, our integration only supported sending via webhooks, which was most suitable for internal or one-off use cases.

Using the Bot Framework, we can now support multi-tenant integrations that can send messages to channels and directly to users, making it possible to build richer notification experiences on top of Microsoft Teams and powered directly through Knock.

You can read more in our refreshed Microsoft Teams documentation on how to get started.

Fixes and improvements

• 👀 We've added inline step editing to the workflow builder for the step name, description, and reference fields.
• 👀 We added support for navigating the workflow builder using the keyboard. You can now use the arrow keys to easily select different steps and navigate your workflows.
• 🐛 We fixed a bug where long workflow keys would wrap in the workflow list.
• 🐛 We fixed an issue where email template setting overrides were not being saved because of invalid override JSON being provided.

Today we're excited to announce the beta release of in-app message types. Building on our in-app messaging components release, with today's release you can now power any UI element in your product—a banner, a carousel, a tag, anything—using Knock's workflow engine and real-time messaging infrastructure. Here's how it works.

In-app message types enable you to map UI elements and components from your application to a message type in Knock. Once you've created a message type, you can use it to target and send native messages to that component in your own product, powered by Knock's real-time messaging infrastructure.

In-app message types are a powerful way for your engineering team to own the structure and implementation of in-app messages displayed to your users, while giving product managers and marketers the flexibility to create and manage the in-app messages sent to your users through Knock's powerful visual workflow builder.

Each in-app message type has a schema that determines the fields available to your content editors when building a new in-app message. Schemas are versioned and can be updated over time to create strong guarantees between the structure expected in your components and the messages exposed over the API.

To render components for a given message type, you use our React SDK and hooks to fetch any messages of that type for the current user. Knock owns the data layer, while your team owns the component, making it possible to create native in-app messaging that leverages your existing design system and component library. This also means that native in-app messaging powered with Knock is just as performant as the rest of your app, and won't be blocked by ad blockers. You can read more and see examples in the documentation.

In-app message types are currently in beta. If you're interested in trying them out, please contact our team.

Today we're excited to announce the launch of a new set of in-app messaging components for our React SDK, making it possible to power a new set of in-app experiences with Knock.

Previously, our in-app SDK was limited to powering feed and inbox experiences, and used to integrate our SlackKit components into your application. Now with today's release, you can use our new <Modal />, <Banner />, and <Card /> components to build out a new set of in-app experiences for your users, all powered by Knock's real-time messaging infrastructure, and seamlessly integrated into our workflow builder.

Our in-app components enable your content editors to create and manage in-app messages directly within Knock's workflow builder as part of a cross-channel messaging strategy. Because in-app messages are just another channel in Knock, you can create them as part of a workflow powered by events, or even when your users enter an audience. That means you can build experiences like:

• Welcome messages: show a modal when a user signs up for your product.
• Overage banners: when a user exceeds some usage threshold on their account, show a banner to let them know.
• Upsell cards: show a persistent message within your product to upsell your users on additional features once they've onboarded.

Each of our out-of-the-box components are fully customizable, with the ability to override the CSS variables or classes associated with each component. Or you can even build your own components on top of our data layer via our hooks, making it easy to integrate Knock's messaging into your existing design system or component library.

Here's a quick look at rendering one of our components to show a banner at the top of your product:

import {
  Banner,
  KnockProvider,
  KnockInAppMessagesChannelProvider,
} from "@knocklabs/react";

const MyApplication = () => {
  const { user } = useCurrentUser();

  return (
    <MyLayout>
      <KnockProvider apiKey={process.env.KNOCK_API_KEY} userId={user.id}>
        <KnockInAppMessagesChannelProvider
          channelId={process.env.KNOCK_IAM_CHANNEL_ID}
        >
          <Banner />
          <MyHeader />
          <MyFooter />
        </KnockInAppMessagesChannelProvider>
      </KnockProvider>
    </MyLayout>
  );
};

Our in-app components are currently in private beta. If you'd like to be added to the beta experience, please reach out to our support team. You can read more about the components in our documentation.

Fixes and improvements

• 👀 We made some visual updates to the look and feel of the workflow builder, including a new improved panels architecture.
• 🐛 We fixed an issue with saving step metadata in the workflow builder.
• 🐛 We fixed a bug with the branch step in the workflow builder that was hiding a maximum depth reached error.
• 🐛 We fixed an issue with some modals that meant they were overflowing unexpectedly.
• 🐛 We fixed an issue with viewing commits and committing workflow changes on the commits page.
• 🐛 We fixed a bug where computed delay windows were showing the incorrect value in workflow run logs.

We've added support for sending emails via SMTP through Knock. Our SMTP provider allows you to send emails through any SMTP server, giving you the flexibility to use your existing email infrastructure with Knock.

You can get started by configuring your SMTP provider in the "Integrations > Channels" page in the Knock dashboard. You can read more about the SMTP channel in our documentation.

Fixes and improvements

• 👀 We've added support for using recipient.preferences as part of the workflow run scope. You can now target any property on recipient preference set within template variables and conditions
• 🐛 We fixed an issue where overrides for branding and logos were not showing the base versions within the dashboard
• 🐛 We fixed an issue that was preventing trigger conditions from being saved in certain cases

Today we’re excited to announce a new way to power your notification workflows: Knock Audiences. Audiences bring the concept of user segmentation into Knock.

An audience represents a list of users you define who all share a common set of characteristics. You can build any number of segments of users that you'd like, bring those audiences into Knock, and then use them to power notification behavior.

With this release, you can bring audiences into Knock programmatically through our new Audiences API and direct integrations with reverse ETL tools like Hightouch and Census. Your audiences are then available to view and manage through the Knock dashboard.

Once you start creating audiences in Knock, you can use them to:

• Trigger workflows when new users are added to an audience. This is great for powering lifecycle messaging (such as new user signups) and transactional messaging (such as payment method updates) use cases
• Orchestrate branch and conditional logic within your workflows (e.g. if a user is in paid-users audience, opt them out of the workflow)

With today's release, we’re excited to expand the messaging use cases you can power with Knock and help our customers power a unified messaging motion across their product and lifecycle marketing.

Audiences are currently in beta. If you want to try them out, you can contact our team to request access. To learn more about what's possible with audiences, check out our documentation.

There's a lot more to come with Audiences in the future. They will form a pivotal building block for new features we're working on over the coming months, and we can't wait to share more with you soon.

Fixes and improvements

• 🐛 We fixed an issue with translations where archiving a namespaced translation would cause other translations for that locale to stop working when previewing and sending
• 🐛 We fixed an issue where using liquid in a JSON editor would sometimes cause the validation to fail

Today we've released a new @knocklabs/expo SDK that includes support for mobile and web applications built using the Expo framework. This SDK includes a new KnockExpoPushNotificationProvider component that streamlines the integration with Expo push notifications, helping you to quickly get up and running with push notifications powered by Knock and Expo.

We've also released a new version of our existing @knocklabs/react-native SDK that includes a new KnockPushNotificationProvider that exposes registerPushTokenToChannel and unregisterPushTokenFromChannel methods to support push notification token registration outside of the Expo ecosystem. You can see these in use in our new React Native example app, where we're integrating with Firebase messaging.

To get started with the Expo SDK, check out the documentation.

Fixes and improvements

• 🐛 We fixed a bug where the test runner could not be accessed in non-development environments
• 🐛 We fixed an issue with adding email template overrides with liquid variables that resolve to JSON

The workflow builder is the visual interface for designing workflows in the Knock dashboard. It allows you to express complex cross-channel notification logic in an easy to reason about way.

After months of development, we're excited to announce a rebuild of the workflow builder with a new architecture, improved performance, and a more intuitive user experience. We've poured a lot of love into this update, and we're excited to share it with you today.

Here are a few of the key differences in the new workflow builder:

• 🚀 Performance: The new workflow builder has been rebuilt from the ground up with a focus on performance. You'll notice that actions like adding and removing steps now feel instant, making it a delight to use.
• 🧩 Refreshed design: We've updated the visual style of the workflow builder to use our Telegraph design system. This includes a new color palette, typography, and iconography.
• 💪 Simplified step editing: Each step panel in the workflow builder has been rebuilt from the ground up to be more intuitive and easier to use.
• 😵‍💫 Goodbye spinners: We've removed virtually all of the loading spinners from the workflow builder as a result of our new architecture, making actions feel more responsive.

Our goal at Knock is to build a powerful product that feels delightful to use, and we're confident that with our new workflow builder foundation, we're well on our way to achieving that goal. We will be making more improvements in the coming weeks, and you'll see us start to roll out these changes to the template editor next as well.

Stay tuned for more updates in the coming weeks, and we'd love to hear your feedback in the meantime.

Fixes and improvements

• 🐛 We fixed a bug where the test runner could not be accessed in non-development environments

Our delay step allows your workflow runs to pause for a certain amount of time before continuing, which is useful for scheduling reminders or other longer lived notifications. Previously, delay windows supported either a fixed amount of time (e.g. 30 minutes) or a dynamic value based on a property available in the workflow run scope.

Now with relative delay windows, you can specify a delay that is relative to a dynamic value provided, such as "30 minutes before the task is due" or "2 days after the task is created".

Relative delay windows are available now under the delay step in the workflow editor. You can get started by reading the documentation.

Fixes and improvements

• 👀 We've visually refreshed the date time comparison component in the dashboard to better understand a timestamp relative to the current user's timezone
• 👀 We've introduced a new search button to workflows, partials, and users to more easily find an item in the dashboard
• 🐛 We fixed an issue where certain pages on the dashboard would break out of their parent scroll container, causing the entire page to scroll
• 🐛 We fixed an issue where a member role could not upload tenant logos

At Knock, we're always looking for more opportunities to give you access to the data that's available within your Knock account so that you can analyze it along with the rest of your product usage data.

With today's release, you can now receive a stream of user and preferences changes directly into your data warehouse. This makes it easy to build models that analyze your notification opt-out rates and how user profile information in Knock changes over time.

This feature is available to Enterprise customers who have set up a data warehouse sync. Read our documentation to learn more.

Fixes and improvements

• 👀 We've moved trigger data into the data property in the template editor, so you now access properties as {{ data.property_name }}
• 👀 We added a link to the billing portal for all customers to see their current daily usage quotas
• 👀 We added support for base_logo_url and base_icon_url when applying tenant branding so that the original branding properties can still be referenced
• 🐛 We removed support from our editor for unsupported liquid tags like date_to_string
• 🐛 We fixed an issue where creating a new HTML partial would not immediately appear in the blocks sidebar
• 🐛 We fixed an issue where committing a change to a partial would not be reflected in the workflows and templates that use it
• 🐛 We fixed an issue where the member role in the account could not upload tenant branding
• 🐛 We fixed an issue with our RadioCard component to ensure the selected state is reflected correctly
• 🐛 We fixed an issue where passing created_at to Segment identifies could cause an error

The data you pass into your Knock workflows is essential to ensure your notifications have the right content and context. Previously, if you omitted a value or passed through the wrong type of data into your workflow triggers, you could lead to malformed or incorrect notifications. Given how critical this data is, we're rolling out the ability to validate the incoming data for your workflow trigger by providing a JSON schema that describes the expected data.

When provided, if the data does not match the schema the workflow trigger API will return a 422 Unprocessable Entity response with a list of errors. This ensures that your workflows are not run should incorrect data be provided.

You can configure a validation schema for your workflow trigger under the "Trigger step" in the workflow builder. It's also possible to supply the workflow trigger schema via our management API and CLI via the trigger_data_json_schema field.

Trigger data validation is available today to all Knock customers. Read our documentation to learn more about how this feature works.

Fixes and improvements

• 👀 We added support for MessageMedia as a new SMS provider
• 👀 We added support for event idempotency through source events (docs)
• 👀 We now expose url and any message interaction data to Segment and Heap for link click and interacted events respectively
• 🐛 We fixed an issue where saving and committing a partial would not update the underlying schema
• 🐛 We fixed an issue where some JSON editors would not scroll correctly

Today we’re releasing support for Partials, a new way to author pieces of content for reuse across templates. Partials are independently updated, versioned, and archived, and can be managed programmatically with the Knock CLI and management API.

Partials are now available to all customers. Read our documentation to learn more about how this feature works.

Fixes and improvements

• 👀 We've made some UI and UX improvements to the workflow list and show pages in the dashboard
• 👀 We've improved the pagination of the workflow list in the dashboard. Paginating will now update the URL, so that refreshing the page or going back will take you to the correct page
• 👀 We added a keyboard shortcut to save translations (cmd + enter)
• 👀 We added new autocomplete suggestions for liquid tags in the template editor. Now when you type {% you'll see suggestions for common tags like assign, if, for, etc
• 🐛 We fixed a performance issue when typing in the create workflow modal
• 🐛 We fixed an issue where the billing page could be cut off at certain screen sizes

Today we’re releasing support for configuring workflow trigger frequency. You can now set a workflow to only trigger once per recipient (user, object or tenant) and never again. When enabled, if a workflow is run more than once for the same recipient, we will not execute the workflow.

Workflow trigger frequency is now available to all customers. Read our documentation to learn more about how this setting works.

Fixes and improvements

• 👀 We added support for a timezone in the date filter in the template editor
• 👀 We improved the scroll behavior around the dashboard, so returning to pages will restore your previous scroll position
• 👀 We disabled the per-word highlighting in commit diffs to improve readability
• 🐛 We loosened the required Expo and React Native versions for our React Native SDKs
• 🐛 We improved the consistency of the timezone and date filters in the template editor between editing and previewing templates

We've introduced a new way to commit and promote a workflow simultaneously right from the workflows page in your development environment. This feature streamlines the process of committing your changes and promoting them to the next environment without having to jump to the commits page. You can access this feature from any workflow page in the Knock dashboard.

Fixes

• 🐛 We fixed an issue where an event sent from Segment could still trigger an archived workflow
• 🐛 We fixed an issue where newlines in the code editor weren't working
• 🐛 We fixed an issue where send windows weren't working for a webhook channel step

• 👀 We added the ability for you to specify a response key in your fetch steps, which controls where the response gets placed in your workflow run data
• 👀 You can now see any subscriptions you have under a tenant via the dashboard
• 👀 We updated the Workflow creation modal to include category selection and improved the manage modal experience
• 👀 We moved the security settings into its own tab in the settings section of the dashboard
• 👀 We added the ability to filter analytics by bounced messages in the dashboard
• 🐛 We fixed an issue where our custom webhook channel would send an empty body on GET requests
• 🐛 We fixed an issue where E.164 phone numbers were not always being validated correctly, causing issues when saving Twilio provider configuration
• 🐛 We fixed an issue that caused schedules to not be created when an account timezone was not set
• 🐛 We fixed an issue that could cause invalid FCM project IDs because of extra whitespace
• 🐛 We fixed an issue with the schedules API that would not allow a null repeats value when scheduled_at was specified
• 🐛 We fixed an issue with our Sendgrid sender that would specify the wrong content type parameter for an attachment

Today we're releasing an update to our native mobile SDKs across iOS and Android to include pre-built components for powering out-of-the-box in-app feed experiences within your mobile applications. Previously, you had to build your own in-app feed experiences on top of our SDK. Now, with these new components, you can easily add an in-app feed to your app with just a few lines of code. Knock takes care of all of the heavy lifting for you, including fetching and displaying the feed items, handling pagination, real-time badge counts, filtering, and more.

Our in-app feed components are customizable and can be tailored to fit your app's design and user experience. If you need more flexibility you can bring your own UI components, and build on top of the view models provided.

You can get started by reading the documentation on iOS and Android.

Fixes and improvements

• 👀 We gave the main dashboard sidebar UI an overhaul, updating the icons in the process
• 👀 We migrated the colors in the dashboard to our new design system, Telegraph
• 👀 We added new filters for the messages API for engagement status, inserted at ranges, and by a list of message ids
• 🐛 We fixed an issue where the code editor would fallback to a serif on certain browsers
• 🐛 We fixed an issue with the tenants API that could cause a 500 error when creating or listing tenants
• 🐛 We fixed an issue with the code editor where you could not scroll the content when using the popout editor

Today we're launching an enhancement to our push notification and device token management functionality. We will now auto revoke tokens that are expired from your user's channel data. Previously, you would need to listen to a message.bounced webhook and execute the token cleanup yourself when your push notifications failed to send.

Now, you can simply enable the option under your push channel settings to "Enable push token deregistration" and we'll automatically remove the expired token from your user's channel data when a push notification fails to send. This will help you keep your user's data clean and up to date without needing to write any additional code.

This feature is available today for all customers. To get started, check out the documentation for push notifications.

Fixes and improvements

• 👀 We added a new error page to better report any dashboard issues to our engineering team
• 👀 We made some light improvements to various empty states around the dashboard
• 👀 We added a missing filter for workflows to filter for all workflows that have a webhook step
• 👀 We now fall back to a recipient ID in the messages table when no email or name is provided on the recipient
• 🐛 We fixed an issue with single ticks in a Slack markdown template would cause a template rendering error

Today we’re launching an enhancement to our in-app notifications to support more actionable types of messages, without needing to drop down into code. Previously, to add inline actions to your in-app notifications you needed to customize a feed cell component. With our new in-app actions you can now toggle between a standard, single-action, or multi-action notification template directly in our template editor.

By default, in-app actions will direct you to the action URL you set on the button on click, but you can also override this behavior by providing a new onNotificationButtonClick callback to handle the action in your app.

As part of this update, we also refreshed the in-app editor UI with a new look and feel to make it easier and faster to create and preview your in-app notifications.

You'll need to upgrade to the latest version of our SDKs across web and mobile to take advantage of the new actionable in-app templates. To get started, check out the documentation for in-app notifications.

Fixes and improvements

• 👀 We now show your account ID under the Settings page in the dashboard.
• 🐛 We fixed an issue with our conditions logic where contains and not_contains would not operate correctly when the argument was a list.
• 🐛 We fixed an issue with our chat and HTTP templates that meant we would double JSON encode values sent from trigger data leading to incorrect results in a rendered template.
• 🐛 We fixed a performance issue with our new code editor where large templates would feel laggy to edit.

Today we’re introducing a new way to create and manage translations in Knock: the t tag.

With our user-friendly t tag, you can draft message templates in your default language (e.g. english), then wrap the content in a t tag to auto-generate a default language translation file for you behind the scenes.

You can then automate translations to other languages by using our API to fetch your translation files, send them to your translation provider (e.g. Transifex), and programmatically bring translations back into Knock.

Here’s why we shipped the t tag.

In our Translations 1.0 release we introduced the concept of Translations into Knock. Translations are JSON objects you use to define a set of translation keys (for example, “WelcomeMessage”) and the translations they map to in each locale you support (en: “Welcome to Knock”, es: “Bienvenidos a Knock”). You then use our t filter to reference that translated content in your message templates.

Our first approach to Translations works great for teams that already have translations for their messages. But, as we’ve grown and seen customers bring more of their organization into Knock, we heard feedback that we needed a way to make translations more accessible for non-technical users creating content in Knock—that’s where our new t tag comes in.

t tags are now generally available for all enterprise customers. To get started, check out the documentation for Translations.

Fixes and improvements

• 👀 When a collection contains more than 10,000 records, we now correctly reflect that in the result count.
• 👀 We improved our recipient inline identify calls to accept a dictionary with just an id in it, rather than requiring an id and at least one property before it was identified.
• 👀 We rolled out our new code editor everywhere in the UI.
• 🐛 We fixed an issue where our pagination controls would show 0 instead of a result count.
• 🐛 We fixed an issue where our markdown validation was overly strict and did not allow for some valid HTML elements and attributes.

Today we’re launching two enhancements to our template editing experience: typeahead autocomplete and a rich text formatting toolbar. These improvements make it easier to write markdown and liquid within our template editor.

First, autocomplete. Now all of the variables available in your workflow run scope, including trigger data, user properties, and more, are available to you in a typeahead autocomplete experience. We’ve also included all of Liquid’s available filters, so you can easily find the right tool to work with your template data.

Next, we added a new formatting toolbar to apply styling to your markdown templates using a familiar rich text editing interface. This means that whether or not you're familiar with markdown, you'll still be able to author rich text content within the Knock template editor.

Fixes and improvements

• 👀 We overhauled our preferences documentation and introduced a new preferences section into the documentation to better explain the different portions of preferences within Knock
• 🐛 We updated the version of the WhatsApp API from v14 to v19
• 🐛 We fixed an issue where app_name and app_url were not being exposed under the "Settings > Variables" section of the dashboard
• 🐛 We fixed the useAuthenticatedKnockClient hook in @knocklabs/react to prevent re-renders from occurring
• 🐛 We fixed a type error in our Go SDK where Messages would not work when a recipient was an object

Today we’re releasing support for directory sync within Knock. When enabled, organizations leveraging an Identity Management Platform like Okta can auto-provision, de-provision, and assign roles to users based within Knock. If you use Okta as your identity provider, you can map Okta groups to specific roles within Knock.

Directory sync is available to all customers on our enterprise plan. Read our documentation to learn more about using directory sync, and reach out here to learn more about our enterprise offering.

Send push notifications with OneSignal

We’re thrilled to announce that we now support OneSignal as a push notification provider. You can now send push notifications via OneSignal while continuing to orchestrate your multi-channel notifications with Knock.

To set up OneSignal as a provider in Knock, check out our documentation.

Fixes and improvements

• 🐛 We fixed an issue with our Node SDK where sending a query parameter as undefined would pass it through to the request.
• 👀 When you create an account in Knock, we now create two default variables for you for app_url and app_name.

Today we’re adding the ability to set workflow trigger conditions on any trigger step. Previously to stop a workflow from executing, you needed to use a branch step at the start of your workflow with no channel steps in the branch. Now using trigger step conditions, you can halt a workflow from executing before any steps run.

This is especially helpful in cases where you have a high volume event stream that you’d like to point at a Knock workflow and then use a trigger condition to select when the workflow should actually run. As an example, you could have an account-balance-updated event connected to a workflow, with a trigger condition to only run the workflow when the account balance goes under five dollars.

You can access trigger step conditions by selecting any trigger step in the workflow builder or using the conditions object in your workflow definition in our management API.

Fixes and improvements

• 🐛 We fixed an issue with our React Native SDK that incorrectly referenced document when instantiating a feed
• 🐛 We fixed an issue with our JS client SDK where extra event listeners could be created when auto-managing sockets is enabled
• 🐛 We fixed an issue where a deleted schedule could leave ghost schedules running

Today we are releasing v1.0 of our Mobile SDKs. Our mobile SDKs wrap Knock’s client APIs and provide powerful abstractions for setting up push notifications and building in-app notification experiences.

Here is what we’re shipping today:

• Native support & cross-platform libraries: Available for iOS (Swift), Android (Kotlin), React Native, and Flutter.
• Streamlined push notifications: We’ve done the schlep work for you: setup is as simple as adding a few lines of code.
• In-app notifications: Methods for fetching, displaying, and managing in-app notifications, along with the ability to connect to our real-time infrastructure.
• User preferences: A preferences API and SDK methods make it easy to manage notification preferences within apps, allowing users to customize notification settings.

You can read about all of our SDKs in our documentation.

Fixes and improvements

• 👀 We renamed the "Defaults" option in the developers menu in the dashboard to be "Preferences"
• 👀 We added React 16 support to our React SDK and improved the bundle size by removing excess dependencies
• 🐛 We fixed an issue with our React SDK where event listeners were not being cleaned up
• 🐛 We fixed an issue with switching environments when setting preference environment defaults that would cause the editor to not be updated
• 🐛 We fixed an issue with our preference setting endpoints where having null preferences could cause updates to fail
• 🐛 We fixed an issue with some message webhooks types that would cause them to fail to register

Today we’re expanding the capabilities of our commit system to include the ability to revert a specific commit. Reverting a commit makes it easy to undo a set of changes you already committed.

Previously when using the Knock commit system, there was no way to reverse a change that had been committed. With revert commits, you can reverse a change directly in the dashboard.

Read more about commits in the docs.

You can also check out this video to see how you can revert a commit from the dashboard.

Fixes and improvements

• 🐛 We fixed an issue where skipped message statuses were not always evaluated correctly.
• 🐛 We fixed an issue where channel data set on a tenant would be incorrectly exposed in the variable pane.
• 🐛 We fixed an issue where system properties like phone_number were not able to be modified when used as preview data on a workflow.
• 🐛 We fixed an issue where our Slack auth API would return a 500 without returning a descriptive error.

In workflow run logs, you can now see the exact preference set that was evaluated during that workflow run. Previously, this information was not surfaced.

Beyond the new preferences section, you can find some additional changes to this section of the dashboard:

• The overview section of a workflow run log now shows workflow run ID, which is useful for debugging.
• All data about the trigger step is now nested under “trigger” in the workflow run log.
• We added a refetch button if you need to reload a workflow run log. Previously you needed to reload the entire page.
• If your workflow has a delay step, the status is updated in real time, indicating when the step has been completed.

Fixes and improvements

• 👀 We added support for side loading preferences when listing users and objects via the API.
• 👀 We added support for the sum filter in liquid.
• 👀 We added support for filtering subscribers of objects by recipients and for filtering the subscriptions of a recipient by objects.
• 👀 We now show your account name and icon in mobile push previews.
• 👀 We removed variable management from the developers section. It is now only located under settings.

We're excited to announce our newest addition to the Knock workflow engine: send windows.

With send windows, you can tell any channel step in your workflow when it should execute and send a message to your customers. For example, if you want to ensure your customers only receive a given transactional email from your product during working hours, you can set its send window for Monday to Friday, between 9:00 a.m. and 6:00 p.m. local user time.

At Knock our mission is to provide engineering and product teams with tooling that helps them build more thoughtful notification experiences for their users, and send windows is a big step forward towards that vision.

Learn more about send windows in our docs.

Fixes and improvements

• 👀 We added "Reset all uncommitted changes" to email layouts, translations, and event action mappings.
• 👀 We now return an error if the Content-Type header is missing from PUT, POST, PATCH, and DELETE API requests with a body.
• 👀 We moved the account settings page to be a separate page from the rest of the dashboard and refreshed the design.
• 🐛 We fixed an issue where pagination within the subscriptions view in the dashboard may have led to no results being returned when clicking "Next".
• 🐛 We fixed an issue where archived sources were still displaying their events within the event selector on a workflow.

Behind the scenes, SlackKit:

• manages your OAuth connection and tokens.
• helps your customers select which channels they want to receive notifications in.
• integrates seamlessly with the rest of Knock, so you can easily send notifications to Slack alongside any other channel.

Shipping a Slack integration has never been easier.

Read the full announcement ->

Today we’re adding support for sending message delivery and engagement data to Heap—a digital insights platform to analyze customer engagement.

This release adds Heap alongside our existing Segment integration as a way to get data out of Knock for analyzing notification usage and engagement.

Note, to correctly analyze custom events in Heap, follow these steps to build new events.

Learn more about our Heap extension in our docs.

Fixes and improvements

• 👀 We improved the way that event payload data shows in the variable pane.
• 👀 We added a new onAuthenticationComplete handler to our SlackAuthButton component in the React SDK.
• 🐛 We fixed an issue with filtering workflows in the workflow run logs view.
• 🐛 We fixed an issue where calling the set tenant API with an invalid payload would return a 500.
• 🐛 We fixed an issue where the workflow template gallery in the dashboard would load in an incorrect initial state.
• 🐛 We fixed an issue where you could pass [null] as valid tokens when setting channel data for push channels.

We've added a new way to navigate across the Knock dashboard and perform common actions through our new command menu. The command menu gives you a quick and easy way to:

• Search and navigate to a particular workflow
• Switch between your Knock environments
• Search for a user using their id or email
• Quick copy your API keys
• ... and much more!

You can get started using the command menu in the dashboard by clicking the new "Search" link in the sidebar, or for all those keyboard shortcut lovers, by typing cmd+k.

Fixes and improvements

• 👀 We added a new "Promote" button to the view commit modal to promote the commit to the next environment.
• 🐛 We fixed an issue where using an event type trigger for a workflow would not default the data section in the variable pane.
• 🐛 We fixed a regression in our Node SDK where the remove subscriptions objects method would fail.

Today we’re extending support for reporting notification metrics to New Relic. Previously, we only supported Datadog as an observability platform, but with today’s release, we’re introducing support for reporting metrics to New Relic as well.

You can read more in the documentation about the types of metrics reported. Our New Relic extension is available to customers on our Enterprise plan only.

New outbound webhook event types

Today we're announcing support for new types of events in outbound webhooks, making it even easier to deeply integrate Knock into your application's workflow. With today's release, you can now listen to changes for any version-controlled content within your Knock dashboard, including workflows, email layouts, and translations.

You can find the full set of supported webhook events in the documentation and can create a webhook by going to the "Developers > Webhooks" section in the Knock dashboard.

Fixes and improvements

• 👀 We greatly improved the bundle size in our @knocklabs/react package by removing the dependency on the date-fns library.

Today we’re shipping our new Flutter SDK, which is a client-side SDK written in Dart to interact with the Knock API and to build in-app notification experiences in Flutter applications.

We have big plans for more in-product experiences that we’ll be bundling into this SDK in the near future. Today’s release is a first step towards that future, giving the base primitives to easily bring all of the functionality of Knock into your applications in an easy-to-consume way.

You can learn more in our Flutter SDK documentation.

Fixes and improvements

• 👀 We added a link to view usage for Enterprise customers under the "Billing" page
• 👀 We redesigned the empty states across the dashboard
• 🐛 We fixed an issue where our Vonage integration would fail when sending multi-part messages

Today we’re releasing a big upgrade to the version control experience in Knock with commit diffs.

With this release, you can now:

• View a commit to see what has changed between that commit and the prior version of the workflow.
• Review a diff when promoting a commit to an environment. You will see the diff between the current state of that environment and the pending commit.
• Audit the full history of commit diffs in your commit log to know exactly what's changed over time.

Read the full announcement here —>

Today, we’re shipping our new Android SDK, which is a client-side SDK written in Kotlin to interact with the Knock API and to build in-app notification experiences in Android applications.

We have big plans for more in-product experiences that we’ll be bundling into this SDK in the near future. Today’s release is a first step towards that future, giving the base primitives to easily bring all of the functionality of Knock into your applications in an easy-to-consume way.

You can learn more in our Android SDK Documentation, or get started now by following the installation instructions.

Fixes and improvements

• 👀 We added support for edge runtimes, like Vercel and Cloudflare Workers, in our Node JS SDK
• 👀 We now show a channel data tab when viewing an individual tenant in the dashboard

Today, we’re shipping our new React SDK (@knocklabs/react), which provides a unified set of hooks and components for integrating Knock into your web applications. You can use our React package to power in-app notification experiences like feeds, toasts, and banners for your users, as well as powering notification configuration via our preferences API.

Our new SDK is the home of all in-product notification experiences powered by Knock, superseding the previous react-notification-feed package. If you’re using the old package, you can read here on how to migrate.

We have big plans for more in-product experiences that we’ll be bundling into this package in the near future. Today’s release is a first step towards that future, giving the base primitives to easily bring all of the functionality of Knock into your applications in an easy-to-consume way.

You can install the React SDK from NPM by running npm install @knocklabs/react and can find the package in our brand new Javascript monorepo.

Fixes and improvements

• 👀 We improved the loading time of message views within the Dashboard
• 👀 We now validate certificates when configuring an APNS channel
• 👀 We now validate the service account JSON when configuring a FCM channel

Earlier this year we released the ability to run recurring workflows for your users via our Schedules API. Today, we're releasing an extension to our schedules API with the ability to schedule a single workflow run in the future for one or more recipients. One-off schedules are perfect to enqueue a workflow that should be run at some future point, without you needing to write your own cron jobs to do so.

Here's an example of creating a one-off schedule for a set of recipients:

await knock.workflows.createSchedules("park-alert", {
  recipients: ["jhammond", "esattler", "dnedry"],
  scheduled_at: "2023-12-25 12:00:00Z"
  data: { type: "dinosaurs-loose" },
  tenant: "jpark",
});

You can learn more about running one-off or recurring schedules in the documentation.

Customize the response of the in-app feed

Today, we’re launching additional privacy controls for our in-app feed API. Previously, when your recipient’s in-app feeds were requested, the response would include the full recipient object, which could lead to personal data about your recipient being returned unnecessarily.

With today's release, you can now use allow or deny lists to control which fields are returned from any entity in your feed request. Here's an example in-app feed response filter:

{
  "actor": {
    "only": ["id"]
  },
  "data": {
    "except": ["credit_card_last4"]
  }
}

Read more in the documentation.

Fixes and improvements

• 🐛 We fixed an issue where clicking links in a message preview could crash the dashboard
• 🐛 We fixed an issue where using tenants as a recipient in a workflow trigger would stop workflow runs from showing

You can now use the Knock CLI to promote individual commits. This was previously available in the dashboard, and today we're bringing it to the CLI. With this addition, it makes it easy to build specific deployement workflows that only promotes the resources you need.

Individual commit promotion is available now in the latest version of the CLI (v0.1.7) and is available across all plans. You can read more in the documentation.

Fixes and improvements

• 👀 You can now go directly to the workflow editor from the workflows page using the 3-dot menu
• 👀 You can now use cmd+return in the preview data editor to save the data and close the modal
• 🐛 We fixed an issue where the update schedules endpoint was missing schema validation for an empty properties object
• 🐛 We fixed an issue where breadcrumbs didn't load properly on our docs site
• 🐛 We fixed a few tooltip and text display issues in the Dashboard

With the introduction of our CLI and management API earlier this year, we added support for working with both workflows and translations locally. Now, we've added support for managing email layouts via the CLI and management API, making it possible to pull down your email layouts locally, make changes to those layouts, and push them back up to Knock to be deployed.

Working with email layouts is available now in the latest version of the CLI (v0.1.x) and is available across all plans. You can read more in the documentation.

Control the number of items rendered in a batch template

While our batch function has always allowed an unlimited number of items to be accumulated per-batch, the number of items that could be rendered in a template from that batch has always been limited to the first or last 10 items. Today, we're adding a new setting into our batch function to control the number of items that can be rendered, with the ability to render up-to 100 items.

Batch render limits are available now on our Enterprise plan only. You can read more in the documentation, or contact our sales team today to arrange a demo.

Fixes and improvements

• 👀 We now highlight the "Developers > Logs" menu item when viewing workflow runs
• 👀 All new accounts now have an in-app feed channel setup by default
• 🐛 We fixed a bug where in certain cases hourly schedules would not repeat

We've expanded the scope of our user deletion endpoint. Now we permanently delete all content associated with a user upon receiving a deletion request. This means that Knock user deletion is now fully GDPR-compliant and can be used to programmatically process right to be forgotten requests. Previously we had supported these requests in an ad-hoc way through our customer support, but with this change you can now programmatically call the user delete or bulk delete APIs and have all content for a user permanently removed.

You can learn more in our user deletion documentation ->

Bypass recipient preference evaluation

We've introduced a per-workflow control to bypass recipient preferences. This is useful in situations where you need to force a critical notification through to a recipient (such as a password reset email) regardless of that recipient's channel preferences.

You can find the new preference control under "Manage workflow" in the workflow three-dot menu. You can learn more in the preferences documentation.

Fixes and improvements

• 👀 We changed the admin role to be able to create and manage environments
• 👀 We changed our combobox behavior for selecting recipients and actors to load a page of data to aid with selection
• 👀 We added support for per-customer overrides for idempotency windows
• 🐛 We fixed an issue where the workflow category selector was case sensitive
• 🐛 We fixed an issue where the knock.messages.delivered metric was not being sent to Datadog

Today we're releasing a new way to close your notification batches, by setting a maximum number of items allowed. This means a batch can now close either temporally (when the batch window ends), or when a certain number of items have been accumulated, giving you even more flexibility on how you batch your notifications.

You can set a maximum batch item limit under the batch step settings. Read more in the documentation.

Fixes and improvements

• 👀 We added a new bulk add subscriptions API endpoint
• 👀 We changed the behavior of our recipient preferences set endpoints to create empty recipient's when setting preferences for new recipients instead of 404-ing
• 👀 We increased the limit on all of our bulk operation endpoints from 100 to 1000 items at a time
• 👀 We added support for the Mailtrap email testing API
• 👀 We added an email field to our docs feedback component
• 👀 We now expose subscription information under a recipient when triggering a workflow from a subscription
• 🐛 We fixed an issue where you could not manage subscriptions under a tenant object
• 🐛 We fixed an issue where some email clients would not report tracking information correctly
• 🐛 We fixed an issue with our batch steps where in certain cases, using a sliding batch window could extend to the maximum batch duration
• 🐛 We fixed an issue where using the CLI to push translations with no changes would result in uncommitted changes being generated
• 🐛 We fixed an issue where webhooks were not being properly created via the Dashboard
• 🐛 We fixed an issue where long variable names would break the layout in the variable pane

With this release we’ve rebuilt the Knock workflow builder from the ground up to support:

• If-else and multi-branch workflows. Use our branch function to create if-else and multi-path messaging workflows.
• An improved user experience. It’s now easier to drag-and-drop steps into the canvas and reorder steps. We’ve also shipped pan-and-zoom controls for moving around the canvas.
• Even better workflow debugging. With our new branch step, we’ve updated our debugger so you can easily see which branch executed in a given workflow.

Read the full announcement here —>

When working with Segment or a similar integration source in Knock, previously all the configuration would take place in the Sources pages. We've now added the ability to add and change your event triggers directly in the workflow builder. There's a toggle from API to Event in the trigger step that will open the event trigger pane where you can add an event, edit its field mappings, and commit it alongside your workflow.

Run workflow tests with event data

You can now test your event-driven workflows directly from Knock! Rather than sending a test event from one of your integration sources, the workflow test runner will automatically pull in the latest event received for you to run rehearsals of a workflow powered by events. This helps you fine tune your mappings and make sure you're getting all the necessary data for your notifications without switching between applications.

Improved event logging

Previously, our event logging was too strict - instead of logging malformed events coming into Knock, our system would drop them, making it hard to know what was wrong. Now we're logging every event, whether it's valid or not. If it's already triggering a workflow, we'll let you know why it did or didn't work. We've also added logs for our test events so that after every run you'll get the same detailed feedback about what's missing or malformed in your event.

Both of these improvements decrease the amount of time you spend tracking down missing data and gets your event-driven workflows into production faster.

Fixes and improvements

• 🐛 We fixed a bug in preference conditions where not_contains wasn't recognizing null as a truthy value
• 🐛 We fixed a bug where reset uncommitted changes was enabled even if there were no commits
• 🐛 We fixed a bug where we were sending duplicate invoices
• 🐛 We fixed a bug where updating workflow categories were hidden under the modal
• 🐛 We fixed some bugs around usernames, they can now be nullable and they will not replace existing usernames on login
• 🐛 We fixed a bug where you couldn't add a condition in channel configuration
• 👀 The E keybinding for opening a template now works in read-only environments
• 👀 We've added a cancel workflow run button in workflow run debugger

Previously when you used a fetch step in a workflow, there was no way to keep track of the properties in the returned payload when building your notification workflows. You would have to memorize the data to use it.

We've shipped a big improvement that eliminates this pain point: we're now storing the fetched data in the workflow variable pane. The variable pane is available in every step of your workflow, so it's now easy to know which variables you can reference as you're building your workflows and message templates. If you have multiple fetch steps in your workflow you'll see a section in the variable pane for each step.

Mailtrap integration

We now support Mailtrap as an email provider within Knock!

If you are currently using Mailtrap to test and send emails, you can now configure a new email channel with Mailtrap in Knock and start using it in your workflows.

Learn more in the docs →

Fixes and improvements

• 🐛 We fixed a bug where customers on our legacy plans weren't able to self-service downgrade
• 🐛 We fixed a bug where tenants weren't able to be inline-identified
• 🐛 We fixed a bug where users weren't able to open the template gallery
• 👀 Cancellation keys are now shown in the workflow run log page

While it's been possible to use Knock to send notifications to non-user recipients for some time, if you wanted to run a test of the workflow to a non-user recipient you needed to use the API, adding a small amount of friction to the process.

Today we're shipping support for running workflow test runs for any of the objects you have set in your Knock environment, from the test runner in the dashboard and via the CLI. This makes it fast and easy to test sending notifications to your object recipients and makes it possible to easily test recipient subscriptions without needing to call the API.

Test runner support for object recipients is available today across all plans and in the CLI as of version v0.1.4.

Fixes and improvements

• 👀 We added the ability to set a maximum duration on a sliding batch window

Today we're launching our new throttle function. With the throttle function, you can limit the number of times a workflow is executed for a recipient within a given window of time, making it trivial to build sophisticated notification alerting workflows that don't spam your users.

Previously if you wanted to throttle the execution of a workflow for a recipient, you would need to keep the logic in your application and control the number of times that your Knock workflow trigger is executed. This means keeping track of the sent notification state and potentially adding additional infrastructure to support this complexity. Now, with the throttle function, you can safely invoke your Knock workflow and know that Knock will apply the throttle controls for you to limit the execution of a workflow for a recipient over the window of time that you specify.

For example, with the throttle function, you can say "execute this workflow at most once per day for each recipient" and safely trigger the Knock workflow any number of times in that window, knowing that if it has already been executed in the window that Knock will terminate the workflow run for you.

Our throttle function is available today across all of our plans. You can read more in the documentation or contact our sales team to see a demo.

Today we're launching our new analytics data warehouse integration. With this integration you can bring the clean, normalized data Knock produces for your cross-channel notifications into your data warehouse to analyze alongside the rest of your product data. With this connector we support data exports to Snowflake, BigQuery, Redshift, and a number of other destinations.

Previously we had offered a Segment integration to stream the normalized notification analytics data into downstream destinations, including a data warehouse. Now with our new data warehouse analytics sync you can configure a data warehouse connection in Knock and we'll start streaming our normalized cross-channel notifications analytics data directly into your data warehouse, so you can analyze it alongside the rest of your data.

Our data warehouse sync is available today on our enterprise plan. You can read more in the documentation or contact our sales team to see a demo.

Fixes and improvements

• 🐛 We fixed an edge case where unsetting channel data could end up marking a recipient's updated_at timestamp as null.
• 🐛 We fixed an issue where sending a malformed recipient's list to our workflow trigger endpoint would not surface a useable error.

Today we're launching a step change in your workflow run debugging experience with our new enhanced conditions debugger that surfaces the conditions we evaluated across step, channel, and preference conditions for each step in your workflow.

Previously, we showed a single log line telling you conditions were not met on step and channel evaluation, leading to a confusing user experience in understanding exactly what caused the condition to not pass. Now, with our new conditions debugger, you can get a clear picture of all of the conditions we evaluated when executing your workflow, including exactly what the variables you're referencing in the conditions evaluated to.

You can read more about the debugging conditions in the documentation.

Sliding batch window support

We've added support for sliding windows in our batch function. Previously, when a batch was opened the window for which the batch was open was static, meaning that there was no way to extend the window to accumulate more items inside of the batch. Today, we've added a new "sliding" feature on our batch windows so that any new activities that are added to the batch will extend the window that the batch is open by recomputing the batch window.

You can read more about sliding batch windows in the documentation.

Fixes and improvements

• 👀 We added a new contains_all operator to complement our existing contains conditions operator.
• 🐛 We fixed an edge case with our user and object upsert API where overriding a null property with an object would cause an API 500.
• 🐛 We fixed an issue where \n characters could cause an issue with push templates.
• 🐛 We fixed a regression where syntax highlighting was broken in our code editor.

Today we're launching our Knock Swift SDK, which you can use to build in-app notification experiences in iOS, macOS, and watchOS. Our Swift SDK makes it easy to interface with the Knock in-app feed, wrapping up all of the real-time socket and API querying behavior for you into an easy-to-use package.

The Swift SDK also supports:

• Getting and setting push token information via channel data.
• Working with user preferences to build in-app preference centers.
• Updating message engagement statuses to track push notification opens and taps.
• ... And much more!

You can install the SDK from Swift Package Manager, Cocoapods, or Carthage. There's also comprehensive documentation and an example iOS app to get you started.

We added support for date filtering for all log views in the dashboard, making it easy to find logs that happened on or around a particular date. Finding particular logs is now trivial, which is especially useful when debugging in high-log volume environments.

The new date filter is available now in all log views and across all plans. Please note: you will only be able to retrieve logs in congruence with your plan's retention policy.

Fixes and improvements

• 👀 When a workflow is triggered from a subscription, we now include the subscription properties under the recipient.subscription namespace in the workflow run scope (docs).
• 👀 We added support for the pap-AW locale.

You can now test run your workflows as you're building them, all from the Knock CLI. As you make and push changes, you can use the new workflow run command to trigger a workflow for to up to 5 recipients at a time, enabling quick iterations of your notifications. See how to make these calls in our CLI docs.

Add a signing key to fetch steps and webhooks

We’re improving the security of our fetch step and HTTP webhooks by introducing request signing. Request signing allows a secret to be shared between Knock and your service so that you can verify that a request has come from Knock. Learn more about enabling this for your workflows.

Fixes and improvements

• 👀 We improved the performance of loading event and action logs
• 👀 We increased the granularity of error messages in the debugger
• 👀 We added a dropdown to navigate between object collections in the dashboard
• 👀 We now show workflow runs tab on users, objects and tenant pages
• 👀 You can now filter tenants by name and ID, and we also show the tenant ID and name in workflow runs that include a tenant
• 👀 When you create a workflow, it is now initially now set to active
• 👀 We made performance and ergonomic improvements to all places that have a user searchbox
• 👀 You can now edit your data payload as JSON in the workflow template builder
• 👀 You can delete variables at the environment level
• 🐛 We fixed a bug where owners of newly created accounts couldn't create new environments
• 🐛 We fixed a bug in which were treating a batch step skip with a conditions_not_met code as an error in our instrumentation code when in fact it is valid
• 🐛 We fixed an edge case where a recipient's timezone property doesn't contain a valid timezone
• 🐛 We fixed an issue where batched workflows that used the same cancellation key weren't being fully canceled
• 🐛 We now prevent tenant and current_message variables from being extracted from templates into the variable pane when editing a template
• 🐛 We added better support for when using assign in liquid templates
• 🐛 We fixed a bug where when switching environments on a translation page the translation wouldn't be found
• 🐛 We fixed a bug that didn't properly use the scheduled_at date for creating and updating schedules
• 🐛 We fixed a bug where long condition names would prevent seeing the "..." menu in the workflow builder
• 🐛 We fixed race condition when scheduling a workflow's next occurrence
• 🐛 We fixed an issue with cloning a workflow where adding variable properties would error during editing
• 🐛 We fixed a bug where users couldn't edit Knock-managed environments
• 🐛 We removed the ability to set a delivered condition on push steps since those aren't supported events for push
• 🐛 We fixed a bug where the batch_key wouldn't be saved in the workflow builder

HTTP Source

HTTP Source lets you trigger your multi-channel notifications from any source that can stream events into Knock. This includes dedicated streaming infrastructure, such as Kafka and Kinesis, as well as any product that can stream events and webhooks (think Supabase functions and Radar location-based events.)

This means you can power Knock with even more parts of your infrastructure to send notifications that are relevant for your customers.

Read the announcement —>

CLI and management API

Now developers can work with Knock resources in code, and automate pushing that code back into Knock to run on our platform. Read our docs to learn how you can scale notifications on Knock while managing our system from your CI/CD environment.

The Knock CLI and management API release is a big step forward for both Knock’s developer experience and for what you can build on top of our platform.

Read the announcement —>

Schedules API

Schedules API is a declarative, code-first way to build recurring notification schedules and to give your users the ability to control when they receive those notifications. We also introduce timezone aware sending with this release, making it even easier to send the right notification at the right time with Knock.

Read the announcement —>

Webhook channel

Webhook channels bring a new level of flexibility and extensibility to Knock’s output layer. You can use webhook channels to notify internal service within your application, or 3rd-party apps such as PagerDuty or Zapier.

The best part of webhook channels is they tie into Knock’s preferences model, so you can surface them to your customers.

Read the announcement —>

Subscriptions API

With subscriptions, you can model lists of users, then notify all users in that list with a single API call.

Subscriptions are a powerful way for you to offload to Knock the responsibility of who should be notified. You can use subscriptions to power alerting use cases and publish/subscribe models, or to model the concept of a set of dynamic followers of a resource.

Read the announcement —>

Knock now supports idempotency so that requests can be retried safely without unintended side effects. This release of idempotency is limited to our workflow trigger endpoint. You can know set an idempotency key on your workflow triggers to ensure that Knock doesn't sent duplicate notifications when you retry requests. You can learn more about API idempotency in Knock in our API reference.

We're powering idempotency in Knock with our new open-source Elixir library for powering idempotency on any API. We're calling it One and Done. 😎 You can learn more about how our One and Done library in our announcement blog post.

Notification localization (i18n) support

In case you missed it last week, we just launched Knock Translations, our solution for teams that need to localize their notifications for a global audience. You can learn more in our announcement post.

Angular in-app feed component

One of our customers wrote a great Angular example of our React in-app feed component. You can find it here. If you're a team that uses Angular and wants to ship an in-app feed in a few minutes, this is a great way to do so. Shoutout to Knock customer and community member Chris Graves for this one!

Fixes and improvements

• 🐛 We fixed a bug in our conditions builder where conditions with empty values could not be created.
• 🐛 We fixed a bug in our fetch step where successful requests that resulted in an empty response would show an error status in the Knock dashboard.
• 🐛 We fixed a bug where our rate limits were too specifically scoped.

Our customers use the variable preview pane to understand which variables a workflow uses in its templates, and to update the values of those variables for use in template previews. Previously, this was managed through a point and click interface, which made it difficult to work with structured data such as lists and objects.

Our new and improved preview data editor lets you work with JSON directly. This means you can copy-paste a sample event payload into the editor and immediately see how it will render in your template. We also handle nested data structures to make it easier to navigate through the lists and objects you're working with in your workflow trigger payloads.

Improved layout management

You can now rename, duplicate, and archive the layouts you create in Knock. This enables teams to clean legacy layouts out of Knock and makes it easier to understand which layouts are in active use within the account.

Configure email providers with JSON overrides

You can now configure your email channels in Knock to always pass through JSON data in the requests Knock makes to that channel. As an example, if you're using SendGrid as your email provider and you want to pass through an email_category to SendGrid, you can configure a JSON override on your channel config. These channel overrides support liquid so you can dynamically set this value based on workflow run state if you prefer. See the example below.

{
  "custom_args": {
    "email_category": "{{ notificationType | default: "TRANSACTIONAL" }}"
  }
}

You can learn more about configuring channels and JSON provider overrides in our docs.

Secret account and environment variables

You can now set your account and environment variables as secrets within Knock. A secret variable is one that will be obfuscated within the Knock dashboard once created. This is helpful for cases where you want to use secret keys as Knock environment variables, e.g. to make calls to downstream systems using the Knock fetch step.

When you're creating a variable, just enable "Set as secret variable".

Fixes and improvements

• 👀 You can now pass a comma-separated list of email addresses to the cc and bcc fields on your email channel configurations.
• 🐛 We fixed an issue where events coming from sources such as Segment or Rudderstack that had properties with empty lists ([]) may fail to sync.
• 🐛 We fixed a bug in our preferences set code that would prevent certain nested preferences from overriding previously set preferences for workflows and categories.
• 🐛 We fixed an issue where creating a new environment could lead to some channel configuration not being set for in-app feeds.

This week we've shipped a major update to message status conditions in the workflow editor. While we have long supported workflow step conditions that evaluate against the status of a preceding notification message, we only ever provided a small set of condition cases.

With this update, we've expanded the set of condition cases available to cover all possible message delivery and engagement statuses. Also included are some validation helpers that will warn you if we detect you've designed a condition that will never evaluate successfully.

This is a fully backwards compatible update—all of your existing message status conditions will continue working as you've come to expect. We're excited about how this update will unlock more powerful, composable control flow for your workflows, especially in combination with Knock open and link tracking.

For more details, visit our message status conditions docs or our general guide on Knock conditions.

Enhanced security mode configuration and user token signing helpers

We're excited to share a couple of developer experience improvements to API security at Knock.

Since the beginning, Knock has required that you include a signed user token in requests to your production environment that use a public API key. Now, you can configure this requirement on a per environment basis. We call this "enhanced security mode", and when enabled we will require those signed user tokens. Existing production environments still have enhanced security mode enabled by default.

We've also made it easier to work with those signed user tokens. When you generate a shared signing key in the Knock Dashboard, we now present the key in base-64 format by default. This can be easier to use within single-line environment variables. The PEM-encoded format is also still available.

The Knock Node SDK now includes a convenience method, Knock.signUserToken(), that will automatically use the KNOCK_SIGNING_KEY environment variable in either base-64 or PEM format to securely sign user IDs for use in your client applications.

Lastly, we've updated our security and authentication guide with more helpful notes on how to work with enhanced security mode.

Head over to the "Developers > API keys" page in the Knock Dashboard to take a look.

Fixes and improvements

• 👀 From the workflows list, you can now open a workflow in a new browser tab by cmd + <click>-ing it.
• 👀 We shipped a small redesign to the "Integrations > Extensions" management page.
• 👀 Users with the support role can now access the Knock analytics page.
• 👀 We added some truncation for lengthy ID and key values across the Knock dashboard.
• 👀 When setting channel data for a user or object, we now validate that the shape of the channel data you send us is valid for the target channel type.
• 👀 Within the workflow builder, you can override channel-level Knock tracking config defaults for specific workflow steps. Now, we've added a button that lets you reset your overrides so that your step once again inherits from channel-level defaults.
• 🐛 We fixed a bug that prevented you from creating a workflow with more than 10 channel steps. You can now create workflows with any number of channel steps.
• 🐛 We fixed a bug where we wouldn't display environment default preferences in the Knock dashboard after first creating them.
• 🐛 We fixed some bugs with user invites where duplicate users would exist after a new user accepted an invite and signed up to join a Knock account.
• 🐛 We fixed a bug where non-visible Liquid statements (e.g. {% if %}) would result in extra, empty <p> tags when rendering a Markdown template into HTML.
• 🐛 We fixed a bug where you couldn't set an empty connections list for the channel data for a chat channel for a user or object.

We're happy to announce that we've added support for object subscriptions to Knock. Object subscriptions make it easy for you to create and manage lists of recipients and trigger notification workflows to all recipients who are subscribed to that list, all from a single API call.

You can use object subscriptions to build pub/sub or alerting features on top of Knock, without the need to manage who should be notified and let Knock handle the efficient fan out of sending notifications to thousands of users simultaneously.

// Create an object to subscribe recipients to
await knock.objects.set("project_alerts", project.id, {
  name: project.name,
});

// Subscribe one or more users to the alerts
await knock.objects.addSubscriptions("project_alerts", project.id, {
  recipients: ["esattler", "dnedry"],
});

// Trigger a workflow to all recipients subscribed
await knock.workflows.trigger("alerts", {
  recipients: [{ collection: "project_alerts", id: project.id }],
});

For more details, visit the Object subscriptions docs.

Analyze your notification event data in downstream tools with our Segment extension (beta)

We're excited to announce that our new Segment extension is now in beta. In just a few clicks you can start sending all of the events associated with the notifications being sent through Knock – clicks, opens, and delivery events – to over 350 destinations available in Segment.

For more details, visit the Segment extension docs. The Segment extension is available on the Growth and Enterprise plans. You can receive beta access by contacting us at support@knock.app.

Fixes and improvements

• 👀 We've changed our preferences API so default preferences will always be merged into the preferences shown in the dashboard and via the API for both users and objects
• 👀 We've extended our support role to include viewing read-only workflows, logs, and workflow runs across all environments
• 👀 You can now press "cmd + k" to access the search bar on our docs
• 🐛 We fixed an issue where our user typeahead wouldn't allow you to select a user where there multiple users with the same emails
• 🐛 We fixed a bug where specifying a sort order on a batch step would not sort the activities in the same order on the /v1/messages/:id/activities API
• 🐛 We fixed an issue where a malformed piece of JSON in a preview variable could cause the app to crash
• 🐛 We fixed a small bug where creating a new email layout would not show up under the "Manage template settings" when selecting a custom layout

We're super excited to announce that we now support Resend as an email provider with Knock. Now you can send great-looking emails through Resend's email API, while orchestrating your multi-channel notifications with Knock.

We're a big fan of the Resend team and of modern developer tooling in general, so we're excited to be able to extend their API to Knock customers everywhere. Happy (re)sending!

Read more in our docs

An improved user search component: find by ID or email

This improvement is a long time coming. We've improved our user search component in a big way. Now when you're in the Knock test runner, you can search for recipients and actors by either their user ID or their email. This makes it much easier to quickly find the recipient you're looking for and send them a test notification.

We've updated all of our other user search experiences (across messages, logs, and workflow runs) to use this new behavior, too. This makes it easier for your support team to quickly find the Knock logs associated with a particular user.

New and improved template editor design

We've added some visual polish to our template editor. It helps with general spacing and readability. We've also added new breadcrumbs to the template editor to make it easier to see where you are in Knock and to quickly return to your workflow canvas.

New undelivered status with outbound webhook support

Our outbound webhooks are a popular way for our customers to stay updated on what's happening in their Knock system and to trigger behavior in their own application based on Knock events.

Previously our message.undelivered webhook would fire with each delivery attempt we made to your downstream notification providers. Now we have two separate webhooks, one for our delivery attempts to your providers (message.delivery_attempted) and one for when delivery has failed and no more attempts will be made (message.undelivered).

This makes it easier to trigger behavior in your application based on undelivered notifications.

Fixes and improvements

• 👀 We've added a workflow tag to our datadog metrics
• 👀 We've made some performance improvements to our analytics views in the Knock dashboard
• 👀 We improved our error messaging when sending a null, undefined, or empty API key into Knock
• 🐛 We fixed an issue where email fields with liquid would fail on downstream providers when resolving to an empty string
• 🐛 We fixed an issue where conditions with arguments that resolved to strings containing periods could cause errors when evaluating some conditions

Today we're announcing that all Knock customers can use the customer data controls we first announced as part of Knock HIPAA compliance. With this release, you can obfuscate customer data within the Knock dashboard while still giving your team the ability to debug your notification system as needed. These controls can be enabled on a per-environment basis, enabling you to secure customer data in production while continuing to work the way you want in your internal-only development environments.

One of our foundational product principles at Knock is developer visibility. We want you to be able to observe the Knock notification system and debug potential issues, just as you would with an in-house notification system. But with great visibility comes great responsibility. With this release, you can continue to debug your notification system with the confidence that your customers' production data is protected, even from your internal team.

You can enable customer data obfuscation by going to "Settings > Environments", and then clicking "Edit environment".

Fixes and improvements

• 👀 We added a new filters section to workflow logs to filter by request ID and status of the requests
• 👀 We improved our conditions handling for comparing null values with > and < operators so a comparison always returns false
• 🐛 We patched an issue where API logs with large lists would never appear in the API log debugger
• 🐛 We added a fix for batching where a workflow run with a batch could display as having an error, even after it has succeeded
• 🐛 We fixed an issue where default preference sets could incorrectly return the wrong preferences when a tenant was specified but there was no corresponding user-tenant preference set.

Most notification feeds share a common set of built-in filters, usually a combination of filter by seen, read, or archival status. But as customers have used our real-time feed infrastructure to build for different use cases (such as inboxes and task centers) they've asked for the ability to introduce custom filters into the notification experiences they build with Knock. Now they can.

With today's release you can filter our feed and message endpoints by any of the data you pass to Knock in your workflow trigger payloads. This means you can introduce any type of filter into your feed experiences, whether that's by completion status (e.g. for task centers), by approver (for approval workflows), or by any other key you can think of. We're super excited about the flexibility this brings to building in-app UI with Knock and the use cases you can power using it.

This feature is now available for all customers across all of our SDKs. You can learn more in our docs. Let us know what feedback you have!

View per-user workflow runs in a single place

Knock already has multiple views into our workflow engine to help developers understand how their API calls to Knock lead to messages sent to customers. But for support and operations teams, these logs aren't always intuitive to parse when you're looking to find all the workflow runs generated for a given recipient.

Today we're launching a new workflow runs view that shows you exactly that. The workflow runs view shows you all workflow runs generated for a given workflow, so you can easily see which workflows were triggered for a given recipient and the messages that were generated as a result. This makes it even easier for everyone on your team to see into the Knock notification engine and to understand how it's messaging customers.

You can find the new workflow runs view in the workflow runs tab under a given workflow's page or under the "logs" page if you want to see all workflow runs within a given environment. You can also filter by a number of properties to find the exact workflow runs you're looking for.

Fixes and improvements

• 👀 We added an expanded version of the popover message template editor
• 🐛 We fixed a cursor display issue on our popover message template editor

Today we’re launching beta support for native link and open tracking within our email, SMS, chat, and in-app channels giving you unprecedented visibility into the cross-channel notifications you’re sending. Previously we had relied on downstream message senders to handle link and open tracking, but bringing this natively into Knock means that you’ll be able to see analytics relating to all types of messages in a single place.

For more details, visit the link and open tracking docs.

Want to sign up for the beta? Let us know.

Monitor your Knock notifications with our Datadog extension (beta)

We are proud to introduce the Knock Datadog extension! In just a few clicks, you can publish a stream of metrics straight from Knock to your Datadog account. These metrics can then power Datadog dashboards, alerts, and troubleshooting. Now it is easier than ever for teams to detect and respond to issues with misconfigured channels, expired credentials, changes in authorization, or downstream issues with Knock itself.

Although Knock engineers monitor and respond to our own suite of alarms, reports, and metrics around the clock already, the new Datadog extension offers additional peace of mind to teams with high operational or compliance requirements.

For more details, visit the Datadog extension docs.

Want to sign up for the beta? Let us know.

Fixes and improvements

• 👀 We made template previews more closely mirror what is actually delivered across SMS, chat, and in-app channels
• 🐛 We sped up queries for API and workflow logs
• 🐛 We fixed an issue where overrides could cause FCM notifications to error

Today we’re super excited to announce the beta release of Knock template localization. With template localization you can use the notification templates you already send with Knock to create locale-specific variants for users that prefer to receive their notifications in a different language. This helps meet your users where they are and improve the notification experience of your product.

Let’s say you have a welcome notification workflow that sends new users an in-app message and an email. For each of those notification templates, you can create a variant that's localized based on each recipient's locale. At runtime Knock uses the locale property on your recipient to determine which language variant of your notification should be sent. We also provide a "default" template that's used for any recipients whose locale isn't supported.

Another great thing about today’s release: though we built template variants for localization use cases, you can use your own custom logic and expressions to power any template variant use case you can dream up. For example, if you wanted to send a tenant-specific variant of a given notification template, you could power it with Knock template variants.

You can learn more about template localization in our documentation and request beta access by sending us a note at support@knock.app.

Enable auto-join for your Knock account

If you're a Knock account owner, as of today you can enable auto-join for users from your domain. A quick example: if you're the Knock admin for your company Collab.io, once you enable auto-join any verified users with a “collab.io” email address can join your account.

This is a win for admins and end users alike. If you're an admin, enabling auto-join means (i) less time spend managing account invites and (ii) a safeguard against users from your domain accidentally creating their own account when they should be working in yours. If you're an end user, it means you can get into the right account for your organization when first signing up for Knock.

You can learn more about enabling auto-join in our docs.

Fixes and improvements

• 🐛 We fixed a bug where template previews weren't honoring brand defaults.
• 🐛 We fixed a bug where activities under a message weren't paginating on the feed API.

We've expanded our workflow trigger inline identify to support setting channel data and preferences for recipients. That means it's now easier than ever to start sending notifications to your users with Knock, without the need to backfill existing data. It even works for setting data for multiple channels and for per-tenant preferences too.

Read more on setting channel data inline and setting preferences inline in our documentation.

Conditions builder improvements

We've added a whole host of new features to our step and channel conditions builder this month. You can now reference:

• Environment variables (e.g. skip this step if we're in the development environment)
• Workflow run state including total_activities and total_actors (e.g. only execute the step if we have more than one item from a batch)
• The current tenant (e.g. only batch for workspace X and never for workspace Y)
• The current workflow (e.g. only send to SMS if the workflow category includes messages)

Read more in our docs.

Fixes and improvements

• 👀 We expanded the delay block to support dynamic delays from the recipient, actor, environment and more
• 👀 We added the ability to reference the current_message.id in your notification templates to get access to the unique, recipient-specific message.id
• 👀 We moved 'Designing workflows' to its own section in the documentation
• 👀 We made improvements to our email previews to be more consistent with what's sent
• 🐛 We fixed an issue where JSON values in chat templates would not escape \n and \ characters correctly
• 🐛 We fixed a bug with mailgun delivery checks where the requests would timeout after 5+ seconds
• 🐛 We fixed an issue where some starter plans could not create a new webhook
• 🐛 We fixed a bug where blank in-app feed messages would fail to send

By popular demand, we’ve brought our condition builder to your per-environment channel configurations. Channel-level conditions are helpful when you want to add a condition to all instances of a channel in a given environment.

An example: let’s say you want to ensure that your email channel will only send notifications to recipients whose email ends in knock.app from your development and staging environments. Now you can.

We surface all channel-conditions on their relevant workflow-level steps and in the Knock debugger, so you’ll always have visibility into why a given notification is or isn’t sending.

Read more in our docs

Set batch order: first or last ten items

We’ve updated our batch function to include a new batch order setting. This enables you to set whether a batch function will include the full activity objects for the first or last ten activities aggregated by your batch function.

As a reminder, the Knock batch function will always return its total count of items and unique actors, but only returns full details for ten items in the batch for the purposes of listing out batch details in a notification (as we are in the example notification below).

Read more in our docs

Fixes and improvements

• 👀 We redesigned the workflow builder
• 👀 Added color labels for environments
• 👀 Now you can commit on your workflow from the workflow builder page

You can now send notifications from Knock to your users on WhatsApp, the popular chat app from Meta. Our integration makes it easy to include WhatsApp in your notifications strategy, opening up another channel for you to reach your users where they are.

Read more in our docs

Vercel integration

We've shipped a new Vercel integration to make it easy for you to set up Knock for your Vercel projects. The integration will link your Knock API keys to your selected Vercel projects and keep them in sync for you.

You can find us in the Vercel integrations marketplace in the "messaging" category and read more in our documentation.

Fixes and improvements

• 👀 [SDKs] We added new event types to our @knocklabs/client library in 0.8.13
• 👀 [SDKs] We added experimental support for cross-browser context feed synchronization in our @knocklabs/client library in 0.8.13 via the new __experimentalCrossBrowserUpdates option
• 👀 We redesigned our trigger conditions editor to be an inline form instead of a modal
• 👀 We added a link to the workflow invoked from a source event action
• 🐛 We fixed an issue where pagination for tenant messages was not working correctly

At Knock, we continually strive to improve the experience our users have building their notification workflows. As of this release, it's much easier to understand at a glance which workflow steps contain conditions and how those conditions will execute based on the variable state of a given workflow run. To see a step's conditions, just hover over its card chin to see a hover over preview of all condition groups present on the step. ✨

Push channel JSON overrides

We now support the ability to add JSON overrides to the notification payloads Knock sends to downstream push channels on your behalf. This means you can now support badge counts, extra data properties, sound files, and other provider-specific settings in your push notifications. You can learn more in our push channel documentation.

Fixes and improvements

• 👀 Show canceled request id in debugger
• 👀 Show delay until values in debugger for steps that support it
• 👀 Support liquid variables in email templates footer links
• 👀 Add tenant brand icons on dashboard
• 👀 Display custom step names on workflow cards
• 🐛 Fix SSO login using Okta tiles

Now you can integrate customer data platforms (CDPs) such as Segment and Rudderstack with Knock to power your product notifications. This means that you can use the identify and track calls you already send to your CDP to identify users in Knock and send them notifications.

• track events can trigger Knock workflows, with custom mapping from event properties into every part of triggering a workflow
• identify events keep user information in sync with Knock, so that user changes like email updates are fully synchronized with Knock with no code changes required in your product

Here's what this unlocks for your team. If you're a product manager that wants to set up a new notification type without taking time from your engineering team, you can create a new notification workflow in Knock and trigger it when Knock receives an event from your CDP. You can map properties from your event into your notification template to personalize messages, and into other parts of your notification workflow to power recipients, tenants, and more.

Check out our integrations overview to get started, or dive into our docs for Segment or Rudderstack.

This is just the start of powering Knock with external sources. We have more providers on the way, including reverse ETL platforms such as Hightouch and Census. If there's a specific event or customer data platform you'd like to see us support, please get in touch.

Fixes and improvements

• 👀 We added the ability to update the number of activities in a batch from the variable pane – very helpful when working with batch data.
• 🐛 We fixed a bug with our account invitations whereby a user without a name would cause invites to be returned as "not found".
• 🐛 We fixed an issue where editing an email template could crash the dashboard for a small number of users.

We're rolling out a whole host of new email and SMS channel providers today, available now under the "Channels" section in your account dashboard.

Email providers

• Sparkpost
• Mandrill
• Mailersend

SMS providers

• MessageBird
• Africa's Talking
• Mailersend
• Sinch
• Vonage

If you need a specific provider not covered in our current providers list, please get in touch.

SAML 2.0 SSO Support

If you use SAML 2.0 SSO to manage authentication into the apps used by your organization, you can now configure your Knock account to enable users to authenticate into your account using your identity provider via SSO.

Note: SAML SSO is only available on our Growth and Enterprise plans.

Learn more about SSO

Fixes and improvements

• 👀 We made some visual improvements to the variable pane in the workflow builder, making it easier to work with batched data like activities and actors
• 👀 We now trim whitespace from email subject lines automatically, making it easier to work with
• 👀 We made some internal improvements to our feeds endpoint, reducing the response time by 86%
• 🐛 We now correctly support .first, .last, and .size calls on arrays in liquid
• 🐛 We fixed an issue where changing template overrides would reset the editor contents within the email template editor
• 🐛 We added more spacing around items in our visual email editor to work more easily on smaller screens
• 🐛 We fixed an issue where message sending logs weren't appearing

Today we're releasing per-tenant default preferences. When your product starts moving into larger organizations, you can often find admins asking for the ability to set a notification preference for all users in their account (or to set a default preference for those users at a minimum.)

Now you can support these types of per-tenant preference use cases with Knock. Our tenant preference model brings the same flexibility as our per-user preferences and lets you put them into the hands of your customers' admins.

Learn more about per-tenant preferences

Set pre-content variables in your email layout

Now you can set variables in your email template that will be rendered in your email layout ahead of your content block. This is great for when you want to set dynamic email preview text or dynamic header content within the layout of your email.

Learn more about pre-content variables

Fixes and improvements

• 🐛 We fixed a bug in our test runner where our typeahead select fields were acting finicky.

Today we’re shipping a new set of account-level roles for the Knock dashboard, making it easy to grant more tailored permissions to members of your team who might not need full access to all resources within your Knock account.

The roles now available on your account are:

• Owner: For your primary admin who manages billing. This role can invite and manage members, manage billing, and do anything available in the admin role. Your account must always have at least one account owner.
• Admin: For admins who need to manage account-level settings. This role can invite and manage members (excluding owner and billing roles), manage account branding, manage environments, and manage advanced developer concepts such as signing keys, variables, and webhooks. This role has all permissions available to the member role.
• Member: For users who are editing notification workflows and templates in Knock. This role can manage workflows, layouts, users, objects, and tenants. Users with this role can make commits and push changes to subsequent environments, and has full access to message and API logs for debugging.
• Support: For users who shouldn't have access to workflows and templates, but should be able to dig into message and API logs for debugging purposes.
• Billing: For account members who shouldn't have access to anything in Knock but billing.

You can see the full breakdown of the permissions available to each role in the documentation.

These new roles are available to all plans today. You can change roles and manage the members of your account from the "Account Settings > Members" page. As a reminder, there are no limits on the number of seats you can have assigned within your Knock account.

Read the documentation →

Dark mode docs 🌚

Our documentation is now available in dark mode for all those night owls out there. You can toggle to dark mode in the top header from any page in the docs.

Fixes and improvements

• 🐛 We fixed an edge-case with our batching function whereby in a set of very specific circumstances a batch could be created twice for a workflow run
• 👀 We added a new section to the docs for "Managing your account" including information about audit logs and managing team members

A couple weeks ago, we launched the fetch function for Knock workflows. Today, we're making it a lot easier to develop this function step with a realtime test runner purpose-built for fetch functions.

When you load the template editor, you should now see the new "Test console" in the lower half of the screen along with a "Send test" button next to the URL field. When you run a fetch function test, Knock will execute your fetch step in isolation, ignoring any steps before or after in your workflow. When the step has finished, Knock will load the result into the test console for your review in realtime with no need for a refresh!

We're always working to provide a great developer experience for everyone building with the Knock platform. With this new test runner, the develop ↔ debug cycle for fetch functions just got a great boost.

Check out the guide on testing fetch functions for more details, or head to the template editor now to try it out.

Set shared preference sets for all users and objects in an environment

We built preference sets in Knock to allow you to configure granular channel and workflow preferences on a per-user and per-object basis. Preference sets serve as a flexible tool to manage things like user-owned credentials and opt-in configurations.

But sometimes you may find you want to set preferences shared across all users and objects in your account. Today we're making that much easier with default preference sets!

You can now navigate to the new "Developers > Defaults" page, where you can configure a preference set that will be global to an entire Knock environment. When Knock loads the preferences for a recipient, it will merge the recipient's owned preferences into the global defaults. User and object preferences will still take precedence, but now you can manage shared preferences in a single space.

Fixes and improvements

• 🐛 We fixed a bug that would prevent users in a small set of cases from saving a channel or fetch function template without a page reload.
• 🐛 We fixed an issue where category preferences required all categories on a workflow to be opted-out before we considered the preference as opted-out.
• 🐛 We fixed an issue where setting conditions for channel-type preferences would result in a 422 Unprocessable Entity error from the Knock API.

We've designed our service with security best practices in mind from day one. Audit logs form an important part of the security and compliance program within an organization, making it easy to proactively monitor for suspicious activity and retroactively understand the impact of a malicious actor. For this reason, we've always captured detailed logs of the actions happening across your account. Today we're pleased to announce that we're shipping support for viewing these audit logs from within the Knock dashboard.

With this initial release you'll see information about all of the actions occurring within Knock with detail about the team member who performed the action and additional context about which resource has been modified. You can even filter to an individual team member or a specific type of action if you need to get more granular.

Audit logs are available now across all plans and have the same retention period as other logs on your account. You'll find your audit logs under the "Settings" page.

Fixes and improvements

• 👀 We separated out the "API Keys" and "Variables" section from under the "Developers" page to make them easier to find in the dashboard
• 🌱 You can now select a preference set to view under a user or object, making it much easier to work with multiple preference sets

Today we're shipping a new function step to the Knock workflow builder: the fetch function. With the fetch function, you can build and execute HTTP requests to any external service as a step in your workflows. Knock will merge any data returned to a fetch step request into the global state for the workflow run, thus making it accessible to all templates in subsequent workflow steps!

You can use fetch functions to grab data for a workflow run that may not be readily available at the time you trigger a workflow, such as for workflows that use batching to create large activity groups. You can even use fetch functions to trigger side effects in your external systems as Knock processes a workflow run.

Our goal is to ensure Knock serves as many possible notification use-cases with a dead-simple interface. The fetch function adds even more flexibility to Knock and unlocks some neat ways to compose workflows.

Check out the new guide on fetch functions or head to the workflow editor now to get started with fetch functions in your workflows.

Trigger conditions for all

Trigger conditions, previously only available for channel steps, are now available for use in all workflow steps. As part of this expansion, we've also added a brand new guide on trigger conditions to the Knock docs.

Trigger conditions allow you to specify if a given step will execute at workflow execution time. They are one of the many ways you can build powerful logical notification flows with Knock.

With this update trigger conditions are now even more powerful and easier to use.

Performance tuning for our API logs

We've seen recently that it could take a long time (several seconds for our largest customers) to load the list of API logs in Knock. So we invested some time to dig in and address the issue. We found that both the structure of the query used to load the logs and the primary database index used to filter the query had a number of optimization opportunities.

After implementing the necessary changes, we've observed a substantial decrease in query time. For our largest customers, we've seen average query execution times decrease from from 12 seconds to 15 milliseconds!

Our API logs are an important part of the developer experience within Knock, and with this release we're ensuring that they feel performant at any scale.

Fixes and improvements

• 🌱 We've added a UI for channel preferences to the user and object preferences tabs, including the ability to toggle a channel on/off from the Knock admin.

You can already use Knock to create branded notifications that put your brand’s best foot forward when you’re communicating with your customers. Now, with today’s per-tenant branding launch, you can extend that same functionality to your own customers.

With per-tenant branding you can set per-tenant overrides for any of the brand elements you already use in your Knock notifications, such as logo, icon, and brand color.

Here’s what this unlocks. If you have an enterprise customer that wants emails from your product to fit their branding (for example in the case they use your product to collaborate with their own customers or vendors), you can now do so with Knock. If custom branding hasn’t been set for a tenant in your application, we fall back to the default branding you set in account settings.

If you're interested in enabling this feature for your account, you can check out the docs and connect with us at support@knock.app.

Fixes and improvements

• 👀 We added support for connecting to AWS SES with an external ID instead of an access key and secret – please get in touch if you'd like this feature enabled on your account!

We've brewed up a fresh SDK for you and have added Java to our list of officially supported SDKs, making it easy to use Knock in your Java projects (including Spring Boot).

You can get started with the Java SDK by checking out the repo on GitHub, or adding the following to your build.gradle file:

dependencies {
  implementation 'app.knock.api:knock-client:0.2.0'
}

Looking for an SDK that we don't currently support? Let us know and we'll consider adding it.

Fixes and improvements

• 👀 We added a new set of integration pages to our marketing site to showcase all of the providers that Knock connects to
• 🐛 We fixed an issue that was causing our test runner to fail to execute test runs
• 🐛 Setting a very long recipient identifier no longer causes a batch step to fail in a workflow execution
• 🐛 Email steps that have missing layouts no longer cause previews to return a 500 error

Today we're making it even easier to create and update your users and objects in Knock. You can now perform user and object identifications as an inline action within calls to the workflow trigger API.

When calling the trigger API, you can choose to include maps of properties describing users and objects to identify in Knock in the recipients and actor fields. While processing your workflow, we'll create or update each of these recipients accordingly.

curl --location --request POST 'https://api.knock.app/v1/workflows/my-workflow/trigger' \
  --header 'Authorization: Bearer sk_test_1234' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "key": "my-workflow",
    "recipients": [
      {"id": "user-1", "name": "User 1", "email": "user1@knock.app"}
    ]
  }'

Our goal is to make Knock as straight forward as possible for you to get started, and powerful enough to scale with your ever evolving needs. With inline identification, you can trigger your first Knock notification with a single API call, as well as explore new ways to manage your users in Knock.

See our guides on identification for users and for objects for more details.

Fixes and improvements

• 🌱 In Knock analytics you can now group notification usage by enagement status

We've expanded our SDK coverage to support Go, making it effortless to start powering your notifications from your Go applications and services.

You can get started with the Go SDK by running go get github.com/knocklabs/knock-go or checking out the repo.

Want an SDK that we don't currently support? Let us know and we'll consider adding it.

Fixes and improvements

• 🌱 You can now toggle the active status of a webhook to mark it as disabled and stop it sending
• 👀 We added a new section in our documentation on going to production
• 🐛 We fixed an issue where in-app notifications in the dashboard weren't getting marked as seen

Today we’re launching Knock analytics. With Knock analytics, you get a single dashboard for understanding the notifications you’re sending across all of your Knock channels, in all of your Knock environments.

With Knock analytics you can understand:

• How your overall notification usage is trending over time.
• How usage volume compares across your different channels and workflows, and whether there are opportunities to batch notifications to decrease the notification volume you’re sending to your users.
• How your delivery rates look for each of your notification channels so you can quickly identify configuration issues.

One of the core value props of Knock is that we act as a single layer to interact with all your delivery providers and their data. Knock analytics is a big part of that, giving you a single place to find valuable insights about the cross-channel notifications you send to your customers.

Fixes and improvements

• 🌱 We expanded the integration guide in our documentation to cover every provider we support
• 🌱 We created and open sourced a new in-app notifications example app: knock-in-app-notifications-react.vercel.app
• 👀 We improved a loading state for API logs, now shown when applying filters or paginating
• 👀 We improved the API error message when a nonexistent workflow is triggered
• 👀 We improved the API error message when a JWT signing key is not yet generated for a non-development environment
• 👀 We improved the API error message when attempting to set channel data on channels that do not support them
• 🐛 We fixed the message details page to now correctly show its archived status
• 🐛 [React Feed] We fixed an issue where Knock websocket connections were being terminated unexpectedly in React 18

Today we’re shipping support for webhooks in Knock so that you can more easily respond to the notification events happening and keep your system synchronized with the data in Knock. For more advanced use-cases of Knock, our customers need to keep track of the data that we’re generating within their own system. Given the inherently asynchronous nature of sending notifications, there hasn't been a great way to do this today without polling data endpoints. Enter webhooks!

In your dashboard you'll now see a page where you can configure a webhook to listen to a number of events related to messages sent via your workflows. Once you set up an endpoint in your service to receive them, you can add the URL to the webhook creator and select which events you'd like to subscribe to. When your webhook starts sending requests you'll see delivery logs for those in the dashboard as well.

Some examples of how you can put webhooks to use in your system:

• Store messages longer than our internal retention period
• Populate a custom log of the messages sent to individual users in your system
• Execute a side-effect in your application if a specific event occurs

With webhooks, you're in more control of your notification data than ever before.

Read the documentation to get started →

Building in-app UI docs

When we first built the Knock Feeds API and React component library, we built them with feeds in mind. Since then we've seen customers use our notification infrastructure to build feeds, toasts, inboxes, preferences experiences, and much more! We've completely re-built our in-app UI documentation to showcase our in-app use cases and how to support them, whether you're building with React, Javascript, or React Native.

Check out the new documentation →

PHP SDK

We've expanded our SDK coverage to support PHP. That means you're now easily able to integrate Knock into your Laravel applications with ease! You can get started with the PHP SDK by running composer require knocklabs/knock-php, or looking at our docs.

PHP SDK on GitHub →

Fixes and improvements

• 🌱 We now show items that have been removed from a batch in our debugger
• 🌱 We made our new documentation search even more thorough as we now index all of our API reference too
• 👀 Users can now be added from the dashboard in any environment, previously we restricted them from being created in production
• 👀 We added the ability to filter workflows by a category and cleaned up the workflows list

Building on our dynamic batch window work earlier this month, batch steps can now be configured with a dynamic batch window that draws from recipient, actor, notify, or environment variable data. A few use cases this unlocks:

• Power per-user digests, where the digest frequency (i.e. daily, weekly) is set as a per-user preference
• Use an environment variable to shorten batch windows in development and staging environments for easier testing
• Set a batch window with data sent in your notify call, such as the priority or severity of an issue

Simply select "Batch for a dynamic window" followed by the batch window type (Recipient, Actor, or Data) and provide the batch window key for looking up the batch window value. This value can be either an ISO-8601 timestamp (e.g. 2022-05-05T20:00:00Z), or it can be a relative duration in the following format:

{
  "unit": "minutes", // Must be one of seconds, minutes, hours, days, weeks, or months
  "value": 10 // Any non-negative integer
}

With this release, our batch function just got even more powerful and we're excited to see what our customers use it to build.

Read the documentation to get started →

Search the Knock docs

A popular request for our API documentation is finally here! Now you can search for items in our API docs to find what you need. Enjoy!

Fixes and improvements

• 🌱 You can now clone workflow steps from within the workflow editor
• 🌱 Workflow logs are now viewable on each workflow under a new “Logs” tab, filtered to show API logs for just that workflow
• 🌱 We now support Mailjet as an email channel
• 🌱 Read-only requests (e.g. loading user feeds) are a little faster thanks to under-the-hood improvements

Today we're announcing our first example app. We're a team that loves to learn by example when we're picking up new developer tools. The fastest way to understand how a tool works is to see it working in real code. Now you can learn by example when you're trying out Knock.

With the Knock example app you can see how a hypothetical collaboration product uses Knock to:

1. Send welcome emails to new users after signup
2. Trigger cross-channel notifications across email and in-app surfaces when actions happen in the app
3. Power Slack integrations, including resource-to-channel notifications
4. Customize user preferences per workflow and channel type
5. Enable users to mute notifications for a particular resource
6. Identify users and their preferences during initial setup with our bulk APIs

Our example app will continue to evolve as we ship new improvements, so stay tuned for more updates!

Check out the example app repo →

Fixes and improvements

• 👀 We now display better error messages when logs can't be retrieved
• 👀 We now support liquid tags on email channels from name attribute
• 🐛 We fixed an issue where email preview errors weren't being communicate well to dashboard users

If you've used a smartphone, you know about push notifications. You may not be as familiar with silent push notifications.

Silent push notifications wake up your app in the background without interrupting your user. As Apple explains it, “A [silent push notification is a notification that doesn’t display an alert, play a sound, or badge your app’s icon. It wakes your app in the background and gives it time to perform some actions”.

An example: in a news reader app you might send silent push notifications when there's new content you want your app to download in the background. Once the new content has finished downloading, you could send a normal push to your user with the latest headline. When your user opens the app, the content is ready, making the experience snappy and polished.

Starting today, Knock supports silent push notifications on Apple, Firebase Cloud Messaging, and Expo Push. For our news reader example, what would have been a complicated set of backend logic becomes a single API call to a three step workflow whenever breaking news arrives:

1. Send a silent push notification
2. Delay (long enough for the device to load their content)
3. Send a normal push notification

You can learn more about how to use silent push notifications in our docs.

Dynamic batch windows

Knock has always supported batching notifications over a set window of time. Now, batch steps can be configured to take a dynamic batch window that is set when you trigger your workflow.

A dynamic batch window will wait for an interval of time provided by you in the data of your notify call under a key you set when you create your workflow. The key you specify in the workflow editor can be dot-delimited (e.g. nested.path.to.window) to reach nested attributes. When this workflow step runs, Knock will use this value to set when your batch window will close.

This value can be either an ISO-8601 timestamp (e.g. 2022-05-05T20:00:00Z), or it can be a relative duration in the following format:

{
  "unit": "minutes", // Must be one of seconds, minutes, hours, days, weeks, or months
  "value": 10 // Any non-negative integer
}

Read the documentation to get started →

Fixes and improvements

• 🌱 The objects page on the dashboard now shows preferences (Previously object preferences were only managed via the API)
• 🌱 Email channel settings can now use liquid tags and be dynamically populated
• 🌱 We now support deleting user and object channel data via the API
• 👀 We now lazy load message delivery logs and limit the list of logs to 25 at a time to keep the experience snappy
• 👀 We improved email layout previews to look even more accurate to what is actually sent
• 🐛 When viewing batched workflows in the debugger, we show more detail about batched workflows including their current status

Today is a good day. We’re shipping our visual template editor to make it even easier to craft great-looking product notifications from within Knock.

Now you can use our drag-and-drop editor to build great looking email notifications that include text, buttons, quotes, and dividers, all without having to write a single line of 90s-era email HTML. (IYKYK.) This is a low code editor, not a no code editor. This means that we take away all the annoying parts of writing email templates, while still giving you the flexibility of markdown, HTML, and liquid syntax for variable injection and control flow. And of course if you want to write raw HTML and CSS on your own, you're always welcome to.

We’ve even added new branding settings so you can ensure your brand elements are consistent across all of your product messaging. 🌠

As of today, our visual template editor is only available for email templates. We'll be expanding the visual template editor to other channel types with interactive components such as Slack later this year. For notification channels with text-only templating—SMS, push, in-app—you'll be able to use the same code editor you already use in Knock. 👍

Read the documentation to get started →

Fixes and improvements

• 👀 We added a better empty state display for Objects when none was found for a given collection
• 👀 We improved the design of the variable pane in the message template editor
• 🐛 We fixed an issue where message logs for email notifications with attachments were taking long to be retrieved in dashboard

When working with preferences, you’ll sometimes run into advanced use cases where you need to provide even more granular preference options for your customers. For example: you may want to let a user mute notifications about a given resource in your product. That’s where preference conditions come into use in the Knock model: they provide a powerful way for you to add extra logic that’s computed during preference evaluation per recipient.

You can now apply a set of conditions to an individual category, workflow, or channel type preference, which will need to return true to send the notification out. The conditions you create can reference properties in your data payload or on the recipient. Here's an example of a condition where we only send a notification if the current resource is not in a list of muted ids for a recipient:

{
  "argument": "data.pageId",
  "operator": "not_contains",
  "variable": "recipient.mutedPageIds"
}

Read the documentation to get started →

More accurate email previews

We know making sure you see an accurate preview for your notifications is crucial when creating your notifications. Previously, we had rendered a close approximation of your emails on the client, but there were some cases where what you would see in the preview tab would differ from what you'd see when you ran a test.

From today we now render the emails on the backend, applying the same set of transformations to the email as you get before it's delivered to your users. This means a much more accurate previewing experience, CSS warts and all #htmltables4eva.

Fixes and improvements

• 👀 We now show you the variable pane on our workflow builder, with a new button in the top bar to toggle the variable pane on and off in both the builder and the message template editor
• 👀 We moved the action menu in the email template editor into the top bar, cleaning up the UI
• 🐛 We fixed an issue where our users.identify and objects.set endpoints weren't correctly upserting data
• 🐛 We fixed an issue with attachments on AWS SES not coming through correctly
• 🐛 We fixed an issue in our Elixir SDK where calling the Users.get_feed/3 endpoint with no options would cause an error

Now you can bring the messages you send with Knock into your own product to power customer support and message logging use cases. Our new message API endpoints allow you to list all of the messages generated by Knock, as well as access additional message information such as batched activities, triggering events, and message content. Our messages API also supports a number of filtering options, so you can easily find the messages you're looking for.

Read the API documentation →

Fixes and improvements

• 👀 Our identify endpoint no longer requires a name or an email for a user
• 🐛 We fixed a bug where nested variable paths weren't being properly parsed when a value existed for a top level path in the template editor
• 🐛 We fixed an edge case in our push sender where sending any empty data payload on a notify call would cause an error

Now you can use Knock to power the notifications you send to Discord.

We support incoming webhooks and Discord bots, so whether you're sending notifications to an internal Discord channel or to a bot that your users are OAuth'ing into their own Discord servers, Knock has you covered.

Like all channels in Knock, once you've configured Discord you're ready to add it into any of your notification workflows. Plus, you'll get full observability into the responses we receive from the Discord API so you can debug as needed.

Learn more about our Discord integration →

Fixes and improvements

• 🌱 We shipped a new request buffer to help buffer incoming workflow trigger requests at scale
• 🌱 We shipped our new push documentation to our docs after it had previously lived in our legacy support feature guides
• 👀 We made a number of improvements to the variable pane editor. Now when you remove all references to a variable in your templates, its corresponding variable is automatically removed from the pane. If you rename all instances of a variable, its corresponding variable in the pane is renamed. This is a big win for variable pane usability 🙌
• 👀 We improved our messaging in the debugger about skipped batch steps when a batch key could not be found in the data payload of the workflow trigger
• 🐛 We fixed a bug where new users could be created by calling the preferences endpoint with a non-existing user_id
• 🐛 We fixed a bug where certain template schemas would cause the app to crash upon attempting to view a workflow
• 🐛 We fixed a bug where the email preview pane would hang when it couldn't find a layout with which to render the preview

It's been a whirlwind of a week here at Knock HQ with our official launch yesterday 🎉

And now, we are back to our regularly scheduled programs — shipping!

• 🌱 knock.app got a facelift with brand new designs!
• 🌱 We added a system status page: status.knock.app
• 🌱 We added JSON editor support for Slack
• 🌱 We added email attachments support for Mailgun
• 👀 Improved the design of toast alerts throughout dashboard
• 👀 Improved the design of associated activities in the message overview
• 👀 Improved the description of the batch key behavior in the workflow editor
• 👀 Improved the empty state display for objects, and non-development environments
• 👀 Added an ability to add a short description (up to 280 chars) to your workflows
• 👀 Added an ability to use liquid syntax for email overrides
• 👀 [Docs] Added a language selector for all of code examples
• 👀 We now automatically set the default retention period of 365 days when creating an in-app channel
• 👀 We now automatically create a message template when creating a new channel step in a workflow
• 👀 We now consistently refer to "uncommitted" changes instead of "unstaged" in some places previously
• 👀 We now display a configured provider logo when choosing a channel step in the workflow editor
• 🐛 Added the missing chat type to the workflows filter
• 🐛 Fixed an issue of accidental duplicate user accounts when signing up by handling user emails case insensitive
• 🐛 Fixed the "View Workflow" link in the popover menu in the Workflows table
• 🐛 Fixed an issue where cloning a workflow with overrides was erroring
• 🐛 Fixed a request timeout issue with viewing certain log items
• 🐛 Fixed the message status logic to use the highest status when there are multiple messages (if one message is "read" and another is "seen", then the evaluated status is "read")
• 🐛 [Docs] Fixed the "Flash of Unstyled Text" (FOUT) issue

Following our recent Slack support release, we are delighted to announce we now support Microsoft Teams as a new provider for our chat channel type 🎉.

Learning how to integrate with a new 3rd-party chat app provider can be a pain. You have to read through a lot of documentation just to understand how their integration model works, and you have to learn their message formatting syntax. With our Teams integration, we're abstracting away the schlep so you can focus on what matters: delivering great messaging.

You can add a Teams step to any of your workflows, just like any other channel. Once you do, we let you use basic markdown to edit your notification templates—we handle the translation into Microsoft's Adaptive Card syntax. If you want to build more advanced Teams messages, we give you a JSON editor so you can write Adaptive Cards yourself.

Like all channels in Knock when you use Teams you get full observability into the responses we receive from the Teams API, and you can store Teams channel data on user or non-user recipients.

Learn more about our Microsoft Teams integration →

Workflows: read-only mode

Knock was built with isolated environments from day one to ensure our customers didn't accidentally make changes to notifications in production. As of today, you can navigate into your production workflows in a safe, read-only mode so you can see which version is live in your production environment (and send test notifications as you need to.)

Fixes and improvements

• 🌱 We added support for users to change their user names within the Knock dashboard
• 👀 We updated the template editor theme to make it easier to parse liquid keywords, variables, and control flow operators

As of today you can include attachments in the email notifications you send with Knock.

Knock already enables you to dynamically update the content of your notifications with variable injection using the data you pass to us in your notify calls, and now you can include one or more attachments within that payload and we'll attach them to your email messages at workflow runtime.

We had to do some interesting work under the hood here to support large incoming data payloads (more on that another time), but we're now able to process multiple files (up to 10mb each) in a rock solid way. We hope you're as attached to this feature as we are. 😁

Learn more in our docs

Fixes and improvements

• 👀 Batch keys are no longer required on batch functions. When no batch key is provided we batch by the recipient and workflow by default
• 👀 We added a new "commit all" action in your development environment under the commits panel
• 👀 We improved the commits panel in the dashboard
• 👀 We made the logs page more obvious and not hidden under the "Developers" section
• 👀 Large binaries sent in your data payloads will now be truncated in API logs
• 🐛 We fixed a bug with our trigger condition logic where steps that didn't produce a message would always evaluate to false on trigger conditions referencing that output
• 🐛 We fixed an issue where Slack summaries were not optional (as they should have been)

When you start with a new developer tool, it can be hard to know how to go from tinkering in your local environment to going live in production. Our new onboarding flow shows the basic steps you need to complete to send notifications to your customers in production using Knock.

We've included the relevant context for making your first API calls to Knock, and we show your progress so you know what to do next. We're excited to see how this guide helps new customers implement notifications in their product even faster than before.

Set notification preferences by workflow category

As of today you can add categories to your workflows in Knock and use those categories in your notification preferences.

Sometimes you want to enable your users to set a preference for a broad category of notifications instead of presenting them with preference controls for every type of notification you send. For example, you might have a category for direct notifications that includes everything from mentions to approvals to tasks due in the next 24 hours. You can learn more about how to power use cases such as this one in our preferences documentation.

Use multiple email layouts in Knock

Many of our customers use a default email layout across all of their transactional notifications, but sometimes you want a different layout for when you're sending a welcome notification from a founder (no styling at all) or an email from your marketing team (a bit more pizzazz). Now you can create multiple email layouts in Knock to use in the different workflows you power with our product.

Fixes and improvements

• 🐛 We fixed a caching issue with cloning workflows
• 👀 We added an explicit save button for our email layouts to make the editing experience better

Knock has successfully completed its SOC 2 Type II audit, certifying the effectiveness of our security processes and controls. You can learn more in our blog post announcement.

We've built Knock with security at the forefront of our design and architecture from day one. Now, automated monitoring through Vanta and formal policies allow us to stay up to date on our security posture at all times.

If you're a customer that would like to receive a copy of the report, please send us a note at security@knock.app.

Filter debugger by endpoint

We've added endpoint filtering to our debugger to make it easier to find the requests you're looking for. If you're debugging preferences work, filter to only see requests made to our preferences endpoint. If you're debugging our feed, filter to see feed requests. And so on.

Fixes and improvements

• 👀 We now surface test runner calls in our developer debugger so you can dig into their workflow runs just as you would for normal API calls made to Knock
• 👀 We've made actor optional on our workflow trigger endpoint (after some helpful customer feedback!). When you include actor on a request you can use the actor. namespace to access user schema properties about the user or object that triggered the notification
• 👀 The debugger now shows linked batched workflows on batch steps so you can know which subsequent events were included in a given batch
• 👀 We updated our docs to move our API reference to its own dedicated part of the site. This gives it some breathing room and surfaces each endpoint as its own section of the sidebar for easier navigation
• 👀 We added a new page to our API documentation describing the functionality of our Feeds API
• 🐛 We fixed a bug where browser auto-fills were hijacking the inputs in our test runner
• 🐛 We fixed a few links in the dashboard that were linking to outdated support documentation
• 🐛 We fixed a bug where long account names would squish the account icon in the dashboard sidebar

Email is an important and widely used channel for many of our customers. If you are using an email channel in Knock, one of the first things you'll want to do is define the layout template for your emails. Knock already generates a great looking email layout for you as a starting point so you can quickly customize it to meet your needs, such as adding links to the footer section. But right now, this requires jumping into the code editor and fiddling with HTML or text content, which can feel like a hassle. We can do better.

Starting today, we've made our default email layout template available through a visual editor, so you can easily add footer links to our out-of-the-box email layout without having to jump into code. You provide the text and URLs for the footer links, and Knock will automatically translate them into HTML links or text equivalents in the layout template. Of course, you always have the ability to drop into the code editor for complete flexibility.

Merge users API

You may run into a situation where you’ve identified an invited user to send them a notification and then that user “graduates” to a fully fledged user after they sign up, leaving you with two user profiles in Knock. Our merge users API is here to help you in this scenario!

You can now call the users.merge method in our SDKs to merge two user profiles together, moving the properties, channel data, and preferences from one user to another. The merge call will also move the message sending history so you can a nice, clear view on the messages sent.

Read more in the users docs →

Fixes and improvements

• 🌱 We added an ability to override certain email channel settings per template for more flexibility
• 👀 [Docs] We updated to include more thorough explanations on workflow functions: batching, delays, and throttling
• 👀 [Docs] We added new security page to provide more information on our security posture and policies
• 👀 [SDK] We released the latest Client JS SDK that improves TypeScript type definitions and introduces two new types of events (items.received.page and items.received.realtime)
• 👀 [API] We added rate limiting on our feeds endpoint (5 reqs/sec/user) as a safety measure for availability of our service
• 👀 [SDK] All of our SDKs have been updated to reflect the new merge users API
• 👀 We improved how we display workflow steps in the workflow editor to show its description, when available
• 🐛 We updated the label of the user id filter UI to read "contains" instead of "is equal to" to more accurately describe the fuzzy match logic

It's always an exciting day here at Knock when we add another channel type to our product. Today we're thrilled to announce that we now support Slack via our new chat channel type. Slack needs no introduction, but our integration in Knock might.

It's now effortless to add Slack support to your product, so your customers can connect their Slack workspace and receive updates in their channels about what's happening in your product. And of course our Slack channel comes with batching, delays, and everything else the Knock workflow engine supports, so you can send more thoughtful, engaging notifications to your customers in Slack.

We made our Slack channel model as flexible as possible, so you control where your customers integrate into Slack and how they map resources in your product into destination channels within Slack. This means that no matter what part of your model you want to map into Slack channels– users, accounts, workspaces, projects–we have you covered.

Learn more about our Slack integration → See an example →

Objects: model and syncronize non-user entities in Knock

Our vision for Knock has always been to power complex notification workflows for your product. Sometimes those workflows necessitate sending notifications to non-users entities in your system. That's where objects come in.

Objects are a powerful and flexible way to ensure Knock always has the most up-to-date information required to send your notifications. They also enable you to send notifications to non-user recipients.

You can use objects to:

• send out-of-app notifications to non-user recipients (such as a Slack channels)
• send in-app notifications to non-user resources in your product (the activity feed you see on a Notion page is a good example)
• reference mutable data in your notification templates (such as when a user edits a comment before a notification is sent)

As an example, SaaS applications often enable users to connect an object in the product they're using to a channel in their own Slack workspace. That way when something happens in that object (e.g. a comment is left) they receive a notification about it in their connected Slack channel. In this case, we can sync (via objects.set) this entity into Knock, connect Slack data to it (via objects.setChannelData), and then reference it as a recipient in a workflow trigger.

We're really excited about the power that objects can unlock for modeling your notification workloads and about the future possibilities they enable. Expect to see a lot more here soon!

Learn more about Objects in our docs →

Fixes and improvements

• 👀 [Docs] We added new provider integration guides into our docs
• 👀 [API] We now support bulk identifying, deleting, and setting preferences for users, available in >= v0.4.0 of our SDKs and via our API.
• 👀 We added a new link to the docs in the bottom left of the dashboard, as well as way to easily send us a support ticket (powered by our new Slack integration internally 😎)
• 👀 We improved the tooltips for workflows with no changes, and message templates that have no changes
• 🐛 We fixed an issue with long property keys overflowing on the user detail page
• 🐛 We fixed a bug where in a very particular case the messages page wouldn't load
• 🐛 We fixed a caching bug with our template gallery where after cloning a template you might see incorrect values

At Knock, we don't think engineering teams should have to give up observability when they decide to rely on a third-party tool instead of building in-house. That's why we've made a focused investment on our debugging tools: we want you to have the same visibility into the Knock notification engine that you'd have if you were running a notification system on your own.

Today we're excited to announce a big step forward for observability into the Knock notification engine that shows exactly what happens when you trigger a notification in Knock.

With our new debugger you can see all of the requests you've sent to the Knock API and, for each one, drill into its related workflow runs, its exception catches (if any are present), and the notifications generated and sent to your customers. We even show non-errors, such as when a user has opted out of a given notification via preferences or if they haven't received a push notification because they haven't installed your mobile app.

You can access the workflow debugger under the "Developers" page in the dashboard. Just open any workflow trigger log and open the workflow runs tab to inspect your workflows.

We took the legwork out of starting notification workflows from scratch: now you can use the built-in template gallery for inspiration or out-of-the-box workflows. This helps developers new to Knock get a sense of what's possible, and for those already familiar with building workflows, a baseline to build from.

You can access the template gallery in two places: first, from the Create workflow button, you'll see there's now a segment to view templates and create directly from there. Secondly, if you've created a blank workflow you'll see a new button to Start with a template.

We've added several categories of templates we see you use most often: collaboration, growth, and authentication. Each one has preset steps that you can adjust once you create your template to tailor to your users. Any channel steps will also automatically use one of your own configured channels.

Fixes and improvements

• 🌱 Added the ability to rename and archive channels
• 👀 Added a number of new liquid helpers including timezone, currency, hashing and more (see the docs here)
• 👀 The template editor for SMS and push notifications is now resizable
• 👀 You can now reset the data payload on the test runner when it deviates from the current workflow schema
• 🐛 Previously line breaks showed as \n in push previews; they now show as true line breaks
• 🐛 We fixed a bug in which the conditions editor didn't allow periods for nested data
• 🐛 We now correctly parse integers and floats in step trigger conditions, rather than treating everything as a string
• 🐛 Fixed a bug where the quick reference would open when typing "?" in the variable pane text editor

Actionable notifications are key in creating a great notification experience for your customers. This is especially useful for things like approvals, or for inline comment replies inside of your application, so your users can take a quick, contextual action right in the notification feed.

Previously, you'd have to extend our NotificationCell component to add inline actions, but with the new v0.5.3 release of the @knocklabs/react-notification-feed library, you can now easily add actions using our pre-built components. Use our button components to add asyncronous actions like approve or reject flows, or bring your own components to introduce any kind of inline action to your notifications.

Take a look at the documentation to get started.

Fixes and improvements

• 👀 We added support for showing the uploaded account icon in the top left corner of the dashboard
• 🐛 We fixed an issue with our SMS providers where users created in the dashboard could cause messages to fail to send
• 🐛 We fixed a bug with our template editor where the page would reload and you would lose your work in certain circumstances

Notifications use branding elements, such as a logo or an icon, to communicate and reinforce your brand values with your users. When you get started with Knock, one of the first things you'll want to do is define those brand elements in your layouts and templates. We now support uploading and managing your brand assets within the Knock dashboard to make this initial experience easier.

Under Settings, you now have a new Branding tab where you will be able to upload your logo as well as an icon. Once uploaded, these branding assets are automatically set and accessible as template variables, so you can start using them in your layouts and templates immediately. We've also added a preview panel so you can quickly get a sense of how they look and feel.

Lastly, Knock will host these uploaded assets for you behind a Content Delivery Network (CDN), closer to where your users are so they always render as quickly as possible.

Fixes and improvements

• 🌱 We now have an official Knock .NET SDK! It is available via the NuGet package manager
• 👀 We made several visual refinements to the dashboard sidebar menu
• 👀 We improved the workflow list to show the types of channel steps configured in each workflow, so you can get an idea about your workflows at a quick glance
• 👀 We improved the usability of defining a trigger condition based on a message status, by using a picklist of message statuses instead of using operators
• 👀 We improved the visibility of the step menu button in the workflow editor
• 🐛 We fixed a bug where in-app provider settings were not being saved
• 🐛 We fixed an issue where a workflow remained in the browser cache after being archived
• 🐛 We fixed a flaky hotkey issue in the workflow editor where pressing (E) did not always take you to the selected step for edit
• 🐛 We fixed a usability issue when defining a trigger condition, where you can now only refer to a step prior to the selected step
• 🐛 We fixed a bug in the email preview where 'From' and 'To' addresses weren't correctly shown based on the selected channel or the recipient

When you start adopting Knock to power all of your notifications in your product, you can end up with a lot of different workflows. To make finding a particular workflow easier, we now support workflow filters. You can filter by a workflow's status (whether it's active or not), whether it has uncommitted changes, by its name or key, and even by the types of steps it contains. Now finding the workflow you're looking for is a breeze!

We've also added a preview to the types of steps within a workflow, so you can easily see all of the workflows that contain a batch step, or even all of your push notification workflows, right from the workflows list.

Fixes and improvements

• 👀 We improved the blank state designs for messages, users, and channels and added a new no results blank state when you're filtering and there are no results.
• 🐛 We fixed a bug where going to the message debug logs wouldn't allow you to use the browser back button.

To make getting started with Knock even easier, you can now manually add a user to a development environment, right from the users page in the Knock dashboard. This means you can easily add a new user to start sending test notifications without using our API or SDKs.

Additionally, when your teammates accept an invite to join your account on Knock we now add them as a user so you can start sending them test notifications. You'll see them appear in your development environment under your users list, and in test runner.

Resetting unstaged changes to a workflow

Sometimes you make changes to a workflow in testing that you want to throw away. Instead of needing to manually revert the changes back to the previous state, you can now select the 'Reset all unstaged changes' button in the workflow menu to reset the workflow to its last committed state.

Fixes and improvements

• 🌱 We added the ability to rename and archive the workflow from the three dot menu on the Workflow page.
• 🌱 We added a new onMarkAllAsReadClick callback to our feed component so you can easily instrument that event, and improved the accessibility of the component in the v0.5.2 release.
• 👀 We improved our user search typeahead component to not collapse users with the same email into one row. We also now show the user id, or email depending on what's being searched for to help you find the right user.
• 👀 We added a new channel filter on the messages list so you can easily find all messages that were sent to a certain channel.

Sandbox mode: test notifications without sending them

Sometimes you don't want a message to be sent in a local or testing environment, but you do want the ability to debug your messages and see what might have gone out. Our new "sandbox mode" enables you to generate and preview messages for a given channel, without sending them to your downstream provider for delivery. Sandbox mode is great for when you want to test a channel's output, but want your messages to end up at /dev/null instead of actually sending live notifications through that channel.

You can enable sandbox mode via your channel configuration from the dashboard today and it's supported across SMS, push, and email channels.

Autogenerate plaintext emails

Writing both an HTML and plaintext template for your emails can be a tedious process. To speed things up, you can now generate the plaintext template straight from the HTML you've crafted, automatically.

All new email templates have this feature enabled by default from today. You'll see the generated plaintext content in the editor and in the preview. If you want to change the setting, you can do so from the plaintext view in the email template editor by toggling the "automatically generate plaintext" switch.

Fixes and improvements

• 🌱 We added the ability to enable email open and link tracking within supported email providers. You'll see the options inside the environment configuration for your provider and they will default to "off" (don't track).
• 🌱 You can now rename environments that you have created from the environments list view in the dashboard.
• 🌱 We now send over the workflow key as a tag, or category to the downstream email provider. This makes it easier to do segmentation and analysis of your emails.
• 👀 We improved the timeline design and debugger blank state in the messages view.
• 👀 We made the wording consistent for when you're committing unstaged changes to an environment.
• 🐛 We fixed a bug whereby you couldn't create an environment with the same name as one that was deleted.
• 🐛 We fixed an interesting edge case in our notification engine that affected test runs in very particular cases.

Today we're launching the first piece of the Knock debugger experience. In our new debugger logs, you can see all of the API requests you've made to Knock, view their status, and filter to find the requests that you need to debug.

This is our first step towards a goal that's important to us at Knock: full developer visibility and observability into the Knock notification engine. It's our belief at Knock that when you use a 3rd-party system to power a part of your stack that's as important as notifications, you shouldn't have to sacrifice visibility and observability.

We have a lot more exciting updates coming soon in this part of the product. Stay tuned.

Fixes and improvements

• 🌱 You can now pop out a separate window for code editing on single-line fields that accept variables and liquid logic, such as subject lines and action URLs
• 🌱 We added the ability to filter by recipient email on our message logs. This makes it even easier to quickly look into any notification issues you're hearing from a specific customer
• 👀 Now when you push workflows to production we show you which of those workflows are inactive in production and ask you whether you want to activate them
• 🐛 We fixed a bug where the undo/redo stack was lost when you'd move back and forth between the editor and the preview in the template editor
• 🐛 We fixed a bug in the test runner where shifting focus back to an actor or recipient field would cause the field to miss the first character inputted into the field
• 🐛 We fixed a bug where Chrome auto-fill was appearing on fields in the test runner

Now you can filter across all lists of resources within Knock. Whether you're looking for a specific workflow, a notification you sent to a customer, or a user within Knock, you can use filters to quickly find what you're looking for.

This is especially helpful for debugging use cases. Want to find all of the notifications sent to a particular recipient? Just filter by that recipient's email address or user ID to find every notification you've ever sent them.

We'll also be adding filtering to our new debugger, which you'll see show up in this changelog in the coming weeks. 🤫

New channel support: Expo for push, Telnyx for SMS

We added two new providers this week. If you manage your mobile app and push notifications through Expo, you can now orchestrate those notifications from within Knock. Same goes for Telnyx. You can now send Telnyx SMS messages from Knock.

Template editor quick reference

Over the last months of our invite-only beta, we've been amazed at the different types of notifications our customers power with Knock. They've used our template editor to build notifications with conditional logic, for loops, and copy that updates depending on the number of items in a given batch.

To help our new customers discover the power of the Knock template editor, today we're shipping our quick reference guide. Just press ? to open the reference and see a list of the properties and keywords you can use to build your Knock templates.

We've also added new documentation about our template editor, so you can go even deeper into the functionality available within it.

Fixes and improvements

• 👀 We shipped a new and improved trigger condition editor that makes it a lot easier to reference the read status of other steps when deciding whether to send a given notification, (e.g. don't send an email if the in-app notification has already been seen.)
• 🌱 We made it easier to preview the action url on an in-app feed message, it now appears beneath the input and on hover of the message in preview
• 🌱 We added the ability to provide a from name on our email channel configurations so you can put your best foot forward when sending emails to customers
• 🐛 We improved the stability and performance of our push notification sender

You can now reorder the steps in a workflow with drag and drop. This is especially helpful when you want to introduce a new batch or delay function into an existing workflow.

Fixes and improvements

• 🐛 We fixed a bug in our environment promotion flow where multiple commits to the same workflow could get into the incorrect order in staging, causing discrepancies between development and production environments
• 🐛 We fixed a bug where new users would get routed to an empty environment on initial sign-in
• 🐛 We fixed a bug where refreshing the users page while in the production environment would route you to development

Delays in Knock have always allowed you to pause the execution of a workflow for a fixed period of time. These "delay for duration" delays are handy for conditional sends and reminders, such as the invite notifications that we power with Knock. With this release we've made delays even more powerful by adding support for "wait until timestamp", where you can specify a future timestamp in your notify payload at which you want the workflow to resume execution. The classic use case for this is task reminders, where you need to trigger notifications at a specific timestamp in the future, rather than at a fixed period from when the workflow was executed.

You can start using timestamp-based delays today. Just select the 'Wait until timestamp' option in the delay step and specify the key to look up the timestamp from your data payload.

Bulk message operations API

We heard from some of our power users that they needed the ability to bulk modify the status of messages sent to their customers, which is especially helpful when needing to archive all of the existing messages for a given user, or mark all of the messages for a particular channel as read.

We've introduced our new bulk message status API to address this need, which lets you update the status of messages on a given channel without needing to know the message ids. It's the first bulk operation API at Knock, and we also introduced an accompanying bulk operation endpoint so you can monitor the progress of these jobs.

You can find the new bulk endpoint in our Postman collection, or can read the API documentation to interact with them via cURL.

Fixes and improvements

• 🌱 We updated our dashboard to include the currently active environment in the URL, making it easier to share links to users, workflows, and messages with your colleagues
• 🌱 We improved the empty state you see when a message can't be found, keeping it inline with what you see for users and workflows
• 🐛 We fixed an edge case in our workflow engine whereby a workflow step could be triggered multiple times when a channel configuration was missing in the environment
• 🐛 We fixed a visual layout issue with our workflow editor where the canvas didn't extend to the bottom of the page

We just shipped the Knock test runner. Now it's easier than ever to test the notifications you build and send with Knock!

If you've been responsible for testing notifications in the past, you know how painful it can be. To test just a single notification, you need to create multiple test users in your product and re-create the real-life scenarios in which they'll receive the notification. It's a time-intensive, tedious process, and one that makes it hard to ensure your customers are getting the best notifications experience possible.

With the test runner, you can test your notifications from right within the Knock dashboard. You can choose which notification(s) you'd like to test, determine which users or test aliases should receive the notification, and run tests across your different development and staging environments as needed. The test runner will remember the inputs used in the last test run for next time, so you can rapidly test and iterate on your notifications.

It just got a whole lot easier to make sure you're delivering great notifications to your customers.

Here's a look at the test runner in action:

Push individual workflows to production

When you're working as a team in Knock, you'll often have a few different notification workflows you're building in parallel. Now you can pick and choose which of those workflows you want to push to production, rather than having to push all of them at once.😅 We're excited to see larger teams adopting Knock and asking for features like these to improve their workflow.

Fixes and improvements

• 🌱 Improved the sidebar layout of the dashboard for easier and more intuitive navigation
• 🌱 Added a new "FCM + APNS" channel group option that can be configured to group both providers as a single push channel (available by request while in beta)
• 🌱 Push notifications now include knock_message_id field in its message data payload, so you can easily track push messages and mark them as seen or read
• 🐛 Fixed a bug with HTML sanitization in our message editor that caused issues with rendering certain email templates
• 🐛 Fixed an issue with timestamps rendering truncated in the Users and the Messages pages
• 🐛 Fixed an issue with an user avatar not updating correctly in the feed item preview when switching actor or recipient users
• 🐛 Fixed an issue where some fonts were not being fetched in the Knock dashboard

We've bundled a whole heap of new fixes and improvements in our 0.5.0 release of our React in-app notification feed component:

• 🌱 Support for dark mode via the new colorMode prop
• 🌱 Added automatic pagination support for when there are more than 50 messages in the feed
• 🌱 Notifications can now be archived easily from the feed component
• 🌱 Added support for overriding the avatar rendered in the notification cell
• 🐛 Fixed an issue with dismissing the component in the popover not working when using the trigger
• 🐛 Fixed an issue where the avatar would show > 2 characters for names that are more than 2 words
• 🐛 Updated all of our dependencies to the latest and greatest versions

You can also read about how to get up-and-running using our feed components in our new blog post.

Message previews

We now support sent messages previews in the Knock dashboard! Just head on over to a sent message and go to the 'Preview' tab to see a representation of the message that we sent to the customer.

Fixes and improvements

• 👀 Shipped @knocklabs/client@0.5.0 which includes a new networkStatus API and optimistic archiving support on the feed
• 🌱 Switched to using refresh tokens in the dashboard to prevent frequent logouts
• 🌱 Moved to using a tags for our tables so now right clicks and other browser features just work
• 🌱 Workflows now show when they have pending changes
• 🐛 Improved the click area on our table cells for ease of navigation
• 🐛 Fixed an XSS vulnerability in our message editor
• 🐛 Fixed a bug where cloning workflows doesn't enforce the key constraints
• 🐛 Fixed some users being incorrectly logged out in the dashboard

It's a short week here at Knock HQ, but we've still got some goodies for you:

• 👀 Added support for dynamic delays specified by a value in the notify data payload
• 🌱 Improved the way long workflow names are handled in the dashboard, as well as some other layout fixes
• 🌱 Added pagination to the workflow list in the dashboard
• 🌱 Improved the in-app notification feed rendering speed
• 🐛 Fixed an issue with a batch step so a specified duration is honored instead of always using a default 30s
• 🐛 Fixed an issue with FCM where integers and booleans in the data payload would cause an error when sending messages
• 🐛 Fixed an issue where users with non-url encoded characters in the id wouldn't load in the dashboard

The dashboard now lets you inspect message delivery logs!

Our new delivery log viewer makes it very easy to see every request to and response from your downstream providers for each message, which provides full visibility into the downstream execution history of a message.

For example, when you're configuring a new channel with Knock, you may run into errors from a downstream provider like SendGrid or Apple's Push Notifications Service. If you can't see these errors in Knock, it makes it hard to know what's going on and how to fix the problem. Delivery logs make it easy to investigate issues like this.

To view these logs:

1. On the dashboard, open the Messages page (You can also open the Messages tab for any of your users)
2. Click on the message you would like to inspect
3. Open the Debug panel to explore each request & response linked to that message

(Note: Messages sent to our in-app feed will have no debug logs because they are entirely managed by Knock.)

Fixes and improvements

• 🌱 We updated the channel and the workflow page to display each provider's brandmark where relevant for better UX
• 🌱 We added a new user's "channel data" page for viewing the configured channel data for each user
• 👀 When configuring a new channel, available providers are now organized by channel type making it easy to find and selected the provider you want
• 👀 We added support for removing items in a batch via our cancellation API
• 👀 We improved how we render liquid templates
• 👀 We pushed updates to our SDKs for Python, Ruby, Elixir, and Node to support our latest features, including the new channel data API for managing user-specific data such as device tokens for push notifications

Push it to the limit. 🤘 We now support sending push notifications from Knock.

If you're using native push notification services (such as Apple Push Notifications service or Firebase Cloud Messaging), you can quickly configure your provider as a push channel within Knock and add it to any of your existing notification workflows. We also support platform-specific previews, so you can see what your push notification looks like across iOS and Android.

As always, push can be used with the Knock preferences model to manage a given user's preferences for receiving push notifications alongside their preferences for other channels such as email, in-app feeds, and SMS.

(Note: We are not supporting intermediary push notification services such as OneSignal in this release. But we will be soon. If that's you, shoot us a note at hello@knock.app and let us know.)

Fixes and improvements

• 👀 We added our Ruby SDK to the code examples modal on our workflow trigger step
• 👀 We cleaned up the placeholder copy in our sign up flow
• 🐛 We fixed a bug in our quick start guide example
• 🐛 We fixed a bug for handling unknown message statuses

We've expanded our SDK coverage to support Ruby, the shiny "gem" of a language that's ever popular in the startup community. That means you're now easily able to integrate Knock into your Ruby-on-Rails applications!

You can get started with the Ruby SDK by running gem install knockapi or checking out the repo.

Want an SDK that we don't currently support? Let us know and we'll consider adding it.

Fixes and improvements

• 🌱 You can now see the phone number and avatar under the main properties on the user page
• 👀 We made the API keys and other sensitive values hide their values by default
• 👀 We fixed an issue whereby you couldn't load message information on the user page in the dashboard
• 🔐 We added rate-limiting to critical endpoints in the management API as well as adding other security patches

We now support sending text messages from Knock. If you're using an existing SMS platform provider (such as Twilio,) you can quickly configure your provider as an SMS channel within Knock and add it to any of your existing notification workflows.

As with all of our channel types, SMS can be used with the Knock preferences model to manage a given user's preferences for receiving SMS messages alongside their preferences for other channels such as email and in-app feeds.

We had a number of requests from our early customers to support SMS, and we're excited to add this new channel type to Knock to help our customers orchestrate their cross-channel notifications.

Fixes and improvements

• 🌱 We updated our channel model in Knock to make it easier to change which provider you're using for a given step in a notification workflow. This helps with multi-provider management and will have a number of benefits as we support push and chat app notifications later this summer. Stay tuned
• 👀 We updated our in-app feed react component to use plain CSS instead of CSS-in-JS. Two nice wins here: the package is smaller and you can extend/override the default CSS used in the component
• 👀 We updated the default behavior of the in-app feed component to wrap text without breaking words
• 👀 We improved our topbar height consistency throughout the dashboard to minimize content layout shift as you navigate between the workflow builder and the notification designer
• 👀 We improved our toast component to make it dismissible in cases where it might block functionality

We're heads down on some big new features this week, and we'll have more to say about that soon. For now we have a smattering of improvements for you:

• 👀 We added the ability to copy channel environment configuration from one environment to another, making it faster to setup your channels when your environment specific channel configuration is the same
• 🌱 Triggering a workflow via the API now returns an error if the actor specified does not yet exist
• 🌱 We added anchor links to our documentation site so that you can easily deep link to each heading
• 🐛 We fixed an issue where you could get stuck in an unauthenticated state on the dashboard
• 🔐 We've been hardening our infrastructure security to lock down any outside attack vectors

We now support Mailgun as an email provider within Knock!

If you are currently using Mailgun to send emails to your customers, you can now configure a new email channel with Mailgun in Knock and start using it in your workflows in no time.

Fixes and improvements

• 👀 We improved the template editor experience where you can now select a different user as an actor or a recipient when crafting your notification template
• 👀 We added the ability to include a custom message when inviting other team members to your Knock account
• 🌱 We added support documentation accessible via the '?' icon in dashboard header
• 🐛 We fixed the user preferences page to be read only (user preferences are updated via the Knock API)
• 🐛 We fixed a bug in the template editor where switching to text view didn't allow editing email texts
• 🐛 We fixed small styling inconsistencies across various popover menus in the dashboard header

When you design a cross-channel notification, you use a lot of shared variables across each of its per channel templates. Whether a notification about a new comment is sent across email, push, or in-app, it's always going to include context about the page it was left on and who left it.

We just shipped our variable explorer to manage this shared state across the different channel templates you design within Knock. The variable explorer makes it super easy to see which properties are available for use within a given workflow, whether they are global variables within your Knock account, properties from your notify or identify calls, or even temporary state generated by functions within your workflow.

Create a property once, then use it across all of the channel templates within your notification workflow. Try it out and let us know what you think.

Amazon SES integration

We now support Amazon's Simple Email Service (SES) as an email provider within Knock. This means that if you already use SES to send emails to your customers, you can get a Knock email channel up and running in minutes. We handle all email orchestration and user preferences with SES, all you have to do is configure your notifications within Knock and we take care of the rest.

You can learn more about how to configure SES in your Knock account in our support documentation.

Leave us feedback

We added a new feedback component to the dashboard so you can tell us what you love and don't love about Knock. We want all the feedback we can get so have at it.

Fixes and improvements

• 👀 We improved the workflow builder so that recently configured channels appear in the builder without a browser refresh
• 👀 We improved the empty state in the workflow builder to help guide new users to channel configuration
• 👀 We updated the message details pane to make it more actionable
• 🐛 We fixed a bug in the message details pane where recipient info was being displayed instead of actor info
• 🐛 We fixed a bug related to multi-environment channel configuration

• 👀 We improved the design of the trigger condition UX to make it easier to add conditions to a channel within a workflow (e.g. if you only want to send an email based on the read status of an in-app message)
• 👀 We added tooltips to our disabled states
• 🌱 We added a new state for when you switch between environments while viewing a resource that doesn't exist in the target environment. Instead of getting a 404, we tell you why the resource wasn't found and direct you to other environments in which you might find it
• 🐛 We fixed a bug where deleted users would cause the message log to error
• 🐛 We fixed a bug where creating a new step in the workflow builder would cause the page to 404
• 🐛 We fixed a text overflow bug in the variables table
• 🐛 We fixed a bug where real-time updates to your workflow schema wouldn't appear in the trigger step payload without a refresh

We added support for Google authentication into our login flow. If your organization uses Google Workspace to manage users, those users can log into Knock using their Google credentials.

Passwordless login

We also shipped passwordless authentication as part of this release. Two things we like about passwordless auth. First, if you're an end user you don't need to keep track of a password for Knock. Second, if you're an organization that enforces two-factor authentication through your identity provider (e.g. Google Workspace,) you can rest easy knowing that the only door into Knock is through the email account of that user.

Fixes and improvements

• 🌱 We added a "get code examples" experience to the trigger step in a workflow. This helps you quickly look at code examples for our supported SDKs and grab the fully formatted notify call (with all necessary data variables included)
• 🐛 We fixed a bug where the message and user lists wouldn't properly load on first view
• 🐛 We fixed an issue with real-time updates per tenant on the notification feed component

Today we support two environments in Knock—development and production—to give you a way to create and test your notifications before pushing them to your customers. But sometimes two environments aren't enough to map to the logical environments that you use in your application.

We now support adding additional environments to Knock so you can ensure the environment promotion flow you use in Knock mirrors what you use in your own deployment flow.

You can add as many other additional environments as you need to support your software development lifecycle. Each new environment acts as a new branch in the content versioning model, allowing you to test in the isolated environment before releasing to production.

You can read more about versioning and environments in our guide.

Tenancy support

Many SaaS applications today enable a single user to access multiple workspaces (or tenants) with the same login. This tenancy model keep data from different customers separate, while allowing users to easily switch between the workspaces they use within that application. As an example, as a Notion user, I use one workspace for my work and another workspace for my personal needs.

When it comes to notifications, the main place where tenancy comes into play is in-app feeds. In the example above, I wouldn't expect to be notified about activity from my personal workspace when I'm in the workspace I use at work.

Today we're releasing tenancy support to handle this use case. Notifications generated by Knock can now be scoped to a tenant, which ensures that they only appear in that tenant's instance of the Knock in-app feed.

We've completely overhauled our feed logic to support this feature. Everything is taken care of for you—tenant scoped feeds show accurate badge counts for just the notifications within that tenant, updates for that tenant populate in real-time—and support is available out-of-the-box in our latest React notification feed components and Client JS SDK.

You can read more about this feature in our guides.

Fixes and improvements

• 🐛 Fixed issue where archived workflows would appear on the "changes not yet in x" list
• 🐛 Fixed issue where new workflows would not show up in the unstaged changes list
• 🐛 Fixed issue where archiving a workflow with pending changes would still keep it in the destination environment
• 🌱 Added ability to duplicate workflows
• 🌱 Added support for displaying custom properties on a user profile page
• 👀 Improved the styling of account and environment variables to aid with clarity

Preferences are a critical part of any notifications system. They let your users tell you when they want to hear from you, and when they don't. A good preferences system gives its users a way to unsubscribe from entire channels (such as email or push) and from individual notifications themselves.

We now support preferences on the Knock API. You can set preferences for your users at the channel, workflow, and channel-workflow level. This gives you the flexibility to offer your customers the preferences they want, in the format you want. You can keep your preferences high-level and just give your users a way to opt-out of channels, or get detailed and let them opt-out of specific notifications, or both.

The best part: once a user sets their preferences, we handle the rest. You won't have to write a single line of code to figure out whether a user needs to receive a given notification based on their preferences.

You can learn more about how Knock preferences work in our API documentation.

Fixes and improvements

• Added support for user deletion for when users leave your product
• Fixed an issue in the template editor where namespaced variables wouldn't save
• Fixed a layout issue on the dashboard that was causing wonky scrolling behavior
• Renamed Notification to Workflow in the Knock model to disambiguate between Notifications and Messages
• Published version 0.2.0 of all Knock SDKs which includes preferences support

When you're building a new notification workflow, it can be hard to keep track of all of the variables you're using across different channels and what you'll ultimately need to use in your notify call to Knock.

We've made this process easier by giving you a sample notify call right within the context of the Knock workflow builder. Just select your trigger step and you'll see the workflow key and data payload to use in your call to Knock. You can also view code examples in your language of choice to quickly copy-pasta the notify call into your backend.

Fixes and improvements

• We updated all of our ID fields to include a quick copy action
• We fixed a bug in the preview variable editor where text wasn't wrapping

Here's a standard use case: you schedule a notification to remind a user about a task they need to complete in a few days, then before you send it, they complete the task. You don't want to send a notification to the user about a task they've already completed. You want to cancel that notification before it sends. Introducing Knock notify cancellation.

Now when an event takes place in your product that means you no longer need to send a notification to a user (a task is completed, an invite is accepted,) you can cancel that notification before it gets sent.

Learn more about canceling workflows in our documentation.

Fixes and improvements

• Added a new default email layout that looks 👨‍🍳😘
• Cleaned up the channel configuration form to better separate required and optional fields
• Fixed a bug where the subject line in the preview editor was getting cut off at a certain length
• Fixed a bug where clicking in the canvas outside of a workflow step wouldn't de-select a step
• Updated the visual styling of our headers
• Fixed a bug where navigating to the preview tab would register as a change on the commit log

We added a users page to make it easier to see who you've sent to Knock. We've found this to be super helpful in development when you want to know what user properties you have available to use in a template design, and to see which users you can call via the API to test a given notification.

You can see the general properties of that user, along with the messages they've received from Knock.

To learn more about working with users via the Knock API, check out our documentation.

We open sourced our React notification feed package

Our @knocklabs/react-notification-feed package is now open sourced under an MIT license and available on GitHub 💃. These components give you an instant, out-of-the-box notification feed that can be dropped into your app and includes real-time updates, accurate badge counts, and marking as "seen" and "read".

If you're not using React, or you want to customize the UI you can use the lower-level client JS SDK, which is exactly what our React feed is built with!

We're huge believers in open sourcing as much as we possibly can at Knock, and welcome contributions back from the community in this or any of our other packages.

Fixes and improvements

• Added an invite new members flow to make it easier for teams working in Knock to invite their teammates
• Added API references to our API documentation
• Fixed a workflow creation bug where typing "-" in label field wouldn't auto-complete "-" in key field
• Fixed a bug where the timeline of events in a given message's log were out of order
• Open-sourced our feed components
• Fixed a bug where concurrent real-time feed updates would sometimes fail to populate both items in real-time

A lot of homegrown notification systems use simple logic when determining whether to notify a user on a given channel: if they can be reached on that channel, notify them. We would know, we shipped plenty of notifications that way at previous companies.

It gets the job done, but it also sends your users redundant email and push notifications about things they may have already seen in your app. There's a ticket in your backlog about sending email based on a condition, but you can never quite get to it.

Now you can user Knock trigger conditions to tell a Knock workflow when it should notify certain channels and when it shouldn't. You can do things such as only send an email if the sibling in-app notification of that email is unread after ten minutes.

We're jazzed about Knock trigger conditions and we're excited to see what you build with them.

Fixes and improvements

• Added support for archiving workflows. Helpful for when you want to clear a workflow out of your dashboard that you aren't using anymore
• Added real-time preview variable updates when switching between edit and preview tabs in workflow editor
• Added local storage for preview variables so they persist as you navigate between different channels within a workflow
• Added support for filtering by workflow key on feed API
• Fixed an intermittent issue in feed when badge was only updating on feed open
• Fixed a bug where unexpected integers were appearing in preview variables
• Fixed a bug where iterating over workflow activities caused unexpected behavior in preview variables
• Fixed blockquote markdown issue
• Fixed a bug where adding variables to action URLs would add unexpected variables to the preview editor
• Moved data key to the top of the Feed API response payload for better DX
• Updated the auto-generated step name to be human readable
• Updated key fields so they don't allow whitespace characters

We just went live with the Knock private beta. This changelog entry marks the first in what will be a weekly update on the new features, fixes, and improvements we've shipped at Knock.

There's a lot available in the private beta. Here are a few highlights.

• Send notifications to email and in-app channels
• Use our in-app feed react component to have a fully featured, real-time feed working in minutes. Want to build your own? Check out our SDKs
• Build advanced notification workflows with our batch and delay functions
• Get full visibility into all of the messages sent by Knock and the delivery status of each
• Manage your notifications using the same commit and environment promotion flow you use in-house

If you want to see the product in action you can check out this six-minute demo.

Want access to the Knock beta? Hit the "get notified" button at the top of this page to add your name to our wait list and to get notified when we have room available.

Fixes and improvements

• Shipped Elixir, Python, and Node SDKs for working with Knock
• Shipped a login flow
• Fixed a bug where environments wouldn't support consistently on the channel configuration page
• Fixed a bug where batches we're being capped at five items
• Fixed a bug where liquid conditionals weren't working in our email channels
• Fixed a bug where feed items weren't always populating in real-time
• Fixed a bug where the unseen badge wouldn't consistently disappear on feed open
• Fixed a bug where failed emails were hanging in "queued" status
• Fixed a bug where new workflows would default to status ON instead of status OFF
• Added 'key' field to workflow page so it's easier to grab for use with the Knock API
• Added support for password resets
• Added relative timestamps to items in the Knock feed
• Updated template editor so all edits trigger ability to commit changes to current environment