Build on your monitoring data
Everything the panel does with monitors, incidents, servers and status pages is available as plain JSON over HTTPS. One token, a few scopes, predictable answers.
Base URL
https://allinonemonitor.com/api/v1
Every answer is JSON: {ok:true, data, meta} or {ok:false, error, code}.
Authentication
Authorization: Bearer aim_…
Tokens are created under API & webhooks in your panel, shown once and stored hashed. A token acts as the user who made it, inside one organisation.
Rate limits
X-RateLimit-Limit / X-RateLimit-Remaining
Per token per minute, from the token or your plan. Over the limit you get 429 with Retry-After. Usage per day is shown next to the token.
Quick start
curl -s https://allinonemonitor.com/api/v1/me \
-H "Authorization: Bearer aim_YOUR_TOKEN"
Create a monitor:
curl -s -X POST https://allinonemonitor.com/api/v1/monitors \
-H "Authorization: Bearer aim_YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"type":"http","name":"Shop","url":"https://shop.example.com","interval_sec":60,"confirmations":2,"locations":["core"]}'
Scopes
Pick the scopes when you create the token. A missing scope answers 403. A token can never do more than the user who created it.
| Scope | Allows |
|---|---|
read | Every GET endpoint: monitors, results, uptime, incidents, alerts, servers, status pages, channels, webhooks, maintenance, locations, plans, usage |
monitors:write | Create, change, delete, pause and resume monitors; create maintenance windows |
incidents:write | Open manual incidents, post updates, acknowledge |
servers:read | Server metric series and the watched services list |
status:write | Reserved for status page changes in a later version |
webhooks:write | Create and delete outbound webhooks |
Endpoints
| Method | Path | What it does |
|---|---|---|
GET | /me | The token, its organisation, plan and usage |
GET | /monitors | List monitors (filters: status, type, q, group_id) |
POST | /monitors | Create a monitor (same fields as the form) |
GET | /monitors/{id} | One monitor with every setting |
PUT/PATCH | /monitors/{id} | Change fields; the rest stays |
DELETE | /monitors/{id} | Delete a monitor and its history |
POST | /monitors/{id}/pause | Pause / resume (…/resume) |
POST | /monitors/{id}/test | Run the check right now from the main server |
GET | /monitors/{id}/results | Raw check results (?hours=24, max 168) |
GET | /monitors/{id}/uptime | Uptime 24h/7d/30d/90d/365d and per-day history (?days=) |
GET | /monitors/{id}/response | Response-time series and per-location breakdown |
GET | /incidents | Incidents (filters: status, resolved, monitor_id, severity, q) |
POST | /incidents | Open a manual incident |
POST | /incidents/{id}/updates | Post a status update (investigating → resolved) |
POST | /incidents/{id}/acknowledge | Acknowledge (stops escalation) |
GET | /alerts | Alert history |
GET | /servers | Servers with their latest metrics |
GET | /servers/{id}/metrics | CPU, memory, disk, load, network series (?hours=) |
GET | /servers/{id}/services | Watched services, containers and disks |
GET | /status-pages | Status pages; …/{id} adds components and the overall state |
GET | /channels | Alert channels (targets shortened, secrets never) |
GET | /webhooks | Outbound webhooks; POST creates, DELETE removes |
GET | /maintenance | Maintenance windows; POST creates |
GET | /locations | Monitoring locations your plan can use |
GET | /plans | Public plans and their limits |
GET | /org/usage | What your organisation uses of its plan |
Lists take ?page= and ?per_page= (max 100) and answer meta {page, per_page, total}. Request and response examples for every endpoint are in the API reference.
Examples without an SDK
PHP
<?php
$token = 'aim_YOUR_TOKEN';
$ch = curl_init('https://allinonemonitor.com/api/v1/monitors?status=down');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $token, 'Accept: application/json'],
]);
$res = json_decode(curl_exec($ch), true);
foreach ($res['data'] as $m) {
echo $m['name'], ' is ', $m['status'], "\n";
}
Python
import requests
API = 'https://allinonemonitor.com/api/v1'
H = {'Authorization': 'Bearer aim_YOUR_TOKEN'}
r = requests.get(f'{API}/monitors', headers=H, params={'per_page': 100})
for m in r.json()['data']:
print(m['id'], m['name'], m['status'])
# open a manual incident
requests.post(f'{API}/incidents', headers=H, json={
'title': 'Planned database failover',
'severity': 'minor',
'message': 'We are switching to the replica.'
})
Node.js
const API = 'https://allinonemonitor.com/api/v1';
const headers = { Authorization: 'Bearer aim_YOUR_TOKEN', 'Content-Type': 'application/json' };
const res = await fetch(`${API}/monitors/42/uptime?days=30`, { headers });
const { data } = await res.json();
console.log(data.uptime['30d'], '% over 30 days');
// pause it
await fetch(`${API}/monitors/42/pause`, { method: 'POST', headers });
Webhooks
Subscribe a URL to events under API & webhooks (or POST /webhooks). Every delivery is a JSON POST with the headers X-AIM-Event, X-AIM-Delivery, X-AIM-Timestamp and X-AIM-Signature. The signature is HMAC-SHA256 of "timestamp.body" with your secret, written as sha256=<hex>. Failed deliveries retry with growing delays; after 50 failures in a row the webhook is switched off.
Events: monitor.down, monitor.up, monitor.degraded, monitor.ssl_expiry, monitor.domain_expiry, monitor.dns_changed, monitor.content_changed, monitor.created, monitor.deleted, server.offline, server.online, server.alert, server.alert_cleared, server.anomaly, server.lve_fault, server.backup_failed, server.k8s, server.raid, server.smart, server.reboot, server.service_down, server.service_up, integration.service_down, integration.error, monitor.anomaly, monitor.correlated, monitor.flapping, monitor.stable, monitor.correlated_up, incident.opened, incident.updated, incident.resolved
Verify a signature in PHP
<?php
$secret = 'your webhook secret';
$body = file_get_contents('php://input');
$ts = $_SERVER['HTTP_X_AIM_TIMESTAMP'] ?? '';
$sig = $_SERVER['HTTP_X_AIM_SIGNATURE'] ?? '';
$expected = 'sha256=' . hash_hmac('sha256', $ts . '.' . $body, $secret);
if (abs(time() - (int) $ts) > 300 || !hash_equals($expected, $sig)) {
http_response_code(401);
exit('bad signature');
}
$event = json_decode($body, true);
// $event['event'] e.g. "monitor.down", $event['data'] ...
Verify a signature in Node
import crypto from 'node:crypto';
export function verify(req, rawBody, secret) {
const ts = req.headers['x-aim-timestamp'];
const sig = req.headers['x-aim-signature'] || '';
const expected = 'sha256=' + crypto.createHmac('sha256', secret).update(`${ts}.${rawBody}`).digest('hex');
const fresh = Math.abs(Date.now() / 1000 - Number(ts)) < 300;
return fresh && sig.length === expected.length && crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected));
}
Errors
| HTTP | code | Meaning |
|---|---|---|
| 400 | bad_request | The body is missing or not JSON |
| 401 | unauthorized | No token, or a revoked / expired / unknown one |
| 402 | plan_limit | Your plan does not allow one more of these |
| 403 | forbidden | The token lacks the scope, or its owner lacks the permission |
| 404 | not_found | No such endpoint or object in your organisation |
| 405 | method_not_allowed | Wrong HTTP method (see the Allow header) |
| 422 | validation | A field is wrong; errors[] says which |
| 429 | rate_limited | Too many requests this minute; wait Retry-After seconds |
CORS: GET requests may be made from a browser on any origin (the preflight answers 204). Keep tokens out of browser code that strangers can read.

