---
title: "AudD for AI startups"
description: "Identify and attribute music in user or training data, build music-aware product features, and enrich media datasets with artist, title, and ISRC using the AudD API."
slug: "/resources/for/ai-startups"
section: "for"
keywords: [audd, ai startup, music identification, dataset enrichment, isrc, bulk recognition]
---

# AudD for AI startups

If you're building on audio or media data, you often need to know what
recorded music is in a file — to attribute it, tag it, or enrich a dataset
with it. AudD is an HTTP API that identifies music against a database of 160
million tracks and returns structured metadata: artist, title, album, label,
release date, recording identifiers, and a universal link. This page is the
concrete shape of the API and the two common paths: a real-time lookup
feature and a bulk enrichment job.

## What you can do

### Add a "what's this song" feature

For a short audio clip captured in your product, call the **standard
endpoint** (`POST https://api.audd.io/`). It returns in under 2 seconds,
accepts files up to 10 MB, and returns `result: null` on no match — distinct
from an error, so "no song here" is a first-class answer your UI can render.
This is the right path for an interactive, one-clip-at-a-time feature.

- Pass a `url` or upload bytes; the response carries `artist`, `title`,
  `album`, `release_date`, `label`, and `song_link` (a universal URL on
  lis.tn).
- Use `return` (Node: `returnMetadata`, Python: `return_metadata`) to attach
  per-provider blocks — `apple_music`, `spotify`, `deezer`,
  `musicbrainz` — when your feature links out to a streaming service.

### Identify and attribute music in user or training data

For longer audio — full tracks, recordings, video — call the **enterprise
endpoint** (`POST https://enterprise.audd.io/`). It chunks the file
server-side and returns one match per recognized segment, so a single file
that contains several tracks yields several attributions. It accepts audio
(MP3, WAV, FLAC, M4A, OGG, AAC, WMA, AIFF) and video (MP4, AVI, MOV, MKV,
WebM), with no practical file-size cap.

- `isrc` (recording ID) and `upc` (release ID) come back on enterprise
  responses for accounts on the Startup plan or higher — the stable
  identifiers to key a dataset on rather than free-text title matching.
- `timecode` is the position inside the matched track at the recognition
  point.

### Enrich a media dataset at scale

To run an existing archive of files through recognition, the path is a bulk
job: iterate your inventory, call the endpoint per item, and write the
structured result back to your dataset keyed by your own ID. The enterprise
endpoint bills per 12 seconds of audio processed, so cost scales with how
much audio you fingerprint — `limit` and `every` are the levers that bound
it.

> **Always set `limit` during development, and on bulk jobs.** The enterprise
> endpoint bills per 12 seconds of audio processed. An unbounded call across
> a large archive can ingest enormous amounts of audio. Set `limit=N` per
> call, and use `every=N` to sample chunks when you need attribution rather
> than a complete per-second tracklist.

### Read fields beyond the typed surface

Every result and per-provider block exposes an `extras` map for additional
fields the SDK doesn't surface as typed properties, and every request
options struct exposes an `extra_parameters` map for form fields not exposed
as typed parameters (typed parameters win on collision). This is how you read
or send fields outside the typed surface without waiting on an SDK release.

## Where to start

- **[Scan a bulk audio archive](/resources/recipes/bulk-audio-archive-scan)**
  — the enrichment path: iterate an archive, recognize each item, and write
  structured metadata back to your dataset.
- **[Build a copyright scanner for user-uploaded content](/resources/recipes/ugc-copyright-scanner)**
  — the per-upload recognition pattern, including how to bound enterprise
  cost on arbitrary user files.
- **[Result fields reference](/resources/reference/result-fields)** — the
  exact response schema your dataset writes against, field by field.
- **[Run recognition on Cloudflare Workers](/resources/integrations/cloudflare-workers)**
  — a serverless deployment for the real-time lookup feature.

## API teaser

Real-time lookup with the standard endpoint — under 2 seconds, `None` on no
match:

```python
from audd import AudD

audd = AudD("test")  # 10 free requests/day on the public test token

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

if result is None:
    print("No song recognized.")
else:
    print(f"{result.artist} — {result.title}")
    print(f"link: {result.song_link}")
```

Bulk enrichment with the enterprise endpoint — one record per recognized
segment, keyed by your own ID:

```python
def enrich(records):
    for rec in records:  # rec = {"id": ..., "url": ...}
        matches = audd.recognize_enterprise(rec["url"], limit=25)
        rec["music"] = [
            {"artist": m.artist, "title": m.title, "isrc": m.isrc,
             "label": m.label, "timecode": m.timecode}
            for m in matches
        ]
        yield rec
```

The recognition method returns a `None`/`null`/`nil`-equivalent on no match
in every SDK. Install for your stack — `pip install audd` (Python),
`npm install @audd/sdk` (Node), `go get github.com/AudDMusic/audd-go` (Go) —
and see the [SDK docs](https://docs.audd.io/sdks) for the other supported
languages. Signup includes 300 free requests with no card.

---

**Related**

- [Scan a bulk audio archive](/resources/recipes/bulk-audio-archive-scan)
- [Standard, enterprise, or streams: how to choose](/resources/concepts/standard-vs-enterprise-vs-streams)
- [Result fields reference](/resources/reference/result-fields)
- [Run recognition on Cloudflare Workers](/resources/integrations/cloudflare-workers)
- [SDK docs](https://docs.audd.io/sdks)
- [API reference](https://docs.audd.io)