Quick Start

This guide walks you through creating your first notiflow and triggering it from your application. By the end, you'll have a working notification flowing through Notiflows.

Prerequisites

• A Notiflows account (sign up here)
• A project created in your Notiflows dashboard

1. Get Your API Key

Every project in Notiflows has its own set of API keys. You'll need the Secret API Key to trigger notiflows from your backend.

1. Open your project in the Notiflows dashboard
2. Navigate to Settings > API Keys
3. Copy your Secret API Key (starts with sk_)

Store your API key as an environment variable:

export NOTIFLOWS_API_KEY=sk_your_api_key_here

2. Create Your First Notiflow

A notiflow defines what happens when you trigger a notification. It's a sequence of steps that can include sending messages through different channels, adding delays, batching notifications, and more.

1. In your project, go to Notiflows
2. Click Create notiflow
3. Enter a name, for example: welcome-email
4. Click Create

You'll be taken to the notiflow overview. Now let's build it.

3. Design the Notiflow

Click on Steps to open the visual builder. Every notiflow starts with a Trigger node and ends with an End node.

Add a Channel Step

1. From the right sidebar, drag an Email step onto the canvas
2. Connect it between the Trigger and End nodes
3. Click on the Email step to configure it

Configure the Channel

1. Select an email channel (you'll need to have one configured in Channels)
2. Set up your email template:
   • Subject: Welcome to our platform, {{ data.name }}!
   • Body: Design your email content using the template editor

You can use Liquid variables like {{ data.name }} or {{ recipient.email }} that will be populated from the data you send when triggering the notiflow.

4. Publish Your Notiflow

Notiflows use versioning to help you safely iterate on your notification logic. When you make changes, they're saved as a draft version. To make your notiflow live, you need to publish it.

1. Go to the Changes tab
2. You'll see your draft version listed
3. Click Publish
4. Confirm the publish action

Your notiflow is now live and ready to receive triggers.

5. Activate the Notiflow

Before a notiflow can process triggers, it needs to be activated.

1. Go to the Overview tab
2. Toggle the notiflow to Active

6. Install the SDK

Add the Notiflows SDK to your backend application.

npm install @notiflows/node

pip install notiflows

gem install notiflows

go get github.com/notiflows/notiflows-go

composer require notiflows/notiflows-php

# Maven
<dependency>
    <groupId>com.notiflows</groupId>
    <artifactId>notiflows-java</artifactId>
    <version>1.0.0</version>
</dependency>

dotnet add package Notiflows

7. Trigger the Notiflow

Now you can trigger your notiflow from your backend whenever you want to send a notification.

import { Notiflows } from '@notiflows/node';

const client = new Notiflows(process.env.NOTIFLOWS_API_KEY);

await client.notify({
  notiflow: 'welcome-email',
  recipients: [
    { external_id: 'user_123' }
  ],
  data: {
    name: 'Jane',
  },
});

from notiflows import Notiflows
import os

client = Notiflows(os.environ["NOTIFLOWS_API_KEY"])

client.notify(
    notiflow="welcome-email",
    recipients=[
        { "external_id": "user_123" }
    ],
    data={
        "name": "Jane"
    }
)

require 'notiflows'

client = Notiflows.new(ENV['NOTIFLOWS_API_KEY'])

client.notify(
  notiflow: 'welcome-email',
  recipients: [
    { external_id: 'user_123' }
  ],
  data: {
    name: 'Jane'
  }
)

package main

import (
    "os"
    "github.com/notiflows/notiflows-go"
)

func main() {
    client := notiflows.NewClient(os.Getenv("NOTIFLOWS_API_KEY"))

    client.Notify(&notiflows.NotifyParams{
        Notiflow: "welcome-email",
        Recipients: []notiflows.Recipient{
            {ExternalID: "user_123"},
        },
        Data: map[string]any{
            "name": "Jane",
        },
    })
}

use Notiflows\Client;

$client = new Client(getenv('NOTIFLOWS_API_KEY'));

$client->notify([
    'notiflow' => 'welcome-email',
    'recipients' => [
        ['external_id' => 'user_123']
    ],
    'data' => [
        'name' => 'Jane'
    ]
]);

import com.notiflows.Client;
import com.notiflows.Recipient;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        var client = new Client(System.getenv("NOTIFLOWS_API_KEY"));

        client.notify(
            "welcome-email",
            List.of(new Recipient("user_123")),
            Map.of("name", "Jane")
        );
    }
}

using Notiflows;

var client = new NotiflowsClient(
    Environment.GetEnvironmentVariable("NOTIFLOWS_API_KEY")
);

await client.NotifyAsync(
    notiflow: "welcome-email",
    recipients: [
        new Recipient("user_123")
    ],
    data: new Dictionary<string, string>
    {
        { "name", "Jane" }
    }
);

Understanding the Parameters

8. Verify Delivery

After triggering your notiflow, you can verify the notification was sent:

1. Go to your notiflow's Runs tab to see execution history
2. Click on a run to see detailed delivery information for each recipient
3. Check the Notifications section in your project to see all sent notifications

What's Next?

Now that you've sent your first notification, explore more features: