---
title: "Music metadata extraction API: a complete guide for developers"
description: "How music metadata extraction APIs identify songs and return artist, album, label, rights identifiers, and streaming links — with practical AudD SDK examples."
slug: "/resources/articles/music-metadata-extraction-api-guide"
section: "articles"
keywords: [audd, music metadata, metadata extraction api, music recognition api, audio fingerprinting]
---

# Music metadata extraction API: a complete guide for developers

You need metadata — artist, album, links, rights identifiers — to build
features, track usage rights, and organize content. Music metadata extraction
APIs solve this by identifying songs and
returning detailed information about artists, albums, labels, and streaming
links.

This guide covers what you need to implement music metadata extraction, from
the underlying concepts to working SDK examples.

## What is music metadata extraction?

Music metadata extraction is the process of identifying audio content and
retrieving the information attached to it: artist, title, album, release date,
record label, rights identifiers, and streaming-service links. Modern APIs do
this with audio fingerprinting: they analyze the audio signal and match it
against a large reference database.

The process converts audio into a compact fingerprint that captures the
recording's acoustic characteristics, then compares that fingerprint against a
catalog of known tracks. Unlike reading embedded file tags, extraction works on
*any* audio source — live streams, recorded files, microphone input, or URLs —
whether or not the original file carries metadata of its own.

## Types of music metadata

### Basic track information
- Artist and title
- Album name
- Release date

### Commercial and rights data
- Record label
- ISRC codes (per recording)
- UPC codes (per release)

### Streaming and discovery
- Apple Music and Spotify links (and Deezer, MusicBrainz)
- A universal `song_link` that redirects to whatever service the user has
- Album artwork via the provider blocks

### Positional metadata
- `timecode` — where in the matched track the submitted clip aligns
- On the enterprise endpoint, per-segment offsets that let you build a
  timestamped tracklist

## How music metadata APIs work

Music metadata APIs use neural-network audio fingerprinting to identify songs.
The flow has four stages:

**Audio fingerprinting.** The API converts audio into a compact fingerprint that
captures the recording's distinctive acoustic signature. The fingerprint stays
consistent across format, quality, and a fair amount of background noise.

**Database matching.** The fingerprint is compared against a reference catalog.
AudD's database covers **160 million songs** and is updated as new music
releases.

**Metadata retrieval.** On a match, the API returns structured metadata — basic
track info, commercial and rights data, and streaming links.

**Continuous recognition.** For live sources, recognition runs continuously,
which is what powers radio monitoring and live-event tracking.

## Key features to look for

### Database size and coverage
A fingerprinting system is only as good as the catalog it matches against. Look
for broad coverage of major labels, independent artists, and the regions
relevant to your audience. AudD recognizes against 160 million songs.

### Recognition speed
AudD's standard endpoint responds in under
2 seconds for a short clip and supports continuous recognition for live audio.

### Multiple input methods
A good API accepts several input shapes:
- Audio file uploads
- Public URLs to audio files
- Live stream feeds
- Microphone recordings captured by your app

### Metadata depth
Beyond basic track info, look for streaming links, artwork, label and rights
information (ISRC/UPC), and positional data like timecode.

### Custom catalog support
Some applications need to recognize their own content. AudD lets you upload your
own tracks to a custom catalog; later recognition calls match against them too,
returning the integer `audio_id` you assigned at upload time. Custom-catalog
access is gated; email [api@audd.io](mailto:api@audd.io) to enable it.

## Implementation methods

### Official SDKs
AudD ships 11 official SDKs — Python, Node/TypeScript, Go, Rust, PHP, Swift,
Kotlin, .NET, Java, C, and C++. They handle authentication, error handling, and
response parsing, so integration is a single method call. Install with the
language's package manager (`pip install audd`, `npm install @audd/sdk`, and so
on).

### Choosing an endpoint
AudD exposes three recognition surfaces by input shape:

- **Standard** (`POST https://api.audd.io/`) — a short audio clip, the single
  best match, under 2 seconds, 10 MB cap.
- **Enterprise** (`POST https://enterprise.audd.io/`) — long audio and video,
  chunked server-side, billed per 12 seconds of audio, returning every match
  with timestamps.
- **Streams** (`addStream` plus callbacks or longpoll) — continuous live audio.

### Callbacks for streams
For live monitoring, register a callback URL and AudD POSTs each match as a song
plays. If you can't host a public callback, poll the longpoll endpoint instead.

## Common use cases

### Content management systems
Music libraries and digital asset managers use extraction to tag and organize
audio automatically instead of entering data by hand.

### Copyright protection
Platforms with user-generated content identify copyrighted music in uploads and
handle licensing accordingly.

### Radio and streaming monitoring
Broadcasters and rights organizations monitor stations and streams to track
airplay and calculate royalties.

### Music discovery apps
Apps that help users identify the song playing around them rely on fast,
accurate extraction, with streaming links for immediate playback.

### Podcast and video analysis
Creators and platforms analyze audio to identify background music and ensure
proper licensing and attribution.

### DJ and production tools
Audio software uses extraction to help DJs and producers identify tracks and
organize libraries.

## Integration examples

