REST API v1

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.

Get an API token Full API reference

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.

ScopeAllows
readEvery GET endpoint: monitors, results, uptime, incidents, alerts, servers, status pages, channels, webhooks, maintenance, locations, plans, usage
monitors:writeCreate, change, delete, pause and resume monitors; create maintenance windows
incidents:writeOpen manual incidents, post updates, acknowledge
servers:readServer metric series and the watched services list
status:writeReserved for status page changes in a later version
webhooks:writeCreate and delete outbound webhooks

Endpoints

MethodPathWhat it does
GET/meThe token, its organisation, plan and usage
GET/monitorsList monitors (filters: status, type, q, group_id)
POST/monitorsCreate 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}/pausePause / resume (…/resume)
POST/monitors/{id}/testRun the check right now from the main server
GET/monitors/{id}/resultsRaw check results (?hours=24, max 168)
GET/monitors/{id}/uptimeUptime 24h/7d/30d/90d/365d and per-day history (?days=)
GET/monitors/{id}/responseResponse-time series and per-location breakdown
GET/incidentsIncidents (filters: status, resolved, monitor_id, severity, q)
POST/incidentsOpen a manual incident
POST/incidents/{id}/updatesPost a status update (investigating → resolved)
POST/incidents/{id}/acknowledgeAcknowledge (stops escalation)
GET/alertsAlert history
GET/serversServers with their latest metrics
GET/servers/{id}/metricsCPU, memory, disk, load, network series (?hours=)
GET/servers/{id}/servicesWatched services, containers and disks
GET/status-pagesStatus pages; …/{id} adds components and the overall state
GET/channelsAlert channels (targets shortened, secrets never)
GET/webhooksOutbound webhooks; POST creates, DELETE removes
GET/maintenanceMaintenance windows; POST creates
GET/locationsMonitoring locations your plan can use
GET/plansPublic plans and their limits
GET/org/usageWhat 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

HTTPcodeMeaning
400bad_requestThe body is missing or not JSON
401unauthorizedNo token, or a revoked / expired / unknown one
402plan_limitYour plan does not allow one more of these
403forbiddenThe token lacks the scope, or its owner lacks the permission
404not_foundNo such endpoint or object in your organisation
405method_not_allowedWrong HTTP method (see the Allow header)
422validationA field is wrong; errors[] says which
429rate_limitedToo 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.

Get a token at /app/api