Identify songs from short audio clips, hours-long broadcast recordings, and live audio streams.

Get an API token · Full docs · Support

curl https://api.audd.io/ \
-F url='https://audd.tech/example.mp3' \
-F api_token='your-api-token'

Get your API token at dashboard.audd.io. The string "test" works for hello-worlds (capped at 10 requests/day).

The API is one HTTP POST and works from any HTTP client. Official SDKs are available for the 11 languages below — they add typed results, retries, and longpoll consumers, but they aren't required.

Available SDKs:Python · Node / TypeScript · Go · Rust · PHP · Swift · Kotlin · C# / .NET · Java · C · C++

Identify a single song from a short audio clip — works like Shazam.

Parameters:

Each language tab shows the raw HTTP form (no SDK), then the official SDK form for the same call.

curl https://api.audd.io/ \
-F url='https://audd.tech/example.mp3' \
-F return='apple_music,spotify' \
-F api_token='your-api-token'

importrequestsr=requests.post("https://api.audd.io/", data={
"url": "https://audd.tech/example.mp3",
"return": "apple_music,spotify",
"api_token": "your-api-token",
}).json()
ifr["status"] =="success"andr["result"]:
s=r["result"]
print(f"{s['artist']} — {s['title']}")
print(s["apple_music"]["url"])

pip install audd

fromauddimportAudDaudd=AudD("your-api-token")
result=audd.recognize(
"https://audd.tech/example.mp3",
return_metadata=["apple_music", "spotify"],
)
print(f"{result.artist} — {result.title}")
print(result.apple_music.url) # direct Apple Music linkprint(result.spotify.uri) # spotify:track:...

constres=awaitfetch("https://api.audd.io/",{method: "POST",body: newURLSearchParams({url: "https://audd.tech/example.mp3",return: "apple_music,spotify",api_token: "your-api-token",}),});const{ status, result }=awaitres.json();if(status==="success"&&result){console.log(`${result.artist} — ${result.title}`);console.log(result.apple_music.url);}

npm install @audd/sdk

import{AudD}from"@audd/sdk";constaudd=newAudD("your-api-token");constsong=awaitaudd.recognize("https://audd.tech/example.mp3",{returnMetadata: ["apple_music","spotify"],});if(song){console.log(`${song.artist} — ${song.title}`);console.log(song.appleMusic?.url);console.log(song.spotify?.uri);}

import (
"encoding/json""net/http""net/url""strings"
)
resp, _:=http.Post(
"https://api.audd.io/",
"application/x-www-form-urlencoded",
strings.NewReader(url.Values{
"url": {"https://audd.tech/example.mp3"},
"return": {"apple_music,spotify"},
"api_token": {"your-api-token"},
}.Encode()),
)
deferresp.Body.Close()
varbodystruct {
Result*struct {
Artist, TitlestringAppleMusicstruct{ URLstring } `json:"apple_music"`
}
}
json.NewDecoder(resp.Body).Decode(&body)
ifbody.Result!=nil {
fmt.Printf("%s — %s\n%s\n", body.Result.Artist, body.Result.Title, body.Result.AppleMusic.URL)
}

go get github.com/AudDMusic/audd-go

import audd "github.com/AudDMusic/audd-go"client:=audd.NewClient("your-api-token")
deferclient.Close()
result, err:=client.Recognize("https://audd.tech/example.mp3", &audd.RecognizeOptions{
ReturnMetadata: "apple_music,spotify",
})
iferr!=nil { log.Fatal(err) }
fmt.Printf("%s — %s\n", result.Artist, result.Title)
fmt.Println("Apple Music:", result.AppleMusic.URL)
fmt.Println("Spotify URI:", result.Spotify.URI)

let r: serde_json::Value = reqwest::Client::new().post("https://api.audd.io/").form(&[("url","https://audd.tech/example.mp3"),("return","apple_music,spotify"),("api_token","your-api-token"),]).send().await?
.json().await?;ifletSome(s) = r["result"].as_object(){println!("{} — {}", s["artist"], s["title"]);println!("{}", s["apple_music"]["url"]);}

