# Deezer Music Catalog Scraper (`parseforge/deezer-music-catalog-scraper`) Actor

Scrape Deezer public music catalog API. Search artists, albums, tracks, playlists with explicit flag, duration, ISRC, release dates, contributors. No API key required.

- **URL**: https://apify.com/parseforge/deezer-music-catalog-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Marketing, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $31.43 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/parseforge-banner.png)

## 🎧 Deezer Music Catalog Scraper

> 🚀 **Search the entire Deezer catalog in seconds.** Pull tracks, artists, albums, playlists, or podcasts with ISRC, BPM, preview URLs, and rich metadata. No API key, no registration, no manual paging.

> 🕒 **Last updated:** 2026-05-12 · **📊 Up to 38 fields** per record · **🎵 100M+ tracks** · **🎤 5 catalog types** · **🌍 180+ countries**

The **Deezer Music Catalog Scraper** queries Deezer's public search API across five resource types (tracks, artists, albums, playlists, podcasts) and returns clean JSON with **up to 38 fields per record**, including image URLs at multiple resolutions, ISRC codes, BPM, audio gain, preview MP3 URLs, contributor lists, available country codes, release dates, fan counts, and ranking scores. The catalog covers more than 100 million tracks across hundreds of millions of albums, with active maintenance for international markets including France, Brazil, Germany, the United States, and the United Kingdom.

The Actor handles pagination, retries, and rate-limit backoff. Toggle `fetchDetails` for track searches and each record gains studio-grade fields (BPM, audio gain, ISRC, available countries, contributors with roles). Eleven sort orders cover ranking, alphabetical, rating, and duration variants so you can land on the exact slice you need without post-processing.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Music-tech engineers, A&R researchers, playlist curators, DJ-software developers, music data scientists, podcast platforms, royalties analysts | Catalog mirroring, ISRC enrichment, BPM and key-feature ML training, podcast discovery, fan-base analytics, preview-clip serving, music recommendation systems |

---

### 📋 What the Deezer Music Catalog Scraper does

Five filtering workflows in a single run:

- 🎵 **Track search.** Full-text across the song catalog with ranking, alphabetical, rating, and duration sorts.
- 🎤 **Artist search.** Pull artists matching your query along with fan counts, album counts, and images.
- 💿 **Album search.** Albums with cover art, release date, contributor list, and track counts.
- 📚 **Playlist search.** Public playlists with creator, track count, and cover image.
- 🎙️ **Podcast search.** Podcast shows with description, image, and share URL.

Each track record can include identifiers (Deezer ID, ISRC), title variants (short and version), audio details (duration, BPM, gain, preview MP3, explicit flags), artist info (ID, name, link), album info (ID, title, cover, release date), and optional contributor and country arrays when `fetchDetails` is enabled.

> 💡 **Why it matters:** the Deezer catalog is one of the largest open music indexes on the web. Building your own mirror means writing custom parsers, paging logic, and back-off handlers. This Actor returns ready-to-load JSON with ISRC for cross-platform matching, BPM for ML, and preview URLs you can stream directly in your app.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded music catalog dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>query</code></td><td>string</td><td><code>"eminem"</code></td><td>Free-text search across the chosen resource type. Deezer search syntax supported.</td></tr>
<tr><td><code>searchType</code></td><td>string</td><td><code>"track"</code></td><td>One of <code>track</code>, <code>artist</code>, <code>album</code>, <code>playlist</code>, <code>podcast</code>.</td></tr>
<tr><td><code>order</code></td><td>string</td><td><code>"RANKING"</code></td><td>Sort order. 11 options including <code>RANKING</code>, <code>RATING_DESC</code>, <code>DURATION_ASC</code>.</td></tr>
<tr><td><code>fetchDetails</code></td><td>boolean</td><td><code>false</code></td><td>When <code>true</code> and search type is <code>track</code>, fetch BPM, gain, ISRC, contributors, and available countries per track. One extra API call per record.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: top 100 tracks matching "rock" by ranking.**

