You can now view, manage, and troubleshoot subscribers directly within your Novu workspace.

What’s New

• Full Subscriber List – See all subscribers in your environment. Each environment has its own isolated subscriber list.

• Sorting Options – Sort subscribers by:

  • Created at

  • Updated at

  

• Easier Subscriber Management – Add new subscribers directly from the UI, including key attributes:

  • Avatar / Image

  • First Name & Last Name

  • Subscriber ID

  • Email & Phone Number

  • Locale

  • Timezone

  • Custom Data

• Edit Subscriber Details – Update attributes in real-time.

• Visibility into Subscriber Preferences – View and manually adjust:

  • Global Preferences – Allow subscribers to set universal channel preferences (e.g., disable SMS across all workflows at once).

  • Workflow Preferences – See all workflows a subscriber is part of, with filtering by workflow tags or preference settings.

• Powerful Search – Find subscribers by:

  • Subscriber ID

  • Email

  • Phone

  • Name

  

• Per-Subscriber Activity Feed – See every event sent (or attempted) for a subscriber, improving troubleshooting and debugging. Filter events by:

  • Workflows (one or multiple)

  • Channels (one or multiple)

  • Transaction ID

This update gives you deeper control and insights into your subscribers—right from the Novu dashboard.

Bug fixes

• 🐛 Clicking outside of dropdowns closes the sidebar

• 🐛 When the new digest step is added the "missing active integration" error is shown

• 🐛 Fixed Incorrect delay step preview

• 🐛 Fix truncated text issue in workflow list and subscribers

More improvements & fixes

• Display the number of conditions in the counter badge on Canvas when conditions are available.

• Update SendInblue to Brevo in the email integrations list.

We’re excited to announce the release of Step Conditions in Novu!

With this new feature, you can now fully customize your notification workflows by controlling the execution of steps based on subscriber data, payload information, and previous step outcomes. This enhancement empowers you to deliver dynamic, personalized notifications tailored to your users' context and behavior.

What’s New?

Subscriber-Based Conditions

Define rules using subscriber attributes like locale, isOnline, or lastOnlineAt.

Example: Send SMS only to offline users.

Payload-Driven Conditions

Create conditions based on workflow trigger payloads for real-time contextual notifications.

Example: Notify users when payload.totalAmount > 100.

Outcome-Based Conditions

Trigger actions based on the outcomes of previous workflow steps, such as steps.{step-id}.seen or steps.{step-id}.read.

Example: Escalate notifications if an in-app wasn’t opened.

Advanced Logic with Condition Groups

Use AND, OR, and nested conditions to create complex workflows for multi-channel escalations or location-based routing.

Expanded Operator Library

A robust set of operators, including comparison, string, and range-based options like contains, is null, between, and more.

Use Cases to Explore

• Multi-Channel Escalation: Notify through additional channels if the primary notification goes unseen.

• Location-Based Notifications: Target users based on their locale or time zone.

• Personalized Content: Adapt messaging based on subscriber or payload attributes.

Why It Matters

Step Conditions give you granular control over your workflows, ensuring that every notification is relevant, timely, and impactful. By simplifying complex logic and reducing unnecessary alerts, you’ll boost user engagement and satisfaction.

Ready to elevate your notification strategy?

Learn More about Step Conditions and start building smarter workflows today! 🚀

We’re thrilled to announce official Novu SDKs for TypeScript, Python, Go, and PHP!

These production-ready libraries empower developers to seamlessly integrate enterprise-grade notifications into their applications—whether you're working with web frameworks, microservices, background workers, or event-driven architectures.

Why This Matters

• Reliability – Built-in idempotency prevents duplicate notifications, and intelligent retry mechanisms ensure successful delivery under any conditions.

• Seamless Developer Experience – Each SDK follows idiomatic best practices, with fully-typed APIs, async support, and lightweight integration.

• Effortless Multi-Channel Notifications – Send notifications via email, SMS, push, in-app, or chat in just a few lines of code.

• Explore the Live API Playground – Instantly test and interact with our API in real time, experiment with requests and responses, and see how it works—no setup required.

TypeScript SDK

