apipush-notificationsdevelopertutorial

Send Push Notifications from Any REST API: The Complete Developer Guide

A language-agnostic guide to sending push notifications from any backend using the FlowAlert REST API — with examples in Node.js, Python, PHP, Ruby, Go, and cURL.

FlowAlert TeamMay 12, 2026 5 min read

Send Push Notifications from Any REST API: The Complete Developer Guide

Push notifications shouldn't require a Firebase project, a service worker, VAPID keys, or a third-party SDK. If your backend can make an HTTP request, it can send a push notification.

This guide covers the FlowAlert Events API — a single REST endpoint you can call from any language, any framework, any infrastructure.

The API in 30 Seconds

curl -X POST https://api.flowalert.io/v1/events \
  -H "Content-Type: application/json" \
  -H "X-Api-Key: fa_live_xxxxxxxxxxxx" \
  -d '{
    "event": "server.cpu_spike",
    "title": "⚠️ High CPU Usage",
    "body": "web-01 is at 94% CPU for 5 minutes",
    "priority": "URGENT"
  }'

That's it. If you have a FlowAlert account and the mobile app installed, that curl command will push a notification to your phone.

API Reference

Endpoint: POST https://api.flowalert.io/v1/events

Authentication: X-Api-Key: <your_api_key> header

Request body:

Field	Type	Required	Description
`event`	string	✅	Your event key. Use dot-notation: `payments.failed`
`title`	string	✅	Push notification title (shown in system tray)
`body`	string	✅	Push notification body text
`priority`	string	—	`LOW`, `NORMAL`, `HIGH`, `URGENT`. Default: `NORMAL`
`data`	object	—	Arbitrary JSON metadata attached to the event
`url`	string	—	Deep link URL that opens when user taps the notification
`dedupeKey`	string	—	If provided, duplicate events with the same key within 10 minutes are ignored

Response:

{
  "ok": true,
  "eventId": "cm_xxxxxxxxxxxxxxxx",
  "eventType": "server.cpu_spike"
}

Examples by Language

Node.js (native fetch)

async function notify({ event, title, body, priority = 'NORMAL', data = {} }) {
  const res = await fetch('https://api.flowalert.io/v1/events', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Api-Key': process.env.FLOWALERT_API_KEY,
    },
    body: JSON.stringify({ event, title, body, priority, data }),
  });
  return res.json();
}

// Usage
await notify({
  event: 'user.signup',
  title: '🎉 New User',
  body: 'alice@example.com just signed up',
  priority: 'NORMAL',
  data: { email: 'alice@example.com' },
});

Python

import os
import requests

def notify(event: str, title: str, body: str, priority: str = "NORMAL", data: dict = None):
    requests.post(
        "https://api.flowalert.io/v1/events",
        headers={
            "Content-Type": "application/json",
            "X-Api-Key": os.environ["FLOWALERT_API_KEY"],
        },
        json={
            "event": event,
            "title": title,
            "body": body,
            "priority": priority,
            "data": data or {},
        },
        timeout=5,
    )

# Usage
notify(
    event="model.training_complete",
    title="✅ Model Training Done",
    body="GPT fine-tune job completed in 4h 23m",
    priority="HIGH",
)

PHP

function flowalert_notify(string $event, string $title, string $body, string $priority = 'NORMAL', array $data = []): void {
    $ch = curl_init('https://api.flowalert.io/v1/events');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_HTTPHEADER     => [
            'Content-Type: application/json',
            'X-Api-Key: ' . ($_ENV['FLOWALERT_API_KEY'] ?? ''),
        ],
        CURLOPT_POSTFIELDS => json_encode(compact('event', 'title', 'body', 'priority', 'data')),
        CURLOPT_TIMEOUT    => 5,
    ]);
    curl_exec($ch);
    curl_close($ch);
}

Ruby

require 'net/http'
require 'json'
require 'uri'

def notify(event:, title:, body:, priority: 'NORMAL', data: {})
  uri  = URI.parse('https://api.flowalert.io/v1/events')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  req = Net::HTTP::Post.new(uri.path)
  req['Content-Type'] = 'application/json'
  req['X-Api-Key']    = ENV['FLOWALERT_API_KEY']
  req.body = { event:, title:, body:, priority:, data: }.to_json

  http.request(req)
end

Go

package notify

import (
	"bytes"
	"encoding/json"
	"net/http"
	"os"
)

type Event struct {
	Event    string                 `json:"event"`
	Title    string                 `json:"title"`
	Body     string                 `json:"body"`
	Priority string                 `json:"priority"`
	Data     map[string]interface{} `json:"data,omitempty"`
}

func Send(e Event) error {
	if e.Priority == "" {
		e.Priority = "NORMAL"
	}

	payload, _ := json.Marshal(e)
	req, _ := http.NewRequest("POST", "https://api.flowalert.io/v1/events", bytes.NewBuffer(payload))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Api-Key", os.Getenv("FLOWALERT_API_KEY"))

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	return nil
}

Deduplication

If you have a monitoring loop that fires every 30 seconds, you don't want 20 notifications for the same alert. Use dedupeKey:

curl -X POST https://api.flowalert.io/v1/events \
  -H "X-Api-Key: $FLOWALERT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "db.connection_pool_exhausted",
    "title": "🔴 DB Pool Exhausted",
    "body": "postgres-primary is rejecting connections",
    "priority": "URGENT",
    "dedupeKey": "db-pool-alert"
  }'

If you fire this every 30 seconds, you'll only get one notification per 10-minute window. The next one only fires after the dedup window resets.

Priority Levels Explained

Priority	Use Case	Behavior
`LOW`	Informational background events	Silent notification / badge only
`NORMAL`	Standard business events	Shows notification banner
`HIGH`	Urgent business events	Sound + banner
`URGENT`	Incidents, failures, pager-level	Loud alert sound, high-priority delivery

Best Practices for Event Keys

Use a consistent dot-notation taxonomy so routing rules stay manageable:

{service}.{resource}.{action}

Examples:
  payments.invoice.paid
  auth.user.registered
  infra.server.cpu_high
  infra.deploy.failed
  ecommerce.order.placed
  ecommerce.refund.requested

This makes your routing rules easier to manage — you can group related events under the same resource prefix (e.g. infra) and create one rule per resource type.

Rate Limits

Plan	Events/month	Notifications/month
Free	1,000	100
Pro	50,000	10,000
Business	Unlimited	Unlimited

For high-frequency monitoring use cases (e.g. healthcheck loops), use dedupeKey to stay within limits and avoid alert fatigue.

Summary

If it can make an HTTP POST, it can send a push notification. One endpoint, one API key, notifications to any mobile device — no service worker setup, no SDK, no Firebase console.

Create your free API key →

All posts Try FlowAlert free