---
title: "AudD for live-streaming platforms"
description: "How platforms that host live video for creators, shopping, fitness, education, events, and gaming use AudD audio streams to know what music played on each channel, drive now-playing overlays, keep music-use logs, flag streams for review, and check replays before publishing."
slug: "/resources/for/live-streaming-platforms"
section: "for"
keywords: [audd, live streaming platform, live shopping, fitness classes, music monitoring, now playing, music log, moderation, replay, hls]
---

# AudD for live-streaming platforms

This page is for teams that operate live video for other people: creator
channels, live shopping, fitness and dance classes, online courses, ticketed
events, gaming. Many channels go live and offline at once, and recorded music
ends up in them: a playlist under a workout class, a track behind a product
demo, a song in a gaming stream. AudD's audio streams API recognizes songs in
a live HLS stream and tells your server which recording played on which
channel. Pair it with the enterprise endpoint to check the recording before it
becomes a replay.

If you are an individual streamer rather than a platform, see
[AudD for Twitch streamers](/resources/for/twitch-streamers).

## What you can do

### Know what music played on each channel

When a channel goes live, your backend calls `addStream` with the channel's
HLS playback URL and a `radio_id`, an integer you map to that channel. AudD
pulls the stream, recognizes the songs, and POSTs each match to one callback
URL for your whole account. Every match carries the `radio_id`, so your
receiver knows which channel it came from. When the broadcast ends, you call
`deleteStream`.

This works with any host that gives you an HLS URL and a "went live / ended"
signal: Amazon IVS state-change events through EventBridge, Mux live-stream
webhooks, Cloudflare Stream live-input notifications, or your own media
server's publish hooks.

### Show viewers what's playing

Pass `callbacks="before"` when you add a stream and the match arrives when a
song starts, not when it ends. Cache the latest match per channel and
render it in your player. A song's `song_link` with `?thumb` appended gives you
cover art. Each stream also has a `longpoll_category` you can give to a
frontend so it can read results without your API token.

### Keep a music-use log per channel

