---
title: "What music recognition matches, and what it doesn't"
description: "AudD identifies recordings, not songs. A case-by-case table of what to expect for re-uploads, noisy captures, remasters, live versions, covers, samples, sped-up audio, AI soundalikes, DJ mixes, and unreleased music, plus how to build a test set that measures it on your own audio."
slug: "/resources/concepts/what-recognition-matches"
section: "concepts"
keywords: [audd, audio fingerprinting, what matches, covers, remaster, live version, sped up, pitch shift, samples, ai generated music, voice clone, dj mix, false negative, test set, moderation]
---

# What music recognition matches, and what it doesn't

AudD identifies **recordings**, not songs. A fingerprint is computed from the
sound of one specific recording, and a match means "this audio contains that
recording." A different recording of the same song (a cover, a live take, a
re-recording) is a different fingerprint. This page walks through the cases
that come up in moderation, monitoring, and tagging, gives an honest expected
outcome for each, and shows how to measure the uncertain ones on your own
audio before you rely on them.

## TL;DR

- A match needs the **same recording** to be in a database AudD searches: the
  public database of about 160 million commercially released songs, or your
  own [custom catalog](/resources/concepts/custom-vs-public-db).
- The same recording survives re-encoding, a different bitrate, clipping to
  an excerpt, a phone-speaker capture, background noise, and speech on top,
  within limits. Very quiet or heavily masked music may not match.
- Covers, interpolations, hummed or sung melodies, and AI soundalikes are new
  recordings. They don't match the original. AudD does not detect covers,
  versions, interpolations, or AI-generated audio.
- Speed, pitch, and tempo changes reduce matching. AudD doesn't publish a
  tolerance; measure it on your own transformed audio.
- For moderation, **"no match" means "unknown", not "cleared".**

## The expected-outcome table

