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.

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

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 [email protected]
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 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 [email protected] in advance. Plans and prices are on the pricing page.

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

Standard, enterprise, or streams: how to choose confirms which endpoint fits your uploads.
The song_link (lis.tn) universal music link covers ?thumb and the SDK helpers.
Apple Music metadata block lists the Apple Music block, including how to read genreNames.
From match to decision turns a match into a policy: when to prefill, ask, or hold.
Public database vs your custom catalog explains audio_id and how catalog matches differ.

Code teaser

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

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 for the other languages.

Related