Everything you need to fire real-time mobile push notifications directly from your custom firmware — ESP32, ESP8266, Arduino, Raspberry Pi, or any DIY microcontroller capable of executing a basic HTTP request.
Download NotifyBridge from the app page and open it in Studio mode. Your account is created automatically — no forms, no email verification. A default app called "NotifyBridge" is ready to use right away, complete with an API token.
You'll use two credentials to send notifications:
Each physical unit you build needs its own device in NotifyBridge. A device is the link between a specific hardware unit and the subscriber who receives its notifications.
Once a subscriber has claimed the device, send notifications with a single HTTP POST. No SDKs. No special libraries. Any device that can make an HTTP request can use this API.
#include <WiFi.h>
#include <HTTPClient.h>
void sendNotification(const String& message, int priority = 0) {
HTTPClient http;
http.begin("https://notifybridge.mindeon.net/v1/messages/send");
http.addHeader("Content-Type", "application/json");
String body = "{";
body += "\"api_token\":\"YOUR_API_TOKEN\",";
body += "\"user_key\":\"YOUR_USER_KEY\",";
body += "\"device_code\":\"MS-ABCD-EF12\",";
body += "\"message\":\"" + message + "\",";
body += "\"priority\":" + String(priority);
body += "}";
int code = http.POST(body);
http.end();
}
curl -X POST https://notifybridge.mindeon.net/v1/messages/send \
-H "Content-Type: application/json" \
-d '{
"api_token": "YOUR_API_TOKEN",
"user_key": "YOUR_USER_KEY",
"device_code": "MS-ABCD-EF12",
"message": "Temperature exceeded 40°C",
"priority": 1
}'
import requests
requests.post("https://notifybridge.mindeon.net/v1/messages/send", json={
"api_token": "YOUR_API_TOKEN",
"user_key": "YOUR_USER_KEY",
"device_code": "MS-ABCD-EF12",
"message": "Temperature exceeded 40°C",
"priority": 1,
})
All available fields in the request body:
| Field | Required | Description |
|---|---|---|
| api_token | Yes | Your app's API token |
| user_key | Yes | Your account key |
| device_code | No | The device to target (MS-XXXX-XXXX). Omit to broadcast — see below. |
| relay_id | No | Alternative to device_code. The internal device ID (e.g. relay_abc123). |
| message | Yes | Notification body text |
| priority | No | -1 Low · 0 Normal (default) · 1 High · 2 Emergency |
| device_name | No | Target a specific subscriber device by name (useful for multi-device households) |
This is the end user's side — it takes about 30 seconds and requires no technical knowledge.
When you create a device in Studio mode the backend generates a Device Code, assigns it a Device ID, and marks it UNCLAIMED. Your User Key is stored as the device's owner. Think of it as a virtual mailbox waiting to be linked to a phone.
Two ways to distribute the Device Code:
What happens when the customer scans:
Two User Keys — the key concept:
| User Key | Owner | Purpose |
|---|---|---|
| Developer | You | Authenticates API requests to send notifications |
| Subscriber | Your customer | Routes notifications to their specific device |
You never need your customer's User Key. Send a notification with your credentials and a Device Code — the backend looks up who claimed that device and routes to them automatically.
Every unit you ship runs the same firmware with the same API Token and User Key — only the Device Code differs. The Device Code determines which customer gets the notification.
Your Factory:
┌─────────────────────────────────────┐
│ Unit #1: Device Code AB-1234-CDEF │ → Customer A's phone
│ Unit #2: Device Code AB-5678-GHIJ │ → Customer B's phone
│ Unit #3: Device Code AB-9012-KLMN │ → Customer C's phone
└─────────────────────────────────────┘
All use same:
- API Token
- Your User Key
- Same firmware code
Run through the complete flow on a real device before shipping to customers. Push notifications don't work in the Android emulator — you need a physical Android phone.
1. Claim for testing
2. Send a test notification
3. Test as an end user
4. Test unclaiming
You can create as many devices as you need under a single app:
The Device Code is what links each unit to a specific customer's phone. Your firmware, API Token, and User Key stay identical across every unit you manufacture.
Groups: Multiple Subscribers, One Device
One of NotifyBridge's most powerful features is Groups — multiple people all receiving notifications from the same device. Perfect for shared devices.
Common use cases:
How it works:
When someone claims a device, they get a User Key. Others who also want to receive notifications from that device can join by entering the same key — they all share it.
Example — Smart Doorbell:
Group characteristics:
| Aspect | Behavior |
|---|---|
| Shared User Key | All group members use the same User Key |
| Shared device list | All members see all devices claimed by the group |
| Claim access | Any member can claim new devices for the group |
| Delivery | One notification → delivered to ALL group members simultaneously |
| Group size | No technical limit (rate limits apply per device) |
| Leave group | Member generates a new User Key and re-registers |
QR Code Display
Every device comes with a built-in QR code that encodes its Device Code. Tap Show QR Code in the device detail view to display, share, or export it. Print it on your hardware or packaging so customers can claim by scanning instead of typing the code manually.
Unclaim and Re-Claim
If a customer needs to transfer their device to a new phone, they open the device in the Devices tab and tap Unclaim Device. Status returns to "Unclaimed" and anyone can claim it again with the same Device Code. As a developer you can also unclaim devices from Studio mode, but only if they haven't yet been claimed by a subscriber.
Delete Devices
To remove a device permanently (e.g. a scrapped unit), open it in Studio mode and tap Delete Device. You can only delete unclaimed devices — if a subscriber has claimed it, they must unclaim it first.
Use priority to control how urgently the notification interrupts the subscriber.
| Value | Name | Behavior |
|---|---|---|
| 2 | Emergency | Critical alert sound — bypasses Do Not Disturb and silent mode |
| 1 | High | Standard sound, cuts through Focus filters |
| 0 | Normal | Standard notification (default) |
| -1 | Low | Silent delivery, no sound or banner interruption |
Every notification costs one push credit. Credits work the same way for everyone — developers and end users alike. When a developer creates a device it draws from their allowance; once an end user claims it, pushes to that device draw from theirs instead.
Free monthly allowance
Every account — developer or end user — gets 3,000 push notifications per month, free. No credit card required. Resets on the first of each calendar month regardless of when you signed up.
Credit packs
When you need more capacity, purchase a one-time credit pack inside the app under Settings → Push Credits. Three sizes are available:
Auto-Recharge
Enable Auto-Recharge under Settings → Push Credits to have the app automatically purchase a pack when your balance drops below a threshold you choose: 20%, 10%, or 5% remaining. Automatic purchases are capped at one per month to prevent unexpected charges.
No hidden fees
No subscriptions. No per-device charges. Both developers and end users pay only when their notification volume exceeds the free monthly allowance. Pricing for credit packs varies by region and is shown in the app before purchase.
When your credits run out, the API returns a 429 response until you add more credits or your monthly allowance resets.
| What you need | Where to find it |
|---|---|
| API Token | Studio → tap your app → API Token section |
| User Key | Settings → Account |
| Device Code | Studio → tap your app → Devices → tap a device |
| Send endpoint | POST https://notifybridge.mindeon.net/v1/messages/send |
| Invite to Group | Subscriber → Devices → Menu (⋮) → "Invite to Group" |
| Join a Group | Subscriber → + → "Join a Group" |
| Device examples | github.com/mindeon/NotifyBridge-Devices |