"Matches" below assumes the recording is in a database AudD searches. "Test"
means the outcome depends on the material, so measure it on yours (see
[Build a test set](#build-a-test-set)).

| What you send | Expected outcome |
|---|---|
| A re-upload of a released track, any common format or bitrate | Matches the recording. |
| An excerpt cut from the middle of a track | Matches. `timecode` tells you where in the track the excerpt sits. |
| A capture from a speaker, a phone, or a room | Usually matches. Distance, room noise, and very low volume make it less likely. |
| Music under speech (vlog, podcast, stream) | Matches when the music is audible enough. Music mixed far below the voice may not. Test. |
| A remaster, radio edit, extended mix, or explicit vs. clean version | These are separate recordings or edits. A match may come back as that exact version or as another version of it. Test, and don't assume the ISRC on the match is the one the uploader used. |
| The same recording on a single, an album, and a compilation | Matches the recording; the album, release date, and UPC can belong to any of those releases. |
| A live recording | Matches only if that particular live recording is in the database (a released live album, for example). It won't match the studio version. |
| A cover by another artist | Doesn't match the original. Matches the cover only if that cover recording is itself released and in the database. |
| A karaoke or instrumental version | A released karaoke or instrumental track is its own recording and matches as itself. A person singing over it is a new recording; the backing track may or may not match. Test. |
| A re-recording by the original artist | A new recording. Matches the re-recording if it's in the database, not the original. |
| An interpolation (a melody or lyric re-performed in a new track) | Doesn't match the original. AudD doesn't detect interpolations. |
| A sample of your track inside someone else's track | Not a public-database question. Upload your tracks to a custom catalog and scan for reuse; see [Detect samples and reuse of your own tracks](/resources/recipes/sample-detection). Test on your material. |
| Sped up, slowed down, or pitch-shifted (nightcore, "slowed + reverb") | Matching gets less likely as the change grows. No tolerance is published. Measure on your audio. |
| AI-generated soundalike or a voice clone | Doesn't match the original. Matches only if that exact generated recording is in a catalog, for example a release in the public database or a file you uploaded to your custom catalog. |
| A DJ mix or a continuous set | The [enterprise endpoint](https://docs.audd.io/enterprise) scans the whole file in 12-second chunks and returns each track it finds. Heavy effects, long transitions, and tempo changes can hide a track in parts of the mix. |
| Production or library music | Matches if the recording is in the public database. To match a specific library reliably, put its tracks in a custom catalog. |
| Unreleased audio (demos, pre-release masters, private stems) | Not in the public database. Upload it to a custom catalog to match it. |
| A video file | Only the audio track is fingerprinted. Nothing visual is matched. |

## Why recordings, not songs

A **song** in the everyday sense is a composition: melody, harmony, lyrics.
A **recording** is one performance of it captured and mixed. Rights follow
the same split: the composition belongs to songwriters and publishers, the
recording to whoever owns the master (see the
[music rights glossary](/resources/reference/music-rights-glossary)).

Audio fingerprinting compares the sound itself. Two performances of the same
song differ in timing, timbre, key, arrangement, and mix, so they produce
different fingerprints. That's why a cover won't match the original, and why
fingerprinting is good at the question "is this exact recording present?"
rather than "is this song being performed?"

A consequence that trips people up: a match tells you which recording played,
and the metadata (artist, title, label, ISRC, UPC) describes that recording
and one release it appears on. It doesn't tell you who owns the composition,
whether the use is licensed, or whether the `label` is the current rights
owner.

## The cases in more detail

### The same recording, degraded

Re-encoding to MP3 or AAC, a lower bitrate, mono, a different sample rate,
trimming to an excerpt, and moderate noise all leave the recording
recognizable. Fingerprinting is built for this. What reduces matching is
losing the music itself: a very short clip, music far below speech or crowd
noise, or heavy processing such as aggressive noise reduction. The
[audio formats and quality](/resources/concepts/audio-format-and-quality)
page covers capture and encoding choices.

The standard endpoint analyzes the **first 12 seconds** of what you send. If
an upload opens with silence or talking, send a later excerpt, or use the
enterprise endpoint, which scans the whole file.

### Versions of the same track

Remasters, radio edits, extended mixes, and explicit/clean pairs share most of
their audio, yet each is its own recording, often with its own ISRC. A clip
from one of them may come back as the version you sent or as another version
that sounds the same at that moment. Which one you get depends on the audio
and on what's in the database, so we don't promise either.

If your logic keys on ISRC (an allow list of licensed tracks, for example),
list every ISRC the license covers, or match on artist and title as a second
check. Test with the actual versions you care about.

### Live recordings, covers, and re-recordings

All three are new recordings. Each matches only itself, and only when it's in
the database. A released live album or a released cover can match; a phone
recording of a concert usually can't, because that performance was never
released. AudD doesn't detect that a recording is a cover or a version of
another song.

### Interpolations and samples

An interpolation re-performs part of a composition, so there's no shared
recording to match. A sample does reuse a recording, but it's usually short,
layered under new material, and often processed. The public database
identifies the new track as itself (if it's released), not the sample inside
it.

When you own the source recordings and want to find them inside other
people's tracks, upload them to a custom catalog and scan candidates with the
enterprise endpoint. The
[sample-detection recipe](/resources/recipes/sample-detection) walks through
it. How short or processed a sample can be and still match depends on the
material, so test with real examples.

### Sped-up, slowed, and pitch-shifted audio

Social uploads often change speed, pitch, or tempo, sometimes on purpose to
avoid detection. Each of these transformations moves the audio away from the
reference fingerprint and makes a match less likely as the change grows. AudD
doesn't publish a tolerance figure. If transformed audio matters to you,
measure it; see [Measure matching on transformed audio](#measure-matching-on-transformed-audio).

### AI-generated soundalikes and voice clones

A model that generates music "in the style of" an artist, or a cloned voice
singing new material, produces a new recording. It won't match the original
recordings it imitates, and AudD doesn't classify audio as AI-generated. A
generated track matches only when that exact generated recording is in a
catalog: if it has been commercially released and is in the public database,
or if you uploaded it to your custom catalog to catch re-uploads.

### DJ mixes

A mix is many recordings back to back, with overlaps. The enterprise endpoint
returns a match for each 12-second chunk it recognizes, with offsets in your
file; a chunk can list more than one song during a transition. DJs often
change tempo to beatmatch, and effects, loops, and long blends can hide a
track for part of its play time. The
[DJ set tracklist recipe](/resources/recipes/dj-set-tracklist) shows how to
collapse chunk matches into a tracklist.

### Library music and unreleased audio

The public database covers commercially released music. Production-library
cues, unreleased masters, demos, and in-house jingles may not be there. If
you need to recognize a specific set of recordings, put them in a custom
catalog (special access; email api@audd.io). A custom match carries an
`audio_id`, and `artist`/`title` may be `null`.

## Practical consequences

### "No match" is not "cleared"

An empty result means AudD found no recording it knows in that audio. The
audio could still contain a cover, an interpolation, a heavily transformed
track, a live performance, or a recording that isn't in the database. For
copyright moderation, treat "no match" as **unknown**, and decide what your
platform does with unknown content (publish, publish and keep monitoring
reports, or review when other signals point to music).

### Pair recognition with human review

Recognition answers one narrow question well. Route the cases it can't settle
to people: disputed matches, uploads with lots of unidentified music, and
reports from rights holders about content that didn't match.
[From match to decision](/resources/concepts/match-to-decision) shows how to
turn results into allow, block, and review outcomes.

### Know what your own content looks like

Every claim on this page that says "test" depends on your audio: your
uploaders' devices, your mix of content, the transformations that are common
on your platform. A small labeled test set answers those questions better
than any general figure.

## Build a test set

1. **Collect real samples by category.** Pull 20 to 50 items per category that
   matters to you: clean re-uploads, phone captures, music under speech,
   remasters and edits, live recordings, covers, sped-up clips, and clean
   content with no music. Use your real uploads where you can.
2. **Label the expected answer.** For each file, record the artist and title
   you expect, or leave them blank when nothing should match.
3. **Run the set and classify each outcome** as correct, wrong track, missed,
   or unexpected match. Keep the scores (Startup plan or higher) for the
   [score calibration](/resources/concepts/score-thresholds) step.
4. **Re-run when inputs change**: a new upload source, a new content category,
   a new transformation trend.

A CSV with `path,category,expected_artist,expected_title` is enough:

```python
import csv
from collections import Counter, defaultdict
from audd import AudD

audd = AudD("your-api-token")  # Get your own token at dashboard.audd.io


def norm(s):
    return (s or "").casefold().strip()


def classify(row, result):
    expected = norm(row["expected_title"])
    if result is None:
        return "missed" if expected else "correct_no_match"
    if not expected:
        return "unexpected_match"
    same = expected in norm(result.title) and norm(row["expected_artist"]) in norm(result.artist)
    return "correct" if same else "wrong_track"


tally = defaultdict(Counter)
with open("testset.csv", newline="") as f, open("results.csv", "w", newline="") as out:
    writer = csv.writer(out)
    writer.writerow(["path", "category", "outcome", "artist", "title", "score"])
    for row in csv.DictReader(f):
        result = audd.recognize(row["path"])  # first 12 seconds of each file
        outcome = classify(row, result)
        tally[row["category"]][outcome] += 1
        writer.writerow([
            row["path"], row["category"], outcome,
            result.artist if result else "", result.title if result else "",
            getattr(result, "score", "") if result else "",
        ])

for category, counts in sorted(tally.items()):
    print(category, dict(counts))
```

Title matching by substring is deliberately loose, since versions often carry
suffixes like "Remastered" or "Radio Edit". Review the `wrong_track` rows by
hand; some will be another version of the right recording.

Each file costs one request. For full-length files, scan with
`audd.recognize_enterprise(path, limit=...)` instead and compare the list of
matches; set `limit` so a long file can't run up the bill.

## Measure matching on transformed audio

To learn how your audio behaves when sped up, slowed, or pitch-shifted, take
files from your test set that match cleanly and generate variants with
ffmpeg:

```bash
in=track.mp3
# Speed and pitch together (playback-rate change, "nightcore" style)
for r in 0.90 0.95 1.05 1.10 1.25; do
  ffmpeg -loglevel error -y -i "$in" -af "aresample=44100,asetrate=44100*$r,aresample=44100" "rate_$r.mp3"
done
# Tempo only, pitch unchanged
for t in 0.90 0.95 1.05 1.10 1.25; do
  ffmpeg -loglevel error -y -i "$in" -af "atempo=$t" "tempo_$t.mp3"
done
# Pitch only, tempo unchanged (about +1 semitone)
ffmpeg -loglevel error -y -i "$in" -af "aresample=44100,asetrate=44100*1.0595,aresample=44100,atempo=1/1.0595" "pitch_up1.mp3"
```

Add each variant to the CSV with the original's expected artist and title and
a category such as `rate_1.10`, run the harness above, and read the match
rate per category. The step where matches start to drop is your platform's
practical limit for that transformation. Use enough source tracks (a few
dozen across genres) that one unusual recording doesn't decide the result.

## FAQ

### Does AudD recognize covers?

No. A cover is a new recording of the same composition, and AudD matches recordings. A cover matches only itself, and only if that cover recording is in the database.

### Will a remaster or radio edit match the original?

It may match as itself or as another version of the same track. They are separate recordings with their own identifiers, so test with the versions you care about and don't assume the ISRC on a match is the exact one used.

### Can AudD detect AI-generated music or voice clones?

No. AudD does not classify audio as AI-generated. A generated recording matches only if that exact recording is in the public database or in your custom catalog.

### How much speed or pitch change can recognition handle?

AudD does not publish a tolerance. Matching becomes less likely as the change grows. Generate sped-up, slowed, and pitch-shifted variants of tracks that match cleanly and measure the match rate on your own audio.

### Does no match mean an upload has no copyrighted music?

No. It means no known recording was found. The upload can still contain covers, interpolations, transformed audio, live performances, or recordings outside the database, so treat no match as unknown rather than cleared.

### How do I recognize unreleased or library music?

Upload those recordings to a custom catalog. Custom catalog access is enabled on request at api@audd.io, and matches against it carry an audio_id that you map back to your own records.

---

**Related**

- [From match to decision: allow, block, and review policies](/resources/concepts/match-to-decision)
- [Public database vs your custom catalog](/resources/concepts/custom-vs-public-db)
- [Interpreting the recognition score](/resources/concepts/score-thresholds)
- [Audio formats and quality for music recognition](/resources/concepts/audio-format-and-quality)
- [Detect samples and reuse of your own tracks](/resources/recipes/sample-detection)
- [Music rights and recognition glossary](/resources/reference/music-rights-glossary)
- [API reference](https://docs.audd.io)

## Sitemap

See the [resources sitemap](https://audd.io/resources/sitemap.md) for every guide and the [glossary](https://audd.io/resources/reference/glossary.md) for AudD terms.