How to Scrape Deezer Tracks, Artists & Albums in 2026

Deezer runs a public JSON API that most people never notice — the same one the site’s own front end calls. It’s genuinely keyless: no OAuth dance, no token expiry, no account. That makes it one of the cleanest music-metadata sources available, but the raw API still hands you one page of results at a time, buries the fields you want in nested objects, and makes you stitch together separate endpoints to go from a search hit to a full artist catalog. This guide covers how api.deezer.com is structured, how to page through it in bulk, and what a clean per-track record looks like.

What’s worth extracting

Each row is one track (or one artist/album in the search and chart modes), with up to 15 fields:

• Identity — id (Deezer’s unique ID), title (track title, or artist/album name in non-track modes), type (track, artist, or album).
• Credits — artist (display name), artistId, album (title), albumId.
• Track detail — duration (seconds), explicit_lyrics ("true" / "false"), releaseDate (album release date, YYYY-MM-DD).
• Popularity — rank (Deezer’s own popularity score — higher is more popular) and position (chart position, in chart mode).
• Media & links — preview (direct URL to a 30-second MP3 clip), cover (album art, 250×250), link (the Deezer page URL).

For genre or catalog analysis you need id, title, artist, duration and rank. For building an audio demo dataset, the preview URL is the field that matters.

How the Deezer API works

The actor calls api.deezer.com and exposes four modes, each mapping to a Deezer endpoint. Pagination is uniform: index-based, batching up to 100 results per call, looping until maxResults (max 2,000) is hit.

Search mode queries by keyword, with searchType selecting tracks, artists or albums:

{
  "mode": "search",
  "query": "eminem",
  "searchType": "track",
  "maxResults": 200
}

Chart mode returns Deezer’s live global rankings — searchType: "track" gives you the global top tracks list, refreshed daily by Deezer:

{
  "mode": "chart",
  "searchType": "track",
  "maxResults": 100
}

artistDetail and albumTracks drill by Deezer ID. Pass a list of artist IDs to pull each artist’s top catalog, or album IDs to list every track in an album:

{
  "mode": "artistDetail",
  "ids": [13],
  "maxResults": 500
}

The natural workflow is to chain them: run a search with searchType: "artist" to discover artistId values, then feed those IDs into artistDetail for full catalogs. Album IDs from a search feed albumTracks the same way.

Which mode for which job

Each mode answers a different question, and mixing them well is where the real coverage comes from:

• search answers “what matches this keyword?” — the broadest entry point. Set searchType to track, artist or album depending on what you’re after. Track search has by far the largest index, so it returns the widest result sets.
• chart answers “what’s popular right now?” — Deezer’s live global rankings, refreshed daily. Pair it with searchType: "track" for the global top tracks; run it on a schedule to build a chart time-series.
• artistDetail answers “what’s this artist’s catalog?” — pass one or more artistId values and pull each artist’s top tracks. This is how you get depth on a known artist rather than a shallow keyword slice.
• albumTracks answers “what’s on this album?” — pass album IDs and list every track, with consistent album metadata (including a reliable releaseDate) across all tracks.

The discover-then-drill pattern — search to find IDs, then artistDetail or albumTracks to pull complete catalogs — beats a single broad search for building a thorough dataset.

▶ Run the Deezer Music Scraper on Apify — search by keyword, pull the global chart, or drill into an artist or album by ID. Keyless, no login. Export tracks to CSV or JSON.

The access reality

Because the Deezer API is a real public endpoint, this is a low-friction scrape — no browser automation, no anti-bot stack, no residential proxies. Datacenter proxy is enough. The constraints are the API’s own shape rather than active defenses:

• 2,000 results per query is the ceiling. Deezer’s search returns up to 2,000 items per query; the actor paginates to that limit. For a bigger dataset, run multiple queries — different keywords, or the search-then-drill workflow above — and combine the outputs.
• releaseDate is sparse in search results. Deezer’s track-level search doesn’t always include a release date, so releaseDate can be null on search-mode rows. If you need reliable dates, use albumTracks mode — it fetches album metadata separately and populates releaseDate for every track in the album.
• Preview URLs are usually present, occasionally not. Most tracks include a 30-second preview MP3, but a small fraction (typically region-locked content) return an empty preview. Filter for a non-empty preview if your use case depends on the audio.
• Search is fuzzy and case-insensitive. Partial matches work, spelling still matters. A zero-result query exits cleanly with an empty dataset — check the keyword or switch searchType rather than assuming failure.

