PRACTICAL GUIDES / UPDATED 2026-11-16

ComfyUI watermarking for images and video

Add invisible watermarks and signed C2PA Content Credentials at the end of your ComfyUI workflow. Ariadne Mark provides free, open-source export nodes for images, native video and final saved files — with verification receipts and all three video profiles.

Generate → edit / resize / encode → Export with Ariadne → marked file + receipt

The extension is ariadne-mark-nodes 0.1.0, published by @ariadne-mark. It calls the existing Ariadne Mark SDK 0.7.3a4 in a separate process. Install the nodes once, connect your SDK kit once, then use an export node in each workflow.

What the ComfyUI nodes do

Node Connect it to Export
Export Images with Ariadne Final IMAGE tensors, including a batch Marked PNG files, embedded C2PA and receipts
Export Video with Ariadne Native Create Video, codec none, with your final frames A marked MP4 in Economy5s, Economy2s or Resilient
Mark Saved File with Ariadne A final PNG, JPEG or MP4 inside ComfyUI input/output A new marked file; the original bytes reach the SDK unchanged

These are terminal export nodes. Download their saved output rather than sending it through another Save Image or encoding step. Later changes can remove Content Credentials or affect watermark recovery.

1. Install the extension from Comfy Registry

Open the Ariadne Mark Registry listing. In ComfyUI-Manager, look for the package ID ariadne-mark-nodes; a catalogue refresh may be needed for a newly published entry.

The following direct Registry installation was tested with the official Python Comfy CLI 1.26.0. Replace the workspace path with your actual ComfyUI folder:

comfy --workspace /absolute/path/to/ComfyUI --skip-prompt --no-enable-telemetry node registry-install ariadne-mark-nodes --version 0.1.0

This installs the extension, not the SDK runtime, watermark models or a signing identity. Continue with the kit setup below before running an Ariadne node. Ensure the extension's requirements.txt is installed in the Python environment that launches ComfyUI; the requirement is filelock, not another Torch installation.

For a manual installation, clone ComfyUI-Ariadne-Mark into ComfyUI/custom_nodes/, install its requirements using your ComfyUI Python, and restart. The adapter uses Comfy's native V3 extension API. The tested configuration is ComfyUI 0.45.0 on Linux x86-64, CPU marking; Windows, macOS and Comfy Cloud have not been qualified for this integration.

2. Connect your Ariadne SDK kit

Follow Build and initialize the deployment kit using the 0.7.3a4 release source and its checksums. Build the SDK Docker image, initialize a development kit for your first local trial and retain the image's immutable ID from ariadne-image.id.

Keep the kit outside ComfyUI's served input, output and temp directories. It holds the registry and signing material; it is persistent project state, not a disposable cache. Your own Docker image must be provisioned before node execution — the adapter does not download images or models while a workflow runs.

Download the adapter configuration example, save it privately, and replace both absolute paths and the image placeholder:

{
  "schema_version": 1,
  "kit_directory": "/absolute/private/path/to/ariadne-kit",
  "runner": {
    "kind": "docker",
    "command": ["docker"],
    "image": "sha256:REPLACE_WITH_YOUR_VERIFIED_LOCAL_SDK_IMAGE_ID",
    "network": "none"
  },
  "timeout_seconds": 900
}

Use the complete local sha256:… image ID, not a mutable tag. The Docker command must be usable by the account running ComfyUI. Set the config path in the environment that launches ComfyUI, then restart that process:

export ARIADNE_COMFY_CONFIG="$HOME/.config/ariadne-mark/comfy.json"
chmod 600 "$ARIADNE_COMFY_CONFIG"
# Launch your usual ComfyUI command from this same environment.

The offline development configuration above was tested. For production signing and timestamps, follow the production setup and configure permitted network access and your own credentials. Installing these nodes does not enroll a C2PA product or issue a production certificate.

3. Export a marked image

Download the image workflow JSON and open it with File → Open in ComfyUI. In Load Image, select your own newly generated image; the example fixture filename is a placeholder. Connect the IMAGE output to Export Images with Ariadne, or replace the loader with the final image output of your generator.

  1. Finish edits, cropping and resizing before the Ariadne node.
  2. Choose a filename_prefix, such as my_render.
  3. Leave created_at_utc blank to record when the node materializes the final rendition, or provide the actual earlier generation time with a timezone.
  4. Run the workflow. The node displays the saved marked PNG and returns files_json.