At Novu, we use our auto-generated TypeScript SDK internally to ensure everything works and behaves as expected. This SDK provides the most up-to-date experience for interacting with the Novu API.

Key Features:

• First-class TypeScript support with strict type safety.

• Seamless integration with Node.js, Next.js, Express, and other JS/TS frameworks.

• Async-ready API with native promises.

• Works with React, Vue, Angular, and modern frontend frameworks.

• The same SDK Novu uses internally—fully battle-tested.

Explore the TypeScript SDK

Python SDK

Python developers can now enjoy first-class Novu support, making it easier than ever to integrate notifications into Django, Flask, FastAPI, Celery, and more.

Key Features:

• Fully-typed API for a smooth development workflow.

• Sync & async support for real-time event-driven notifications.

• Works with Django, Flask, FastAPI, Celery, and task queues.

• Ideal for event-driven architectures (Kafka, RabbitMQ, Redis Pub/Sub).

Explore the Python SDK

Go SDK

Go developers can now integrate Novu notifications effortlessly into microservices, background workers, and serverless environments.

Key Features:

• Idiomatic Go API with structured types.

• Sync & async workflows with automatic retries.

• Works with Gin, Echo, Fiber, Chi, AWS Lambda, and Google Cloud Functions.

• Integrates seamlessly with RabbitMQ, NATS, Kafka, and AWS SQS.

Explore the Go SDK

PHP SDK

PHP developers can now take advantage of enterprise-grade notifications with a fully-supported Novu PHP SDK.

Key Features:

• Clean, intuitive PHP API with strong type support.

• Works with Laravel, Symfony, CodeIgniter, and Slim.

• Seamless queue & background job support (Laravel Queues, Symfony Messenger, AWS SQS).

• Perfect for CMS & CRM integrations (WordPress, Drupal, Magento).

Explore the PHP SDK

Our Partnership with Speakeasy

Building best-in-class SDKs isn’t just about wrapping API endpoints—it’s about creating a world-class developer experience across every language.

That’s why we partnered with Speakeasy to auto-generate our SDKs from OpenAPI, allowing us to deliver high-quality, idiomatic SDKs while maintaining our internal development velocity.

Why We Love Working with Speakeasy:

• We don't have to write the SDKs manually! 🚀

• Trust that every SDK ships with world-class DX, following idiomatic conventions for each language.

• Streamlined CI/CD – The build and release process is fully automated.

• Zero maintenance overhead after the initial setup.

• Internal velocity boost – We use the SDKs ourselves to dogfood E2E testing and internal cross-service communication.

• Forced us to invest heavily in OpenAPI – ensuring better API consistency and scalability.

🚀 Get Started Today!

Whether you’re scaling enterprise notifications or integrating Novu into your next project, our new SDKs for TypeScript, Python, Go, and PHP provide the flexibility and power you need.

📖 Check out the official documentation and start sending notifications in minutes!

The Variable Popover is a game-changer for dynamic content in Novu’s dashboard, eliminating the need to manually write or reference Liquid syntax. Instead of coding variables and transformations by hand, you can simply pick, configure, and preview everything directly in the UI—no more guesswork, no more syntax errors.

With this intuitive popover, inserting, modifying, and previewing dynamic content is faster, smarter, and code-free.

Why It Matters

Previously, handling dynamic variables in notifications required:

• Manually referencing variable names

• Writing and debugging Liquid syntax

• Switching screens to preview filter results

This was not only tedious but also left room for syntax errors and broken notifications.

The Variable Popover changes this by introducing a visual, no-code approach to working with dynamic data.

Key Benefits

• No More Manual Liquid Syntax – Pick and configure variables directly in the UI.

• Instant Context & Live Previews – See exactly how each variable will render.

• Error-Free Transformations – Apply filters (e.g., capitalization, date formatting, number adjustments) without worrying about syntax.

• Quick Modifications – Set default values, adjust formats, and preview outputs in real-time.

• Filter Suggestions – Novu will automatically suggest filters based on your variable type

The Bottom Line

The Variable Popover in Novu eliminates the need to manually write LiquidJS, making notification configuration faster, more intuitive, and error-free.

