Notifications,
delivered everywhere.

A TypeScript notification library for Node.js. Write a notification once, then send it by email, SMS, push, Slack, websockets and to an in-app inbox.

Get started

billing_service.ts

await facteur
  .notification(InvoicePaidNotification)
  .to(jane)
  .params({ amount: 100 })
  .send()

Acmenow

Invoice paid

Your invoice of $100 has been paid.

ACME

Invoice of $100 paid. Thanks, Jane!

Acme Billing9:41

Jane Cooper paid $100

Inbox1

Invoice of $100 paid

Just now

Channels

Every address your users have

Install only the providers you use. Bring your own when you need more.

Messaging

Email, SMS, chat

Reach people where they already read: their inbox, their phone, your team channels.

Configure a channel

Includes

In-appBuilt-in inbox

Your own inbox

Store notifications, push them live, and render them with a typed API and React hooks.

Build an inbox

Includes

Push and HTTP

Devices and services

Native and web push for your apps, signed webhooks for everything else.

Write a custom channel

Includes

In code

From class to inbox in four steps

A notification is a class. Facteur carries it to every channel you configured.

One class per notification

Declare where it goes and how it reads on each channel.

invoice_paid_notification.ts

import { Notification } from '@facteurjs/core/types'
import { DatabaseMessage } from '@facteurjs/core/database'
import { TwilioMessage } from '@facteurjs/core/channels/twilio'
import type { User } from './user.js'

export default class InvoicePaidNotification extends Notification<User, { amount: number }> {
  static options = {
    name: 'Invoice paid',
    category: 'billing',
    deliverBy: { database: true, twilio: true },
  }

  asDatabaseMessage() {
    return DatabaseMessage.create().setType('invoice-paid').setContent({ amount: this.params.amount })
  }

  asTwilioMessage() {
    return TwilioMessage.create().setBody(`Invoice of $${this.params.amount} paid.`)
  }
}

One call, every channel

Facteur resolves targets, applies preferences and retries failures.

billing_service.ts

import { facteur } from './facteur.js'
import InvoicePaidNotification from './invoice_paid_notification.js'

// One recipient
await facteur.notification(InvoicePaidNotification).to(user).params({ amount: 100 }).send()

// Thousands of recipients, in chunks, without stopping on failures
await facteur
  .notification(InvoicePaidNotification)
  .to(customers)
  .params({ amount: 100 })
  .chunkSize(100)
  .concurrency(5)
  .continueOnError()
  .send()

A fake for your tests

Swap Facteur for a recorder, then assert what was sent.

billing.spec.ts

import assert from 'node:assert'
import { test } from '@japa/runner'
import { facteur } from '#services/facteur'

test('notifies the customer when an invoice is paid', async () => {
  using fake = facteur.fake()

  await billing.markAsPaid(invoice)

  fake.assertSent(InvoicePaidNotification, (sent) => {
    assert.equal(sent.to.id, invoice.customerId)
  })
})

An inbox in your frontend

React hooks read and update stored notifications through the Server API.

inbox.tsx

import { useMarkAsRead, useNotifications } from '@facteurjs/react'

export function Inbox() {
  const { data: notifications = [] } = useNotifications({ limit: 10, status: 'unread' })
  const markAsRead = useMarkAsRead()

  return (
    <ul>
      {notifications.map((notification) => (
        <li key={notification.id}>
          Invoice of ${notification.content.amount} paid
          <button onClick={() => markAsRead.mutate({ notificationId: String(notification.id) })}>
            Mark as read
          </button>
        </li>
      ))}
    </ul>
  )
}