cargo add audd

use audd::{AudD,RecognizeOptions};let audd = AudD::new("your-api-token");let return_metadata = ["apple_music".into(),"spotify".into()];letSome(r) = audd
.recognize_with("https://audd.tech/example.mp3",RecognizeOptions{return_metadata:Some(&return_metadata), ..Default::default()},).await? else{returnOk(())};println!("{} — {}", r.artist, r.title);ifletSome(am) = r.apple_music.as_ref(){println!("Apple Music: {}", am.url.as_deref().unwrap_or(""));}

$r = json_decode(file_get_contents(
'https://api.audd.io/',
false,
stream_context_create(['http' => [
'method' => 'POST',
'header' => 'Content-Type: application/x-www-form-urlencoded',
'content' => http_build_query([
'url' => 'https://audd.tech/example.mp3',
'return' => 'apple_music,spotify',
'api_token' => 'your-api-token',
]),
]])
), true);
if ($r['status'] === 'success' && $r['result']) {
$s = $r['result'];
echo"{$s['artist']} — {$s['title']}\n";
echo$s['apple_music']['url'] . "\n";
}

composer require audd/audd

useAudD\AudD;
$audd = newAudD('your-api-token');
$result = $audd->recognize(
'https://audd.tech/example.mp3',
returnMetadata: ['apple_music', 'spotify'],
);
echo"{$result->artist} — {$result->title}\n";
echo$result->apple_music->url, "\n";
echo$result->spotify->uri, "\n";

varreq=URLRequest(url:URL(string:"https://api.audd.io/")!)
req.httpMethod ="POST"
req.setValue("application/x-www-form-urlencoded", forHTTPHeaderField:"Content-Type")
req.httpBody ="url=https://audd.tech/example.mp3&return=apple_music,spotify&api_token=your-api-token".data(using:.utf8)let(data, _)=tryawaitURLSession.shared.data(for: req)letjson=tryJSONSerialization.jsonObject(with: data)as?[String:Any]iflet result =json?["result"]as?[String:Any]{print("\(result["artist"]!) — \(result["title"]!)")}

// Package.swift: .package(url: "https://github.com/AudDMusic/audd-swift", from: "1.0.0")
import AudD
letaudd=tryAudD(apiToken:"your-api-token")guardlet result =tryawait audd.recognize("https://audd.tech/example.mp3",
returnMetadata:["apple_music","spotify"])else{return}print("\(result.artist ??"?") — \(result.title ??"?")")print(result.appleMusic?.url ??"")print(result.spotify?.uri ??"")

val body =FormBody.Builder()
.add("url", "https://audd.tech/example.mp3")
.add("return", "apple_music,spotify")
.add("api_token", "your-api-token")
.build()
val response =OkHttpClient().newCall(
Request.Builder().url("https://api.audd.io/").post(body).build()
).execute()
println(response.body?.string())

// Gradle: implementation("io.audd:audd-kotlin:1.0.0")importio.audd.AudDval audd =AudD("your-api-token")
val result = audd.recognize(
"https://audd.tech/example.mp3",
returnMetadata =listOf("apple_music", "spotify"),
)
result?.let {
println("${it.artist} — ${it.title}")
println(it.appleMusic?.get("url"))
println(it.spotify?.get("uri"))
}

usingvarhttp=newHttpClient();varcontent=newFormUrlEncodedContent(newDictionary<string,string>{["url"]="https://audd.tech/example.mp3",["return"]="apple_music,spotify",["api_token"]="your-api-token",});varresponse=awaithttp.PostAsync("https://api.audd.io/",content);Console.WriteLine(awaitresponse.Content.ReadAsStringAsync());

dotnet add package AudD