By replacing complex syntax with interactive UI controls and real-time previews, it ensures every notification is formatted correctly—without needing to debug Liquid code.

Try it now

We've noticed common patterns in how teams build notification workflows, yet many still start from scratch. Instead of reinventing the wheel, why not begin with a set of proven, ready-to-use workflows designed for multi-channel delivery?

The Novu Workflow Template Store eliminates this redundancy by providing a library of standardized, pre-built notification workflows that align with industry best practices.

These templates cover essential use cases such as account security, user engagement, transactional updates, and system alerts, offering a structured approach to notification management.

Each template includes predefined multi-channel steps, logical sequencing, and boilerplate content, significantly reducing implementation time.

Why Standardized Notification Workflows?

Most notification systems adhere to predictable patterns.

A password reset request, for instance, typically includes an email or SMS with a reset link.

A welcome sequence often involves an onboarding email, followed by a follow-up message if the user remains inactive.

Instead of reinventing these workflows, the Workflow Template Store provides structured, reusable solutions that can be customized as needed.

By standardizing notifications, organizations can:

• Ensure consistency in user communication.

• Reduce development effort by leveraging existing templates.

• Minimize errors associated with custom-built workflows.

• Improve reliability through tested, best-practice implementations.

Each template is designed with multi-channel capabilities, supporting email, SMS, push notifications, and chat platforms (Slack, Discord, etc.) while following logical fallback mechanisms.

How it works?

What comes next?

Growing the Workflow Template Store!

The Workflow Template Store is not static—it will continuously expand with more pre-built workflows. The Novu team is actively adding new templates, covering additional use cases, industries, and integration needs.

Submit your workflow template requests

Managing notifications across environments can be complex, but it’s also essential for delivering seamless and reliable user experiences. Novu's Multi-Environment Support introduces a structured, secure, and efficient way to handle your notification workflows at every stage—from development to production.

What This Means for You

Novu environments provide logical separation of data, workflows, and configurations between stages of your development lifecycle.

Each environment—whether for testing, staging, or production—is fully independent, offering you the confidence to build and deploy without accidental overlap or data leakage.

Key Capabilities

1. Isolated Environments

   Each environment functions independently, allowing you to:

   • Maintain unique subscriber lists.

   • Configure workflows specific to the environment.

   • Separate message histories, activity feeds, and integration settings.

   • Manage branding assets uniquely for each environment.

2. Environment-Specific Security

   • Application Identifiers: Unique, frontend-friendly identifiers tied to each environment.

   • API Secret Keys: Backend-specific keys that ensure secure and controlled API access.

3. Change Management

   Novu’s commit and promotion model minimizes risks in production by enforcing structured change handling:

   • Save updates in the Development environment.

   • Validate changes before promoting them to higher environments.

   • Sync your changes to Production or Staging environments

4. Custom Environments for Advanced Development life-cycles

   For more complex development lifecycles, you can create additional environments such as QA or Staging.

   • Custom environments allow greater flexibility in testing and validation.

   • Environments are ordered hierarchically, ensuring logical promotion paths from Development to Production.

   • Manage new environments directly through the Environments page in your Novu dashboard.

How to Use Multi-Environment Support

1. Default Setup: Each account comes pre-configured with Development and Production environment.

2. Add Custom Environments:

   • Navigate to the Environments tab (Under Developer section) to add environments such as Staging or Sandbox.

3. Credential Setup: Use the environment-specific Application Identifier and API Secret Key to configure integrations dynamically.

4. Promote Changes:

   • Validate changes in Development.

   • Promote updates to higher environments using the dashboard.

Try it Out

Click here to visit the Dashboard V2 Environments page

Start managing your environments today and take full control of your notification workflows.

We’re thrilled to introduce Novu Dashboard 2.0, the ultimate upgrade to your notification management experience! Packed with powerful features and a sleek new design, this release empowers both technical and non-technical teams to build, manage, and customize workflows with unparalleled ease.

Here's what’s new

Cloud Workflow Editor

The cloud no-code visual workflow editor is back—redesigned, reimagined, and powered by a hosted Framework SDK.

