Qobuz APIqobuz.com ↗
Access Qobuz music catalog data: search albums, tracks, and artists, browse new releases, fetch charts, and retrieve label profiles with tracklists.
What is the Qobuz API?
This API exposes 7 endpoints covering the Qobuz music catalog, giving you structured access to album details, artist profiles, track metadata, new releases, and best-seller charts. The search_music endpoint returns paginated results across albums, tracks, and artists, while get_album delivers a full tracklist with per-track duration, performer credits, and editorial description. Response objects include genre, label, release date, and cover art URLs.
curl -X GET 'https://api.parse.bot/scraper/98acea9c-2084-49d3-a688-c77d0b858f35/search_music?page=1&type=albums&query=radiohead' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace qobuz-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Qobuz SDK — bounded, re-runnable; every call capped."""
from parse_apis.Qobuz_Music_API import Qobuz, SearchType, NotFound
client = Qobuz()
# Search for albums by query — limit= caps TOTAL items fetched.
for album in client.album_summaries.search(query="radiohead", type=SearchType.ALBUMS, limit=3):
print(album.title, album.artist, album.release_date)
# Drill-down: take ONE album summary, then fetch its full details.
hit = client.album_summaries.search(query="radiohead", type=SearchType.ALBUMS, limit=1).first()
if hit:
full = hit.details()
print(full.title, full.genre, full.label, full.duration)
for track in full.tracklist[:3]:
print(f" {track.track_number}. {track.title} ({track.duration}s)")
# Get a label's upcoming releases with rich tracklist data
label = client.labels.get(id="9322146")
print(label.name, label.albums_count, f"upcoming: {label.upcoming_total}")
for release in label.upcoming_releases[:3]:
print(release.title, release.artist, release.release_date)
for t in release.tracklist[:2]:
print(f" {t.track_number}. {t.title} ({t.duration}s)")
# Charts — top sellers
for entry in client.chart_entries.browse(genre_id="112", limit=3):
print(f"#{entry.rank}", entry.title, entry.artist)
# Typed error: wrap a fallible get call.
try:
detail = client.albums.get(id="0634904032432")
print(detail.title, detail.artist)
except NotFound as e:
print(f"not found: {e}")
print("exercised: album_summaries.search / .details / labels.get / chart_entries.browse / albums.get")
Full-text search across the Qobuz catalog. Returns albums, tracks, or artists matching the query. Results are paginated with 20 items per page.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination (1-based). |
| typerequired | string | Type of content to search for. |
| queryrequired | string | Search query text. |
{
"type": "object",
"fields": {
"page": "current page number",
"type": "search type used",
"items": "array of search results (shape varies by type)",
"query": "echoed search query",
"total": "total number of results available"
},
"sample": {
"data": {
"page": 1,
"type": "albums",
"items": [
{
"id": "0634904032432",
"genre": "Alternative & Indie",
"label": "XL Recordings",
"title": "In Rainbows",
"artist": "Radiohead",
"duration": 2554,
"release_date": "2007-10-10",
"tracks_count": 10,
"cover_image_url": "https://static.qobuz.com/images/covers/32/24/0634904032432_600.jpg"
}
],
"query": "radiohead",
"total": 1000
},
"status": "success"
}
}About the Qobuz API
Catalog Lookup
The get_album endpoint returns up to 15 fields per album including tracklist (an array of objects with track_number, media_number, title, duration, and performers), label, genre, release_date, description (HTML editorial copy), and tracks_count. The get_track endpoint narrows to a single track and adds previewable — a boolean indicating whether a sample is available — along with album_id for cross-referencing. get_artist returns a discography array of up to 25 album summaries per page, a bio field, and an image_url.
Search and Discovery
The search_music endpoint accepts a query string and a required type parameter (album, track, or artist), returning paginated results with a total count. Browse new releases with browse_new_releases, which supports three optional filters: genre_id (e.g. '112' for Pop/Rock, '80' for Jazz), a label string for case-insensitive partial matching, and a label_id for exact label filtering. get_charts returns the current best-seller album chart with per-entry rank fields, optionally filtered by genre_id.
Label Profiles and Upcoming Releases
The get_label endpoint retrieves a label's name, description, image_url, and full albums_count alongside paginated upcoming_releases — albums with future release dates sorted by nearest date first. Each upcoming release is enriched with full album metadata including tracklist, duration, and tracks_count. Note that cost scales with the number of upcoming albums on the page since each is fetched individually. The endpoint accepts either a numeric label_id or a full Qobuz label URL.
The Qobuz API is a managed, monitored endpoint for qobuz.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when qobuz.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official qobuz.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a new-release tracker filtered by genre and record label using
browse_new_releaseswithgenre_idandlabelparams - Populate a music database with full tracklists and performer credits via
get_album - Monitor upcoming release schedules for specific record labels using
get_labelupcoming_releases - Display current best-seller charts by genre for a music editorial site using
get_charts - Cross-reference track metadata with streaming data by fetching
previewableandperformersfromget_track - Build an artist discography page with biography and cover art using
get_artistdiscography andimage_urlfields - Drive music search autocomplete or catalog search with paginated results from
search_music
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Qobuz have an official developer API?+
What does `get_label` return, and why does it cost more per page?+
get_label returns the label's profile fields (name, description, image_url, albums_count) plus a paginated list of upcoming (future-dated) releases. Each upcoming album in the list is enriched with full album detail — including tracklist, duration, and tracks_count — so the number of individual album fetches scales with the page size (up to 20 albums per page).Can I retrieve streaming URLs or full audio for tracks?+
previewable boolean. You can fork the API on Parse and revise it to add an endpoint if your use case requires different output fields.Does the search endpoint support filtering by genre or release year?+
search_music accepts only query, type, and page — there are no genre, year, or label filters on the search endpoint itself. Filtering by genre is available on browse_new_releases and get_charts via the genre_id parameter. You can fork the API on Parse and revise it to add filtered search behavior.How many albums does `get_artist` return in the discography, and can I paginate it?+
get_artist returns up to 25 album summaries per call in the discography array. The current endpoint does not expose a page parameter for the discography. The albums_count field tells you the total number of albums on the artist profile. You can fork the API on Parse and revise it to add pagination over the full discography.