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

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

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

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 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 [email protected]). 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 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

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.
Label the expected answer. For each file, record the artist and title you expect, or leave them blank when nothing should match.
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 step.
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:

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:

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 [email protected], and matches against it carry an audio_id that you map back to your own records.

Related