---
title: "AudD for music video generation startups"
description: "How AI music video generators use AudD to identify the song a user uploads, fill in title, artist, cover art, release date and genre, tell an artist's own release from someone else's track, and check generated audio for released recordings."
slug: "/resources/for/music-video-generators"
section: "for"
keywords: [audd, music video generator, ai music video, song upload, song identification, cover art, genre, rights check, generated audio, custom catalog]
---

# AudD for music video generation startups

This page is for teams building products that turn a song into a video:
AI music video generators, audio-reactive visualizers,
promo and social cut-downs for artists. Your users upload a song and expect
the video to fit it. AudD's API tells you which released recording that
upload is, with the title, artist, album, release date, label, cover art and
streaming links, in under 2 seconds. You can use that to fill in the project
for the user, steer the visual style, and know when a user is uploading
someone else's track.

## What you can do

### Fill in the project from the upload

When a user uploads a song, send a short excerpt to the **standard endpoint**
(`POST https://api.audd.io/`). It costs one request per call and returns one
match, or `result: null` when the recording isn't recognized. A match gives
you `artist`, `title`, `album`, `release_date`, `label` and `song_link`. Use
them to name the project, write the credit line on the video, and prefill
the description the user will post with it, instead of asking the user to
type them.

The standard endpoint analyzes the first 12 seconds of the audio you send.
Songs often open with silence, a count-in or a quiet intro, so cut an
excerpt from a point past the intro (15 seconds from about 30 seconds in
works for most songs) rather than sending the file as uploaded. That also
keeps the request well under the endpoint's 10 MB limit.

### Steer the visuals with the song's own metadata

- **Cover art.** Append `?thumb` to a `song_link` on lis.tn and you get the
  release's cover image (the SDKs expose it as `thumbnail_url` /
  `thumbnailUrl`). Use it as a reference image, or to pull a palette.
- **Genre.** Request the Apple Music block with `return=apple_music`. Apple's
  data includes `genreNames`, which you can feed into the style prompt or
  the template picker. It isn't a typed SDK field, so read it from the
  block's extras (`model_extra` in Python, `extras` in Node). Each provider
  you request adds some latency.
- **Era.** `release_date` lets a template lean towards the look of the year
  the song came out.

Every field can be missing. Treat the metadata as a suggestion the user can
change, not as the only input to the generator.

### Tell the user's own release from someone else's track

Many of your users are artists making videos for their own songs. Others
upload a track they like by an artist they have nothing to do with. A
recognition result lets you treat these differently:

| What comes back | What it usually means | What you might do |
|---|---|---|
| A match whose artist is the user's connected or verified artist name | The user's own released song | Prefill everything, no extra step |
| A match by another artist | A released recording the user may not have rights to use in a video | Ask the user to confirm they have permission, or apply your policy for published exports |
| `result: null` | Unreleased, original, generated, a cover, or simply not recognized | Unknown, not cleared. Ask for the details yourself |
| A match carrying `audio_id` | A track from your own custom catalog (see below) | Whatever your catalog means: your licensed library, songs made on your platform |

A match tells you which recording is in the upload. It doesn't tell you who
holds the rights, or whether this user has permission to put it in a video.
Video platforms run their own recognition on uploads, so a video set to a
commercial recording can be claimed or muted after the user posts it. Telling
the user before they render saves them a wasted export.

### Check generated audio for released recordings

If your product generates the music as well as the video, you can send each
generated track through the same check before it goes to the user. A match
means the output contains audio that fingerprints as a released recording,
which is worth stopping. No match doesn't mean the track is original: AudD
matches recordings, and a soundalike, a pastiche or a new performance of
an existing song is a different recording. See
[what recognition matches](/resources/concepts/what-recognition-matches).

### Recognize your own tracks with a custom catalog

A custom catalog is a private fingerprint database on your account. Upload a
stock library you license to users, or the songs your platform generated,
and later recognition calls match against it as well as against the public
database. Matches from your catalog carry an `audio_id`, the ID you gave the
track. That's how you can tell a song made on your platform from an outside
upload, or check which plan a library track was licensed under. Custom
catalog access isn't on by default; email api@audd.io.

## How the pieces map to your needs

