Laidline

Laidline is a marking kit for generative AI providers. Every image, audio clip, video or long text your system produces leaves signed (a C2PA manifest, shown to readers as Content Credentials, signed with your own key), watermarked (open models, so anyone can check the result) and logged (a tamper-evident evidence log). Detection is free for everyone, and the EU AI Act Article 50 paperwork is pre-filled from the log. Laidline runs inside your own workers: media, models and keys stay on your infrastructure.

What it marks

• Image: PixelSeal by default, TrustMark selectable, with keyed payloads.
• Audio: AudioSeal, in any container PyAV reads, with streaming sessions for voice agents.
• Video: VideoSeal on a GPU, keyframe TrustMark on a CPU.
• Text: SynthID-style and KGW watermarks, applied through the vLLM and transformers plugins.

laidline detect returns graded evidence for any of them. It never says "human-made".

Install

Laidline needs Python 3.12 or newer. Install the extras for what you mark:

Combine extras in one line: pip install "laidline[image,audio,server]".

The media extras pull in PyTorch, and the default build from PyPI includes CUDA (about 3.2 GB to download, even on a host without a GPU). On a CPU-only host, install the CPU build first and the extras after it:

pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
pip install "laidline[image,audio,server]"

Model weights download on first use. laidline models fetch downloads them ahead of time. The install guide covers install sizes and GPU setup.

Hello world

pip install "laidline[image]"
laidline init --system-name my-image-model --org "Yourcompany Inc"   # writes laidline.yaml, a payload key and a development certificate
laidline mark in.png                                             # writes in.marked.png and prints its asset id
laidline detect in.marked.png                                    # graded evidence, never "human-made"

The same from Python, in your own worker:

from laidline import Marker

marker = Marker.from_config("laidline.yaml")   # load once per process
marked = marker.mark_image("in.png", fmt="png")
open("out.png", "wb").write(marked.data)

Until you register, your marks carry a trial issuer number and the shared pool key. They read as a grade D shared mark: the watermark is found, but it does not identify you. Registering gives you a private mark and a certificate bound to your name; Going to production walks through it, with a key in your KMS and a trust-list certificate.

Plugins and tools

Each plugin is its own package and installs laidline with the extras it needs:

• laidline-comfyui: a ComfyUI save node that marks every image it writes.
• laidline-diffusers: attach(pipe, marker) marks every image a diffusers pipeline returns.
• laidline-vllm: the vLLM logits processor for the text watermark.
• laidline-transformers: a generate helper that adds the text watermark.
• laidline-pipecat: a Pipecat processor that marks speech from your TTS service.
• laidline-livekit: a LiveKit Agents wrapper that marks speech from your TTS node.
• laidline-bench: the robustness and latency benchmarks, run with laidline bench.

Integrations says which one fits where your outputs are produced.

Cost

Detection and verification are free, always. Marking is free up to 1,200 credits a month (one image is one credit), and nothing stops at the cap. Plans, credits and what happens above the free amount are on Licensing.

Licence

Laidline is source-available under the Laidline Source-Available Licence: you can read, run, modify and self-host it, but not use it to build a competing product or hosted service. It is not open source. Model weights download under their own licences; the third-party licences page lists them.

Documentation

Start with the quickstart. The overview is the full tour, configuration lists every setting and grading explains how to read a detect result.