---
title: "Replace YouTube Content ID for non-YouTube surfaces"
description: "Content ID only operates on YouTube. To detect copyrighted music on your own platform, app, or archive, run your own recognition with the AudD API."
slug: "/resources/migrate/from-content-id-for-non-youtube"
section: "migrate"
keywords: [audd, content id, copyright detection, ugc, isrc, custom catalog]
---

# 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.

```python
# 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.

```python
# 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
[api@audd.io](mailto:api@audd.io) to enable it, then upload via
`POST api.audd.io/upload/`. See
[Public database vs your custom catalog](/resources/concepts/custom-vs-public-db)
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.

```python
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

1. **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.
2. **Get an AudD token.** Sign up at
   [dashboard.audd.io](https://dashboard.audd.io) (300 free requests, no
   card).
3. **Install an SDK.** For example `pip install audd`,
   `npm install @audd/sdk`, or `go get github.com/AudDMusic/audd-go`. See the
   [SDK docs](https://docs.audd.io/sdks) for all 11.
4. **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.
5. **Register your own reference recordings, if needed.** If you maintain
   reference files in Content ID, request custom-catalog access (email
   api@audd.io) and upload them via `POST api.audd.io/upload/`.
6. **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](/resources/recipes/ugc-copyright-scanner) and
   [DMCA takedown evidence](/resources/recipes/dmca-takedown-evidence)
   recipes.
7. **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**

- [Build a copyright scanner for user-uploaded content](/resources/recipes/ugc-copyright-scanner)
- [Generate DMCA takedown evidence](/resources/recipes/dmca-takedown-evidence)
- [Public database vs your custom catalog](/resources/concepts/custom-vs-public-db)
- [API reference](https://docs.audd.io)