usingAudD;awaitusingvaraudd=newAudD.AudD("your-api-token");varresult=awaitaudd.RecognizeAsync("https://audd.tech/example.mp3",returnMetadata:new[]{"apple_music","spotify"});Console.WriteLine($"{result?.Artist} — {result?.Title}");Console.WriteLine(result?.AppleMusic?.Url);Console.WriteLine(result?.Spotify?.Uri);

varclient = HttpClient.newHttpClient();
varbody = "url=https://audd.tech/example.mp3&return=apple_music,spotify&api_token=your-api-token";
varreq = HttpRequest.newBuilder(URI.create("https://api.audd.io/"))
.header("Content-Type", "application/x-www-form-urlencoded")
.POST(BodyPublishers.ofString(body))
.build();
System.out.println(client.send(req, BodyHandlers.ofString()).body());

<!-- Maven -->
<dependency><groupId>io.audd</groupId><artifactId>audd</artifactId><version>1.0.0</version></dependency>

importio.audd.AudD;
importio.audd.RecognizeOptions;
varaudd = newAudD("your-api-token");
varr = audd.recognize(
"https://audd.tech/example.mp3",
RecognizeOptions.builder()
.returnMetadata("apple_music", "spotify")
.build()
);
System.out.println(r.artist() + " — " + r.title());
if (r.appleMusic() != null) System.out.println(r.appleMusic().url());
if (r.spotify() != null) System.out.println(r.spotify().uri());

CURL*c=curl_easy_init();
curl_easy_setopt(c, CURLOPT_URL, "https://api.audd.io/");
curl_easy_setopt(c, CURLOPT_POSTFIELDS,
"url=https://audd.tech/example.mp3&return=apple_music,spotify&api_token=your-api-token");
curl_easy_perform(c); /* response goes to stdout by default */curl_easy_cleanup(c);

# CMakeadd_subdirectory(audd-c)
target_link_libraries(your_appPRIVATEaudd)

#include<audd.h>audd_client_t*client=audd_client_new("your-api-token", NULL);
constchar*want[] = { "apple_music", "spotify", NULL };
audd_recognize_options_topts= { .return_metadata=want };
audd_recognition_t*r=NULL;
if (audd_recognize(client, "https://audd.tech/example.mp3", &opts, &r) ==AUDD_OK&&r) {
printf("%s — %s\n", audd_recognition_artist(r), audd_recognition_title(r));
constaudd_apple_music_t*am=audd_recognition_apple_music(r);
constaudd_spotify_t*sp=audd_recognition_spotify(r);
if (am) printf("Apple Music: %s\n", audd_apple_music_get_url(am));
if (sp) printf("Spotify URI: %s\n", audd_spotify_get_uri(sp));
audd_recognition_free(r);
}
audd_client_free(client);

CURL *c = curl_easy_init();
curl_easy_setopt(c, CURLOPT_URL, "https://api.audd.io/");
curl_easy_setopt(c, CURLOPT_POSTFIELDS,
"url=https://audd.tech/example.mp3&return=apple_music,spotify&api_token=your-api-token");
curl_easy_perform(c);
curl_easy_cleanup(c);

# CMakeadd_subdirectory(audd-cpp)
target_link_libraries(your_appPRIVATEaudd::audd)

#include<audd/audd.hpp>
audd::AudD client("your-api-token");
audd::RecognizeOptions opts;
opts.return_metadata = {"apple_music", "spotify"};
if (auto result = client.recognize("https://audd.tech/example.mp3", opts)) {
std::cout << result->artist << " — " << result->title << "\n";
if (result->apple_music) std::cout << "Apple Music: " << result->apple_music->url << "\n";
if (result->spotify) std::cout << "Spotify URI: " << result->spotify->uri << "\n";
}

Same call, just point at a local path. SDKs that auto-detect treat strings as URL-or-path; SDKs that take an explicit Source accept a file variant.

curl https://api.audd.io/ \
-F file=@/path/to/audio.mp3 \
-F return='apple_music,spotify' \
-F api_token='your-api-token'

