---
title: "AudD for music lawyers and licensing investigators"
description: "Use AudD to gather evidence of unauthorized music use — artist, title, label, ISRC, UPC, and exact in-content timestamps — and to investigate where a recording appears across long-form and social content."
slug: "/resources/for/lawyers-and-investigators"
section: "for"
keywords: [audd, music copyright, licensing investigation, isrc, upc, dmca evidence]
---

# 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

1. **[Generate DMCA takedown evidence](/resources/recipes/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).

2. **[Build a copyright scanner for user-uploaded content](/resources/recipes/ugc-copyright-scanner)**
   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.

3. **[Interpreting the recognition score](/resources/concepts/score-thresholds)**
   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.

4. **[Recognition result fields](/resources/reference/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.

```python
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](/resources/recipes/dmca-takedown-evidence)
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**

- [Generate DMCA takedown evidence](/resources/recipes/dmca-takedown-evidence)
- [Build a copyright scanner for user-uploaded content](/resources/recipes/ugc-copyright-scanner)
- [Interpreting the recognition score](/resources/concepts/score-thresholds)
- [Recognition result fields](/resources/reference/result-fields)
- [API reference](https://docs.audd.io)