---
title: "ISRC codes explained: what they are and how to use them in your music app"
description: "What ISRC codes are, how they're structured, and how to retrieve and validate them in a music app using AudD's recognition API and SDKs."
slug: "/resources/articles/isrc-codes-explained-for-music-apps"
section: "articles"
keywords: [audd, isrc, music metadata, recognition api, royalties, catalog management]
---

# ISRC codes explained: what they are and how to use them in your music app

Every commercially released recording carries a unique code that identifies it
across every platform, database, and royalty system worldwide. It isn't the
audio fingerprint used for recognition — it's a 12-character alphanumeric
identifier called the ISRC.

If you're building music apps, managing catalogs, or tracking royalties,
you'll deal with ISRCs constantly. This guide explains what
they are, how they're structured, and how to retrieve and validate them
programmatically.

## What is an ISRC code?

An ISRC (International Standard Recording Code) is a unique identifier assigned
to a specific sound recording. The displayed form looks like **US-ABC-12-34567**
and breaks down into four parts:

- **US** — country code (2 characters)
- **ABC** — registrant code (3 characters, assigned to the label or
  distributor)
- **12** — year of reference (2 digits)
- **34567** — designation code (5 digits, unique within that registrant and
  year)

Each ISRC identifies one specific recording. The same composition recorded by
different artists gets different ISRCs, and even a re-recording by the same
artist gets a new ISRC. The hyphens are for display only — stored and
transmitted, the code is 12 characters with no separators (`USABC1234567`).

## Why ISRC codes matter for music apps

Titles and
artist names are not dependable keys. "Hurt" could mean Nine Inch Nails' original
or Johnny Cash's cover. "The Beatles" might be stored as "Beatles" in one
database and "The Beatles" in another. An ISRC removes that ambiguity — it points
at exactly one recording regardless of how the surrounding metadata is formatted.

### Common use cases

- **Royalty tracking** — performance rights organizations and platforms report
  plays by ISRC, so accurate codes are tied directly to whether rights holders
  get paid.
- **Catalog management** — labels use ISRCs as the backbone for tracking
  recordings across territories, formats, and platforms.
- **Rights and copyright** — content-identification systems link audio to
  ownership information through the ISRC.
- **Analytics** — one ISRC equals one recording, which is what makes
  cross-platform play aggregation possible.

## How ISRC codes are assigned

The International Federation of the Phonographic Industry (IFPI) administers the
ISRC system globally. National agencies assign a registrant code to each label or
distributor, who then generates unique ISRCs for their recordings. In practice
the flow is: register with a national agency, receive a registrant code, generate
ISRCs per recording, embed them in files and database entries, and report plays
using them.

## Getting ISRC data through an API

Music recognition APIs can return the ISRC alongside other metadata once they
identify a recording from audio. With AudD, the ISRC is available on the Startup
plan and higher — on lower plans the field is simply absent from the response,
which is normal and not an error.

```python
from audd import AudD

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

song = audd.recognize("https://audd.tech/example.mp3")
if song:
    print("Title:", song.title)
    print("Artist:", song.artist)
    print("ISRC:", song.isrc)  # None on plans below Startup, or if unknown
```

Treat the ISRC as nullable. A successful match can lack one — older recordings
and some independent releases were never registered — so design your code to
handle its absence rather than assuming it's always present.

If the SDK doesn't model a particular field as a typed property, you can still
read it: in Python any extra field lands on the result's `model_extra` map, and
in Node on `extras`.

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

const audd = new AudD(process.env.AUDD_API_TOKEN ?? "test");

const song = await audd.recognize("https://audd.tech/example.mp3");
if (song) {
  console.log({ title: song.title, artist: song.artist, isrc: song.isrc });
}
```

## Validating and normalizing ISRCs

A valid ISRC is exactly 12 characters: a 2-letter country code, a 3-character
alphanumeric registrant code, a 2-digit year, and a 5-digit designation code,
with no separators in storage. A few rules keep your data clean:

- **Normalize on input.** ISRCs arrive with hyphens (`US-ABC-12-34567`) or
  without (`USABC1234567`). Strip separators and uppercase before storing, then
  re-insert hyphens only for display.
- **Validate the format.** Reject codes that don't match the 12-character
  pattern so malformed data doesn't enter your catalog.
- **Plan for missing codes.** Not every recording has an ISRC. Keep a fallback
  identification path (audio recognition, or artist/title matching) for records
  that lack one.
- **Don't assume global uniqueness is perfect.** Human error occasionally
  produces a duplicate ISRC. If an ISRC is your primary key, log collisions
  rather than silently overwriting.

## ISRC and audio recognition together

Audio recognition and ISRC retrieval complement each other. Recognition answers
"what recording is this?" from the audio; the ISRC it returns gives you a
standardized identifier you can hand to royalty, rights, and analytics systems —
without running a separate lookup. That combination, audio-based identification
plus a stable cross-platform code, is what lets an app go from a raw clip to a
record that the rest of the music industry already understands.

If you need to identify every recording in a long file rather than a single
clip, the **enterprise** endpoint chunks the audio server-side and returns every
match with timestamps (and ISRC on Startup-and-above), billed per 12 seconds.

```python
matches = audd.recognize_enterprise("long-mix.mp3", limit=10)
for m in matches:
    print(m.timecode, m.isrc, m.artist, "—", m.title)
```

Set a `limit` during development so a long file doesn't expand into more billed
work than you intend.

## Wrapping up

ISRC codes are the identifiers the rest of the music industry already speaks.
Retrieve them from recognition responses, normalize and validate them on the way
in, and design for the cases where they're missing. A recognition API that
returns the ISRC alongside the audio match gives you both halves — identification
and a standardized key — in a single call.

Get a token at [dashboard.audd.io](https://dashboard.audd.io) and read the
[API reference](https://docs.audd.io) to start.

---

**Related**

- [How to extract music metadata from audio using an API](/resources/articles/extract-music-metadata-api)
- [Result fields reference](/resources/reference/result-fields)
- [Glossary](/resources/reference/glossary)
- [API reference](https://docs.audd.io)