---
title: "AudD for record labels and publishers"
description: "How labels and publishers use AudD to find unauthorized use of catalog tracks, detect leaks of unreleased music, spot samples and interpolations, and track radio airplay."
slug: "/resources/for/labels-and-publishers"
section: "for"
keywords: [audd, record label, music publisher, custom catalog, sample detection, airplay monitoring]
---

# AudD for record labels and publishers

If you own or administer recordings, your day-to-day questions are about
*your* catalog: is someone using our tracks without a license? Did an
unreleased master leak? Is a new release sampling one of ours? Which stations
are actually playing our artists? This page answers each of those questions
in turn, with a recipe that already implements the workflow.

AudD's music-industry users include Sony, Warner Music Group, and Universal
Music Group. The mechanism underneath is a music-recognition HTTP API: you
upload your catalog to a private fingerprint database on your account, then
run audio — uploads, social URLs, radio streams — through recognition and get
back which of *your* tracks appear, where, and how often.

## What you can do

### Find unauthorized use of your catalog across platforms

The core move for a rights owner is to flip recognition around: instead of
"is there any commercial music here," ask "is *my* recording here." You do
that by uploading your masters to a **custom catalog**
(`POST api.audd.io/upload/`, special access required — email api@audd.io).
Once your tracks are in your account's private fingerprint database,
recognition calls can match incoming content against them.

- When user-uploaded or published content reuses one of your recordings,
  recognition against your custom catalog returns an `audio_id` identifying
  the exact uploaded master that matched, so you know precisely which work
  was used.
- The `audio_id` is also how you tell a catalog match apart from a match
  against the public 160-million-song database: it appears only on
  custom-catalog matches, and on those matches `artist`/`title` may be null
  because that metadata comes from what you uploaded.

### Detect leaks of unreleased music

Unreleased masters are the highest-stakes case: the track isn't in any public
database, so only *you* can recognize it. Upload the unreleased recording to
your custom catalog, then scan the places leaks surface.

- Because an unreleased master lives only in your custom catalog, a
  recognition match against it is unambiguous — no public recording can
  produce a false positive for an unreleased work.
- Leaks surface in long uploads, videos, and streams, not just clips. The
  **enterprise endpoint** (`POST https://enterprise.audd.io/`) chunks long
  audio and video server-side, and the **streams** surface watches continuous
  live audio; both can match against your custom catalog.

### Detect samples and interpolations

A sample is a fragment of one of your recordings reused inside another track —
often short, often pitched or time-stretched. Recognition against your custom
catalog finds the reused segment and tells you where in the matched recording
it came from.

- Matching incoming content against your custom catalog returns the
  `audio_id` of the sampled master and a `timecode` — the position *within
  your recording* where the matched fragment sits.
- To scan many candidate tracks rather than one, run your release-screening
  queue through the enterprise endpoint, which processes long files and full
  uploads against your catalog.

### Track radio airplay for your artists

Royalty conversations and marketing decisions both need real airplay data:
which stations play your artists, and how often.

- The **streams** surface (`addStream`, `setCallbackUrl`, and
  `GET /longpoll/`) recognizes songs off many radio streams around the
  clock — an independent record of where your tracks are played on air.
- To get airplay specifically for *your* catalog rather than a generic
  now-playing log, match the stream recognitions against your custom catalog,
  keep only the rows that are yours, and aggregate them into an airplay
  chart.

## Where to start

- [**Detect samples and reuse of your own tracks**](/resources/recipes/sample-detection)
  — the foundational recipe: upload your catalog, then identify catalog
  matches (samples, leaks, re-uploads) in incoming content via `audio_id`.
- [**Monitor radio airplay for your music catalog**](/resources/recipes/radio-airplay-monitor)
  — register many radio streams, record every recognition, filter to your
  catalog, and aggregate into an airplay chart.
- [**Public database vs your custom catalog**](/resources/concepts/custom-vs-public-db)
  — the concept underneath all of the above: how a custom-catalog match
  differs from a public match, and how to tell them apart in a response.
- [**Standard, enterprise, or streams: how to choose**](/resources/concepts/standard-vs-enterprise-vs-streams)
  — which recognition surface fits each input: a clip, a long upload, or a
  live stream.

## Identify a catalog match

Once your masters are uploaded, a custom-catalog match is identified by its
`audio_id`. The shape below is the heart of leak and sample detection: a match
that came from *your* catalog rather than the public database.

```python
from audd import AudD

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

# Recognize incoming content; matches can come from your custom
# catalog or the public 160-million-song database.
result = audd.recognize("https://audd.tech/example.mp3")

if result is None:
    print("no match")
elif result.audio_id is not None:
    # audio_id present => matched one of YOUR uploaded masters
    print(f"catalog match: audio_id={result.audio_id} at {result.timecode}")
else:
    # a public-database commercial recording
    print(f"public match: {result.artist} — {result.title}")
```

A non-null `audio_id` is the unambiguous signal that the audio matched a
recording you uploaded — a leak, a sample, or an unauthorized reuse. On those
matches `artist` and `title` reflect what you supplied at upload time and may
be null if you didn't supply them.

```json
{
  "audio_id": 184237,
  "timecode": "00:14",
  "song_link": "https://lis.tn/Warriors"
}
```

> **Custom catalog upload needs special access.** Uploading your masters to a
> private fingerprint database via `POST api.audd.io/upload/` is enabled per
> account — email api@audd.io to turn it on before you build the upload step.

---

**Related**

- [Detect samples and reuse of your own tracks](/resources/recipes/sample-detection)
- [Monitor radio airplay for your music catalog](/resources/recipes/radio-airplay-monitor)
- [Public database vs your custom catalog](/resources/concepts/custom-vs-public-db)
- [Standard, enterprise, or streams: how to choose](/resources/concepts/standard-vs-enterprise-vs-streams)
- [SDK docs](https://docs.audd.io/sdks)
- [API reference](https://docs.audd.io)