Direct naar inhoud

API, CLI en MCP

Drie manieren om in hetzelfde account te komen, met dezelfde planlimieten en dezelfde rechten die je rol al geeft. Alles hieronder is een van deze drie, dus het is handig om te weten waarvoor je kwam.

API

REST, vanuit een pipeline, een script of je eigen tools. Een token die je zelf uitgeeft en intrekt, en JSON beide kanten op.

De API

CLI

Eén Python-bestand, niets te installeren. Dezelfde API, voor iemand achter een terminal in plaats van een programma: lijst wat down is, voeg een monitor toe.

De command line client

MCP

Eén adres, geplakt in Claude of iets anders dat het protocol spreekt. Het leest het account en wijzigt het, als jij, in een gesprek.

Voor een assistent

Je API-token

Maak er een onder API-tokens in je account. Het wordt één keer getoond, we bewaren alleen een vingerafdruk ervan, en het hoort bij jou in plaats van bij de organisatie: het kan niet meer dan jij kunt, en het stopt met werken als je vertrekt of je rol verandert. Kies lezen, of lezen en schrijven.

Stuur het als Authorization: Bearer n404_... bij elke call. De eerste die de moeite waard is, is /api/v1/me, die antwoordt voor welke organisatie de token werkt, welke rol het heeft en welke van de twee scopes het heeft: iemand met twee accounts heeft twee tokens en geen andere manier om te zien welke in een omgevingsvariabele zit.

Wat er in versie 1 zit

Aanroep Wat het doet
GET /api/v1/me Wat deze token is, en voor welke organisatie het werkt
GET /api/v1/monitors Elke monitor, oudste eerst
POST /api/v1/monitors Maak er een, volgens dezelfde regels als het formulier volgt
GET /api/v1/monitors/{id} Eén monitor
PATCH /api/v1/monitors/{id} Wijzig de naam, het adres, het interval of de configuratie, of pauzeer het
DELETE /api/v1/monitors/{id} Verwijder het, en de geschiedenis ervan
GET /api/v1/monitors/{id}/status Wat het nu doet, en de uptime over een periode
GET /api/v1/groups Elke groep, met hoeveel monitors erin zitten
POST /api/v1/groups Maak er een; een naam die al bestaat geeft de groep terug die die naam heeft
GET /api/v1/groups/{id} Eén groep
PATCH /api/v1/groups/{id} Geef het een nieuwe naam, of pas de beschrijving aan
DELETE /api/v1/groups/{id} Verwijder het. De monitors blijven, zonder groep
GET /api/v1/incidents Storingen, nieuwste eerst, gefilterd op status, monitor of periode
GET /api/v1/incidents/{id} Eén incident, met de probes die het zagen en bevestigden
GET /api/v1/maintenance Onderhoudsvensters en wat ze dekken
GET /api/v1/maintenance/{id} Eén venster, met de monitors en groepen die het dekt
POST /api/v1/maintenance Plan er een in, op de klok van je organisatie, zodat een deploy een venster kan openen voordat het begint
DELETE /api/v1/maintenance/{id} Verwijder het. Wat het al dekte blijft gedekt
GET /api/v1/status-pages Elke statuspagina, en of die aan staat
GET /api/v1/status-pages/{id} Eén pagina, en wat erop gepubliceerd is
POST /api/v1/status-pages/{id}/monitors Zet een monitor op de pagina, onder de naam die het publiek moet zien
DELETE /api/v1/status-pages/{id}/monitors/{id} Haal het van deze pagina af. Andere pagina's houden het
POST /api/v1/status-pages/{id}/groups Zet een groep op de pagina; de monitors erin komen ook mee
DELETE /api/v1/status-pages/{id}/groups/{id} Haal de kop weg. De monitors blijven gepubliceerd

Elke id in een pad of body is de UUID, nooit een nummer. Schrijven vereist een read- en write-token en een rol die mag schrijven: de scope is wat je aan een programma gaf, de rol is wat je mocht doorgeven.

openapi.json

Het document is OpenAPI 3.1. Het beschrijft elke call, de vorm van elke body, en de bearer token, zodat een client gegenereerd kan worden in plaats van geschreven: openapi-generator, oapi-codegen en de rest lezen het zoals het is. De operaties zijn genoemd naar een persoon, dus de gegenereerde methoden zijn listMonitors en createMonitor.

Versie 1 groeit alleen maar: een veld kan worden toegevoegd, niets wordt verwijderd of hergetypt, en een tweede versie zou een tweede pad zijn. Dus een gegenereerde client blijft werken, en door hem opnieuw te genereren krijg je wat nieuw is.

Een client, als je er een wilt