Create workflows in minutes without writing a single line of code. For advanced use cases, seamlessly switch to code and sync workflows directly into your account. Simple or custom, the choice is yours.

• Effortless and intuitive: Build workflows directly in your dashboard with a powerful visual editor.

• Code-free by default: Design and customize workflows without ever opening a text editor.

• Unmatched flexibility: When you need full control, eject to code and leverage the full power of Novu’s framework.

New Visual Email Editor

Creating emails is easy now. When you add an email step to your workflow and configure the email template, you’ll gain access to a WYSIWYG email block editor—designed to feel as intuitive as Notion’s page interactions.

With pre-designed components, you can build stunning, high-performing emails in minutes. Personalization? No problem. Seamlessly integrate dynamic variables to deliver a tailored experience for every user.

We have partnered with maily.to to create the best possible email crafting experience powered by react.email. In upcoming releases, we are doubling down on our react email integration and will allow to customize the experience with your own components.

Improved Activity Feed

We have redesigned the activity feed to make it easier to view and debug your workflows right from the new dashboard UI. In a more condensed view, highlighting what's important.

In-App notification testing

Test in-app notifications directly from the UI dashboard.

When you add an in-app step to your workflow, you can easily trigger the workflow and view the notification in your Novu UI dashboard inbox. This makes it simple to test, refine, and iterate quickly on the design, content, and overall experience of your in-app communication channel.

With Novu Dashboard 2.0, users across different roles gain value:

• Developers: Get started quickly for simpler use cases without writing code. For complex integrations, seamlessly transition to code when needed using the Novu Framework SDK.

• Product Teams: Operate independently with intuitive tools while keeping workflows safeguarded against critical errors.

• Everyone: Enjoy the ease of a unified, 100% cloud-based platform that eliminates the need for locally running engines or bridges.

Migration from V1 to V2

At this time, automatic migration isn’t available. However, you can create new workflows in V2 while using your existing V1 workflows alongside them.

Visit the new Dashboard and tell us what you think about it!

What’s next?

The team is currently working on multiple exciting projects:

• New subscriber management page

• More Email blocks

• Branding management

• Inbox improvements

• Workflow Template Store

• Step conditions

• New Rest API SDKs for major languages

You can now control the position of the popover content by specifying the placement and placementOffset props for the @novu/react component.

<Inbox
  applicationIdentifier="Your App ID"
  subscriberId="Subscriber ID"
  placement="bottom-end"
/>

The package supports the following placements:

type Placement = "bottom-end" | "bottom-start" | "left-end" | "left-start" | "right-end" | "right-start" | "top-end" | "top-start" | "bottom" | "left" | "right" | "top";

For further adjusting the placement the placementOffset could be used:

<Inbox
  applicationIdentifier="Your App ID"
  subscriberId="Subscriber ID"
  placement="bottom-end"
  placementOffset={10}
/>

Fixes

• Truncate workflow name and center empty notifications text in preference component

The Novu Framework SDK is now more compatible than ever across bundles with added native ESM + CJS builds. This ensures you can manage your notifications across multiple js runtimes.

Features

• Bundle native ESM + CJS builds

• Support Next.js 15, including Turbopack dev (next dev --turbo)