importrequestswithopen("audio.mp3", "rb") asf:
r=requests.post("https://api.audd.io/",
data={"return": "apple_music,spotify", "api_token": "your-api-token"},
files={"file": f},
).json()
ifr["status"] =="success"andr["result"]:
s=r["result"]
print(f"{s['artist']} — {s['title']}")
print(s["apple_music"]["url"])

result=audd.recognize("audio.mp3", return_metadata=["apple_music", "spotify"])
print(f"{result.artist} — {result.title}")
print(result.apple_music.url)

import{readFileSync}from"node:fs";constform=newFormData();form.append("file",newBlob([readFileSync("audio.mp3")]));form.append("return","apple_music,spotify");form.append("api_token","your-api-token");constres=awaitfetch("https://api.audd.io/",{method: "POST",body: form});const{ status, result }=awaitres.json();if(status==="success"&&result){console.log(`${result.artist} — ${result.title}`);console.log(result.apple_music.url);}

constsong=awaitaudd.recognize("./audio.mp3",{returnMetadata: ["apple_music","spotify"],});if(song)console.log(`${song.artist} — ${song.title}`,song.appleMusic?.url);

import (
"bytes""io""mime/multipart""net/http""os"
)
f, _:=os.Open("audio.mp3")
deferf.Close()
varbuf bytes.Bufferw:=multipart.NewWriter(&buf)
fw, _:=w.CreateFormFile("file", "audio.mp3")
io.Copy(fw, f)
w.WriteField("return", "apple_music,spotify")
w.WriteField("api_token", "your-api-token")
w.Close()
resp, _:=http.Post("https://api.audd.io/", w.FormDataContentType(), &buf)
deferresp.Body.Close()
// parse resp.Body as JSON, same shape as the URL example

result, _:=client.Recognize("/path/to/audio.mp3", &audd.RecognizeOptions{
ReturnMetadata: "apple_music,spotify",
})
fmt.Printf("%s — %s\n%s\n", result.Artist, result.Title, result.AppleMusic.URL)

let part = reqwest::multipart::Part::file("audio.mp3").await?;let form = reqwest::multipart::Form::new().part("file", part).text("return","apple_music,spotify").text("api_token","your-api-token");let r: serde_json::Value = reqwest::Client::new().post("https://api.audd.io/").multipart(form).send().await?
.json().await?;

use audd::RecognizeOptions;let return_metadata = ["apple_music".into(),"spotify".into()];ifletSome(r) = audd
.recognize_with("audio.mp3",RecognizeOptions{return_metadata:Some(&return_metadata), ..Default::default()},).await?
{println!("{} — {}", r.artist, r.title);}

$ch = curl_init('https://api.audd.io/');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => [
'file' => newCURLFile('audio.mp3'),
'return' => 'apple_music,spotify',
'api_token' => 'your-api-token',
],
]);
$r = json_decode(curl_exec($ch), true);
curl_close($ch);
if ($r['status'] === 'success' && $r['result']) {
echo"{$r['result']['artist']} — {$r['result']['title']}\n";
echo$r['result']['apple_music']['url'] . "\n";
}

$result = $audd->recognize('audio.mp3', return_metadata: ['apple_music', 'spotify']);
echo"{$result->artist} — {$result->title}\n";
echo$result->apple_music->url, "\n";

letboundary=UUID().uuidString
letcrlf="\r\n"letfileData=tryData(contentsOf:URL(fileURLWithPath:"audio.mp3"))varbody=Data()
body.append("--\(boundary)\(crlf)Content-Disposition: form-data; name=\"file\"; filename=\"audio.mp3\"\(crlf)Content-Type: audio/mpeg\(crlf)\(crlf)".data(using:.utf8)!)
body.append(fileData)
body.append("\(crlf)--\(boundary)\(crlf)Content-Disposition: form-data; name=\"return\"\(crlf)\(crlf)apple_music,spotify\(crlf)--\(boundary)\(crlf)Content-Disposition: form-data; name=\"api_token\"\(crlf)\(crlf)your-api-token\(crlf)--\(boundary)--\(crlf)".data(using:.utf8)!)varreq=URLRequest(url:URL(string:"https://api.audd.io/")!)
req.httpMethod ="POST"
req.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField:"Content-Type")let(data, _)=tryawaitURLSession.shared.upload(for: req, from: body)