Everything the actor returns is publicly accessible catalog metadata plus the 30-second preview clips Deezer itself serves — no paywalled content, no user data, no full audio.

Example output

One fully populated track row:

{
  "id": "1109731",
  "title": "Lose Yourself",
  "artist": "Eminem",
  "artistId": "13",
  "album": "Curtain Call: The Hits",
  "albumId": "119606",
  "duration": "326",
  "rank": "980436",
  "explicit_lyrics": "true",
  "preview": "https://cdnt-preview.dzcdn.net/api/1/1/2/7/a/0/27a14827ff1e82c5e40e8b6a934a8637.mp3",
  "link": "https://www.deezer.com/track/1109731",
  "releaseDate": "2005-12-06",
  "cover": "https://cdn-images.dzcdn.net/images/cover/e2b36a9fda865cb2e9ed1476b6291a7d/250x250-000000-80-0-0.jpg",
  "position": "2",
  "type": "track"
}

Schema design for downstream use

When Deezer rows land in your warehouse, a few choices pay off later:

• Cast the string fields on ingest. duration, rank, position and explicit_lyrics all arrive as strings. Convert duration and rank to integers and explicit_lyrics to a boolean at load time so downstream queries don’t fight the types.
• Store id and artistId / albumId as your join keys. Titles and album names collide and change; the Deezer IDs are stable and let you link tracks to artists and albums cleanly.
• Keep rank even if you filter on position. In chart mode position is the slot, but rank is the continuous popularity score — retain it so you can re-sort or compare across queries that aren’t chart-scoped.
• Snapshot the chart with a run timestamp. If you’re tracking chart movement, tag each run with its date on ingest; the API gives you a live snapshot, so the date is the axis of your time-series.

Who uses this

• Music researchers who need bulk metadata on artists, songs or albums for academic or industry studies.
• Playlist curators and music bloggers discovering tracks programmatically by keyword or chart position.
• Data engineers assembling music-recommendation datasets or training data — the preview URL and rank score are both useful features.
• Marketing analysts tracking chart performance over time by running the chart mode on a schedule and diffing rankings.
• App developers integrating a music catalog into a product without maintaining an API key or OAuth flow.
• Quiz and game builders bulk-collecting preview clips plus track metadata for thousands of songs.

Cost and effort: build vs. managed

The Deezer API is free and unauthenticated, so a script is feasible — but the index-based pagination, the null-releaseDate gap that forces an album-metadata lookup, the search-then-drill ID chaining, and normalizing the nested artist/album objects into flat columns all add up. And it’s yours to keep running as Deezer adjusts the API.

The managed actor is pay-per-result: a fraction of a cent per track row plus a trivial start fee. A 500-track search completes in seconds; a full 2,000-result run takes one to two minutes. With no proxy or anti-bot cost, the entire bill is essentially per-row, which makes large music datasets cheap to build and re-build on a schedule.

Common pitfalls

Deezer-specific things to know:

• Chart mode’s popularity is rank, not position alone. position is the chart slot; rank is Deezer’s underlying popularity score. Sort by rank descending to surface the best-known tracks in any result set, chart or search.
• Null releaseDate on search rows is expected. Don’t treat it as an error — switch to albumTracks when you need dates, or accept the gap for track-search work.
• All numeric-looking fields are strings. duration, rank, position and explicit_lyrics come back as strings. Cast them before doing math or boolean logic downstream.
• searchType: "track" has the widest index. Deezer’s track index dwarfs its album and artist indexes — use track search for the largest result sets and drill to artists/albums when you need structure.
• Region-locked previews are empty, not broken. A missing preview usually means the track is geo-restricted, not that the scrape failed.
• This is an independent tool. The scraper is not affiliated with or endorsed by Deezer; it consumes the same public endpoints any browser uses.

Wrapping up

Deezer’s public API is a rare gift — a keyless, browser-grade music-metadata source with a daily-refreshed global chart. The work is in the plumbing: index pagination, flattening nested credits, filling the release-date gap, and chaining search into artist and album drills. If you need a quick lookup, hit the API. If you need bulk track datasets or a chart time-series exported to a spreadsheet, a managed actor carries it for a fraction of a cent per row.

▶ Open the Deezer Music Scraper on Apify — one run yields up to 2,000 tracks with artist, album, duration, rank and 30-second preview URLs, exportable to CSV, Excel or JSON. No API key, no login. Start on Apify’s free monthly credit.