AudD for music lawyers and licensing investigators

If your work turns on which recording is playing, who released it, and exactly where it appears in a piece of content, AudD gives you that data from audio or video files and from links to live content. This page is for music lawyers, rights enforcement teams, licensing investigators, and forensic analysts who need to identify recordings and document their position inside a file precisely enough to stand behind in a complaint or a report.

AudD is a music-recognition HTTP API with a database of 160 million songs. You POST audio (or a URL) and get back the recording’s identification — artist, title, album, release date, label, and, on the right plan, ISRC and UPC — along with timing data you can turn into file-absolute timestamps. AudD supplies the identification; the legal determination is yours (see the note below).

What you can do

The recurring problem in this work is the gap between hearing that a track is present and documenting it well enough that someone else can verify it. A note that says “their video uses our song” is not evidence. A record that says “this ISRC plays from 00:04:06 to 00:06:18 in this file, label X, score 100” is. AudD closes that gap.

Identify the exact recording, not just the song. A match returns artist, title, album, release_date, and label. The label is what ties a recording to a commercial rights holder; a non-null label is your signal that the match is a released recording you can name precisely.
Capture the recording’s standard identifiers — ISRC and UPC. The International Standard Recording Code (isrc) identifies the specific recording; the Universal Product Code (upc) identifies the release. These are the strongest single identifiers you can put in a filing. They are returned on enterprise calls and on a Startup plan or higher — a null ISRC does not mean the match is invalid, but an ISRC makes the strongest record.
Pinpoint where in the content a track appears. Each match carries start_seconds / end_seconds — the song’s file-absolute position, in seconds, ready to turn into a real clock time a reviewer can seek to. There’s no offset math to do: recognize_enterprise requests accurate offsets by default, so those positions come back precise. A track that plays for two minutes shows up as a run of consecutive matches naming the same recording, which you collapse into a single span with a start and an end.
Scan content of any length, and find every track in it. Where the standard endpoint is built for a short audio clip and returns one result, the enterprise endpoint handles full-length songs, short-form videos, podcasts, broadcasts, and DJ sets, and finds every recognized track rather than one. That is what you need when the question is “what music is in this two-hour stream,” not “name this clip.”
Investigate links to live and social content directly. AudD parses content URLs server-side, so an investigation can pass a link to a piece of content rather than downloading and re-hosting it first.
Calibrate confidence deliberately. Every match carries a score. For evidence work you decide the threshold at which a match is citable versus one that goes to manual review — and you can require a label and/or an ISRC/UPC before a match counts as takedown-grade.
Read fields beyond the typed surface. If a metadata field you need for a record isn’t one of the named result fields, the response exposes a model_extra map per match for additional fields outside the typed surface.

AudD provides the identification data, not the legal filing. The API tells you what was recognized and where it appears in a file. Deciding whether to file, drafting the complaint, asserting ownership, and weighing fair use or licensing are yours to handle. The output is input to that process, not legal advice.

Where to start

Generate DMCA takedown evidence is the core recipe for this work. It runs offending content through the enterprise endpoint, reads each match’s file-absolute start_seconds / end_seconds, collapses a held track into one evidence span, formats it as HH:MM:SS, filters to spans that carry a label or ISRC/UPC, and renders an evidence pack as both JSON (for your case records) and a human-readable summary (to paste into a complaint).
Build a copyright scanner for user-uploaded content covers the upstream problem: finding the content worth investigating in the first place by scanning uploads as they arrive, capturing ISRC, UPC, label, and timestamps for every match.
Interpreting the recognition score explains how to read the score and how to set application-specific thresholds for auto-accept, manual review, and rejection — directly relevant to deciding which matches are strong enough to cite.
Recognition result fields is the field-by-field reference for the result object, including the distinction between timecode (position inside the matched recording) and start_seconds / end_seconds (position in your content file) — a distinction that matters when you are locating an infringement.

Code teaser

This recognizes a piece of content with the enterprise endpoint and prints each recognized recording with its standard identifiers and a file-absolute start time. Always set limit while developing: the enterprise endpoint bills 1 request per 12 seconds of audio processed, so an unbounded call on long content meters every fragment.

from audd import AudD
from audd.errors import AudDError


def fmt_hms(seconds: float) -> str:
    s = int(seconds)
    h, rem = divmod(s, 3600)
    m, sec = divmod(rem, 60)
    return f"{h:02d}:{m:02d}:{sec:02d}"


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

try:
    # limit caps metered fragments while developing; accurate offsets are on by
    # default, so each match comes back with a file-absolute start_seconds.
    matches = audd.recognize_enterprise(
        "https://audd.tech/example.mp3",
        limit=25,
    )  # -> list[EnterpriseMatch]
except AudDError as e:
    raise SystemExit(f"Recognition failed: {e}")

for m in matches:
    if m.start_seconds is None:
        continue  # fragment without a usable position — skip it
    at = fmt_hms(m.start_seconds)  # file-absolute position
    print(f"{at}  {m.artist} — {m.title}  "
          f"[ISRC {m.isrc}, label {m.label}, score {m.score}]")

A run prints one line per recognized fragment, in time order, each with a real HH:MM:SS position in the file and the identifiers you would cite. A track held for two minutes shows up as a run of consecutive lines naming the same recording. Clean content returns an empty list — not an error, and distinct from one. Every field is Optional: the SDK parses leniently, so guard start_seconds (as above) and expect isrc, upc, or label to be None on a given match.

The DMCA takedown evidence recipe takes this further: collapsing consecutive same-track chunks into one span with a start and an end, filtering to citable matches, and rendering the full evidence pack.

Related