Eén bestand, Python 3.9 of nieuwer, geen dependencies. Download het, maak het uitvoerbaar, en zet je token in de omgeving. Het doet alles wat de API doet, want elke opdracht is één call naar de routes hierboven.

nomore404.py nomore404_mcp.py

curl -O https://nomore404.com/api/nomore404.py
curl -s https://nomore404.com/api/nomore404.py.sha256 | sha256sum -c
chmod +x nomore404.py
export N404_TOKEN=n404_...

./nomore404.py monitors list
./nomore404.py monitors add --type https --target shop.example.com
./nomore404.py incidents --state open

De tweede regel is de moeite waard om uit te voeren. Die controleert het bestand tegen de digest die we naast het bestand publiceren, wat de digest is van precies wat deze server verstuurt, zodat een download die onderweg is aangepast niet overeenkomt. ./nomore404.py --version geeft aan van welke release het afkomstig is, en elke aanvraag die het doet vermeldt hetzelfde in zijn User-Agent.

De token komt uit N404_TOKEN of uit een nomore404.env-bestand naast het script, nooit uit een commandoregelvlag: een argument is zichtbaar in ps voor elke gebruiker op de machine en blijft in je shellgeschiedenis staan.

Voor een assistent

Een assistant kan dit account lezen en wijzigen via het Model Context Protocol. Er zijn twee manieren om toegang te krijgen en die zijn niet hetzelfde.

Eén adres, niets te installeren

Plak dit waar je assistant vraagt om een aangepaste connector. Het stuurt je hierheen om in te loggen en aan te geven voor welke organisatie de verbinding is, en dat is de hele setup.

Het handelt als jij: je rol wordt bij elke oproep gelezen, dus een assistant die is verbonden door iemand die alleen mag lezen, kan alleen lezen. Het leest monitors, storingen, uptime, onderhoudsvensters en groepen, en het kan ze toevoegen en wijzigen, inclusief het verwijderen van een monitor en de geschiedenis ervan. Ontkoppel het wanneer je wilt via API-tokens, waar het naast hen wordt vermeld.

Of voer het zelf uit en laat het blijven lezen

nomore404_mcp.py biedt dezelfde API als tools vanaf je eigen machine. Houd het naast nomore404.py, die het gebruikt voor de token en voor paginering. Het leest en schrijft nooit, wat de reden is om het te kiezen: een assistant is een beller die tot dingen kan worden overgehaald, en een tool die een monitor en zijn geschiedenis verwijdert, is één prompt verwijderd van gebruik.

Twee bestanden, een token ernaast, en één regel om de server te registreren. Claude Code:

curl -O https://nomore404.com/api/nomore404.py
curl -O https://nomore404.com/api/nomore404_mcp.py
echo 'N404_TOKEN=n404_...' > nomore404.env

claude mcp add nomore404 -- python3 "$PWD/nomore404_mcp.py"

Alles wat het protocol spreekt is hetzelfde commando geschreven als JSON, waar die client zijn servers ook bewaart:

{
  "mcpServers": {
    "nomore404": {
      "command": "python3",
      "args": ["/path/to/nomore404_mcp.py"]
    }
  }
}

Geen van beide noemt de token, omdat dat niet zou moeten: het wordt gelezen uit nomore404.env naast de scripts, of uit N404_TOKEN in de omgeving waarmee de assistant het start. Vraag het daarna wat er down is, waarom een incident is geopend, of hoe een monitor deze maand heeft gepresteerd.

Beide zijn een paar honderd regels en de moeite waard om te lezen voordat je ze uitvoert. Geen van beide is verpakt of ondertekend, en niets weerhoudt je ervan om je eigen client te genereren vanuit het document.

Fouten en lange lijsten

Eén foutvorm

De status geeft de categorie aan. Het lichaam geeft aan welke fout het was, met een code om op te vertakken en een zin om te lezen. De zin kan in elke release worden herschreven, dus niets mag deze parsen.

{
  "error": {
    "code": "monitor_not_found",
    "message": "Nothing here with that id."
  }
}

Cursors, geen offsets

Een lijst antwoordt met items en next_cursor. Geef de cursor terug om de volgende pagina te krijgen, en stop wanneer deze null is. Incidenten komen binnen terwijl je ze leest, en een offset zou je stilletjes één rij twee keer laten zien en nooit de volgende.

GET /api/v1/incidents?limit=50
GET /api/v1/incidents?limit=50&cursor=...

Hoeveel je mag vragen

Eén token mag honderdtwintig oproepen per minuut doen. Elk antwoord bevat RateLimit-Remaining en RateLimit-Reset, zodat een goed functionerende client zichzelf kan reguleren in plaats van de limiet te vinden door deze te overschrijden. Over de limiet is een 429 met Retry-After.

Maak een gratis account aan