| Need | AudD piece | Notes |
|---|---|---|
| Name the song a user uploaded | Standard endpoint on an excerpt | One request per upload; under 2 seconds |
| Cover art for the template | `song_link` + `?thumb` | No provider block needed |
| Genre for the style prompt | `return=apple_music`, then `genreNames` from extras | Adds latency; can be missing |
| Rights prompt before rendering | Your rules on top of the match | Compare the artist to the user's verified artist name |
| Screen generated songs | Standard endpoint on an excerpt of each output | A match is a stop signal; no match isn't clearance |
| Recognize your own library or generated songs | Custom catalog, matches carry `audio_id` | Special access; email api@audd.io |
| Find every song in a long upload (a mix, a medley) | Enterprise endpoint with `limit` | Bills per 12 seconds processed |

## Things to plan for

- **Where in the flow.** Recognition takes under 2 seconds, so it fits
  between upload and the first preview. Run it on the server, where your API
  token stays private, and don't block the upload on it: if the call fails,
  let the user fill in the fields.
- **One excerpt is enough for one song.** An upload is normally one song, so
  one standard request answers it. Reach for the
  [enterprise endpoint](/resources/concepts/standard-vs-enterprise-vs-streams)
  only when uploads can contain several songs, and set `limit` on every call.
- **Unreleased music.** Your users upload songs before they're out. Decide
  whether your terms of service and privacy policy cover sending uploads to a
  recognition provider, and tell users.
- **Volume.** The standard endpoint has no rate limit. If you expect a large
  launch or a sharp spike, write to api@audd.io in advance. Plans and prices
  are on the [pricing page](https://audd.io/pricing).

## What AudD doesn't do

- It doesn't license music, name rights holders, or decide whether a user may
  use a song. Your policy does.
- It doesn't detect AI-generated audio, covers, soundalikes or style copies.
  An AI-generated song that has been released through a distributor is a
  released recording like any other and can match as itself.
- It doesn't transcribe or analyze the music for beats, sections or mood.
  It identifies the recording and returns its metadata.

## Where to start

1. **[Standard, enterprise, or streams: how to choose](/resources/concepts/standard-vs-enterprise-vs-streams)**
   confirms which endpoint fits your uploads.
2. **[The song_link (lis.tn) universal music link](/resources/concepts/lisn-song-link)**
   covers `?thumb` and the SDK helpers.
3. **[Apple Music metadata block](/resources/reference/apple-music)** lists the
   Apple Music block, including how to read `genreNames`.
4. **[From match to decision](/resources/concepts/match-to-decision)**
   turns a match into a policy: when to prefill, ask, or hold.
5. **[Public database vs your custom catalog](/resources/concepts/custom-vs-public-db)**
   explains `audio_id` and how catalog matches differ.

## Code teaser

Cut an excerpt past the intro, recognize it, and fill in the project:

```python
import subprocess
from audd import AudD

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

def excerpt(path, seconds=15):
    # 15 seconds from about 30 s in, or the last 15 seconds of a shorter song.
    probe = subprocess.run(
        ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path],
        capture_output=True, text=True, check=True,
    )
    start = max(0, min(30, float(probe.stdout) - seconds))
    out = path + ".excerpt.mp3"
    subprocess.run(
        ["ffmpeg", "-y", "-loglevel", "error", "-ss", str(start), "-t", str(seconds),
         "-i", path, "-vn", "-ac", "1", "-b:a", "128k", out],
        check=True,
    )
    return out

def describe_upload(path, user_artist_name=None):
    result = audd.recognize(excerpt(path), return_metadata=["apple_music"])
    if result is None:
        return {"status": "unknown"}  # unreleased, original, generated, or not recognized

    genres = []
    if result.apple_music and result.apple_music.model_extra:
        genres = result.apple_music.model_extra.get("genreNames", [])

    own = bool(user_artist_name) and (result.artist or "").casefold() == user_artist_name.casefold()
    return {
        "status": "own_release" if own else "third_party",
        "title": result.title,
        "artist": result.artist,
        "album": result.album,
        "release_date": result.release_date,
        "cover_url": result.thumbnail_url,
        "genres": genres,
    }
```

The recognition method returns `None` / `null` / `nil` on no match in every
SDK. Install for your stack, `pip install audd` (Python) or
`npm install @audd/sdk` (Node), and see the
[SDK docs](https://docs.audd.io/sdks) for the other languages.

---

**Related**

- [AudD for AI startups](/resources/for/ai-startups)
- [AudD for video platforms and UGC moderation](/resources/for/video-platforms)
- [What music recognition matches, and what it doesn't](/resources/concepts/what-recognition-matches)
- [The song_link (lis.tn) universal music link](/resources/concepts/lisn-song-link)
- [Recognition result fields](/resources/reference/result-fields)
- [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.