Store each match with the channel, the time, and the artist, title, album, and
label. With the default callback timing (at song end) the match also carries
`play_length`, the seconds the song played. A per-channel log gives you facts
to bring to a licensing conversation: which recordings appeared, on which
channels, how often. ISRC and UPC are available on request (see
[the streams docs](https://docs.audd.io/streams)) and need a Startup plan or
higher.

### Flag streams for review

Your platform decides what a match means. A fitness class on a "no recorded
music" policy and a DJ channel with a venue licence need different rules.
Route matches to a review queue, notify the creator, or have your player mute
the audio, according to each channel's policy. AudD only reports what it
recognized. It doesn't act on the stream.

### Check replays before publishing

After a broadcast, extract the recording's audio and send it to the enterprise
endpoint (`https://enterprise.audd.io/`). It returns every recognized segment
with its position in the file, so you can publish, edit, or hold the replay.
Enterprise bills one request per 12 seconds of audio processed. Set `limit` on
every call, and use `every`/`skip` to sample when a yes/no answer is enough.

## How the pieces map to your needs

| Need | AudD piece | Notes |
|---|---|---|
| Which songs played on each live channel | Audio streams: `addStream` / `deleteStream`, results by callback | One account-wide callback URL; route by `radio_id` |
| Now-playing overlay | Streams with `callbacks="before"`; `song_link?thumb` for cover art | Or the hosted widget at `widget.audd.tech` via `longpoll_category` |
| Music-use log with durations | Streams with default callback timing (`play_length`) | `label` is the releasing label, not necessarily the rights owner |
| Moderation flags | Your rules on top of each match, plus `score` | See [score thresholds](/resources/concepts/score-thresholds) |
| Replay check | Enterprise endpoint on the recorded audio, with `limit` | Returns file positions you can mute or cut |
| Streams on Twitch or YouTube instead of your own host | `twitch:<channel>`, `youtube:<id>`, `youtube-ch:<id>` shortcuts | No HLS URL needed |

## Things to plan for

- **Concurrency, not channel count.** The [streams docs](https://docs.audd.io/streams)
  have you set a maximum number of concurrent streams on the dashboard. What
  you size is how many channels are live at once. Decide what happens when a
  go-live would exceed it, and consider monitoring only channels where music
  matters. Prices are on the streams docs page. For platform volumes, email
  api@audd.io.
- **Callback rate.** With fewer than 500 streams, AudD sends at most 3
  callbacks per second (burst 15). Beyond that, callbacks queue and arrive
  late. Estimate your peak from concurrent channels and how often songs
  change.
- **Playback URLs AudD can reach.** AudD fetches the URL from its servers for
  the whole broadcast. Signed or expiring URLs, origin-bound tokens, IP
  allowlists, and cookies can all break that. Test with a real broadcast, and
  swap in a fresh URL with `setStreamUrl` if yours expire.
- **Latency.** Measure it on your own streams: the time from a song starting to
  your callback arriving. This page doesn't quote a number.
- **Private channels.** Decide whether sending a private class's or event's
  audio to a third party fits your terms and privacy policy.

## What AudD doesn't do

- It doesn't mute, block, or take down streams or replays. Your platform does.
- It doesn't license music, name rights holders, or say whether a use is
  permitted. A match tells you which recording played.
- It matches recorded music. Covers, live performances of a song, humming, and
  AI-generated soundalikes are not what it detects.
- It doesn't look at video. It can't spot a restream of someone else's video
  by its picture.
- Using it doesn't make a platform compliant with any law or platform rule.

## Where to start

1. **[Monitor your users' live streams for music](/resources/integrations/live-stream-platforms)**
   is the build: the IVS, Mux, and Cloudflare Stream events to listen for,
   a FastAPI handler that adds and removes streams, the callback receiver that
   routes by `radio_id`, `radio_id` allocation, signed URLs, sizing, and the
   replay scan.
2. **[Flag and remove music in a live-event recording](/resources/recipes/flag-music-in-live-recording)**
   turns enterprise matches into a report and a muted or cut copy of the
   recording.
3. **[How to identify music in live audio streams using an API](/resources/articles/identify-music-in-live-audio-streams)**
   covers the streams model in general: callbacks, longpoll, formats,
   reliability.
4. **[Show recognized music on a Twitch stream](/resources/integrations/twitch-extension)**
   shows the viewer-facing side if some of your creators also stream to
   Twitch.

## Code teaser

When the host says a channel went live, start monitoring it. Every match then
arrives at your one callback URL, tagged with that channel's `radio_id`.

```python
from audd import AudD

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

# Once, at deploy time: where AudD POSTs every match on the account.
audd.streams.set_callback_url("https://live.example.com/audd/your-secret-path")

# On "stream started" (IVS Stream Start, Mux video.live_stream.active, ...):
audd.streams.add(
    url="https://stream.mux.com/PLAYBACK_ID.m3u8",  # the channel's HLS playback URL
    radio_id=4182,                                   # your channel's permanent integer ID
    callbacks="before",                              # match at song start
)

# On "stream ended" (IVS Stream End, Mux video.live_stream.idle, ...):
audd.streams.delete(radio_id=4182)
```

The callback receiver reads each POST with
`audd.streams.handle_callback(request)`, which returns a match (with
`radio_id`, `timestamp`, and `song.artist` / `song.title` / `song.label` /
`song.song_link`) or a stream-health notification (`650` can't connect, `651`
no music). The [integration guide](/resources/integrations/live-stream-platforms)
has the full receiver.

---

**Related**

- [Monitor your users' live streams for music](/resources/integrations/live-stream-platforms)
- [AudD for video platforms and UGC moderation](/resources/for/video-platforms)
- [AudD for Twitch streamers](/resources/for/twitch-streamers)
- [Webhook callbacks vs longpoll for stream results](/resources/concepts/callback-vs-longpoll)
- [Agent notes: streams and longpoll](/resources/agents/streams)
- [Streams API reference](https://docs.audd.io/streams)

## Sitemap

See the [resources sitemap](https://audd.io/resources/sitemap.md) for every guide and the [glossary](https://audd.io/resources/reference/glossary.md) for AudD terms.