letfile=URL(fileURLWithPath:"audio.mp3")guardlet result =tryawait audd.recognize(.file(file),
returnMetadata:["apple_music","spotify"])else{return}print("\(result.artist ??"?") — \(result.title ??"?")")print(result.appleMusic?.url ??"")

val body =MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart(
"file", "audio.mp3",
File("audio.mp3").asRequestBody("audio/mpeg".toMediaType())
)
.addFormDataPart("return", "apple_music,spotify")
.addFormDataPart("api_token", "your-api-token")
.build()
val response =OkHttpClient().newCall(
Request.Builder().url("https://api.audd.io/").post(body).build()
).execute()
println(response.body?.string())

importio.audd.Sourceval result = audd.recognize(
Source.FilePath(File("audio.mp3")),
returnMetadata =listOf("apple_music", "spotify"),
)
result?.let { println("${it.artist} — ${it.title}${it.appleMusic?.get("url")}") }

usingvarhttp=newHttpClient();usingvarform=newMultipartFormDataContent();form.Add(newStreamContent(File.OpenRead("audio.mp3")),"file","audio.mp3");form.Add(newStringContent("apple_music,spotify"),"return");form.Add(newStringContent("your-api-token"),"api_token");varresponse=awaithttp.PostAsync("https://api.audd.io/",form);Console.WriteLine(awaitresponse.Content.ReadAsStringAsync());

varresult=awaitaudd.RecognizeAsync("/path/to/audio.mp3",returnMetadata:new[]{"apple_music","spotify"});Console.WriteLine($"{result?.Artist} — {result?.Title}{result?.AppleMusic?.Url}");

varboundary = "----" + UUID.randomUUID();
varcrlf = "\r\n";
varfileBytes = Files.readAllBytes(Path.of("audio.mp3"));
varhead = ("--" + boundary + crlf
+ "Content-Disposition: form-data; name=\"file\"; filename=\"audio.mp3\"" + crlf
+ "Content-Type: audio/mpeg" + crlf + crlf).getBytes();
vartail = (crlf + "--" + boundary + crlf
+ "Content-Disposition: form-data; name=\"return\"" + crlf + crlf
+ "apple_music,spotify" + crlf
+ "--" + boundary + crlf
+ "Content-Disposition: form-data; name=\"api_token\"" + crlf + crlf
+ "your-api-token" + crlf
+ "--" + boundary + "--" + crlf).getBytes();
varbody = newByteArrayOutputStream();
body.write(head); body.write(fileBytes); body.write(tail);
varreq = HttpRequest.newBuilder(URI.create("https://api.audd.io/"))
.header("Content-Type", "multipart/form-data; boundary=" + boundary)
.POST(BodyPublishers.ofByteArray(body.toByteArray()))
.build();
System.out.println(HttpClient.newHttpClient().send(req, BodyHandlers.ofString()).body());

importjava.nio.file.Path;
varr = audd.recognize(
Path.of("audio.mp3"),
RecognizeOptions.builder()
.returnMetadata("apple_music", "spotify")
.build()
);
System.out.println(r.artist() + " — " + r.title());