```json
{
    "query": "rock",
    "searchType": "track",
    "order": "RANKING",
    "maxItems": 100
}
````

**Example: artists matching "daft punk" with full detail.**

```json
{
    "query": "daft punk",
    "searchType": "artist",
    "order": "RANKING",
    "fetchDetails": true,
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** preview MP3 URLs are signed and expire after a few hours. Re-run the Actor to refresh links before serving them in production. Available country codes only appear when `fetchDetails` is enabled for tracks.

***

### 📊 Output

Each record contains up to **38 fields** depending on resource type. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://cdn-images.dzcdn.net/images/cover/.../1000x1000-..."` |
| 🆔 `id` | number | `4005499231` |
| 🏷️ `type` | string | `"track"` |
| 🔗 `url` | string | `"https://www.deezer.com/track/4005499231"` |
| 📌 `title` | string | undefined | `"Rock Music"` |
| 📌 `titleShort` | string | undefined | `"Rock Music"` |
| 📌 `titleVersion` | string | undefined | `"(Single Version)"` |
| 🔗 `shareUrl` | string | undefined | `"https://www.deezer.com/track/..."` |
| 👤 `name` | string | undefined | `"Daft Punk"` (artist results) |
| 🔢 `isrc` | string | undefined | `"USAT22601815"` |
| ⏱️ `duration` | number | undefined | `115` (seconds) |
| 📈 `rank` | number | undefined | `974379` |
| 🔞 `explicit` | boolean | undefined | `false` |
| 🔞 `explicitContentLyrics` | number | undefined | `6` |
| 🔞 `explicitContentCover` | number | undefined | `2` |
| 🎵 `preview` | string | undefined | `"https://cdnt-preview.dzcdn.net/.../*.mp3"` |
| 🎵 `bpm` | number | undefined | `120.5` |
| 🎚️ `gain` | number | undefined | `-7.5` |
| 🔢 `trackPosition` | number | undefined | `3` |
| 💿 `diskNumber` | number | undefined | `1` |
| 🌍 `availableCountries` | string\[] | undefined | `["US","FR","GB"]` |
| 👥 `contributors` | array | undefined | `[{"id":1,"name":"...","role":"Main"}]` |
| 📅 `releaseDate` | string | undefined | `"2026-04-12"` |
| 🆔 `artistId` | number | undefined | `1462230` |
| 👤 `artistName` | string | undefined | `"Charli xcx"` |
| 🔗 `artistUrl` | string | undefined | `"https://www.deezer.com/artist/1462230"` |
| 🆔 `albumId` | number | undefined | `977071531` |
| 💿 `albumTitle` | string | undefined | `"Rock Music"` |
| 🔗 `albumUrl` | string | undefined | `"https://www.deezer.com/album/977071531"` |
| 🖼️ `albumCoverBig` | string | undefined | `"https://cdn-images.dzcdn.net/.../500x500-..."` |
| 🔢 `nbTracks` | number | undefined | `12` |
| 👥 `nbFans` | number | undefined | `34500` |
| 🔢 `nbAlbum` | number | undefined | `15` |
| 👥 `fans` | number | undefined | `123` |
| 📅 `creationDate` | string | undefined | `"2024-01-15"` |
| 👤 `user` | string | undefined | `"playlist creator name"` |
| 📝 `description` | string | undefined | `"Podcast description text..."` |
| ✅ `available` | boolean | undefined | `true` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-12T16:30:14.277Z"` |

#### 📦 Sample records

<details>
<summary><strong>🎵 Charli xcx "Rock Music" with ISRC and explicit flags</strong></summary>

```json
{
    "imageUrl": "https://cdn-images.dzcdn.net/images/cover/541d16866655847bdb95125f0d0b14c4/1000x1000-000000-80-0-0.jpg",
    "id": 4005499231,
    "type": "track",
    "url": "https://www.deezer.com/track/4005499231",
    "title": "Rock Music",
    "titleShort": "Rock Music",
    "isrc": "USAT22601815",
    "duration": 115,
    "rank": 974379,
    "explicit": false,
    "explicitContentLyrics": 6,
    "explicitContentCover": 2,
    "preview": "https://cdnt-preview.dzcdn.net/api/1/1/c/d/8/0/cd8dcc997f9924f8525b2b30391fb0bb.mp3",
    "artistId": 1462230,
    "artistName": "Charli xcx",
    "artistUrl": "https://www.deezer.com/artist/1462230",
    "albumId": 977071531,
    "albumTitle": "Rock Music",
    "albumUrl": "https://www.deezer.com/album/977071531",
    "albumCoverBig": "https://cdn-images.dzcdn.net/images/cover/541d16866655847bdb95125f0d0b14c4/500x500-000000-80-0-0.jpg",
    "available": true,
    "scrapedAt": "2026-05-12T16:30:14.277Z"
}
```

</details>

<details>
<summary><strong>🎤 Michael Jackson "Rock with You" with title version metadata</strong></summary>

```json
{
    "imageUrl": "https://cdn-images.dzcdn.net/images/cover/9a1084ee1062fd9cd8dbeb1a8978351d/1000x1000-000000-80-0-0.jpg",
    "id": 15586286,
    "type": "track",
    "url": "https://www.deezer.com/track/15586286",
    "title": "Rock with You (Single Version)",
    "titleShort": "Rock with You",
    "titleVersion": "(Single Version)",
    "isrc": "USSM17900817",
    "duration": 220,
    "rank": 956159,
    "explicit": false,
    "preview": "https://cdnt-preview.dzcdn.net/api/1/1/b/6/c/0/b6c28146ba0e1c1f1cc4b59d02bed47c.mp3",
    "artistId": 259,
    "artistName": "Michael Jackson",
    "artistUrl": "https://www.deezer.com/artist/259",
    "albumId": 1440807,
    "albumTitle": "Off the Wall",
    "albumUrl": "https://www.deezer.com/album/1440807",
    "available": true,
    "scrapedAt": "2026-05-12T16:30:14.278Z"
}
```

</details>

<details>
<summary><strong>🎹 Elton John "Rocket Man" classic with longer duration</strong></summary>

```json
{
    "imageUrl": "https://cdn-images.dzcdn.net/images/cover/56121010d25e75058e2cc817037ad19b/1000x1000-000000-80-0-0.jpg",
    "id": 1144863,
    "type": "track",
    "url": "https://www.deezer.com/track/1144863",
    "title": "Rocket Man (I Think It's Going To Be A Long, Long Time)",
    "titleShort": "Rocket Man (I Think It's Going To Be A Long, Long Time)",
    "isrc": "GBAMB7200006",
    "duration": 283,
    "rank": 825071,
    "explicit": false,
    "artistId": 413,
    "artistName": "Elton John",
    "artistUrl": "https://www.deezer.com/artist/413",
    "albumId": 122698,
    "albumTitle": "Honky Chateau",
    "albumUrl": "https://www.deezer.com/album/122698",
    "available": true,
    "scrapedAt": "2026-05-12T16:30:14.278Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🎵 | **Five catalog types.** Tracks, artists, albums, playlists, and podcasts queried through one consistent interface. |
| 🔢 | **ISRC codes included.** Industry-standard recording identifiers let you join Deezer data with Spotify, Apple Music, and PRO databases. |
| 🎚️ | **Audio features.** BPM and gain available with `fetchDetails`, ready for ML and DJ-software ingestion. |
| 🌍 | **Country availability.** Track-level country whitelist for geo-fenced licensing decisions. |
| 🎵 | **Preview MP3 URLs.** 30-second clips you can stream directly in dashboards and demos. |
| 🔁 | **11 sort orders.** Ranking, alphabetical, rating, and duration variants for precise slicing. |
| 🚫 | **No authentication.** Public Deezer API only. No login or token required. |

> 📊 The Deezer catalog covers 100M+ tracks across 180+ countries with active maintenance for major international markets.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Deezer Music Catalog Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **100M+ tracks** | **Live per run** | 5 types, 11 sorts | ⚡ 2 min |
| Paid streaming-platform APIs | $99+/month | One platform | Streaming | API-defined | ⏳ Hours |
| Legacy community music dumps | Free | Stale subset | Rarely | None | 🐢 Days |
| Manual scraping of music sites | Free | One site at a time | Manual | None | 🐢 Days |

Pick this Actor when you need quick, structured music metadata with ISRC and audio features and no API keys to manage.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Deezer Music Catalog Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a search `query`, pick a `searchType`, optionally toggle `fetchDetails`, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor walk the catalog.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎵 Music-Tech & DJ Software

- BPM-based playlist builders and mixing tools
- Key-feature ingestion for harmonic mixing apps
- ISRC-keyed catalog cross-matching with Spotify
- Preview-clip serving for in-app discovery

</td>
<td width="50%" valign="top">

#### 📊 Music Analytics & A\&R

- Fan-base growth tracking across artists
- Genre and tempo trend analysis
- Cross-platform popularity scoring
- Catalog gap audits for licensing teams

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎙️ Podcast Platforms

- Podcast directory enrichment with cover art
- Search-driven discovery features
- Episode count and refresh tracking
- Cross-platform metadata reconciliation

</td>
<td width="50%" valign="top">

#### 🤖 ML & Recommendations

- Audio-feature training sets for genre models
- Embeddings on track names and descriptions
- Collaborative-filter seed data via fan counts
- Sequence models on playlist order and duration

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Deezer Music Catalog Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly, daily, or weekly refreshes keep music dashboards and recommendation indexes in sync automatically.

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter a search query and pick a search type, click Start, and the Actor hits Deezer's public search API, paginates through the results, and emits a clean structured record per item. Toggle `fetchDetails` for tracks to add BPM, gain, ISRC, contributors, and country availability.

#### 🎵 What's the difference between `searchType` track and album?

`track` returns individual songs with full audio metadata. `album` returns full album records with cover art, release date, and track count. Use `track` for granular catalog work and `album` for release-level analysis.

#### 🔢 What is an ISRC and why does it matter?

ISRC (International Standard Recording Code) is the global identifier for sound recordings. It lets you join the same song across Spotify, Apple Music, Tidal, and royalties databases. Every Deezer track exposes its ISRC.

#### 🎚️ How accurate is BPM?

Deezer derives BPM via audio analysis. It is generally accurate within a few BPM for most genres. For mission-critical DJ-software use, cross-check against your own analysis pipeline.

#### 🔁 How often is the data refreshed?

Deezer's catalog updates continuously. Every run pulls the latest catalog state, so your dataset reflects current records as of run time. Re-run for fresh preview URLs (they expire after a few hours).

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (hourly, daily, weekly) and keep a downstream database in sync.

#### ⚖️ Is this data legal to use?

Deezer publishes its catalog metadata via a public API. Metadata such as titles, artists, ISRC, and durations is generally permissible to use. Audio preview clips remain copyrighted; review Deezer's terms before redistributing them.

#### 💼 Can I use this data commercially?

Metadata can typically be used commercially for analytics, recommendations, and search features. Preview audio and cover art are subject to the licensing terms of each work and Deezer's terms of use. Consult counsel for your specific use case.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Deezer Music Catalog Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe music data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh catalog data into your app backend, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🎵 Spotify Scraper**](https://apify.com/parseforge/spotify-scraper) - Spotify catalog, playlists, and artist data
- [**🎵 Apple Music Scraper**](https://apify.com/parseforge/apple-music-scraper) - Apple Music tracks, artists, and chart data
- [**🎙️ Podcast Index Scraper**](https://apify.com/parseforge/podcast-index-scraper) - Open podcast directory metadata
- [**🎬 SoundCloud Scraper**](https://apify.com/parseforge/soundcloud-scraper) - SoundCloud tracks, artists, and play counts
- [**🎵 MusicBrainz Scraper**](https://apify.com/parseforge/musicbrainz-scraper) - Open music encyclopedia with releases and credits

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more music and media catalog scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Deezer S.A. or any of the artists whose catalog metadata it returns. All trademarks mentioned are the property of their respective owners. Only publicly available catalog metadata is collected.

# Actor input Schema

## `query` (type: `string`):

Free-text search across artists, albums, tracks (Deezer search syntax supported)

## `searchType` (type: `string`):

Which Deezer resource to search

## `order` (type: `string`):

Result ordering

## `fetchDetails` (type: `boolean`):

When searching tracks, fetch each track's BPM, gain, ISRC, available countries, and contributors (1 extra API call per track).

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "query": "eminem",
  "searchType": "track",
  "order": "RANKING",
  "fetchDetails": false,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "eminem",
    "searchType": "track",
    "order": "RANKING",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/deezer-music-catalog-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "eminem",
    "searchType": "track",
    "order": "RANKING",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/deezer-music-catalog-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "eminem",
  "searchType": "track",
  "order": "RANKING",
  "maxItems": 10
}' |
apify call parseforge/deezer-music-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/deezer-music-catalog-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Deezer Music Catalog Scraper",
        "description": "Scrape Deezer public music catalog API. Search artists, albums, tracks, playlists with explicit flag, duration, ISRC, release dates, contributors. No API key required.",
        "version": "0.0",
        "x-build-id": "1NBZzCjaHSAsmZGla"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~deezer-music-catalog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-deezer-music-catalog-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~deezer-music-catalog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-deezer-music-catalog-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~deezer-music-catalog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-deezer-music-catalog-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search across artists, albums, tracks (Deezer search syntax supported)"
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "track",
                            "artist",
                            "album",
                            "playlist",
                            "podcast"
                        ],
                        "type": "string",
                        "description": "Which Deezer resource to search",
                        "default": "track"
                    },
                    "order": {
                        "title": "Sort order",
                        "enum": [
                            "RANKING",
                            "TRACK_ASC",
                            "TRACK_DESC",
                            "ARTIST_ASC",
                            "ARTIST_DESC",
                            "ALBUM_ASC",
                            "ALBUM_DESC",
                            "RATING_ASC",
                            "RATING_DESC",
                            "DURATION_ASC",
                            "DURATION_DESC"
                        ],
                        "type": "string",
                        "description": "Result ordering",
                        "default": "RANKING"
                    },
                    "fetchDetails": {
                        "title": "Fetch full detail (track only)",
                        "type": "boolean",
                        "description": "When searching tracks, fetch each track's BPM, gain, ISRC, available countries, and contributors (1 extra API call per track).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
