REST API
Every WebFrost HTTP route with authentication, request and response shapes, status codes and rate limits.
The server exposes a JSON REST API under /api/v1, plus an unauthenticated GET /health. The web UI uses these same routes. Examples assume API=http://localhost:3000/api/v1 and KEY holds an API key.
Versioning
Version 1 of the API is frozen for 0.1.0. Every route below lives under /api/v1; the tables write routes without the prefix (/snapshots is /api/v1/snapshots). GET /health is not versioned. Within v1, changes are additive: new routes, new optional request fields and new response fields. Clients should ignore fields they do not know.
An unknown route under /api answers 404 { "error": "not found", "code": "NOT_FOUND" } as JSON.
Deprecated /api alias
The same routes are still served without the version, as /api/snapshots for /api/v1/snapshots. It is purely a path alias: it runs the same handlers, uses the same authentication and shares the same rate limits, and it returns the v1 response shapes (envelopes, ISO timestamps, error codes), not the shapes of earlier pre-release builds. Every alias response, errors and file downloads included, carries:
Deprecation: true
Link: </api/v1/snapshots?page=2>; rel="successor-version"Link holds the path and query of the v1 equivalent. The alias will be removed in a later 0.x release; move clients to /api/v1 now.
Authentication
Every /api/v1/* route requires authentication except POST /auth/login, POST /auth/logout, GET /setup/status and POST /setup. Unauthenticated requests get 401 { "error": "unauthorized", "code": "UNAUTHORIZED" }.
API key. Send it as a bearer token:
curl -H "Authorization: Bearer $KEY" $API/snapshotsCreate keys in the UI (Settings, API keys), with webfrost admin key create, or with POST /settings/keys. Keys are stored as SHA-256 hashes and shown once.
Session cookie. Browsers use the cookie set by POST /auth/login or POST /setup. It is named session, HttpOnly, SameSite=Strict and Secure (unless WEBFROST_INSECURE_COOKIES=true), valid for 7 days, and backed by a server-side session: logging out revokes it, logging in again revokes the session in the cookie it replaces, and changing the password revokes every session of the user.
Cross-origin protection. A state-changing request (POST, PUT, PATCH, DELETE) without a bearer token must come from the app's own origin: its Sec-Fetch-Site header must be same-origin or none. Without Sec-Fetch-Site, an Origin header, when present, must match the Host. Anything else gets 403 { "code": "CROSS_ORIGIN_REQUEST" }. same-site is refused too, so a sibling subdomain cannot act with the session cookie. Clients that are not browsers send neither header and are not affected; bearer-token requests are never checked.
Public read. With WEBFROST_PUBLIC_READ=true, a fixed set of GET routes also works without credentials. See Public read for the list.
AUTH_DISABLED=true turns authentication off (GET /setup/status then reports needsSetup: false and GET /auth/me returns { "username": "admin" }). For development only.
Conventions
- Bodies and responses are JSON, except downloads and
POST /import/file(multipart). A request body with any otherContent-Typegets415. Requests without a body (DELETE, logout) need noContent-Type. - Errors are
{ "error": "message", "code": "CODE" }; see Errors. - Length limits: passwords 1024 characters, usernames 128, API key and tag names 100, tag colors 32, cron expressions 256, URLs 8192.
- Timestamps are ISO 8601; see Timestamps.
- Lists are paginated; see Pagination. Lists of snapshots and imports are newest first.
- Snapshot
statusis exactly one ofpending,doneorfailed.
Errors
Every error response, from every route and including the /api alias, has the body:
{ "error": "invalid url", "code": "VALIDATION" }error is a message for people and may change between releases. code is stable, in UPPER_SNAKE_CASE: branch on it.
| Code | Status | Meaning |
|---|---|---|
BAD_REQUEST | 400 | Malformed request not covered by a more specific code: an unknown extractor on download, an extractor with no preview, an invalid cookie |
VALIDATION | 400 | The body or query failed validation: a bad URL (invalid url), a snapshot bundle that breaks a rule (invalid manifest: ..., invalid bundle: ...), a bad cron expression, a missing url or content on import, a password that is too short, expiresAt not ISO 8601 or in the past, any other schema failure (invalid request) |
INVALID_JSON | 400 | The body is not valid JSON |
FETCH_FAILED | 400 | An import could not fetch the feed or file at the given url |
UNAUTHORIZED | 401 | No credentials, or an invalid session or API key |
INVALID_CREDENTIALS | 401, 403 | 401 on POST /auth/login for a wrong username or password; 403 on POST /auth/change-password for a wrong current password (403 so clients do not treat it as an expired session) |
FORBIDDEN | 403 | For example a stored file reference that points outside storage |
CROSS_ORIGIN_REQUEST | 403 | A state-changing cookie request from another origin (the CSRF guard) |
SETUP_TOKEN_INVALID | 403 | POST /setup without the right WEBFROST_SETUP_TOKEN |
NOT_FOUND | 404 | No such resource or route |
CONFLICT | 409 | The tag already exists, or setup is already complete |
PAYLOAD_TOO_LARGE | 413 | An import over WEBFROST_IMPORT_MAX_BYTES or WEBFROST_IMPORT_MAX_URLS, a snapshot bundle over WEBFROST_IMPORT_BUNDLE_MAX_BYTES, or any other body over the request limit |
UNSUPPORTED_MEDIA_TYPE | 415 | The body is not application/json (or not multipart/form-data for /import/file, or not application/zip for /snapshots/import) |
RATE_LIMITED | 429 | Too many requests; see Retry-After and Rate limits |
INTERNAL | 500 | Unexpected server error |
A request body above the server's absolute maximum size is refused by the HTTP runtime itself with 413 before it reaches the API, so that one response may not carry the JSON body. Outside POST /snapshots/import, a body sent with Transfer-Encoding: chunked and no Content-Length is refused with 411 (code BAD_REQUEST): only the bundle import streams a body of unknown length.
Pagination
Every list endpoint returns the same envelope:
{ "items": [], "total": 42, "page": 1, "limit": 20 }total counts all matching rows, not only this page. Every list accepts these query parameters:
| Query | Default | Description |
|---|---|---|
page | 1 | 1-based page |
limit | 20 | Page size, capped at 200. Non-integers are truncated; a value that is not a number falls back to the default. |
The lists are GET /snapshots (also with q and status; newest first), GET /tags (by name), GET /snapshots/:id/tags (by name), GET /schedules (oldest first), GET /imports (newest first) and GET /settings/keys (oldest first).
Timestamps
Every timestamp in a response (createdAt, lastRunAt, nextRunAt, expiresAt, lastUsedAt, ...) is ISO 8601 in UTC with a Z and whole seconds, such as 2026-11-21T21:42:38Z, whichever database WebFrost uses. Request fields that take a timestamp accept ISO 8601; see expiresAt under Stats and settings.
Rate limits
Limits are per client IP over a sliding one-minute window, held in memory, and shared with the deprecated /api alias:
| Scope | Limit |
|---|---|
GET and HEAD on /api/v1/* | 300 per minute |
POST /snapshots, POST /snapshots/:id/retry, POST /snapshots/import, POST /import, POST /import/file | 60 per minute |
POST /auth/login, POST /auth/change-password, POST /setup | 10 per minute |
A limited request gets 429 with a Retry-After header (seconds). The client IP is the TCP peer address. X-Forwarded-For is used only when WEBFROST_TRUST_PROXY=true, which you should set only behind a reverse proxy. Proxies append the address they saw to the header, so the server takes the entry WEBFROST_TRUSTED_PROXY_HOPS (default 1) places from the right, never the client-chosen left-most one. IPv6 clients share one limit per /64.
Health
| Method | Route | Auth | Description |
|---|---|---|---|
GET | /health | none | { "status": "ok" } |
Setup
| Method | Route | Auth | Description |
|---|---|---|---|
GET | /setup/status | none | { needsSetup, publicRead, setupTokenRequired } |
POST | /setup | none | Create the admin user (first run only) |
POST /setup takes { "username", "password", "setupToken"? }. The username must not be empty and the password needs at least 8 characters, otherwise 400 VALIDATION. When the server has WEBFROST_SETUP_TOKEN set (setupTokenRequired: true), the request must carry that token, as the setupToken field or an X-Setup-Token header, otherwise 403 { "code": "SETUP_TOKEN_INVALID" }. On success it returns { "apiKey": "..." } (shown once) and sets a session cookie. Once an admin exists it answers 409 CONFLICT.
curl -X POST $API/setup -H "Content-Type: application/json" \
-H "X-Setup-Token: $WEBFROST_SETUP_TOKEN" \
-d '{"username": "admin", "password": "a-long-password"}'Auth
| Method | Route | Description |
|---|---|---|
POST | /auth/login | { username, password }. Sets the session cookie, returns { "ok": true }. 401 INVALID_CREDENTIALS for wrong credentials. |
POST | /auth/logout | Revokes the session and clears the cookie. 204, also when the session has already expired or been revoked. |
GET | /auth/me | { username }. username is null when authenticated by API key. |
POST | /auth/change-password | { currentPassword, newPassword } |
change-password answers 400 VALIDATION if newPassword has fewer than 8 characters and 403 INVALID_CREDENTIALS (not 401) if currentPassword is wrong, because the caller is authenticated and clients treat 401 as an expired session. On success every session of the user is revoked and a browser caller receives a fresh cookie.
Snapshots
| Method | Route | Description |
|---|---|---|
POST | /snapshots | Queue a URL for archiving. 202. |
GET | /snapshots | List snapshots, or search with ?q=. |
GET | /snapshots/:id | One snapshot with archive results and per-extractor metadata. |
POST | /snapshots/:id/retry | Archive a snapshot again, in place. 202, 404, or 409 while it is being archived. |
POST | /snapshots/import | Store a snapshot archived elsewhere, from a snapshot bundle (application/zip). 201. |
DELETE | /snapshots/:id | Delete a snapshot and its files. 204, or 404. |
Create
curl -X POST $API/snapshots -H "Authorization: Bearer $KEY" \
-H "Content-Type: application/json" -d '{"url": "https://example.com"}'
# 202 { "id": 1, "url": "https://example.com", "status": "pending" }The body takes url and an optional colorScheme, "light" or "dark": the theme the browser archives the page in (screenshot, PDF, Page view). Without it the server default WEBFROST_COLOR_SCHEME applies. The web UI sends its current theme.
curl -X POST $API/snapshots -H "Authorization: Bearer $KEY" \
-H "Content-Type: application/json" -d '{"url": "https://example.com", "colorScheme": "dark"}'The URL must be http or https and at most 8192 characters, otherwise 400 { "error": "invalid url", "code": "VALIDATION" }; a body that fails validation in any other way gets the same response. The pipeline runs in the background; poll the snapshot until status leaves pending.
List
curl "$API/snapshots?page=1&limit=20&status=done" -H "Authorization: Bearer $KEY"
# { "items": [...], "total": 42, "page": 1, "limit": 20 }| Query | Default | Description |
|---|---|---|
page | 1 | 1-based page |
limit | 20 | Page size, capped at 200 |
status | none | Filter by pending, done or failed |
q | none | Full-text search term |
Each item is { id, url, status, createdAt, extractors, title, excerpt, screenshotUrl, tags }. extractors lists only extractors that succeeded. title and excerpt come from Readability. screenshotUrl is the path of the download route for the video media-poster still when the snapshot has one, else for the small thumbnail WebP (/api/v1/snapshots/:id/archives/thumbnail/download), else for the full screenshot (/api/v1/snapshots/:id/archives/screenshot/download), or null when there is neither.
Search
curl "$API/snapshots?q=climate+change&page=1&limit=20" -H "Authorization: Bearer $KEY"The query uses FTS5 syntax ("exact phrase", prefix term*, OR, NOT; column filters on SQLite). On PostgreSQL and MySQL the same common syntax is accepted; see full-text search. It searches URL, title, extracted text and tag names. An invalid expression returns no results. rank is lower for better matches on every database, but its scale differs between them. Results are ranked by relevance, status filters them like the list, and each item adds snippet and rank to the list fields:
{ "id": 1, "url": "https://example.com", "snippet": "...climate <mark>change</mark>...", "rank": -1.2, "status": "done" }The snippet is HTML-escaped; its only markup is the literal <mark> tag. Render it as text with highlights, never as raw HTML from an untrusted source.
Detail
GET /snapshots/:id returns the list fields plus:
archiveResults:[{ id, extractor, content, downloadUrl, previewUrl, createdAt }]for extractors that succeeded. See Archive results.extractorMeta: an object keyed by extractor name,{ status: "success" | "failed", durationMs, fileSizeBytes, error? }.
Browser extractors that could not run (Chromium missing, navigation failed, SSRF violation) appear in extractorMeta with status: "failed" and an error, and are absent from extractors and archiveResults. Guests see error: "extraction failed" instead of the raw message, which can name internal hosts and paths. media is skipped silently, with no entry, when yt-dlp is missing or the URL is not a media page. An unknown id answers 404.
Retry
POST /snapshots/:id/retry archives a snapshot again under the same id: same URL and color scheme, every result replaced by the new run. It answers 202 with { "id": 7, "status": "pending" } and the snapshot is pending until the run ends (poll GET /snapshots/:id). An unknown or non-numeric id answers 404; a snapshot that is still pending answers 409 with code CONFLICT. Use it for a page that changed or a video a site refused the first time. It needs credentials, also when public read is on.
Import a snapshot bundle
POST /snapshots/import stores a snapshot that another WebFrost archived, usually webfrost push from your own machine (see Archive on your machine, keep it on the server). The body is the bundle itself, a ZIP file made by webfrost export or webfrost push, sent as Content-Type: application/zip (not multipart). It may be chunked; the server streams it to a private file under WEBFROST_DIR/tmp and counts the bytes on the way.
webfrost export 12 -o snapshot-12.zip
curl -X POST $API/snapshots/import -H "Authorization: Bearer $KEY" \
-H "Content-Type: application/zip" --data-binary @snapshot-12.zip
# 201 { "id": 57, "url": "https://www.youtube.com/watch?v=...", "status": "done" }The import always creates a new snapshot with a new id. Its status (done or failed), creation time, color scheme, results (inline content, errors, durations) and files come from the bundle; tags are matched by name and created when missing; a done snapshot is added to the search index. Nothing is fetched and no pipeline runs. Importing the same bundle twice makes two snapshots.
It needs credentials like every write (an API key, or a session with the CSRF check), also when public read is on, and counts against the 60-per-minute rate limit of snapshot creation. At most two imports run at once per server process; a third gets 429 RATE_LIMITED with Retry-After: 30 before its body is read. While the upload streams in, the connection may go up to 255 seconds without data before it is closed; once the body is complete there is no idle timeout while the server copies it into storage.
| Status | When |
|---|---|
201 | Imported: { id, url, status } |
400 VALIDATION | The bundle is not a valid ZIP, its manifest breaks the format, or its entries break a rule below. Nothing is stored. |
429 RATE_LIMITED | Two imports are already running, or the rate limit; see Retry-After |
413 PAYLOAD_TOO_LARGE | The upload, or its content once decompressed, is over WEBFROST_IMPORT_BUNDLE_MAX_BYTES (default 2 GiB) |
415 UNSUPPORTED_MEDIA_TYPE | The body is not application/zip |
Bundle format, version 1. A ZIP (stored or deflate entries, no ZIP64, so under 4 GiB) holding manifest.json and one entry per file-backed result:
{
"format": "webfrost-snapshot",
"version": 1,
"snapshot": {
"url": "https://www.youtube.com/watch?v=...",
"status": "done",
"createdAt": "2026-11-21T21:42:38Z",
"colorScheme": null,
"tags": ["talks"]
},
"results": [
{ "extractor": "readability", "content": "{\"title\":\"...\"}", "error": null, "durationMs": 120, "sizeBytes": 5120, "createdAt": "2026-11-21T21:42:40Z" },
{ "extractor": "media", "file": "media.mp4", "error": null, "durationMs": 48000, "sizeBytes": 73400320, "createdAt": "2026-11-21T21:43:28Z" },
{ "extractor": "pdf", "error": "browser unavailable: ...", "durationMs": 30000, "sizeBytes": null, "createdAt": "2026-11-21T21:42:45Z" }
]
}The server treats a bundle as untrusted input:
- The manifest is checked strictly: unknown fields, an unknown
version, a non-http(s)URL, a timestamp that is not ISO 8601 UTC (YYYY-MM-DDTHH:MM:SSZ) or an extractor outside the list below are refused. - Inline results (
html,readability) carrycontentand no file, at most 50 MiB (UTF-8) each, the most the pipeline's fetch can return.readabilitycontent must be the Readability JSON object:title,byline,excerpt,textContentandcontentare strings ornull, and no field holds an object or array. snapshot.urlis stored in its parsed, normalised form (HTTPS://Example.COM/a bbecomeshttps://example.com/a%20b).- A successful file-backed result names its entry in
file, and each extractor has fixed names:screenshot.png,thumbnail.webp,page.pdf,archive.warc,dom.html,singlefile.html,media.mp4ormedia.mp3,media-metadata.json,poster.jpg. No other name, and so no path, is accepted. A failed result has no file. - Every entry must be referenced by the manifest exactly once. Duplicate names, unreferenced entries, encrypted, ZIP64 or overlapping entries are refused.
- Sizes are checked from the ZIP directory before anything is written, and again while each entry is decompressed (fed to the inflater 4 KiB at a time, it is stopped within about 4 MiB of passing its declared size; the CRC must match), so a zip bomb stops at its declared size.
- The server picks where each file is stored and serves it with the content type of its extractor, never one from the bundle. Archived HTML is still shown only through the sandboxed preview.
sizeBytesis recomputed from what was stored.
If something fails after the checks (a corrupt entry discovered while decompressing, storage unavailable), everything written for the import is removed again. While the files are copied the new snapshot exists with the internal status importing: it is left out of lists, search, stats and GET /snapshots/:id (404), and DELETE or POST /snapshots/:id/retry on it answer 409 CONFLICT. If the server dies during an import, the next start removes that snapshot and its files, and the upload left in WEBFROST_DIR/tmp, once they are over an hour old.
Archive results
{
"id": 7,
"extractor": "pdf",
"content": null,
"downloadUrl": "/api/v1/snapshots/1/archives/pdf/download",
"previewUrl": null,
"createdAt": "2026-11-21T21:42:38Z"
}contentholds the data only for inline extractors (readabilityandhtml, as a JSON string). It isnullfor file-backed ones:warc,pdf,screenshot,thumbnail,dom-snapshot,singlefile,media,media-posterandmedia-metadata. Storage paths and S3 keys never appear in API output, for admins or guests.downloadUrlis always the relative path of the v1 download route.previewUrlis the relative path of the v1 preview route fordom-snapshotandsinglefile, andnullfor every other extractor.
Guests (see Public read) get the same shape.
Archive files
| Method | Route | Description |
|---|---|---|
GET | /snapshots/:id/archives/:extractor/download | Download one format |
GET | /snapshots/:id/archives/:extractor/preview | Render archived HTML inline in a sandbox |
:extractor is one of warc, pdf, screenshot, thumbnail, readability, dom-snapshot, singlefile, html, media, media-poster, media-metadata. An unknown name answers 400 BAD_REQUEST, a snapshot or result that does not exist (or has no content) 404.
curl -OJ $API/snapshots/1/archives/screenshot/download -H "Authorization: Bearer $KEY"| Extractor | Content type | File name |
|---|---|---|
warc | application/warc | archive.warc |
pdf | application/pdf | page.pdf |
screenshot | image/png | screenshot.png |
thumbnail | image/webp | thumbnail.webp |
dom-snapshot | text/html | dom.html |
singlefile | text/html | singlefile.html |
media | video/mp4 or audio/mpeg | media.mp4 or media.mp3 |
media-poster | image/jpeg | poster.jpg |
media-metadata | application/json | media-metadata.json |
readability, html | application/json | readability.json, html.json (the stored value as is) |
Downloads carry Content-Disposition: attachment. With the S3 backend every file format except media-metadata answers 302 to a presigned URL valid for one hour; the URL signs the content type and an attachment disposition (response-content-type, response-content-disposition), so archived HTML downloads instead of rendering on the bucket's origin. See Storage.
preview works only for dom-snapshot and singlefile (400 BAD_REQUEST otherwise). It serves the page with Content-Security-Policy: sandbox; default-src 'none'; ..., so scripts, forms and network requests are disabled even if the URL is opened directly. The UI frames it in <iframe sandbox="">.
Tags
| Method | Route | Description |
|---|---|---|
GET | /tags | List tags by name, paginated: items are { id, name, slug, color, createdAt }; color is null when none was set |
POST | /tags | { name, color? }. 201 with the tag. 409 CONFLICT if a tag with that name (or slug) exists. |
DELETE | /tags/:id | Delete a tag and remove it from all snapshots. 204, or 404. |
GET | /snapshots/:id/tags | Tags on a snapshot, paginated |
POST | /snapshots/:id/tags | { tagId }. 201 with the tag, also when it was already attached. 404 for an unknown snapshot or tag. |
DELETE | /snapshots/:id/tags/:tagId | Remove a tag from a snapshot. 204, or 404 when the snapshot does not exist or the tag is not on it. |
Tag names are part of the search index and stay in sync when you add or remove tags after archiving.
Schedules
| Method | Route | Description |
|---|---|---|
POST | /schedules | { url, cron }. 201 with the schedule. 400 VALIDATION for an invalid URL or cron expression. |
GET | /schedules | List schedules, oldest first, paginated |
GET | /schedules/:id | One schedule, or 404 |
PATCH | /schedules/:id | { "paused": true } or { "paused": false } (required). Returns the updated schedule, or 404. |
DELETE | /schedules/:id | 204, or 404 |
A schedule is { id, url, cron, createdAt, lastRunAt, nextRunAt, paused, lastStatus, consecutiveFailures }. lastStatus is success, failed or null. The API creates URL schedules only; add an RSS feed schedule with webfrost schedule add --rss. See Scheduled archiving.
Import
| Method | Route | Description |
|---|---|---|
POST | /import | Import from a URL or inline content. 202. |
POST | /import/file | Import an uploaded file (multipart/form-data). 202. |
GET | /imports | Import history, newest first, paginated |
POST /import takes JSON { url?, content?, format? }. Send url (a feed or file to fetch) or content (raw text), otherwise 400 VALIDATION. A url that cannot be fetched answers 400 FETCH_FAILED. format is rss, opml, netscape or text; it is detected when omitted, and any other value is ignored. A url without a format is tried as an RSS feed first. Only RSS imports skip URLs that are already archived. POST /import/file takes a file field and an optional format field, and answers with the same { queued, skipped, total, format }; total is the number of URLs found.
An import larger than WEBFROST_IMPORT_MAX_BYTES (default 10 MiB: the file, the content field or the fetched url) or with more URLs than WEBFROST_IMPORT_MAX_URLS (default 10000) is refused with 413 { "code": "PAYLOAD_TOO_LARGE" } and queues nothing.
curl -X POST $API/import -H "Authorization: Bearer $KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/feed.xml", "format": "rss"}'
# 202 { "queued": 12, "skipped": 3, "total": 15, "format": "rss" }
curl -X POST $API/import/file -H "Authorization: Bearer $KEY" \
-F "[email protected]" -F "format=netscape"GET /imports returns the pagination envelope with items { id, sourceUrl, format, queued, skipped, createdAt }. Format rules and deduplication: Bulk import.
Stats and settings
| Method | Route | Description |
|---|---|---|
GET | /stats | { snapshotCount, storageBytes, storageByExtractor, successRate, activeScheduleCount, failedToday }. Cached for 60 seconds. |
GET | /settings/info | { version, storagePath, snapshotCount } |
GET | /settings/keys | List active API keys, oldest first, paginated: items are { id, name, expiresAt, lastUsedAt, createdAt } |
POST | /settings/keys | { name, expiresAt? }. 201 with { id, name, expiresAt, lastUsedAt, createdAt, rawKey }; rawKey is shown once. |
DELETE | /settings/keys/:id | Revoke a key. 204, or 404. |
expiresAt is optional and ISO 8601, such as 2027-01-01T00:00:00Z. A value without an offset is read as UTC. It must be in the future, otherwise 400 VALIDATION. Omit it or send null for a key that never expires.
storageByExtractor maps each extractor name to its bytes on disk. successRate is the percentage (0 to 100, two decimals) of done snapshots among those that are not pending, created in the last 30 days. failedToday counts snapshots that failed since 00:00 UTC.
Status codes at a glance
Every error status carries an error code.
| Status | Meaning |
|---|---|
200, 201 | Success, created |
202 | Accepted; work continues in the background (snapshot, import) |
204 | Deleted, logged out |
302 | Download redirect to a presigned S3 URL |
400 | Invalid input, malformed JSON, failed import fetch |
401 | Not authenticated |
403 | Cross-origin request; wrong setup token; wrong current password on change-password; storage reference refused on download |
404 | Not found, including unknown /api routes |
409 | Already exists (tag name, setup already done) |
413 | Import over the size or URL-count limit |
415 | Request body is not JSON (or not multipart for /import/file) |
429 | Rate limited; see Retry-After |