Push notifications from any script, server or webhook

Every notification, kept and readable

The app keeps a history of what arrived, labelled with the group it came from and the time it landed. Swipe to delete one, clear them all, or pull to refresh. Mute a group on one device when you want quiet there and keep it loud on another.

Notifications you control

Groups with their own keys

Create a notification group per system or project. Each has its own API key, so you can rotate or revoke one without touching the rest.

History and a widget

Everything that arrived is listed in the app, and a home-screen widget on iPhone and Android shows the latest. History is optional: by default a notification is delivered and not kept on the server.

Mute per device

Silence a group on your phone at night and keep it active on the iPad in the office. Muting is per device, not per account.

Priority levels

Send quiet, normal or urgent. Quiet lands without a sound; urgent is delivered as Time Sensitive on iOS, so it breaks through Focus modes, and as an alarm-class notification on Android, so it sounds even on silent.

Tap-through links

Add a URL and the notification opens it when tapped: a dashboard, a log, a camera feed.

Teams

Share a group with family or colleagues by email invitation. One POST reaches every member's devices, and the owner chooses who may send. Creating a team needs Premium; a free account can join one. See how teams are used.

Manage it on the web

Groups, API keys, devices and teams live at pocketnotifier.vanmo.se, so you can copy a key from any computer. A Test button on each group sends a sample and reports how many devices got it, without counting against your quota.

Your data, in your hands

Export everything as a zip of JSON files, change your password, sign out everywhere, or delete the account and all its data. All from the Account page, no email required.

Free to start

100 notifications a month, 3 devices and 3 groups on the free plan. Premium is one purchase: unlimited notifications, devices and groups, plus Teams.

Android too

The same account and groups work in the Android app from Google Play.

Works with anything that can make an HTTP request

There is nothing to install where the notification comes from. If it can send an HTTP POST with a header and a bit of JSON, it can notify you.

• curl and shell scripts
• cron and systemd timers
• Python, Node.js, PowerShell
• GitHub Actions and GitLab CI
• Home Assistant (HACS integration)
• Uptime and health checks
• Proxmox, Unraid and NAS scripts
• Webhooks from any SaaS

Set up in two minutes

1. Create a notification group

   Sign in at pocketnotifier.vanmo.se or in the app, create a group and copy its API key. You can view and copy it again any time.

2. Send a notification

   POST JSON to the notify endpoint with the key in the X-Api-Key header. title and body are the message and at least one of them is needed; url and priority are optional.

   curl -X POST https://pocketnotifier.vanmo.se/api/notify \
     -H "X-Api-Key: pn_your_group_key" \
     -H "Content-Type: application/json" \
     -d '{"title": "Backup finished",
          "body": "4.2 GB in 3 min 12 s",
          "url": "https://example.com/backups",
          "priority": "normal"}'

3. Receive it

   Install the app, sign in with the same account and allow notifications. Press Test on the group in the web app to check the route without spending a notification. Mute any group per device under Notification settings.

Send from your language

Every example does the same thing: one HTTPS POST to the notify endpoint, the group's key in the X-Api-Key header and a small JSON body. Keep the key out of the code; the examples read it from an environment variable called POCKET_NOTIFIER_KEY.

Longer text is cut, not refused, and the whole request body is capped at 16 KB. The service answers as soon as the notification is queued, so a script is never held up by the push round trip.

import json, os, urllib.request

req = urllib.request.Request(
    "https://pocketnotifier.vanmo.se/api/notify",
    data=json.dumps({
        "title": "Backup finished",
        "body": "4.2 GB in 3 min 12 s",
        "url": "https://example.com/backups",
        "priority": "normal",
    }).encode(),
    headers={
        "X-Api-Key": os.environ["POCKET_NOTIFIER_KEY"],
        "Content-Type": "application/json",
    },
    method="POST",
)
with urllib.request.urlopen(req) as res:
    print(res.status)  # 2xx means it was accepted

const res = await fetch("https://pocketnotifier.vanmo.se/api/notify", {
  method: "POST",
  headers: {
    "X-Api-Key": process.env.POCKET_NOTIFIER_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    title: "Backup finished",
    body: "4.2 GB in 3 min 12 s",
    url: "https://example.com/backups",
    priority: "normal",
  }),
});
if (!res.ok) throw new Error(`Pocket Notifier answered ${res.status}`);

