More / Changelog
More

Changelog

Every change to the Detectivision content moderation API and its documentation, newest first: new endpoints, fields, flags and fixes.

On this page

Changes that affect integrations are listed here, newest first. Additions do not break existing code: new response fields may appear at any time, so read responses in a way that ignores fields you do not know.

2026-10-26#

  • Send the file itself. POST /api/v1/moderation also takes a form (multipart/form-data): the image or the video in the field file, and the usual fields beside it as text (type, mode, flags, fps, tracking, async, metadata as JSON text). An image file may be up to 10 MB and a video file up to 20 MB; a larger video goes by its URL, up to 100 MB. A file sent as application/octet-stream or without a type is recognised by its first bytes. See Image and Video.
  • Images in base64. In a JSON body, input can also be the image as a data URL: data:image/jpeg;base64,… (or PNG, WebP, GIF, BMP), up to 10 MB of image. To make room, a moderation request's JSON may now be up to 14 MB (it was 256 KB). Videos go as a file or by URL. See In base64.
  • What is kept. A file or a base64 image is checked and not stored; the request keeps only its name, such as upload: photo.jpg. An async request's file waits in storage only until its check runs, and never longer than 24 hours. See Async requests.
  • Nothing else changes. Text, URLs and every other field work as before, and so do prices, credits, rate limits, answers and webhooks. A file over its limit gets 413 payload_too_large; an empty file or base64 that cannot be read gets 400 invalid_input. See Errors.

2026-10-16#

  • Your account's email and plan. GET /api/v1/account also returns the account's email and plan, the name of its current plan (or null when it has none). An app reads them with the account:read scope, which now says it shares the email and the plan. See Read your account.
  • flags has no set order. The docs said the flags raised come strongest first; they do not, so code that reads only the first flag can miss the strongest. Look for each flag you act on, and compare their confidence yourself. A flag's detections do come strongest first. See Responses.
  • At most 50 async checks waiting. An account can have at most 50 async checks waiting at once; one more gets 429 too_many_requests with Retry-After: 60. The limit was not in the docs before. See How many can wait.

2026-10-04#

  • Content a check will not look at is a final answer. It is refused with 422 content_declined, free; it used to be 503 temporarily_unavailable, which told clients to retry.
  • Video fps is 0.5 to 10. A lower rate is refused with invalid_input (invalid_request in a JSON body).
  • What a check already read of a long video is charged. When a video is refused with video_too_long after part of it was read at a cost, that part is charged (five units at most, in charged). A video whose length cannot be read costs the longest check, five units.
  • Long videos are refused, not checked in part (breaking). A video pays a unit per started minute at fps: 1, with no cap, and one check takes at most 300 frames (5 minutes at fps: 1). A longer video, or one that takes more than 80 seconds to check, gets video_too_long and costs nothing. Before, it was checked up to 300 frames, charged 5 units and marked media.truncated. See Video.
  • Input errors before credits. An input that is wrong before anything is downloaded is refused with invalid_input even when the balance is short. This covers a text over 10,000 characters, a URL that is not http(s), an fps out of range and an upload of the wrong type. Such an input used to get insufficient_quota. See Errors.
  • Larger moderation bodies. POST /api/v1/moderation takes up to 256 KB of JSON, so 10,000 characters fit even when your JSON library escapes every one of them.
  • Dropped connections are not charged. If the connection drops before a check finishes, its credits come back within about 20 minutes and the request shows as failed. See When you are charged.

2026-10-03#

  • Text and video pay by size (breaking for billing). A text pays the table price per started 2,500 characters (1 to 4 units), a video per started 60 frames checked, a minute at fps: 1 (1 to 5 units). A video holds one unit when it starts and is charged for its frames when it is done, below zero if the balance was short. Characters are now counted as Unicode code points, so a text of 10,000 emoji is accepted. See Size.
  • Async requests. Send "async": true and the API answers 202 with the request's id at once; the check runs shortly after, at the price table, and its result comes as moderation.completed (or the new moderation.failed) and from GET /api/v1/moderation/{id}, which says queued or processing until then. See Async requests.
  • Immediate answers cost twice the table (breaking for billing). An answer given at once, the default, now costs twice the price table; async checks cost the table. Live sessions keep their price.
  • One error shape (breaking). Every error is now {"error": "<code>", "message": "…"}, plus details when a request body was refused. error used to be a sentence (Invalid input, Insufficient Quota); it is now a stable code (invalid_input, insufficient_quota), and the sentence is in message. The 503 body's code is now error, in lower case (temporarily_unavailable, not_available_yet). See Error codes.
  • Rate limits. Calls are limited per API key and per address, a minute at a time; over a limit the answer is 429 with Retry-After. See Rate limits.

2026-10-02#

  • Your flags. GET /api/v1/flags lists, per type, the flags your account may send, including flags set up for your account only. Requests and live sessions accept exactly those. See Flags.

  • Console and actions. Every request takes metadata (your own JSON, sent back unchanged everywhere).

    • Define your own actions and take them in the dashboard's Console or through the API (POST /api/v1/moderation/{id}/actions).
    • Your system gets each one as a moderation.action webhook.
    • Read a request back with GET /api/v1/moderation/{id}.
    • Live moments carry the session's metadata in live.moment.
    • The Console shows one request at a time, by type, with your actions at its foot and keys for them.

    See Console and actions.

  • Webhooks. Get events at your own URL as they happen: moderation.completed, moderation.flagged, live.moment and live.session.ended.

    • Add endpoints in the dashboard under Webhooks.
    • Messages are signed the Standard Webhooks way.
    • Failed messages are retried for about 28 hours.

    See Webhooks. The OpenAPI description has a webhooks section with their bodies.

  • Live streams. A session that stops by itself now always gives one of the documented reasons. A stream link that cannot be read ends with The stream could not be read. See When a session stops by itself.

2026-10-01#

  • Playground. The categories you choose now go into the Code view's request as flags, and the price shown follows them.
  • Choosing flags. The docs now say what leaving a flag out saves: the models that feed none of your flags are not run, and capture and censor cost what detect costs when none of your flags is found by a model that says where. Every request field table lists flags.

2026-09-28#

  • Brands. A new visual flag, brand, finds the logos of about 300 well-known brands. Each detection names the brand in label, and censor mode hides the logos. See Flags.

  • Alcohol. alcohol finds more drinks (bottles, cans and glasses of beer, wine, spirits and cocktails), and tells coffee, water, juice and soda apart better.

  • Tracking. Videos and live sessions take tracking: true. Each finding is followed from frame to frame, so a frame where a model misses it still carries it:

    • Detections have track.
    • Detections that tracking added have tracked: true.
    • A censored video follows each object on every frame.

    It is free. See Tracking.

2026-09-27#

  • Documentation. Public docs, API reference, OpenAPI description, llms.txt and the MCP server.
  • Live streams. Sessions take frameSide (the size of the kept pictures) and momentEvery (how often a flagged frame is kept). For HLS links the stream's rendition closest to frameSide is watched. See Live streams.
  • Service status. A single missed health check no longer makes a type unavailable: its status turns degraded first, and unavailable only when the checks keep failing or requests cannot be served.