Guides & Integrations

Connect Notifikations to any tool, script, or automation — and get push notifications wherever your work happens.

Jump to an integration

Claude Code Langflow Agno Codex cURL GitHub Actions Home Assistant JavaScript n8n Python Shortcuts Zapier Make Power Automate OpenClaw Base44 Shell scripts Uptime monitor

Claude Code

Claude Code supports hooks — shell commands that run automatically when Claude starts a session, finishes a task, or triggers specific events. Wire Notifikations into a hook and you'll get an iPhone notification the moment Claude completes a long task, even if you've walked away from your machine.

Add a Stop hook to ~/.claude/settings.json so every Claude session end triggers a push:

// ~/.claude/settings.json
{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET -H 'Content-Type: application/json' -d '{\"title\":\"Claude done\",\"message\":\"Task finished\"}'"
          }
        ]
      }
    ]
  }
}

You can also add a hook scoped to a specific project by placing a settings.json inside the project's .claude/ folder — useful when you want notifications only for certain repos.

Hooks run in the background, so the notification arrives even if you've switched apps or locked your phone.

Langflow

Langflow lets you build LLM pipelines visually. Add a Notifikations call at the end of any flow so you get an iPhone notification the moment a long generation, retrieval, or agent run completes.

Option 1 — API Request component
Drop an API Request component as the final node in your flow. Set Method to POST, URL to your webhook, and map the message field from any upstream output.

Option 2 — Python tool for agents
Register Notifikations as a callable tool so the agent can notify you itself:

from langflow.base.tools import tool
import httpx

@tool
def notify(message: str, title: str = "Langflow") -> str:
    """Send a push notification to the developer's iPhone.
    Call this when a task is complete or requires human attention."""
    resp = httpx.post(
        "https://api.notifikations.com/api/v1/YOUR_SECRET",
        json={"message": message, "title": title},
        timeout=5,
    )
    return "sent" if resp.is_success else "failed"

Add the tool to your agent component's Tools list. The agent will call notify() whenever it decides the user should know something — or you can force it at the end of a Chain component.

Use interruption-level: time-sensitive in the JSON payload if you want the notification to break through Focus modes.

Agno

Agno is a Python agent framework. Register Notifikations as a Toolkit and the agent can push a notification at any point in its reasoning loop — when a task finishes, when it needs human input, or when it hits an error.

import httpx
from agno.tools import Toolkit

class NotifikationsTools(Toolkit):
    def __init__(self, secret: str):
        super().__init__(name="notifikations")
        self.secret = secret
        self.register(self.notify)

    def notify(self, message: str, title: str = "Agent") -> str:
        """Send a push notification to the developer's iPhone.
        Use when a task is complete or requires human attention.

        Args:
            message: The notification body text.
            title: Optional title shown above the message.
        """
        resp = httpx.post(
            f"https://api.notifikations.com/api/v1/{self.secret}",
            json={"message": message, "title": title},
            timeout=5,
        )
        return "sent" if resp.is_success else "failed"

Wire it into your agent:

from agno.agent import Agent
from agno.models.anthropic import Claude

agent = Agent(
    model=Claude(id="claude-opus-4-6"),
    tools=[NotifikationsTools(secret="YOUR_SECRET")],
    instructions="When you finish a multi-step task, call notify() with a one-line summary.",
)

agent.run("Research and summarise the top 5 AI papers from this week")
The docstring on notify() is what the model reads. Keep it concise and describe when to call it so the agent uses it at the right moment.

Codex CLI

OpenAI Codex CLI runs agentic tasks in your terminal. Chain a curl call after any codex invocation to get notified when the agent finishes — especially useful for long refactors or multi-file generations you kick off and then step away from.

# Run Codex, then notify when it exits
codex "refactor the auth module to use JWT" && \
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -H 'Content-Type: application/json' \
    -d '{"title":"Codex done","message":"Refactor complete ✅"}'

For a fire-and-forget wrapper, drop this function in your shell profile:

# ~/.zshrc or ~/.bashrc
function ntf-codex() {
  codex "$@"
  local status=$?
  local msg=$([ $status -eq 0 ] && echo "✅ Done" || echo "❌ Failed")
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -d "Codex: $msg — $1"
}

Then just call ntf-codex "your prompt here".

cURL

The fastest way to send a notification — no dependencies, works on any machine with curl installed. All you need is your secret from the app.

# Plain text — simplest possible call
curl -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
  -d 'Deploy finished ✅'
# Custom title, message, and sound
curl -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
  -H 'Content-Type: application/json' \
  -d '{
    "title": "Build done",
    "message": "All tests passed",
    "sound": "brrr"
  }'
# GET request — no body required (useful for webhooks)
curl "https://api.notifikations.com/api/v1/YOUR_SECRET?title=Alert&message=Disk+at+90%25"

Append -s (silent) to suppress curl's progress output in scripts. See the full docs for all supported fields.

GitHub Actions

Add a notification step at the end of any workflow to get push alerts for deployments, test results, or release events. Store your webhook secret in Settings → Secrets → Actions as NTF_SECRET — never hardcode it in the YAML.

# .github/workflows/deploy.yml
on: [push]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm run build

      - name: Notify on success
        if: success()
        run: |
          curl -s -X POST "https://api.notifikations.com/api/v1/$\{{ secrets.NTF_SECRET }}" \
            -H 'Content-Type: application/json' \
            -d '{"title":"Deploy succeeded","message":"$\{{ github.repository }} → $\{{ github.ref_name }} 🚀"}'

      - name: Notify on failure
        if: failure()
        run: |
          curl -s -X POST "https://api.notifikations.com/api/v1/$\{{ secrets.NTF_SECRET }}" \
            -H 'Content-Type: application/json' \
            -d '{"title":"Build failed ❌","message":"$\{{ github.repository }} on $\{{ github.ref_name }}"}'

Works with any trigger — PRs, releases, scheduled runs, or manual workflow_dispatch events.

Home Assistant

Home Assistant's RESTful command integration lets you call any HTTP endpoint from automations, scripts, and the action panel. Add Notifikations as a service and trigger it from any automation — motion detected, door left open, appliance cycle finished, you name it.

Add this to your configuration.yaml:

# configuration.yaml
rest_command:
  notifikations_send:
    url: "https://api.notifikations.com/api/v1/YOUR_SECRET"
    method: POST
    content_type: "application/json"
    payload: '{"title":"{{ title }}","message":"{{ message }}"}'

Then call it from any automation or script:

# automation.yaml (or via the UI editor)
automation:
  - alias: "Washing machine done"
    trigger:
      - platform: state
        entity_id: sensor.washing_machine_power
        to: "0"
        for: "00:01:00"
    action:
      - service: rest_command.notifikations_send
        data:
          title: "Laundry done 👕"
          message: "Washing machine finished"
Reload your Home Assistant config after editing (Developer Tools → YAML → Reload All YAML) and the service appears in the action picker.

JavaScript / Node.js

Use the native fetch API — works in Node.js 18+, Deno, Bun, and any modern browser context without any dependencies.

async function notify(message, title) {
  await fetch("https://api.notifikations.com/api/v1/YOUR_SECRET", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ message, title }),
  });
}

// Call it anywhere in your code
await notify("Job finished", "Cron");

Wrap it as a fire-and-forget helper so it never blocks your main flow:

function notifyAsync(message, title) {
  fetch("https://api.notifikations.com/api/v1/YOUR_SECRET", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ message, title }),
  }).catch(() => {}); // silent — don't let a failed notification crash your app
}

// Hook into process exit for scripts
process.on("exit", (code) => {
  notifyAsync(code === 0 ? "Script finished ✅" : "Script failed ❌", "Node.js");
});

n8n

n8n's built-in HTTP Request node can call any webhook — no custom code required. Drop one at the end of any workflow to push a notification when automation runs complete, leads come in, or errors occur.