### Recognize a short clip

```python
from audd import AudD

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

song = audd.recognize("https://audd.tech/example.mp3")
if song:
    print(f"{song.artist} — {song.title} ({song.album})")
else:
    print("no match")
```

### Add streaming links

Request only the providers you render, since each one adds a little latency:

```python
song = audd.recognize(
    "https://audd.tech/example.mp3",
    return_metadata=["apple_music", "spotify"],
)

if song:
    print("Apple Music:", song.streaming_url("apple_music"))
    print("Spotify:", song.streaming_url("spotify"))
    print("Universal link:", song.song_link)
```

The same call in Node looks like this:

```ts
import { AudD } from "@audd/sdk";

const audd = new AudD("test"); // get your own token at dashboard.audd.io

const song = await audd.recognize("https://audd.tech/example.mp3", {
  returnMetadata: ["apple_music", "spotify"],
});

if (song) {
  console.log(song.artist, "—", song.title);
  console.log("Apple Music:", song.streamingUrl("apple_music"));
}
```

### Extract a full tracklist from a long file

```python
matches = audd.recognize_enterprise(
    "https://audd.tech/example.mp3",
    limit=10,  # cap metered chunks while developing
)
for m in matches:
    print(m.timecode, m.artist, "—", m.title, m.isrc)
```

> **Always set `limit` on enterprise calls during development.** The enterprise
> endpoint bills per 12 seconds of audio processed. An unbounded call on a
> multi-hour file ingests the whole thing — start with a small `limit` and raise
> it once you understand the cost on your real inputs.

## Performance and accuracy

**Audio quality.** Most APIs work with compressed formats, and AudD's
fingerprinting tolerates low bitrates, background noise, and slight distortion.
Heavily clipped or distorted audio still hurts accuracy.

**Clip length.** The standard endpoint is tuned for a **short audio clip** — it
analyzes up to about 12 seconds of audio, and within that range more reasonably
clean audio generally helps. You don't need the whole recording. For long files
where you want every song, use the enterprise endpoint.

**Database freshness.** Recognition coverage depends on a current catalog. AudD
updates its 160-million-song database as new music releases.

## Reading the metadata surface

Through the SDK, prefer typed properties and helpers over reaching into provider
blocks by hand. Every field is nullable — degrade gracefully when one is
missing:

```python
if song:
    print("Artist:", song.artist)
    print("Title:", song.title)
    print("Album:", song.album)
    print("Label:", song.label)
    print("Released:", song.release_date)
    print("ISRC:", song.isrc)  # present on Startup plan or higher
    print("Spotify:", song.streaming_url("spotify"))
    print("Universal link:", song.song_link)
```

For any field outside the typed surface — undocumented or newly added metadata —
read it from `song.model_extra` in Python (`song.extras` in the Node SDK).
That's the supported way to access fields the SDK doesn't yet model.

## Best practices

**Handle the three outcomes separately.** A match returns a result, a clean
no-match returns `None`/`null` (a successful response — not an error), and
server errors raise typed exceptions. Branch on each explicitly.

**Cache results.** Store recognized metadata to avoid repeat calls for the same
audio and to build a local library.

**Respect rate limits and bound cost.** Queue batch work instead of firing
parallel requests, and always set `limit` on enterprise calls so a long file
doesn't meter hundreds of chunks.

**Protect your token.** The `api_token` is a bearer-style secret: keep it
server-side and rotate it from [dashboard.audd.io](https://dashboard.audd.io).

**Validate gracefully.** Responses are lenient by design; check for required
fields and handle missing data rather than assuming every field is present.

## Frequently asked questions

**What audio formats are supported?**
AudD's standard endpoint accepts MP3, WAV, FLAC, M4A, OGG, AAC, WMA, and AIFF.
The enterprise endpoint also accepts video formats (MP4, AVI, MOV, MKV, WebM)
and extracts the audio.

**Can I recognize music from live streams or radio?**
Yes. AudD's streams surface supports continuous, real-time recognition from live
streams and radio with 24/7 monitoring.

**Does it work with custom or unreleased content?**
Yes. Upload your own tracks to a custom catalog and later recognition calls match
against them, returning the `audio_id` you assigned. Access is gated; email
api@audd.io.

**What's the typical response time?**
The standard endpoint returns in under 2 seconds for a short clip. Enterprise
recognition of a long file takes longer because it chunks and scans the whole
input.

**How do I handle songs that aren't recognized?**
A no-match is a successful response with a null result. Branch on it explicitly —
render a "try again" path, offer manual tagging, or fall back to user-contributed
metadata.

## Conclusion

Choose the endpoint that fits your input, handle no-match and error cases
cleanly, and bound enterprise cost with `limit`. AudD gives you 300 free
requests on signup with no card, so testing against your own content is cheap
to run.

---

**Related**

- [Standard, enterprise, or streams: how to choose](/resources/concepts/standard-vs-enterprise-vs-streams)
- [How to identify songs in audio files with the AudD API](/resources/articles/identify-songs-in-audio-files)
- [Recognition result fields](/resources/reference/result-fields)
- [API reference](https://docs.audd.io)