Mark a picture, song or clip

POSThttps://api.kennmarq.com/v1/mark

Send a picture or a song; get it back with an invisible watermark and a signed, time-stamped C2PA manifest. Send a clip; get a job, and the marked clip from GET /v1/marks/{id} when it's done. A picture counts one mark, a song five per started minute, a clip five per started second. Needs a key with the mark scope.

Request

multipart/form-data, with these fields. Text fields are trimmed; flags take true/false (or 1/0, on/off, yes/no).

Options of later releases (metadata, webhook, ai_disclosure, categorize, describe, marking by url) are refused with 400 option_not_available rather than ignored, so you never believe a file got something it didn't.

Example

curl https://api.kennmarq.com/v1/mark \
  -H "Authorization: Bearer $KENNMARQ_API_KEY" \
  -F file=@render.jpg \
  -F source=created \
  -F provider="Acme Inc." \
  -F model="FLUX.1 schnell" \
  -F model_version="1.0" \
  -F app_name="Acme Studio" \
  -F app_version="2.1" \
  -F output_format=webp \
  -D headers.txt \
  -o render.marked.webp

import { readFile, writeFile } from "node:fs/promises";

const form = new FormData();
form.append("file", new Blob([await readFile("render.png")], { type: "image/png" }), "render.png");
form.append("source", "created");
form.append("model", "FLUX.1 schnell");

const res = await fetch("https://api.kennmarq.com/v1/mark", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.KENNMARQ_API_KEY}` },
  body: form,
});
if (!res.ok) throw new Error((await res.json()).error.message);
await writeFile("render.marked.png", Buffer.from(await res.arrayBuffer()));
console.log(res.headers.get("x-mark-id"), res.headers.get("x-marks-used"));

import os, requests

with open("render.png", "rb") as f:
    res = requests.post(
        "https://api.kennmarq.com/v1/mark",
        headers={"Authorization": f"Bearer {os.environ['KENNMARQ_API_KEY']}"},
        files={"file": ("render.png", f, "image/png")},
        data={"source": "created", "model": "FLUX.1 schnell"},
        timeout=60,
    )
res.raise_for_status()
open("render.marked.png", "wb").write(res.content)
print(res.headers["X-Mark-Id"], res.headers["X-Marks-Used"])

Response

200 with the marked file as the body, and these headers:

Songs

MP3, WAV or M4A, up to 15 minutes. The song comes back in the same call, in its own format (or the one output_format names), with its sample rate, channels and text tags; cover art isn't kept. Its sound carries Meta's AudioSeal mark, shaped under the music so no one hears it, and its manifest is signed and time-stamped like a picture's. AudioSeal's 16 bits say the file was marked by us, not which file: a song's credential travels in its manifest, and a song has no X-Watermark-Id.

The mark is read back from the encoded file: when it reads back, the manifest says the file carries it (X-Audio-Watermark: claimed). In a very quiet or silent recording there's nothing to hide it under; the file is then signed without that claim (unclaimed). A song longer than the marks you have left this month is refused before any work, with 402 quota_exceeded.

Clips

MP4 (or QuickTime), up to 4,500 frames (2.5 minutes at 30 frames a second, 75 seconds at 60, 5 minutes at 15), 1920x1080 either way round, 60 frames a second, 1 GB through an upload: what we can mark within a job's time. Your plan marks a few clips at a time (clips at a time). A clip is marked as a job: the call answers 202 at once with the mark's ID, and GET /v1/marks/{id} says when it's done, with a link to download it. Endpoints you add in the dashboard get mark.completed or mark.failed (webhooks).

{ "object": "mark", "id": "mk_…", "status": "running", "kind": "clip",
  "created_at": "2026-11-12T10:00:00.000Z", "url": "https://api.kennmarq.com/v1/marks/mk_…" }

Every frame carries Meta's Video Seal watermark, with a random ID like a picture's (watermark_id): it leads to the clip's durable credential when its metadata is stripped. Its sound carries AudioSeal, as a song does. The clip comes back as H.264 in MP4, upright (a phone's rotation is applied to the pixels), at the same size, frame times and sound, signed and time-stamped. Before it goes out, the watermark's ID is read back from 64 of its frames; a clip it doesn't read back from fails, as a picture does. Our safety floor reads 12 frames of every clip, and with check your policy too (two marks a frame); a blocked frame fails the job with the frame's answer in safety.

What we check before answering

We fail closed: a file goes back only if it was marked as asked. Before answering, the marker reads the signed file back and validates its manifest and time-stamp; then we check that the answer is for this mark, in this environment, in the format asked for, with the exact bytes the marker described. If anything is off you get 502 mark_failed and no file, and the mark isn't counted.

The safety check

Every picture we mark goes through our own floor, whatever you send: explicit content with someone who appears to be a child is never marked, and the call answers 422 content_blocked. With check set, the file and the input are checked under your policy as well. A clip is read on 12 frames. A block answers with the check in safety, and picture says which one it was:

{
  "error": { "code": "content_blocked", "message": "The safety check blocked this picture, so nothing was marked. See \"safety\" for why.", "request_id": "req_…" },
  "safety": { "object": "safety_check", "policy": "ai-act", "verdict": "block", "reason": "sexual_apparent_minor",
              "nudity": { "label": "explicit", "score": 0.98 }, "apparent_minor": true, "realistic_face": true,
              "picture": "file", … }
}

A blocked call counts the checks it ran, not the mark. A block by our floor alone, with check off, counts nothing.

Errors

Error bodies follow the common format.

Privacy

We record each mark's ID, watermark ID, SHA-256 and sizes, never the file, its name or its contents. A clip's marked file waits for you for a day, then is deleted. Marks say how a file was made, never who made it or the prompt. A safety check's answer is never written into the file's marks, and nothing of a blocked picture is kept. An upload is deleted as soon as the call has used it.