CURL*c=curl_easy_init();
curl_easy_setopt(c, CURLOPT_URL, "https://api.audd.io/");
curl_mime*form=curl_mime_init(c);
curl_mimepart*p;
p=curl_mime_addpart(form); curl_mime_name(p, "file"); curl_mime_filedata(p, "audio.mp3");
p=curl_mime_addpart(form); curl_mime_name(p, "return"); curl_mime_data(p, "apple_music,spotify", CURL_ZERO_TERMINATED);
p=curl_mime_addpart(form); curl_mime_name(p, "api_token"); curl_mime_data(p, "your-api-token", CURL_ZERO_TERMINATED);
curl_easy_setopt(c, CURLOPT_MIMEPOST, form);
curl_easy_perform(c);
curl_mime_free(form);
curl_easy_cleanup(c);

constchar*want[] = { "apple_music", "spotify", NULL };
audd_recognize_options_topts= { .return_metadata=want };
audd_recognition_t*r=NULL;
audd_recognize(client, "/path/to/audio.mp3", &opts, &r);

CURL *c = curl_easy_init();
curl_easy_setopt(c, CURLOPT_URL, "https://api.audd.io/");
curl_mime *form = curl_mime_init(c);
auto *p = curl_mime_addpart(form);
curl_mime_name(p, "file");
curl_mime_filedata(p, "audio.mp3");
for (auto [name, value] : {
std::pair{"return", "apple_music,spotify"},
std::pair{"api_token", "your-api-token"},
}) {
p = curl_mime_addpart(form);
curl_mime_name(p, name);
curl_mime_data(p, value, CURL_ZERO_TERMINATED);
}
curl_easy_setopt(c, CURLOPT_MIMEPOST, form);
curl_easy_perform(c);
curl_mime_free(form);
curl_easy_cleanup(c);

audd::RecognizeOptions opts;
opts.return_metadata = {"apple_music", "spotify"};
auto result = client.recognize("/path/to/audio.mp3", opts);

{
"status": "success",
"result": {
"artist": "Imagine Dragons",
"title": "Warriors",
"album": "Warriors",
"release_date": "2014-09-18",
"label": "Universal Music",
"timecode": "02:32",
"song_link": "https://lis.tn/Warriors",
"apple_music": { "url": "https://music.apple.com/...", "previews": [...], "...": "..." },
"spotify": { "uri": "spotify:track:...", "external_urls": { "spotify": "https://open.spotify.com/..." }, "...": "..." }
}
}

When result is null, no match was found. The timecode field is the position within the original song where your clip was playing. The apple_music and spotify blocks are present only when included in return=.

WebSocket variant: Connect to wss://api.audd.io/ws/?api_token=[token] and stream multiple files (binary) without waiting for responses — useful for high-throughput pipelines.

The enterprise endpoint accepts files of any length — hours-long DJ mixes, full radio recordings, video files — and returns every recognized track with timestamps.

Requests are counted as 1 per 12 seconds of audio. Use skip and every to control cost.

Parameters:

Cost example:skip=4&every=1 scans 12s then skips 48s → 1 request per minute of audio. skip=9&every=1 → 1 request per 2 minutes.

curl https://enterprise.audd.io/ \
-F url='https://audd.tech/djatwork_example.mp3' \
-F accurate_offsets='true' \
-F limit='1' \
-F api_token='your-api-token'

r=requests.post("https://enterprise.audd.io/", data={
"url": "https://audd.tech/djatwork_example.mp3",
"accurate_offsets": "true",
"limit": "1",
"api_token": "your-api-token",
}).json()
forchunkinr.get("result", []):
forsonginchunk["songs"]:
print(f"[{chunk['offset']}] {song['artist']} — {song['title']} (score: {song['score']})")

formatchinaudd.recognize_enterprise(
"https://audd.tech/djatwork_example.mp3",
accurate_offsets=True, limit=1,
):
print(f"[{match.offset}] {match.artist} — {match.title} ({match.score})")

constr=awaitfetch("https://enterprise.audd.io/",{method: "POST",body: newURLSearchParams({url: "https://audd.tech/djatwork_example.mp3",accurate_offsets: "true",limit: "1",api_token: "your-api-token",}),}).then(r=>r.json());for(constchunkofr.result??[]){for(constsofchunk.songs){console.log(`[${chunk.offset}] ${s.artist} — ${s.title} (${s.score})`);}}