Steps in the n8n editor:

  1. Add an HTTP Request node at the end of your workflow.
  2. Set Method to POST.
  3. Set URL to https://api.notifikations.com/api/v1/YOUR_SECRET.
  4. Under Body, choose JSON and enter your payload.
  5. Save and activate the workflow.
// HTTP Request node — Body (JSON)
{
  "title": "n8n workflow done",
  "message": "{{ $json.summary }}"
}

You can interpolate any expression from previous nodes in the message field — so the notification body can include record counts, names, or status codes from earlier steps.

Use the Error Trigger node + an HTTP Request to Notifikations to get push alerts whenever any workflow in your n8n instance fails.

Python

No third-party packages required — the standard library is all you need.

import urllib.request, json

def notify(message, title=None, secret="YOUR_SECRET"):
    url = f"https://api.notifikations.com/api/v1/{secret}"
    payload = {"message": message}
    if title:
        payload["title"] = title
    data = json.dumps(payload).encode()
    req = urllib.request.Request(url, data=data,
          headers={"Content-Type": "application/json"})
    urllib.request.urlopen(req)

# Usage
notify("Scrape finished — 4,201 records", title="Crawler")

For machine-learning or long-running data pipelines, add a decorator so you never forget a notification:

import functools, traceback

def notify_when_done(title="Script"):
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            try:
                result = fn(*args, **kwargs)
                notify(f"{fn.__name__} finished ✅", title=title)
                return result
            except Exception as e:
                notify(f"{fn.__name__} failed: {e}", title=f"{title} ❌")
                raise
        return wrapper
    return decorator

# Usage
@notify_when_done(title="Training")
def train_model():
    # ... your training code
    pass

Apple Shortcuts

The Shortcuts app can call any URL with a Get Contents of URL action — no code required. This is great for building personal automations that notify you from your iPhone or Mac itself, or as a trigger from Focus Filters, NFC tags, or widget taps.

Build the shortcut:

  1. Open the Shortcuts app and create a new shortcut.
  2. Add a Get Contents of URL action.
  3. Set the URL to https://api.notifikations.com/api/v1/YOUR_SECRET.
  4. Set Method to POST.
  5. Set Request Body to JSON and add keys: title and message.
  6. Run the shortcut — the notification arrives instantly.
Combine with Automation (time of day, location, app open) to build powerful personal alerts without writing a single line of code.

You can also call Notifikations from a Shortcut triggered by a Personal Automation — for example, notify yourself when you arrive somewhere, or send a reminder at a specific time.

Zapier

Use Zapier's built-in Webhooks by Zapier action to send a push notification as part of any Zap — triggered by Gmail, Stripe, Typeform, Airtable, or hundreds of other apps.

Setup:

  1. In your Zap, add an action step and search for Webhooks by Zapier.
  2. Choose POST as the event.
  3. Set the URL to https://api.notifikations.com/api/v1/YOUR_SECRET.
  4. Set Payload Type to JSON.
  5. Add the fields: title and message — you can map values from any earlier step.
  6. Test the step and publish the Zap.
Map dynamic fields from your trigger — for example, include a customer name from a Stripe payment event or a form submission from Typeform in the notification message.

Make (formerly Integromat)

Make's HTTP module can call any endpoint from any scenario. Add one as the last module to push an iPhone notification when a scenario finishes — whether it's processing leads, syncing records, or running a scheduled data job.

Setup:

  1. Add an HTTP → Make a request module to your scenario.
  2. Set URL to https://api.notifikations.com/api/v1/YOUR_SECRET.
  3. Set Method to POST.
  4. Set Body type to Raw and Content type to application/json.
  5. Enter your payload in the Request content field.
// Request content (Raw JSON)
{
  "title": "Make scenario done",
  "message": "Processed {{1.total}} records"
}

Map any bundle value from previous modules into the message field using Make's {{moduleIndex.fieldName}} syntax.

