Developer examples

Send your first WardenPoint notification from code

Copy a ready-to-run starter example for cURL, PHP/Laravel, Node.js, Python or Go. Use API keys from your dashboard, recipient UUIDs from your workspace and keep secrets outside source code.

Start free Open full guide
Uptime SLA
99.99%
P99 response
~20ms
Languages
5
send-alert.sh
POSThttps://wardenpoint.com/api/v1/notifications/send
# Send a critical production alert
curl -X POST https://wardenpoint.com/api/v1/notifications/send \
-H "X-API-Key: $WARDENPOINT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"recipient_uuid": "00000000-0000-4000-8000-000000000001",
"message": "Production checkout latency above threshold",
"priority": "critical"
}'
200 OK· 20ms·
Ln 9

Official clients

Skip the boilerplate with first-party tools

Three officially maintained clients. A Python SDK on PyPI and a single-binary Go CLI wrap the REST API; a Go library sends alerts and heartbeats from long-running services and devices. Install, add your key, and page on-call in a few lines.

Python SDK

PyPI

Send alerts, fire templates and page on-call from any Python app, job or pipeline. Includes a guard() context manager that alerts when your code raises.

pip install wardenpoint
from wardenpoint import WardenPoint
 
wp = WardenPoint(api_key="acb_…") # or set WARDENPOINT_API_KEY
wp.alerts.send(recipient="ops-oncall", message="DB primary down", priority="high")
View on PyPI Source on GitHub

Go CLI

Go

A single static binary for shell scripts, cron jobs and CI runners. Pipe a failing command straight into an alert — no dependencies, no runtime.

go install github.com/WardenPoint/wardenpoint-cli@latest
wardenpoint auth login --api-key acb_…
wardenpoint alert send --to ops-oncall -m "DB primary down" -p high
Source on GitHub Download a binary

Go library for services and devices

Go

Embed it in a daemon, an edge gateway or a Raspberry Pi. Fire and Resolve never block your code; a bounded queue retries through outages and never drops an alert without a log line. A heartbeat pages the owner group when the device goes silent. Standard library only.

go get github.com/WardenPoint/wardenpoint-go
wp, err := wardenpoint.New(wardenpoint.Config{
IntegrationURL: os.Getenv("WARDENPOINT_URL"), // generic webhook integration
Secret: os.Getenv("WARDENPOINT_SECRET"),
HeartbeatInterval: time.Minute, // silence pages the owner group
})
go wp.Run(ctx)
 
wp.Fire(wardenpoint.Alert{
ID: "boiler-silent",
Title: "Boiler sensor silent",
Severity: wardenpoint.Critical,
})
wp.Resolve("boiler-silent")
Source on GitHub Docs on pkg.go.dev

Pick your stack

One API, five idiomatic clients

The same JSON contract everywhere. Drop the snippet into your project, swap in the API key from the dashboard, and you are live.

Live request

Predictable JSON, every time

Idempotent endpoints, RFC-compliant errors and a response envelope you can log straight into your incident timeline.

Your request
POST/api/v1/notifications/send
# Headers
X-API-Key: wp_live_8h2k…
Content-Type: application/json
 
# Body
{
"recipient_uuid": "00000000-…-000000000001",
"message": "Production latency above SLO",
"priority": "critical"
}
WardenPoint response
200 OK· 20ms application/json
{
"id": "notif_8h2k7yQrxJp",
"status": "queued",
"recipient_uuid": "00000000-0000-4000-8000-000000000001",
"message": "Production checkout latency above threshold",
"priority": "critical",
"channels_planned": ["telegram_voice", "voice_call", "email"],
"escalation_chain_id": "esc_4j2k9bMcvL",
"created_at": "2026-05-17T13:42:18Z",
"links": {
"self": "/api/v1/notifications/notif_8h2k7yQrxJp",
"ack": "/api/v1/notifications/notif_8h2k7yQrxJp/ack"
}
}

Best practices

Production-grade integration in three habits

Use API keys intentionally

Create API keys in the dashboard, store them in environment variables or secret managers and rotate them when team access changes.

Address recipients by UUID

Client-facing examples use recipient_uuid values so public integrations do not depend on internal database IDs.

Send concise alert payloads

Include service, severity, environment and a link to your source system instead of unnecessary sensitive details.

Implementation path

From test alert to production integration

  1. 1Step 1

    Create an API key

    Generate a key in dashboard settings and store it outside source code before testing examples.

    $ wardenpoint keys create --name=production
  2. 2Step 2

    Pick a test recipient

    Use a sandbox recipient first, confirm channel routing, then promote the integration to the production responder group.

    $ curl .../v1/recipients?limit=5
  3. 3Step 3

    Wire up retries

    Handle non-2xx responses, log failures in your source tool and avoid sending duplicate high-priority alerts.

    $ if (res.status >= 500) retry()

API surface

Every endpoint you'll reach for

Send alerts, manage recipients, inspect delivery — all from one REST surface secured by your API key.

Open API reference
MethodPathPurpose
POST/api/v1/notifications/sendDispatch a notification to a recipient with priority and channels.
GET/api/v1/notifications/{id}Inspect status, delivery attempts and acknowledgement state.
POST/api/v1/notifications/{id}/ackAcknowledge an incident programmatically and stop escalation.
GET/api/v1/recipientsList recipients in your workspace with channel capabilities.
POST/api/v1/recipientsCreate a recipient with telegram_id, phone, email and routing rules.
PATCH/api/v1/recipients/{uuid}Update escalation timeouts, channel order or quiet hours.
Start shipping

Ready to send your first alert?

Create a workspace, copy any snippet from this page and replace the API key. Your first alert is one request away.

Get API key Read the docs
  • Free plan
  • No credit card
  • Setup in 5 minutes