---
title: Quick Start
description: Send your first notification with Notiflows in minutes
---

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](https://app.notiflows.com/signup))
- A project created in your Notiflows dashboard

## 1. Get Your API Keys

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

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

<Callout type="warn">
Keep your secret key secure. Never expose it in client-side code or public repositories.
</Callout>

Store your API keys as environment variables:

```bash
export NOTIFLOWS_API_KEY=pk_your_api_key_here
export NOTIFLOWS_SECRET=sk_your_secret_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.

<Callout>
Don't have a channel configured yet? Head to **Channels** in your project and connect an email provider like Resend, SendGrid, or Amazon SES.
</Callout>

## 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.

<Tabs items={['Node.js', 'Python', 'Ruby']}>
<Tab value="Node.js">
```bash
npm install @notiflows/node
```
</Tab>
<Tab value="Python">
```bash
pip install notiflows
```
</Tab>
<Tab value="Ruby">
```bash
gem install notiflows
```
</Tab>
</Tabs>

## 7. Trigger the Notiflow

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

<Tabs items={['Node.js', 'Python', 'Ruby']}>
<Tab value="Node.js">
```typescript
import Notiflows from '@notiflows/node';

const client = new Notiflows({
  apiKey: process.env.NOTIFLOWS_API_KEY,
  secret: process.env.NOTIFLOWS_SECRET,
});

await client.notiflows.run('welcome-email', {
  recipients: [{ external_id: 'user_123' }],
  data: { name: 'Jane' },
});
```
</Tab>
<Tab value="Python">
```python
from notiflows import Notiflows
import os

client = Notiflows(
    api_key=os.environ["NOTIFLOWS_API_KEY"],
    secret=os.environ["NOTIFLOWS_SECRET"],
)

client.notiflows.run(
    "welcome-email",
    recipients=[{"external_id": "user_123"}],
    data={"name": "Jane"},
)
```
</Tab>
<Tab value="Ruby">
```ruby
require "notiflows"

client = Notiflows::Client.new(
  api_key: ENV["NOTIFLOWS_API_KEY"],
  secret: ENV["NOTIFLOWS_SECRET"]
)

client.notiflows.run("welcome-email", {
  recipients: [{ external_id: "user_123" }],
  data: { name: "Jane" }
})
```
</Tab>
</Tabs>

### Understanding the Parameters

| Parameter | Description |
|-----------|-------------|
| `notiflow` | The identifier of the notiflow to trigger (e.g., `welcome-email`) |
| `recipients` | An array of recipient objects, each with an `external_id` field |
| `data` | (Optional) An object containing variables used in your notification templates |
| `topic` | Alternative to `recipients` - a topic identifier to notify all subscribers |
| `actor` | (Optional) The user performing the action, with an `external_id` field |

<Callout>
Use either `recipients` or `topic`, not both. With `recipients`, you specify exactly who gets notified. With `topic`, all users subscribed to that topic receive the notification.
</Callout>

## 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:

<Cards>
  <Card title="Add More Channels" href="/docs/channels-providers/overview">
    Send notifications via SMS, push, in-app, Slack, and more
  </Card>
  <Card title="User Management" href="/docs/concepts/users">
    Manage user profiles and their notification preferences
  </Card>
  <Card title="Build Complex Flows" href="/docs/learn/building-notiflows/overview">
    Add delays, batching, throttling, and multi-channel orchestration
  </Card>
  <Card title="React In-App Feed" href="/docs/sdks/client-side/react">
    Display real-time notifications in your web application
  </Card>
</Cards>