using System.Net.Http.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key",
    Environment.GetEnvironmentVariable("POCKET_NOTIFIER_KEY"));

var response = await client.PostAsJsonAsync(
    "https://pocketnotifier.vanmo.se/api/notify",
    new
    {
        title = "Backup finished",
        body = "4.2 GB in 3 min 12 s",
        url = "https://example.com/backups",
        priority = "normal"
    });

response.EnsureSuccessStatusCode();

package main

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

func main() {
	payload, _ := json.Marshal(map[string]string{
		"title":    "Backup finished",
		"body":     "4.2 GB in 3 min 12 s",
		"url":      "https://example.com/backups",
		"priority": "normal",
	})
	req, _ := http.NewRequest(http.MethodPost,
		"https://pocketnotifier.vanmo.se/api/notify", bytes.NewReader(payload))
	req.Header.Set("X-Api-Key", os.Getenv("POCKET_NOTIFIER_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	// res.StatusCode is 2xx when the notification was accepted
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

var json = """
    {"title": "Backup finished",
     "body": "4.2 GB in 3 min 12 s",
     "url": "https://example.com/backups",
     "priority": "normal"}
    """;

var request = HttpRequest.newBuilder(URI.create("https://pocketnotifier.vanmo.se/api/notify"))
    .header("X-Api-Key", System.getenv("POCKET_NOTIFIER_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(json))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());

<?php
$context = stream_context_create(["http" => [
    "method"  => "POST",
    "header"  => "X-Api-Key: " . getenv("POCKET_NOTIFIER_KEY") . "\r\n"
               . "Content-Type: application/json\r\n",
    "content" => json_encode([
        "title"    => "Backup finished",
        "body"     => "4.2 GB in 3 min 12 s",
        "url"      => "https://example.com/backups",
        "priority" => "normal",
    ]),
]]);

file_get_contents("https://pocketnotifier.vanmo.se/api/notify", false, $context);

$body = @{
  title    = "Backup finished"
  body     = "4.2 GB in 3 min 12 s"
  url      = "https://example.com/backups"
  priority = "normal"
} | ConvertTo-Json

Invoke-RestMethod -Method Post -Uri "https://pocketnotifier.vanmo.se/api/notify" `
  -Headers @{ "X-Api-Key" = $env:POCKET_NOTIFIER_KEY } `
  -ContentType "application/json" -Body $body

#!/bin/sh
# Reusable helper: notify "Title" "Body" [quiet|normal|urgent]
notify() {
  curl -sS -X POST https://pocketnotifier.vanmo.se/api/notify \
    -H "X-Api-Key: $POCKET_NOTIFIER_KEY" \
    -H "Content-Type: application/json" \
    -d "{\"title\": \"$1\", \"body\": \"$2\", \"priority\": \"${3:-normal}\"}"
}

if /usr/local/bin/backup.sh; then
  notify "Backup finished" "Nightly backup completed"
else
  notify "Backup failed" "Check the log on the NAS" urgent
fi

# crontab: run it every night at 03:00
# 0 3 * * * POCKET_NOTIFIER_KEY=pn_xxx /usr/local/bin/backup-and-notify.sh

- name: Notify on failure
  if: failure()
  run: |
    curl -sS -X POST https://pocketnotifier.vanmo.se/api/notify \
      -H "X-Api-Key: ${{ secrets.POCKET_NOTIFIER_KEY }}" \
      -H "Content-Type: application/json" \
      -d '{"title": "CI failed",
           "body": "${{ github.repository }} on ${{ github.ref_name }}",
           "url": "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}",
           "priority": "urgent"}'

What comes back

A successful POST answers with the notification's id and the number of accounts it was queued for: one for a personal group, the accepted member count for a team.

{"id": "6f1c2e8a-4b0d-4f6e-9c2a-1d3e5f7a9b0c", "recipients": 1}

Home Assistant integration

Home Assistant can call the API with a rest_command, but the open-source PocketNotifier integration makes it native: every notification group you add becomes a notify.<name> action, usable in automations, scripts, blueprints and the Send a notification dialog, with the tap-through URL and the priority passed straight through.

Install it

1. Add the repository to HACS

   In HACS open the three-dot menu, choose Custom repositories, add https://github.com/trdle/Pocket-notifier-ha with the category Integration, then install PocketNotifier and restart Home Assistant.

2. Add a channel per notification group

   Go to Settings, Devices & Services, Add Integration and search for PocketNotifier. Enter a channel name and the group's API key. The name becomes the action: Household turns into notify.household. Repeat for every group or team you want to reach.

3. Try it

   In Developer tools, Actions, pick the new action and send a test. The key is not checked when you add the channel, so a wrong key shows up here as a delivery error in the log.

How the fields map

Someone at the door, with the camera one tap away

automation:
  - alias: "Doorbell"
    trigger:
      - platform: state
        entity_id: binary_sensor.doorbell
        to: "on"
    action:
      - action: notify.household
        data:
          title: "Doorbell"
          message: "Someone is at the front door"
          data:
            url: "https://my.home-assistant.io/lovelace/cameras"

The washing machine is done

A smart plug reports power. When it drops under 5 W for two minutes, the cycle is over.

automation:
  - alias: "Washing machine finished"
    trigger:
      - platform: numeric_state
        entity_id: sensor.washing_machine_power
        below: 5
        for: "00:02:00"
    action:
      - action: notify.household
        data:
          title: "Laundry"
          message: "The washing machine has finished"

A leak that has to get through Focus

Urgent is delivered as Time Sensitive on iOS, so it shows even when Do Not Disturb is on.

automation:
  - alias: "Water leak"
    trigger:
      - platform: state
        entity_id: binary_sensor.kitchen_leak
        to: "on"
    action:
      - action: notify.household
        data:
          title: "Water leak in the kitchen"
          message: "The sensor under the dishwasher is wet"
          data:
            priority: urgent
            url: "https://my.home-assistant.io/lovelace/water"

A quiet nightly summary

Quiet lands in the list without a sound or a banner.

automation:
  - alias: "Nightly summary"
    trigger:
      - platform: time
        at: "22:30:00"
    action:
      - action: notify.living_room
        data:
          title: "Good night"
          message: "Doors locked, lights off, heating set to 18°"
          data:
            priority: quiet

Point an automation at a team's channel instead of a personal group and the whole household gets it. The integration is open source: trdle/Pocket-notifier-ha on GitHub.

Teams: one message, everyone who should know

A team is a notification group shared with other people. You invite members by email, they accept in the app or on the web, and anything sent with a team key reaches every member's devices. The owner decides who may send: each member with send permission gets a key of their own, so removing someone revokes only theirs and nobody else has to change anything. Invitations expire after seven days. No shared account, no group chat to scroll past. Creating a team and sending to it need Premium; a free account can join one team and receive.

The family

A new home video lands in the Family library on Plex. Tautulli's webhook agent, or Jellyfin's webhook plugin, posts to the Family team: "Summer 2026, lake trip, is ready to watch". Everyone sees it, nobody has to be told, and the link opens the library.

The household

Home Assistant sends to the Household team: the washing machine is done, someone is at the door, the garage was still open at 23:00. Things only one person cares about stay in a personal group, which can be muted per device.

A small ops team

Monitoring and CI post to the Production team. Urgent breaks through Focus for whoever is on call; the others read it in the morning. A new colleague gets an invitation, a leaver is removed and their key stops working, and nobody else's key changes.

A club or a class

The coach runs a Shortcut that posts "Practice cancelled, pitch flooded" to the Under-9s team and every parent has it in seconds. Shortcuts can send the POST directly with Get Contents of URL.

The Plex example, as a Tautulli webhook

In Tautulli add a Webhook notification agent for the "Recently added" trigger, set the URL to https://pocketnotifier.vanmo.se/api/notify, add the headers X-Api-Key and Content-Type: application/json, and use a JSON body like this. Tautulli fills in the placeholders.

{
  "title": "New family video",
  "body": "{title} ({year}) is ready to watch",
  "url": "https://plex.example.com/library/family",
  "priority": "quiet"
}

Pocket Notifier or email alerts?

Email works until it does not: it lands in a tab you are not looking at, gets filtered, or arrives late. A push notification is the thing your phone was built to show you.

Frequently asked questions