Add an Error handler route with another HTTP module pointing to Notifikations so you also get push alerts when a scenario fails mid-run.

Power Automate

Power Automate's HTTP action (available on premium plans) can POST to any webhook. Use it as the final step in any cloud flow to get push notifications from Microsoft 365 events, SharePoint changes, Teams messages, or any other trigger.

Setup:

  1. Add a New step and search for the HTTP action.
  2. Set Method to POST.
  3. Set URI to https://api.notifikations.com/api/v1/YOUR_SECRET.
  4. Under Headers, add Content-Type → application/json.
  5. Set Body to your JSON payload — use the dynamic content picker to insert values from earlier steps.
// Body (use dynamic content for the message value)
{
  "title": "Power Automate",
  "message": "@{triggerOutputs()?['body/subject']}"
}
No premium plan? Use Premium connectors → HTTP with Azure AD if available in your tenant, or wrap the HTTP call in an Azure Function triggered by the flow.

OpenClaw

OpenClaw is a web scraping and monitoring platform. Use its built-in HTTP action or webhook output to fire a Notifikations push whenever a page changes, a price drops, or a scrape job finishes.

In any OpenClaw workflow that supports an outgoing webhook or HTTP action, point it at your Notifikations URL:

# OpenClaw outgoing webhook / HTTP action config
URL:    https://api.notifikations.com/api/v1/YOUR_SECRET
Method: POST
Headers:
  Content-Type: application/json
Body:
  {
    "title": "Price alert",
    "message": "{{item.name}} dropped to {{item.price}}"
  }

This way you get a push to your iPhone the moment OpenClaw detects the change — no need to keep checking a dashboard.

Base44

Base44 is a no-code app builder. Any app you build in Base44 can call external APIs using its HTTP action block. Wire Notifikations into a button, form submission, or data trigger to send a push notification from your custom Base44 app.

In the Base44 action editor, add an HTTP Request block with these settings:

# Base44 HTTP action settings
URL:    https://api.notifikations.com/api/v1/YOUR_SECRET
Method: POST
Headers:
  Content-Type: application/json
Body (JSON):
  {
    "title": "New submission",
    "message": "{{form.name}} submitted the form"
  }

You can map any Base44 variable or field value into the message, so each notification contains the relevant context from your app's data.

Shell scripts

Append a curl call to any shell script to get notified when it finishes — whether it succeeds or fails. Good for training runs, data exports, backups, or any long-running process.

#!/bin/bash
# your long-running process
python train.py --epochs 50

if [ $? -eq 0 ]; then
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -H 'Content-Type: application/json' \
    -d '{"title":"Training done","message":"Model finished ✅"}'
else
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -d 'Training failed ❌'
fi

Or define a reusable shell function and call it at the end of any script:

function ntf() {
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -d "$1"
}

# Usage anywhere in the script
ntf "Backup complete"
ntf "Deployment finished 🚀"

Uptime monitor

Ping your webhook from a cron job to get an iPhone alert whenever a service goes down.

#!/bin/bash
# crontab: */5 * * * * /path/to/check.sh

STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://myapp.example.com/health)

if [ "$STATUS" != "200" ]; then
  curl -s -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
    -H 'Content-Type: application/json' \
    -d "{\"title\":\"Down!\",\"message\":\"myapp returned HTTP $STATUS\",\"sound\":\"brrr\"}"
fi

Notification with a deep link

Tapping the notification opens a URL directly in Safari (or your app).

curl -X POST https://api.notifikations.com/api/v1/YOUR_SECRET \
  -H 'Content-Type: application/json' \
  -d '{
    "title": "PR merged",
    "message": "feat: dark mode support",
    "open_url": "https://github.com/you/repo/pull/42"
  }'

Fan-out to all devices

Use your user secret (instead of the device secret) to send to every device on your iCloud account at once.

curl -X POST https://api.notifikations.com/api/v1/YOUR_USER_SECRET \
  -d 'Sent to all your devices'

The response includes a sent count: {"success":true,"sent":2,"failures":0}