Replace YouTube Content ID for non-YouTube surfaces

This page is for teams who know YouTube Content ID and need the same kind of copyright detection on a surface Content ID does not cover: your own app, your user-generated-content pipeline, your media archive, or a podcast/livestream product. Content ID is YouTube’s internal rights-management system — it operates only on content uploaded to YouTube, and it is available to rights holders who meet YouTube’s eligibility criteria. It is not an API you can point at your own platform. If you need detection on your surfaces, you run your own recognition. AudD provides that over an HTTP API: you send a file, URL, or live stream, and you get back the recognized track with its metadata and timestamps. This is not a replacement for Content ID on YouTube — it covers the surfaces Content ID does not reach.

Concept mapping

YouTube Content ID concept	AudD equivalent
Reference files (the recordings you register so YouTube can match them)	A custom catalog of your own tracks, uploaded via `POST api.audd.io/upload/`.
The match against YouTube’s broader reference database	Recognition against AudD’s public database of 160 million songs.
A claim / match on an uploaded video	A recognition result: `artist`, `title`, `album`, `label`, `isrc`, `upc`, plus the in-file `timecode` / offsets where the music appears.
Match segment timestamps	Per-match `timecode`, and `start_offset` / `end_offset` on enterprise matches (with `accurate_offsets`).
YouTube-only scope (only content on YouTube)	Any audio or video you control — a file, a URL, an archive, or a live stream — via the standard, enterprise, and streams endpoints.
Content Manager / CMS dashboard	Your own application logic, built on the recognition results.

The equivalent call

Content ID does its matching inside YouTube; there is no request you make from your own code. The equivalent on your platform is to send the content to AudD and act on what it returns. For files longer than a short clip — full uploads, podcast episodes, archived recordings — use the enterprise endpoint, which chunks the file server-side and returns every match with timestamps.

# Detect copyrighted music in a user upload on YOUR platform
from audd import AudD

audd = AudD("your-api-token")  # token from dashboard.audd.io

matches = audd.recognize_enterprise(
    "https://audd.tech/example.mp3",
    limit=10,            # stop after 10 matches; ALWAYS set this in development
    accurate_offsets=True,  # precise in-file start/end offsets per match
)

for m in matches:
    print(f"{m.artist} — {m.title}")
    print(f"  label: {m.label}  ISRC: {m.isrc}  UPC: {m.upc}")
    print(f"  appears at: {m.timecode}")

Always set limit on enterprise calls during development. The enterprise endpoint bills per 12 seconds of audio processed. On a long archive an unbounded call ingests the whole file; limit=N stops after N matches.

For copyright-sensitive metadata, the fields that matter map directly to what a rights workflow needs: isrc and upc identify the exact recording and release, label names the rights holder, and timecode (plus start_offset / end_offset with accurate_offsets) pin down where in the file the music plays. isrc and upc are returned on enterprise calls and on Startup-plan accounts and above.

Matching against your own reference recordings

Content ID lets you register reference files so YouTube matches against your catalog. The AudD equivalent is a custom catalog: you upload your own tracks to your account, and later recognition calls match incoming audio against them. A custom-catalog match returns audio_id (your reference to the uploaded track); artist/title may be null if you didn’t supply them at upload time.

# After enabling custom-catalog access, recognition matches your tracks too.
match = audd.recognize("https://audd.tech/example.mp3")
if match and match.audio_id is not None:
    print("matched a track from your custom catalog:", match.audio_id)

Custom-catalog access is gated — email [email protected] to enable it, then upload via POST api.audd.io/upload/. See Public database vs your custom catalog for when each database produces a match.

Monitoring a live surface

If the surface is live — a stream you host, a broadcast you ingest — use the streams endpoints. Register a callback URL and add a stream; AudD recognizes songs as they play and POSTs each match to your callback.

audd.streams.set_callback_url("https://your-server.example/audd-callback")
audd.streams.add(url="twitch:somechannel", radio_id=1)

The stream URL accepts direct stream URLs (HLS, Icecast, m3u/m3u8) and the shortcuts twitch:<channel>, youtube:<video_id>, and youtube-ch:<channel_id>. Each callback delivers the recognized song plus the radio_id — an integer you assign to each stream (not a string asset ID like Content ID uses) — so you can attribute a match to the right source. Set callbacks="before" to receive a callback at the moment a song starts. If you cannot host a public callback URL, poll GET /longpoll/ instead and pull matches on your own schedule.

What’s different

Where it operates. Content ID operates only on content uploaded to YouTube. AudD operates on any audio or video you can send it — a file (MP3, WAV, FLAC, M4A, OGG, AAC, WMA, AIFF), a video file via the enterprise endpoint (MP4, AVI, MOV, MKV, WebM), a URL, or a live stream — regardless of where that content lives.
Who can use it. Content ID is available to rights holders who meet YouTube’s eligibility criteria. AudD is a self-serve API: sign up, get a token, call it.
How you integrate. Content ID surfaces matches inside YouTube’s Content Manager; there is no API call from your own code. AudD is an HTTP API you call from your backend, with 11 official SDKs.
What you match against. Content ID matches against YouTube’s reference database plus reference files you register. AudD matches against its 160-million-song public database, a custom catalog you upload, or both.
What a match gives you. AudD returns structured metadata you can feed into your own workflow — artist, title, album, release_date, label, isrc, upc, song_link, and the in-file timecode / offsets — rather than a claim recorded inside another platform’s dashboard.
Enterprise billing unit. AudD’s enterprise endpoint bills per 12 seconds of audio processed and expects a limit; budget around audio duration.
Pricing. AudD’s per-request pricing is public: 300 free requests on signup (no card), then $5 per 1,000 requests pay-as-you-go, with volume plans on the dashboard.

Migration steps

Identify the surface. Pin down where you actually need detection — a UGC upload pipeline, a media archive, a podcast feed, a livestream — since that decides which endpoint you use.
Get an AudD token. Sign up at dashboard.audd.io (300 free requests, no card).
Install an SDK. For example pip install audd, npm install @audd/sdk, or go get github.com/AudDMusic/audd-go. See the SDK docs for all 11.
Pick the endpoint by job. Short clip → standard recognize(...). Full uploads, episodes, or archive files → recognize_enterprise(..., limit=N, accurate_offsets=True). Live surfaces → streams (set_callback_url + add), or longpoll if you can’t host a callback.
Register your own reference recordings, if needed. If you maintain reference files in Content ID, request custom-catalog access (email [email protected]) and upload them via POST api.audd.io/upload/.
Build the action from the result. Decide what your platform does on a match — block, flag for review, attach isrc/upc/label for a rights record, or assemble takedown evidence. The recognition result gives you the fields; the policy is yours. For a worked end-to-end version of this step, see the copyright scanner and DMCA takedown evidence recipes.
Verify with a fixed input. Run https://audd.tech/example.mp3 through the chosen path and confirm the fields you depend on (isrc, upc, label, timestamps) are present before going live.

Related