How Claude Marks AI-Generated Content?

Anthropic has signed the EU AI Act’s Article 50(2) Code of Practice on Transparency of AI-Generated Content and is implementing that commitment in its models. Claude models launched on or after August 2, 2026 embed a machine-readable mark in generated output: text receives an imperceptible watermark, while supported generated files receive cryptographically signed provenance metadata.

Try Apidog today

This is not an EU-only feature or a Claude chat-app feature. It applies worldwide to supported output from the Claude Platform API, Claude, Claude Code, Claude Cowork, and Claude Tag. If your backend calls the Claude API, the text returned by the model carries that mark, as does output you pass on to users.

For teams building APIs around Claude, this affects model selection, file-processing pipelines, disclosure design, and automated tests. This guide explains what gets marked, what marks can prove, and which checks to add to your CI pipeline. If you test AI-backed endpoints, Apidog can run those checks on every build.

The short version

Question	Answer
What gets marked?	Generated text gets an embedded watermark. Generated .svg, .png, and .jpg files get signed C2PA metadata.
Which models?	Claude models launched on or after August 2, 2026 at launch. Earlier models are being retrofitted during a transition period.
Which surfaces?	Claude Platform API, Claude, Claude Code, Claude Cowork, and Claude Tag.
Which regions?	Everywhere Claude is offered, not only the EU.
Cloud resellers?	Embedded watermarks apply through AWS, Google Cloud, and Microsoft Foundry. Signed provenance metadata may not be available on every platform.
Can you turn it off?	No. Text watermarking is applied at the model level.
Does a mark prove Claude wrote it?	No. It indicates the content may have been processed by Claude.
Does no mark prove a human wrote it?	No. The absence of a mark proves nothing.

What Anthropic committed to

The Code of Practice on Transparency of AI-Generated Content was published on June 10, 2026 and had roughly 190 signatories by the end of July. The European Commission and the AI Board confirmed it as an adequate voluntary route to demonstrate compliance with Article 50 of the AI Act.

Anthropic signed as a provider of both generative AI models and generative AI systems. Its commitments are:

• Mark new models from day one. Claude models launched in the EU on or after August 2, 2026 support machine-readable marking at launch.
• Apply marking across products. Supported model output is marked in the API, Claude, Claude Code, Claude Cowork, and Claude Tag.
• Support detection. Anthropic says it will help users and third parties detect its marks, with technical documentation to follow.
• Retrofit older models. Models launched before August 2, 2026 are within the legal transition period, and retrofitting is underway.

The operational detail is important: detection support is promised but not yet shipped, and fleets can be mixed. A model you pinned earlier in 2026 may return unmarked output while a newer model marks every response.

Technique one: an invisible text watermark

Supported Claude models weave a watermark into generated text. It is not visible, does not change the meaning or readability of the response, and is not a visible tag, appended notice, or reliably identifiable hidden Unicode character.

Two implementation properties matter.

The watermark travels with copied text

Because the mark is embedded in the text rather than attached as file metadata, it can survive copy and paste. A response moved from Claude into an email, CMS, pull request, or Slack message retains the signal.

This differs from file metadata, which can disappear as soon as content leaves its original container.

The watermark is applied at the model level

There is no request header, API parameter, or enterprise plan that disables it. If you call a supported marked model, its generated text is marked.

For a white-label API, do not design around the assumption that you can remove the mark later. Treat marking as a property of the model ID you selected.

Short responses may not be detectable

Text watermarking is statistical. It needs enough generated text to encode and detect a reliable signal. Very short responses may fall below the detection threshold.

Technique two: signed C2PA provenance metadata

For supported generated file types—currently .svg, .png, and .jpg—Claude attaches signed provenance metadata using the C2PA open standard.

C2PA works differently from a text watermark:

• A watermark embeds a signal in content.
• C2PA attaches a cryptographically signed manifest to a file.
• If the file changes without a corresponding re-signing operation, verification can report that the signature is invalid.

This is useful for provenance, but C2PA metadata is container-level data. Any system that rewrites the container can remove it.

