C2PA in Music: A Claude MCP for Reading Content Provenance

A LinkedIn post by Dawid Owczarek stopped my scroll: Google Lyria is now embedding C2PA manifests inside the MP3s you download from it. I went and checked, and yes, the file really does contain a cryptographically signed manifest declaring who made the track, what tool produced it, and what watermark was applied. That sent me down a rabbit hole, and this post is the result. The headline, though, is not Lyria. The headline is C2PA itself, finally arriving in audio.

If you work in music, you have spent years living with ISRC, ISWC, ISNI, and DDEX. Those standards answer the question who owns this recording. C2PA answers a different question: who created it, and how. That is the layer music has been missing, and the layer AI makes urgent.

What C2PA actually is

C2PA stands for the Coalition for Content Provenance and Authenticity. It is a JDF-hosted open standard, founded in 2021 by Adobe, Microsoft, Intel, BBC, and others, with Google joining as a steering member shortly after. The spec defines a binary container that lives inside a media file and carries a cryptographically signed history of how that file came to be.

A C2PA manifest contains:

• A claim generator identifying the software that created the manifest
• A list of assertions (actions, hashes, training data declarations, soft bindings)
• Ingredients describing source assets used as inputs
• A signature that ties everything to a known certificate issuer

The whole thing is designed to be self-contained and tamper-evident. You can rename a file, strip its ID3 tags, or re-encode the audio, and the manifest either travels with the file intact or breaks in a detectable way.

What Google Lyria proved

The clearest sign that audio C2PA has crossed the line from spec to product is what Google shipped in Lyria. When you download a Lyria-generated MP3, the file contains a fully populated C2PA manifest. Here is a snippet from a track I generated, abbreviated for clarity:

{
  "active_manifest": "urn:c2pa:80faaddf-fe27-1e7d-0ce5-4a70eeba2dd1",
  "manifests": {
    "urn:c2pa:80faaddf-fe27-1e7d-0ce5-4a70eeba2dd1": {
      "claim_generator_info": [
        {
          "name": "Google C2PA Core Generator Library",
          "version": "916434528:916944653"
        }
      ],
      "assertions": [
        {
          "label": "c2pa.actions.v2",
          "data": {
            "actions": [
              {
                "action": "c2pa.created",
                "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia",
                "description": "Created by Google Generative AI."
              },
              {
                "action": "c2pa.edited",
                "digitalSourceType": "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia",
                "description": "Applied imperceptible SynthID watermark."
              }
            ]
          }
        }
      ]
    }
  }
}

This is a real-world example of every piece of the spec working in audio: claim generator, signed actions, IPTC digitalSourceType URI for AI disclosure, and a SynthID watermark recorded as a c2pa.edited action. The whole manifest is signed by Google LLC.

Why C2PA matters for the music industry

Music has spent years building IDs and registries to answer ownership. C2PA layers on top to answer origin. The combination changes several workflows materially.

Reading C2PA in plain English with Claude

The official tool for reading C2PA is the Rust c2patool binary. It works, but the output is raw JSON, and few people in the music industry will install a Rust CLI to inspect a download.

So we built mtl-c2pa-mcp, an open-source MCP server that wraps the official c2pa-python library and exposes it as tools inside Claude Code.

The server exposes seven tools:

c2pa_summary       Human-friendly overview: generator, AI flag, actions, watermark, signature
c2pa_read          Full raw manifest store
c2pa_assertions    All assertions from the active manifest
c2pa_ingredients   Source assets used to create this file
c2pa_verify        Signature issuer, validation state, failures
c2pa_scan          Audit a folder: which files carry C2PA, which are AI-generated
c2pa_info          Library version and supported MIME types

Install once:

git clone https://github.com/musictechlab/mtl-c2pa-mcp.git
cd mtl-c2pa-mcp
poetry install
claude mcp add -s user mtl-c2pa -- poetry --directory $(pwd) run python -m mtl_c2pa_mcp

Then ask Claude in plain English:

"What does the C2PA manifest in ~/Downloads/track.mp3 say?"

Claude finds the file, calls the MCP, and renders the manifest as a clean table:

Under the hood, that's the JSON the c2pa_summary tool returns:

{
  "file": "/Users/you/Downloads/track.mp3",
  "generator": {
    "name": "Google C2PA Core Generator Library",
    "version": "916434528:916944653"
  },
  "is_ai_generated": true,
  "digital_source_types": [
    "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia"
  ],
  "actions": [
    {"action": "c2pa.created", "description": "Created by Google Generative AI."},
    {"action": "c2pa.edited",  "description": "Applied imperceptible SynthID watermark."}
  ],
  "signature_issuer": "Google LLC",
  "validation": "valid"
}

Ask for the full manifest store and c2pa_read returns everything, including the signing certificate metadata, claim version, and validation status:

For an A&R team auditing a batch of demos, c2pa_scan walks a directory and reports which files carry a manifest and which are flagged as AI-generated. No spreadsheet, no manual triage:

In the screenshot, four MP3s in ~/Music. One (the Lyria-generated track) carries a Google-signed C2PA manifest flagged as trainedAlgorithmicMedia. The other three are unsigned. 25% coverage, with a clear AI-or-not column.

What's next

The MCP solves the problem for developers and anyone comfortable in Claude Code. But most of the people who actually need to read a C2PA manifest, A&R scouts, label managers, rights administrators, music lawyers, journalists, will never open a terminal. Raw JSON is not a deliverable for them.

So phase two is a visual C2PA translator at musictechlab.io: drop a file in the browser, see the manifest rendered in plain English (Who, What, When, How), with a trust score and a JSON export for the technical readers who want it. Everything client-side, nothing uploaded, similar to what melchersystem.com has done for images, but tuned for audio and the music industry's specific provenance questions.

If you produce, distribute, or license music, this is the moment to start paying attention. C2PA is no longer a slide in a keynote. It is a thing you can grep for in a downloads folder.

Who already implements C2PA

The list of organizations shipping C2PA in production is no longer short. As of 2026 the coalition counts over 6,000 members and affiliates, and the implementation list spans cameras, AI services, creative tools, and social platforms.

The music side is the newest entry in this lineup. Google Lyria is the first major AI music service to ship C2PA in downloadable MP3s, but the infrastructure (signing libraries, trust lists, viewer apps) is already mature on the image and video side. That groundwork is what makes audio adoption practical now rather than years away.

Resources

Need Help with C2PA and Music Provenance?

Building C2PA into your distribution pipeline, AI music platform, or rights workflow? We've been there.

Let's talk, no sales pitch, just honest engineering advice.