• Support a single package import for all Web Frameworks (for example in Next.js: import { workflow, serve } from '@novu/framework/next)

Bug fixes

• Ensure missing schemas infer a Record<string, unknown> type for corresponding data to enforce consumer-type strictness.

• Remove the erroneous "Hydrate step failed" error log when previewing steps with more than one step.

• Replace all computed property keys for type inference with static declarations to improve compiler performance.

• Stop validating controls for non-previewed steps to prevent incorrect validation messages.

• Stop logging discovery of workflows that weren't included in the serve function.

• Prevent specification of payload and control schemas for primitive types, allowing only object types to be specified.

Global Preferences now only display channels on which the Subscriber receives notifications, ensuring the Subscriber only sees relevant channels and reducing UI noise for customers.

You can now control the name and description fields when creating framework-based workflows:

workflow('welcome-onboarding', async ({ step }) => {
  await step.email('send-email', async () => ({
    subject: 'Welcome to our platform!',
    body: 'Welcome to our platform!',
  }));
}, {
  name: 'Welcome Onboarding',
  description: 'This is a welcome onboarding email workflow. It is a simple workflow that sends a welcome email to the user.',
  tags: ['critical', 'business'],
});

The name will be later used for display in the Subscriber Preferences on the Inbox component and in the Dashboard editor UI.

LiquidJS JSON Support for Controls

JSON objects can now be used as part of the content controls with Liquid: {{payload.comments | json}}

Other notable changes

• Add support for custom tunnels in npx novu dev command using --tunnel (#6711)

• Propagate Bridge server runtime error messages and stack traces to Bridge client (#6708)

Since day one, we've been building our API services on top of the NestJS framework. We've been working with an internal module for @novu/framework for a few months now and are excited to open-source the module for our customers to use in their Nest applications as well!

To learn more on how to integrate with your Nest application read our docs.

import { Module } from '@nestjs/common';
import { NovuModule } from '@novu/framework/nest';
import { testWorkflow } from './novu/workflows';

@Module({
    imports: [
        NovuModule.register({
            apiPath: '/api/novu',
            workflows: [testWorkflow],
        }),
    ],
})
export class AppModule {}

We are excited to ship more customizable and granular control over the default subscriber preferences and change the visibility of the different preferences controls.

Preference on all levels

The new preference control allows the following scenario:

• A developer specifies the default behavior in the code

• A non-technical team member can override the behavior using the dashboard

• A subscriber can change the default preference behavior using the <Inbox /> component or API.

Common usecases

• Hiding critical workflows from the user preferences

• Setting some channels as on or off by default for given workflows

• Disable the ability to control the code-set settings from the UI for system-critical workflow and only manage them in code.

Read more on our docs

Other notable changes

• @novu/js and @novu/react v2.4.0

  • By default, hide the critical workflows from the preference list

  • Preview for inbox notification content in the dashboard now supports bold in the subject and in the body

  • 🐛 Bug Fix: notification.read() call returning empty notification object

  • 🐛 Bug Fix: The wrong time was displayed with old notifications

  • 🐛 Bug Fix: The notification mark as actions appear to be under the subject/body

You can now self-host v2.0 API, Dashboard, and workers using our public Docker Image.

We have also updated our Community Self-Hosting page and docker instructions with basic system requirements and services required to run Novu on-prem.

The new Docker image aligns with the latest @novu/framework capabilities for defining and running code-based workflows as part of our workflow engine execution. Read more on our docs.

Note: In the new docker image, only code-based workflows will be supported with limited backward compatibility; a backward-compatible version is planned for release in the upcoming weeks.

To get started, visit our Get Started Guide

Our <Inbox /> Component now supports React Native apps 🎉

To learn more, read our React Native Quick Start Guide on how to get started. We have also created a sample project using Expo and React Native.

You can now filter the subscriber preference list on our <Inbox /> component. This is very handy when you have multiple user types in your system, and they don't need to see specific notification workflows that are irrelevant to them.

This is achieved by passing the preferencesFilter prop to the component and mentioning the workflow tags the current subscriber should see.

<Inbox
  applicationIdentifier="YOUR_APPLICATION_IDENTIFIER"
  subscriberId="YOUR_SUBSCRIBER_ID"
  preferencesFilter={{ tags: ['mention', 'newsletter', 'security'] }}
/>

New popover animations

Added a new subtle and slick show and hide animation when opening the Inbox component.

Other notable changes

• The shadows of the Inbox can now be controlled using the colorShadow variable

• Improved the spacing around the "Time Ago" label when long notification text is visible

The latest <Inbox /> release now enables you to mark text as bold. Enclose your desired text with asterisks (**), and voilia!

Learn more in the docs, or play with it live in our <Inbox /> Playground.

The new Inbox 2.0.0 release now supports a framework-native navigation system that replaces the old browser full-page navigation system we had in place. This ensures smooth and fast client-side navigation while maintaining the browser history for a more delightful end-user experience.

The new routerPush will receive the url path defined within the workflow on both the notification and action levels:

export const inAppDemo = workflow("in-app-demo", async ({ step }) => {
  await step.inApp("send-in-app", async () => {
    return {
      subject: "This is a _test_ subject"  + new Date(),
      body: "This is a test body",
      avatar: 'https://static.vecteezy.com/system/resources/thumbnails/006/487/917/small_2x/man-avatar-icon-free-vector.jpg',
      redirect: {
        url: "/a-relative-page-in-my-app",
      },
      primaryAction: {
        label: 'Accept',
        redirect: {
          url: '/another-relative-page-in-my-app',
        }
      },
      secondaryAction: {
        label: 'Secondary action',
        redirect: {
          url: 'https://google.com',
        }
      },
    };
  });
});

We've just added the autocomplete functionality in our Step Controls editor to enhance your workflow:

• Liquid filters: Apply Liquid filters (e.g. upcase) directly within autocomplete suggestions for better content control.

• Seamless navigation: Use arrow keys to navigate suggestions, press ENTER to select the variable, or press ESC to close the dropdown quickly.

• Variable editing: Easily navigate and edit variables within curly braces. Errors are now shown instantly when dealing with incomplete or invalid variables.

If you're looking for a simple and easy way to create a beautiful in-app notification experience for your users, look no further.

New features

• Subscriber preferences: Customize notification settings directly in the app.

• Notifications feed: A centralized hub for all notifications with subject lines for quick information access.

• Bell/Counter component: Visual notification alerts with an unread badge for better clarity.

Enhancements

• Filtering options: Easily filter notifications by unread or archived status, improving inbox management.

• Archive/unarchive notifications: Efficiently manage your notification list while keeping a historical record for later retrieval.

• Bulk actions: Archive all or all read notifications in one go for quicker inbox organization.

Updated functionalities

• Unread badge: Replaces the previous "unseen badge" for improved familiarity and clarity.

• Archiving vs. removal: Notifications are now archived instead of removed, preserving historical data and preventing accidental data loss.

Design and performance improvements:

• Revamped design: A refreshed, user-friendly design focused on clarity and efficiency, reducing confusion.

• Performance boost: The new component is powered by SolidJS, leading to faster interactions, a smaller bundle size, and better overall performance.

• Optimized resource usage: Single WebSocket connection across tabs and consolidated API calls reduce load on services, improve load times, and enhance user experience.

To learn more, check out our documentation.

Modifying your notification steps in the UI just got easier. With the latest revamp of the Step Controls, we introduce:

• More intuitive UI and sleeker design

• Autocomplete suggestions for interpolated payload input when modifying the controls

• Instant control validation

Learn more about controls in our documentation.

We just rolled out an SSO (Single Sign-On) integration, enabling you to authenticate your organization’s users with your existing SAML infrastructure.

Some of the capabilities that the new integration unlocks include:

• The ability to configure multi-factor authentication

• Custom, SAML-based SSO configuration per customer request

• Infrastructure for role-based access control

To learn more or learn how to enable SSO for your organization, check out our documentation.

You can now reference a created workflow using the Framework SDK, and get a complete end-to-end type safety and auto-completion for your triggers.

import { workflow } from '@novu/framework';

const commentWorkflow = workflow('comment-on-post', async ({ step }) => {
  await step.email();
}, {
 payloadSchema: z.object({
   post: z.object({
     id: z.number(),
     title: z.string()
   })
 }) 
});

// complete type-safety for the payload object
commentWorkflow.trigger({
  to: { subscriberId: '[email protected]' },
  payload: { 
    post: {
      id: 1234,
      title: 'Post Title'
  }
});

It's still possible to make the trigger from any of our backend SDKs (Node, PHP, Go, etc..) following the trigger command:

from novu.api import EventApi

url = "https://api.novu.co"
api_key = "<NOVU_API_KEY>"

novu = EventApi(url, api_key).trigger(
    name="<WORKFLOW_TRIGGER_IDENTIFIER>", # This is the Workflow ID
    recipients="<UNIQUE_SUBSCRIBER_IDENTIFIER>",
    payload={},  # Your custom Novu payload goes here
)

You can now use Zod Schemas for defining your payload and step controls schemas. The Framework SDK will infer those zod schemas and provide a run-time validation and autocompletion for usage.

Here is an example of a Zod-based validation:

import { workflow } from '@novu/framework';
import { z } from 'zod';

workflow('comment-workflow', async ({ step }) => {
  await step.email('digest-email', async (controls) => ({
    subject: controls.subject,
    body: 'body'
  }), {
    controlSchema: z.object({
      subject: z.string().default('Hi {{subscriber.firstName}}'),
      openAiModel: z.enum(['gpt-3.5-turbo', 'gpt-4o']).default('gpt-4o'),
      aiPrompt: z.string().default('Produce a concise comment digest'),
    })
  });
}, { 
  payloadSchema: z.object({
    name: z.string(),
    comment: z.string() 
  }) 
});

Common usecases

• Validate trigger payload contents to make sure that null or undefined data ends up in your notifications.

• Provide default values for non-required attributes

• Create custom validation logic based on backend logic

• Define UI step controls and expose UI elements from zod schemas

To learn more about Zod integration, read our documentation.

You can now pass your push and chat tokens directly from novu.trigger endpoint. This eliminates the need for a separate process to keep push tokens in sync with Novu.

This behavior aligns with how email and phone fields can be passed during the trigger phase.

novu.trigger('workflow-id', {
  to: {
    subscriberId: 'subscriber-id',
    channels: [
      {
        providerId: 'fcm',
        credentials: {
          deviceTokens: ['token-1'],
        },
      },
    ],
  },
  payload: {},
});

Our API will upsert those credentials on the subscriber entity and use them for delivery.

You can now run custom code as part of your Echo workflows. Our workflow engine will ensure the durability and persistence of running your code.

Custom steps is our way to unlock limitless flexibility when it comes to your workflows:

• Integrate with 3rd party services like CMS, Localization, Templating, HubSpot

• Fetch and reuse data from your database and reuse across your workflow

• Run AI Prompts to enrich your notifications

• Create a custom provider that Novu might not be supported yet

• Stream analytical data back to your Dataware house

• And more...

We are curious to hear what the broader development community will invent with it.

Want to learn more? Visit our docs

We're excited to announce the integration of WhatsApp Business into Novu's platform!

WhatsApp is a cornerstone of communication in over 180 countries, making it a vital tool for businesses to reach their audiences. You asked for it, and we listened. With this integration, you can now leverage WhatsApp to send timely and personalized notifications directly to your users.

Some use cases you might be interested in:

• Engage users with custom alerts, reminders, and status updates directly through WhatsApp

• Set up and manage automated workflows triggering based on user actions or predefined conditions

• Sending high-volume notifications? Enjoy stable and reliable delivery regardless of the volume

Steps to start sending:

1. Create a Facebook Developer App

2. Setup WhatsApp Product

3. Send a Sandbox Message

4. Add a Test Phone Number

5. Send a test notification from Novu

Read more Here

Novu Echo has a new integration with React Email, making it incredibly easy for developers to incorporate fully functional email capabilities directly within their React applications.

Key Enhancements:

• Streamlined integration: Set up React Email with your Novu Echo in just three steps, whether you're starting from scratch or integrating into an existing project.

• Component-Based emails: Utilize React components to construct and send rich, interactive emails directly from your React or Next.js applications.

• Developer-centric workflow: From installation to sending out your first email, the process is designed with developer ease in mind

E-mail shouldn’t be hard. Give the new integration a shot!

Read more

Hello to all Builders.

We're thrilled to announce the launch of our new Changelog!

In our relentless journey to innovate, solve problems, and create the best solutions for our customers, we've been hard at work improving our SaaS product. And we don't want you to miss out on any of the action. That's why we've introduced this Changelog - a dedicated place where you can keep track of all the updates, improvements, and new features we're rolling out.

Here’s what you can expect:

• Feature Releases: Everything that is new

• Improvements: Details on tweaks we've made to existing functionalities for better performance and usability.

• Bug Fixes: Details on fixes we've made so you can enjoy a smoother product experience.

You can simply bookmark this page or subscribe to our newsletter to get regular updates. Our transparency, your trust, and mutual growth are what matter to us the most.

Thank you for your continued support and happy hacking!

Novu Team.