Verified Human Cert MCP Server | MusicTech Lab

The line between human-made and machine-generated music is getting blurry. Verified Human Cert (VHC) is one answer to that problem: a public registry where artists and labels certify that their tracks were created by humans.

We wanted to query that registry without leaving our terminal. So we built an MCP server for it and open-sourced it: mcp-verifiedhumancert.

What the server does

The server exposes six tools that map directly to the VHC public API:

Tool	What it does
`vhc_verify_isrc`	Verify a certification by ISRC code
`vhc_verify_track`	Check certification status by artist + track name
`vhc_verify_cert`	Look up a certification by cert number
`vhc_registry`	List recently issued certifications
`vhc_stats`	Platform statistics, tier breakdowns, totals
`vhc_pricing`	Current pricing and bundle options

No API key needed. The VHC registry is public, and all these endpoints are read-only.

Once connected, you just talk to Claude:

"Is ISRC USHM82148308 certified as human-made?"
"Check if 'Yesterday' by The Beatles has a VHC certification"
"Show me the latest certified tracks"

The multi-agent workflow

This is where it gets interesting. We already had mcp-metadata, our open-source MCP server for reading and writing audio file metadata (ID3 tags, ISRC codes, Vorbis comments). Combining the two servers creates a multi-agent pipeline:

Agent 1 (mcp-metadata) reads the ISRC code from an audio file
Agent 2 (mcp-verifiedhumancert) verifies that ISRC against the VHC registry
Claude orchestrates both agents and presents the result

User: "Read the ISRC from song.flac and check if it's certified"

Agent 1 (mcp-metadata): metadata_read("song.flac") -> ISRC: USHM82148308
Agent 2 (mcp-verifiedhumancert): vhc_verify_isrc("USHM82148308") -> certified: true

Two MCP servers, two specialized agents, one orchestrator. No glue code, no custom integrations. Claude handles the coordination.

Multi-agent workflow: mcp-metadata reads ISRC from an audio file, then mcp-verifiedhumancert checks the VHC registry

This pattern scales to any number of MCP servers. Each server handles one domain, and Claude routes between them based on what the user asks.

Why this matters for the music industry

The rise of generative audio tools has created a trust problem. Listeners, labels, and platforms need a way to distinguish human-created work from machine-generated output. VHC provides that layer of trust, and our MCP server makes it accessible to developers and tooling without building custom API integrations.

Verify Tracks

Check any track's certification status by ISRC, artist name, or cert number.

Multi-Agent Pipeline

Combine with mcp-metadata to read ISRC from files and verify automatically.

No Auth Required

The VHC registry is public. No API keys, no signup, no rate limits to worry about.

Setting it up

1. Clone and install

git clone https://github.com/musictechlab/mcp-verifiedhumancert.git
cd mcp-verifiedhumancert
poetry install

2. Register with Claude Code

Add this to your ~/.claude/settings.json or project .claude/settings.local.json:

claude_mcp_config.json

{
  "mcpServers": {
    "vhc": {
      "command": "poetry",
      "args": ["--directory", "/path/to/mcp-verifiedhumancert", "run", "python", "-m", "mcp_verifiedhumancert"]
    }
  }
}

3. Start using it

That's it. Ask Claude anything about the VHC registry:

"Look up cert number VH-2026-000001"
"What are the current VHC pricing tiers?"
"How many tracks are certified on the platform?"

Looking up cert VH-2026-000001 in Claude Code

Querying VHC pricing tiers in Claude Code

Under the hood

The server is built with FastMCP, the Python SDK for the Model Context Protocol. The architecture is straightforward:

client.py - a thin HTTP wrapper around the VHC REST API using httpx
server.py - six tool definitions that call the client and return JSON
Tests - full test coverage using respx for HTTP mocking

server.py

@mcp.tool()
def vhc_verify_isrc(isrc: str) -> str:
    """Verify a human-made music certification by ISRC code."""
    result = client.verify_by_isrc(isrc)
    return json.dumps(result, indent=2, ensure_ascii=False)

client.py

def verify_by_isrc(isrc: str) -> dict:
    """Verify a certification by ISRC code."""
    return _get("/api/v1/verify", params={"isrc": isrc})

The entire server is under 200 lines of Python. That's intentional. MCP servers should be thin wrappers, not application frameworks.

The project uses Poetry for dependency management, Ruff for linting and formatting, and pytest with respx for testing. CI runs on GitHub Actions.

What we learned building MCP servers

This is the third MCP server we have open-sourced at MusicTech Lab (after signnow-mcp and mcp-metadata). A few patterns have emerged:

Keep servers focused. One server per domain. Don't bundle unrelated tools into a single server.
Separate the client from the server. The HTTP client should be testable independently of the MCP layer.
Return JSON, not prose. Let Claude format the output for the user. The server's job is to provide structured data.
Skip authentication when you can. Public APIs make MCP servers trivial to set up. No .env files, no OAuth flows, no token management.

Open source

The full source code is on GitHub: musictechlab/mcp-verifiedhumancert. MIT licensed. Contributions welcome.

If you're building MCP servers for the music industry, or if you're using Verified Human Cert and want to integrate it into your tooling, we'd love to hear from you.