constmatches=awaitaudd.recognizeEnterprise("https://audd.tech/djatwork_example.mp3",{accurateOffsets: true,limit: 1},);for(constmofmatches){console.log(`[${m.offset}] ${m.artist} — ${m.title}`);}

Every SDK exposes the same enterprise recognition under each language's naming conventions (recognize_enterprise, recognizeEnterprise, RecognizeEnterprise, etc.) — see the per-language docs.

Monitor radio stations, Twitch broadcasts, YouTube live streams, and any audio stream in real time. You provide stream URLs, AudD monitors them continuously, and delivers recognition results via webhook callbacks or longpoll.

Pricing: $45/stream/month with AudD's catalog, or $25/stream/month with your own catalog only.

1. Set your callback URL:

curl https://api.audd.io/setCallbackUrl/ \
-F url='https://yourserver.com/audd-webhook' \
-F api_token='your-api-token'

If you don't have a server, use https://audd.tech/empty/ as the callback and pull results via longpoll instead.

2. Add streams:

# Radio / Icecast / HLS / DASH
curl https://api.audd.io/addStream/ \
-F url='https://npr-ice.streamguys1.com/live.mp3' \
-F radio_id='3249' \
-F api_token='your-api-token'# Twitch channel
curl https://api.audd.io/addStream/ \
-F url='twitch:monstercat' \
-F radio_id='5513' \
-F api_token='your-api-token'# YouTube live (video or channel)
curl https://api.audd.io/addStream/ \
-F url='youtube:5qap5aO4i9A' \
-F api_token='your-api-token'

3. Receive results at your callback URL:

{
"status": "success",
"result": {
"radio_id": 7,
"timestamp": "2020-04-13 10:31:43",
"play_length": 111,
"results": [{
"artist": "Alan Walker, A$AP Rocky",
"title": "Live Fast (PUBGM)",
"score": 100,
"song_link": "https://lis.tn/LiveFastPUBGM"
}]
}
}

By default callbacks fire when a song finishes playing. Pass callbacks=before on addStream to fire when a song starts instead.

As an alternative to callbacks, pull results via longpoll:

https://api.audd.io/longpoll/?category=[longpoll_category]&timeout=50&since_time=[timestamp]

Get longpoll_category from /getStreams/. Or embed a live now-playing widget:

https://widget.audd.tech/?ch=-[longpoll_category]&background&history&shadow

Every official SDK exposes a longpoll consumer that handles the timestamp bookkeeping for you — see the per-SDK docs.

Fingerprint your own tracks so future recognition calls match against them. Useful for proprietary catalogs, sound effects, voice samples, or audio you can't share with general-purpose music databases.

Access is granted per-account — email api@audd.io to request it. Once enabled, every SDK has a custom_catalog.add() (or equivalent) method for uploading tracks.

Full error catalog at docs.audd.io.

• Audio length: the standard endpoint expects a short clip — a few seconds is enough, longer is better than shorter. For files with multiple songs in them, use the enterprise endpoint instead.
• Provider links: specify return=apple_music,spotify,deezer,napster,musicbrainz to attach those services' track URLs and IDs to the response.
• Enterprise cost: use skip and every to sample long files instead of scanning every chunk; set limit=1 if you only need one match per chunk.

• API dashboard — get your token, manage billing, configure streams
• Full documentation — complete API reference
• audd-chrome-extension — recognize music in any browser tab
• RedditBot — music recognition bot for Reddit
• DiscordBot — identify music in Discord channels (Go)
• Code examples on GitHub — community uses

• API tokens & billing:dashboard.audd.io
• Documentation:docs.audd.io
• Email:api@audd.io
• Custom terms — >500k requests/month, >100 simultaneous streams, or enterprise account for ISRC/UPC metadata: api@audd.io