Common metadata-stripping operations include:

• Resizing or thumbnail generation
• Re-encoding
• Format conversion
• Screenshotting
• Re-saving in an editor
• CDN image optimization

Your own upload and image-delivery pipeline is often where C2PA disappears. Before making provenance claims, test whether your API preserves metadata after every transformation. See how to test an API for C2PA metadata stripping.

To inspect a manifest manually:

c2patool generated-image.png

You can also use the browser-based Content Credentials verification page. The same classifier-and-manifest pattern is covered in building an AI image detector API with C2PA.

Where marks apply

Use this checklist when reviewing your model routing and deployment architecture.

Models

Marking ships with models launched on or after August 2, 2026. Older models are being retrofitted.

If your application pins a model ID from earlier in 2026, assume its output is unmarked until Anthropic confirms otherwise.

Products

Embedded text watermarks apply to generated text across:

• Claude Platform API
• Claude
• Claude Code
• Claude Cowork
• Claude Tag

Provenance metadata applies where Claude supports file processing.

Cloud partners

Embedded watermarks carry through when supported models are accessed through AWS, Google Cloud, or Microsoft Foundry.

Signed provenance metadata may not carry through every cloud platform because it depends on the platform’s file-handling capabilities. If your compliance workflow depends on C2PA, verify it specifically for Bedrock, Vertex, or Microsoft Foundry rather than assuming equivalent behavior.

Regions

The implementation is worldwide, even though the regulatory obligation originates in Europe.

What a detected mark tells you

A detected mark means content may have been processed by Claude. It does not prove authorship.

Two common cases explain why:

1. Claude may have edited human-authored material. A person can write an article, then use Claude to translate, summarize, proofread, or tighten it. The result can carry a mark even when the underlying ideas and most of the original writing came from a human.
2. Marked content can be changed later. People can edit, excerpt, remix, and combine generated text with other material. A detected mark can indicate that Claude touched some content at some point; it does not establish that the current document was fully generated by a model.

Do not use a positive result as a plagiarism verdict or as a definitive authorship claim.

What no mark tells you: nothing

The inverse is also true: no detectable mark does not prove content was written by a human.

Claude-generated content may have no detectable mark when:

• It came from a model released before marking was supported.
• The text was heavily edited, paraphrased, translated, or mixed with other material.
• The passage is too short for reliable detection.
• File metadata was removed by format conversion, re-saving, resizing, or screenshotting.
• The content came through a platform, feature, or file type that does not support that marking type.

A workflow that treats “no watermark found” as proof of human authorship is unreliable by design. This applies to academic integrity tools, hiring workflows, and content moderation systems. The same limitation appears in image-detection workflows; see why AI image detection fails.

What this means if you build on Claude

Anthropic’s guidance is clear: if you deploy Claude in your own product, independently assess what Article 50 requires for your product or service. Using a compliant provider does not automatically make your application compliant.

The roles are distinct:

• Anthropic is the provider and owns the machine-readable marking obligation under Article 50(2).
• You are typically the deployer and may have separate duties under Article 50(4) for deepfakes and AI-generated text published on matters of public interest.

For an engineering team, focus on these three items.

1. Track marking by model ID

Store marking status next to your model routing configuration.

For example:

{
  "model": "your-pinned-model-id",
  "text_watermark_expected": true,
  "c2pa_output_supported": true
}

Do not model this as a global claude_is_marked boolean. During the transition period, marking depends on the specific model version and output type.

2. Test whether your pipeline strips provenance

Any endpoint that accepts, transforms, stores, or re-serves files can silently drop C2PA manifests.

Audit these code paths first:

• Image upload handlers
• Thumbnail workers
• Image conversion jobs
• CDN optimization rules
• File proxy endpoints
• Storage migration scripts

3. Return disclosures through your API contract

A disclosure only shown in your web UI does not help API consumers. If your API returns model output, expose a machine-readable signal in the response body or headers.

For example:

X-AI-Generated: true
X-Model-Provider: anthropic
X-Model-ID: your-pinned-model-id

Or include it in your JSON schema:

{
  "content": "Generated response text",
  "ai_generated": true,
  "model_id": "your-pinned-model-id"
}

See adding AI disclosure to your own API and the Article 50 breakdown for API developers.

Turn this into tests you run in CI

Compliance documentation is useful, but contract tests catch regressions. Add these tests to every AI-backed API workflow.

1. Assert model pinning

Verify that responses report the model ID you expect. Silent upgrades or fallback routing can change whether output is marked.

pm.test("returns the expected model", () => {
  const body = pm.response.json();

  pm.expect(body.model_id).to.eql(
    pm.environment.get("expected_model_id")
  );
});

2. Assert disclosure fields or headers

If your API contract promises ai_generated: true or an X-AI-Generated header, assert it for every path that can return model output, including cached and error-handling paths.

pm.test("includes AI generation disclosure", () => {
  const body = pm.response.json();

  pm.expect(body.ai_generated).to.eql(true);
  pm.expect(pm.response.headers.get("X-AI-Generated")).to.eql("true");
});

3. Verify C2PA provenance after transformations

For endpoints that return or re-serve generated images:

1. Fetch the output file from your API.
2. Run it through c2patool or another C2PA verifier.
3. Assert that a manifest exists.
4. Assert that the manifest still verifies after resizing, caching, or CDN delivery.

Example CI step:

curl -fsS "$IMAGE_API_URL/generated-image.png" -o output.png
c2patool output.png

Run this test against the exact production-like path that includes storage, transforms, and CDN behavior.

4. Validate schema conformance

Keep disclosure fields in your OpenAPI definition and validate every response against it. This prevents a refactor from silently removing AI-origin fields.

components:
  schemas:
    GeneratedResponse:
      type: object
      required:
        - content
        - ai_generated
        - model_id
      properties:
        content:
          type: string
        ai_generated:
          type: boolean
        model_id:
          type: string

These are ordinary API assertions. In Apidog, define response assertions and post-response scripts, save them as a test scenario, and run the scenario with apidog-cli in CI. See API assertions and automating API tests in GitHub Actions. You can download Apidog to build the scenario.

FAQ

Can I disable Claude’s watermark for my product?

No. Text watermarking is applied at the model level. There is no API parameter, request header, or plan tier that removes it.

Does the watermark change Claude output quality?

Anthropic says the watermark does not change the meaning, quality, or readability of generated text. It is not visible to users.

Is there a public tool to detect Claude’s text watermark?

Not yet. Anthropic has committed to supporting detection for users and third parties, with technical documentation to follow. Until official tooling is available, treat third-party “Claude detectors” as unvalidated classifiers rather than readers of Anthropic’s official mark. See how to detect Claude’s watermark.

Do older Claude models watermark output?

Not automatically. Models launched before August 2, 2026 are within the transition period while Anthropic works to retrofit marking. Assume older model IDs return unmarked text until support is confirmed.

Does this apply through Bedrock or Vertex?

Embedded text watermarks do. Signed provenance metadata may not, because it depends on the file-handling features each platform provides.

How does this compare with OpenAI and Google?

Google’s SynthID covers images, audio, video, and text, and its text implementation has been open-sourced. OpenAI attaches C2PA Content Credentials to generated images and committed in May 2026 to embedding SynthID alongside them, but has not shipped a text watermark. See Claude vs ChatGPT vs Gemini watermarking.

The takeaway

Claude’s marking uses two different mechanisms for two different jobs:

• Text watermarks travel with generated words but are probabilistic, need sufficient text to detect, and can only indicate that Claude may have processed content.
• C2PA metadata is precise and tamper-evident but can be removed by ordinary file transformations in your own pipeline.

Neither mechanism is a plagiarism detector, and neither makes your product compliant by itself.

Treat marking as one signal in a broader system: pin and track your model IDs, expose AI disclosures in API contracts, preserve provenance where possible, and run regression tests on every build.