ComfyUI Load Image connected to Export Images with Ariadne, showing a completed image export
A real completed export in ComfyUI. The input shown is a procedural test fixture; the screenshot is an interface example, not a downloadable marked asset.

Generated image tensors may be RGB or RGBA, with 256–4096 pixels per side and up to 1,000 images in a batch. For an existing final JPEG, use Mark Saved File with Ariadne. Existing signed media remains subject to the SDK's upstream-history checks; this is not a way to replace another creator's provenance.

4. Export video and choose a watermarking profile

Connect your final frames to native Create Video, select codec none, then connect its VIDEO output to Export Video with Ariadne. Set audio_kind to none for silent video, or original for non-synthetic source audio. Generated speech and music are outside this visual-media workflow.

Profile Config value Use it when
Economy5s — default economy_5s Lower marking compute is the priority for your complete-file delivery workflow
Economy2s economy_2s You want more frequent marked windows and can spend more compute
Resilient resilient You want the denser marking profile and accept its higher CPU cost

Read the profile selection guide and versioned recovery tests for complete files, trims and transformations. The extension preserves the SDK's profiles and defaults; it does not create a new compliance threshold or guarantee survival after every edit.

The native video node accepts 8-bit sRGB SDR, even dimensions of 256–1920 pixels per side, and at most 300 seconds / 18,000 frames. For an already encoded or file-backed video, finish the MP4 first and use Mark Saved File with Ariadne. This keeps the final file's bytes intact as they enter the SDK.

5. Download and verify the final file

The node publishes media and receipts under:

ComfyUI/output/ariadne/<prefix>_<job>/
  image_0000.png          # or video.mp4 / the saved-file export
  image_0000.png.receipt.json
  export.json

Download the exact saved output. Its SHA-256 should match the export receipt. Use your Ariadne verifier and registry, or the same provisioned SDK Docker image for an independent watermark read. For example, from the directory containing a downloaded PNG:

# IMAGE is the immutable ID of your already-provisioned SDK image.
docker run --rm --pull never --network none \
  --cpus 2 --memory 4g --user "$(id -u):$(id -g)" \
  --read-only --tmpfs /tmp:rw,nosuid,size=512m \
  -v "$PWD:/media:ro" "$IMAGE" \
  verify /media/image_0000.png --verification-scope current

Use the actual exported filename for video or another image. A valid development signature can still have an untrusted issuer; verification results explain the difference between a recovered ID, signature validity, issuer trust and file binding. A standard C2PA reader can also inspect the embedded manifest independently.

What was tested

The Registry-installed 0.1.0 package was exercised in a clean ComfyUI 0.45.0 checkout on Linux x86-64 CPU with SDK 0.7.3a4:

Read the qualification summary, publication run and source repository. These are functional integration checks with procedural fixtures, not a new throughput or durability benchmark. The CPU measurements describe their own workloads and runtime conditions.

Common integration questions

Does watermarking need the same GPU as generation?

The qualified SDK runner uses CPU. It does not change your generation model's GPU configuration. The Docker runner is bounded to 2 CPU / 4 GiB, and its timeout is configurable. That memory limit is not a measured peak. Models are reused within one image batch, not across separate node executions.

What happens if marking fails?

The workflow raises an error and publishes no output for that adapter batch. It does not silently return an unmarked original. Check the private kit's job logs for missing configuration, a busy kit, receipt mismatch, timeout or SDK rejection. Keep keys and private logs out of public issues.

Does the node include a public verifier?

The nodes export files. The SDK deployment kit supplies a separately operated verifier and recovery registry. Your files are processed on your own infrastructure; the adapter does not upload them to an Ariadne service.

How does this help with AI labeling compliance?

It puts marking, signed provenance and export checks into the workflow you already use. Use the EU AI Act guide, California guide and requirements matrix to connect those technical measures to your product's duties and remaining actions.

Is the ComfyUI integration free?

The adapter is Apache-2.0 open source, with no per-export plugin fee. SDK and model components retain their own licences. Compute, hosting and any production signing/timestamp services remain your operating costs; see the cost guide.

Browse documentation ↗