# Deezer Scraper - Tracks, Albums, Artists, Playlists & Lyrics (`abotapi/deezer-com-scraper`) Actor

Scrape Deezer by keyword or URL. Extract tracks, albums, artists, playlists, lyrics, radios, charts and public profiles. Get BPM, ISRC, contributors, release dates, availability, full tracklists, artist top tracks and discographies.

- **URL**: https://apify.com/abotapi/deezer-com-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 catalog records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Deezer Scraper: Music Catalog, Tracks, Albums, Artists, Playlists & Charts

Deezer Scraper turns Deezer's music catalog into a clean JSON API. Search tracks, albums, artists, playlists, radios and public user profiles by keyword, read the global or per-genre charts, or paste any Deezer link and get the full record: complete album and playlist track listings, artist top tracks and discographies, per-track BPM, ISRC, contributors and release dates, fan counts, chart positions, and optional lyrics with line and word timing. Export to JSON, CSV or Excel, or pull results straight into your app through the API.

### Why This Scraper?

- **Two ways in.** Search by keyword (six entity types), or paste any Deezer link (track, album, artist, playlist, radio, genre or public profile) and the actor picks the right read.
- **Full track listings, not truncated samples.** Albums and playlists return the collection record plus one row per track, walked across every result page (a 1,075-track playlist was verified to come back complete, not cut at the first hundred).
- **Per-track depth on demand.** In search mode, switch on detail enrichment to add BPM, the full contributor list, ISRC, release date, disk and track positions, and the per-country availability list - billed per track only when you use it.
- **Charts per genre.** Read the global or per-genre charts for tracks, albums, artists or playlists in one run.
- **Lyrics in any mode.** Add plain lyrics, time-synced LRC lines, word-level karaoke timing, songwriters and publishers to every track row, billed only where lyrics were found.
- **Built for schedules.** Incremental mode returns only new and changed records on recurring runs, and a refused run fails loudly instead of returning an empty dataset.

### Use Cases

- **Music analytics:** build catalogs of tracks, albums and artists with popularity rank, fan counts and chart positions for trend research.
- **Playlist monitoring:** walk any public playlist on a schedule and get only the tracks added, removed or reordered since the last run.
- **Catalog enrichment:** attach BPM, ISRC, contributors and release metadata to your own music database.
- **Chart tracking:** follow the global or per-genre charts daily and diff what moved.
- **Content and media tooling:** feed previews, cover art and canonical links into apps, bots or newsletters.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `id` | `"track:3135556"` (prefixed with the entity type so mixed runs stay unique) |
| `deezerType` | `"track"` (also `"album"`, `"artist"`, `"playlist"`, `"user"`, `"radio"`) |
| `title` | `"One More Time"` |
| `url` | Deezer link to the record |
| `durationSec` | `320` |
| `artistName` / `artistId` / `artistUrl` | `"Daft Punk"` / `27` / artist link |
| `artistFans` | `4500000` |
| `albumTitle` / `albumId` / `albumUrl` | `"Discovery"` / `302127` / album link |
| `bpm` / `gain` | `122.7` / `-9.2` (detail enrichment) |
| `isrc` | `"GBDUW0000059"` (detail enrichment) |
| `releaseDate` | `"2001-03-07"` |
| `contributorNames` | `["Daft Punk"]` (detail enrichment) |
| `availableCountries` | `["US", "GB", "DE", ...]` (detail enrichment) |
| `trackIds` / `trackTitles` | the collection's full track listing, in order |
| `collectionContext` | `"Discovery"` (the album or playlist a walked track came from) |
| `genres` | `["Dance", "Electronic"]` |
| `previewUrl` | 30-second MP3 preview |
| `explicitLyrics` | `false` |
| `lyricsStatus` | `"found"`, `"not_found"` or `"failed"` (Include lyrics on; empty otherwise) |
| `lyrics` | full lyrics as plain text |
| `lyricsSynced` | time-synced lyrics in LRC format: `"[00:00.02]Work it, make it\n..."` |
| `lyricsSyncType` | `"word"`, `"line"` or `"none"`: the timing Deezer has for the song |
| `lyricsWords` | word-level timing, per line: `[{"startMs": 9825, "endMs": 13625, "line": "Time stood still", "words": [{"startMs": 9825, "endMs": 9862, "word": "Time"}, ...]}]` (word timing on) |
| `changeType` / `changedFields` / `firstSeenAt` / `lastSeenAt` | incremental mode only |

Album rows also carry `label`, `copyright` and `albumTrackCount`; playlist rows carry `description`, `fans` and `creatorName`; artist rows carry `artistAlbumCount`. Every row records the `sourceQuery` or `chartGenreId` that produced it and `detailFetched`, and lyrics rows add `lyricsWriters` and `lyricsCopyright`.

### How to Use

1. Pick a **mode**: `search` (keyword or charts) or `url` (paste links).
2. Fill in that mode's section: keywords, entity type and charts for search; links and collection depth for URL mode. Filters and sorting apply in both. Switch on detail enrichment if you need BPM, ISRC and contributors on search results.
3. Set **Max records** to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Search for tracks with full detail:**

```json
{
  "mode": "search",
  "queries": ["daft punk"],
  "searchType": "track",
  "fetchDetails": true,
  "maxItems": 50
}
```

**Read the global chart for artists:**

```json
{
  "mode": "search",
  "source": "chart",
  "searchType": "artist",
  "chartGenreId": 0,
  "maxItems": 100
}
```

**Walk a playlist's complete track listing:**

```json
{
  "mode": "url",
  "urls": ["https://www.deezer.com/playlist/3155776842"],
  "maxItems": 500
}
```

**Paste an album and an artist, discography included:**

```json
{
  "mode": "url",
  "urls": [
    "https://www.deezer.com/album/302127",
    "https://www.deezer.com/artist/27"
  ],
  "includeArtistReleases": true
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/deezer-com-scraper").call(run_input={
    "mode": "url",
    "urls": ["https://www.deezer.com/album/302127"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["deezerType"], item["title"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/deezer-com-scraper').call({
    mode: 'search',
    queries: ['daft punk'],
    searchType: 'track',
    fetchDetails: true,
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### What URL mode returns for each link type

| Pasted link | Rows returned |
| --- | --- |
| Track | one fully detailed track row (that read is the fetch itself, so no surcharge) |
| Album | the album row (label, copyright, genres, full track ids/titles) plus one row per track |
| Artist | the artist row plus their top tracks; optionally the full discography (`includeArtistReleases`) |
| Playlist | the playlist row (description, fans, creator, full track ids/titles) plus one row per track, walked across every page |
| Radio | the station row plus its current track list |
| Public user profile | the profile; optionally their public playlists (`includeUserCollections`) |

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run or dataset ID and the actor skips everything already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same scope. Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only after a run that scanned the whole scope, and only with `emitExpired`). `stateKey` names or shares the stored state. With incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped records into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **MCP connectors** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where records should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (keyword or charts) or `url` (paste links). |
| `queries` | array | `["daft punk"]` | Keywords to search (search mode). |
| `searchType` | string | `track` | Restrict a search to `track`, `album`, `artist`, `playlist`, `user` or `radio`. |
| `source` | string | `search` | `search` (keywords) or `chart` (global/per-genre charts). |
| `chartGenreId` | integer | `0` | Genre id for chart mode (`0` = global chart). |
| `urls` | array | sample | Deezer links (url mode): track, album, artist, playlist, radio, genre or public profile. |
| `includeArtistReleases` | boolean | `false` | Artist links also return the full discography. |
| `includeUserCollections` | boolean | `false` | User links also return their public playlists. |
| `excludeExplicit` | boolean | `false` | Drop explicit-flagged records. |
| `minDurationSec` | integer | `0` | Keep records at least this long in seconds (`0` = disabled). |
| `maxDurationSec` | integer | `0` | Keep records at most this long in seconds (`0` = disabled). |
| `sortBy` | string | `relevance` | `relevance` (source order), `title` or `duration`. |
| `fetchDetails` | boolean | `false` | Search mode: read each track's full detail (BPM, ISRC, contributors, availability). Per-track surcharge. |
| `includeLyrics` | boolean | `false` | Any mode: add lyrics, LRC-synced lines, songwriters and publisher to every track row. Charged per track with lyrics found. |
| `lyricsWordTiming` | boolean | `false` | With lyrics on: also return per-word timing in `lyricsWords` (karaoke). No extra charge. |
| `maxItems` | integer | `20` | Stop after this many records (`0` = no limit). |
| `maxPages` | integer | `0` | Max result pages per keyword or link (`0` = no limit). |
| `resumeFromRunId` | string | (none) | Continue one interrupted run. |
| `incrementalMode` | boolean | `false` | Return only new and changed records on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode state. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged records. |
| `emitExpired` | boolean | `false` | Also return (and bill) expired records. |
| `proxy` | object | Apify Proxy | Connection settings. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on records written to each connector per run. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "id": "track:3135556",
  "deezerType": "track",
  "title": "One More Time",
  "url": "https://www.deezer.com/track/3135556",
  "durationSec": 320,
  "explicitLyrics": false,
  "isrc": "GBDUW0000059",
  "previewUrl": "https://cdns-preview-d.dzcdn.net/stream/track.mp3",
  "releaseDate": "2001-03-07",
  "bpm": 122.7,
  "artistId": 27,
  "artistName": "Daft Punk",
  "artistUrl": "https://www.deezer.com/artist/27",
  "artistFans": 4500000,
  "albumId": 302127,
  "albumTitle": "Discovery",
  "albumUrl": "https://www.deezer.com/album/302127",
  "label": "Parlophone (France)",
  "copyright": "(C) 2001 Daft Life Ltd.",
  "genres": ["Dance", "Electronic"],
  "contributorNames": ["Daft Punk"],
  "availableCountries": ["US", "GB", "DE"],
  "collectionContext": null,
  "detailFetched": true,
  "changeType": null,
  "changedFields": [],
  "firstSeenAt": null,
  "lastSeenAt": null
}
```

### Plan Requirement

The default connection setting works out of the box on every plan. The catalog API is open and needs no key; the connection is only there to keep large runs polite.

### FAQ

#### How much does it cost?

You pay per record returned, with track detail enrichment billed only when you switch it on in search mode, and lyrics billed only for tracks where lyrics were found when you switch Include lyrics on. The **Pricing** tab shows the current rates. Use **Max records** to cap the cost of any run.

#### Is it legal to scrape Deezer?

This actor reads Deezer's own public catalog API, which is documented, open and needs no authentication. You are responsible for how you use the data: follow Deezer's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Song recordings, lyrics and artwork can be subject to third-party rights; this actor returns catalog metadata and official preview links, not media files. Lyrics are copyrighted by the publishers listed in `lyricsCopyright`: check you have the rights you need before republishing them.

#### Can I get lyrics?

Yes. Turn on **Include lyrics** and every track row gets its full lyrics, time-synced LRC lines when Deezer has timing (most popular tracks do), the songwriters and the publishers. It works in every mode, including every track of a pasted album or playlist. Lyrics are read in batches, so a 1,000-track playlist adds about 15 seconds. Lyrics are licensed per country: a track Deezer has no lyrics for in the connection's country comes back with `lyricsStatus: "not_found"` and is not charged. To read lyrics as a given country sees them, use a residential connection with that country set.

#### Can I get word-by-word (karaoke) timing?

Yes. Also turn on **Lyrics: word-level timing** and each track with word timing gets `lyricsWords`: every line with its start and end in milliseconds, and every word inside it with its own start and end. `lyricsSyncType: "word"` tells you which tracks have it; most popular tracks do. It costs nothing extra but makes each row larger.

#### Can I get podcasts or shows?

No. Deezer retired the public podcast endpoints: the API answers with an error for every podcast id, and podcast search is rejected. Only the music catalog (tracks, albums, artists, playlists, radios, charts, public profiles) is covered.

#### Can I get only new or changed tracks on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records, and unchanged ones are not billed.

#### Why did my run fail instead of returning an empty dataset?

If the catalog refuses every request, the run stops with a clear message so "no results" is never confused with "nothing could be read". Run it again in a few minutes.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🧩 <a href="https://apify.com/abotapi/tidal-catalog-scraper"><b>TIDAL Scraper</b></a><br>Scrape TIDAL tracks, albums, artists, playlists and public mixes by search phrase or URL...</td><td>🧩 <a href="https://apify.com/abotapi/anghami-catalog-scraper"><b>Anghami Scraper</b></a><br>Scrape Anghami's public catalog by keyword or player URL. Rows carry their kind (song...</td></tr>
<tr><td>🤖 <a href="https://apify.com/abotapi/suno-music-scraper"><b>Suno Scraper</b></a><br>Collect public Suno music data: songs with lyrics, style tags, model version, play and...</td><td>🤖 <a href="https://apify.com/abotapi/udio-com-scraper"><b>Udio Scraper</b></a><br>Collect public Udio tracks with the complete generation prompt, full lyrics, style tags...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/bandsintown-concert-event-scraper"><b>Bandsintown Scraper</b></a><br>Scrape Bandsintown concert and festival dates: artist tour calendars, venue profiles...</td><td>🛒 <a href="https://apify.com/abotapi/discogs-scraper"><b>Discogs Scraper</b></a><br>Scrape the Discogs catalogue by keyword, filter or link: releases, masters, artists and...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support & custom scrapers

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/deezer-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <abotapi@proton.me> or message [Telegram @abotapi](https://t.me/abotapi).
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Choose 'search' to query the catalog by keyword (or read the charts), or 'url' to scrape pasted Deezer links: track, album, artist, playlist, radio, genre and public user-profile pages.

## `queries` (type: `array`):

Keywords to search for, one search per row (e.g. "daft punk"). Combined with Entity type below.

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

What to search for: tracks (default), albums, artists, playlists, radios, or public user profiles.

## `source` (type: `string`):

Search reads keyword results. Charts reads Deezer's global or per-genre charts for the entity type above (charts cover tracks, albums, artists and playlists).

## `chartGenreId` (type: `integer`):

Deezer genre id whose chart to read (0 = all genres). Find ids via a genre URL like https://www.deezer.com/en/genre/116 - the number at the end is the id.

## `urls` (type: `array`):

Paste track, album, artist, playlist, radio, genre, chart or public user-profile URLs (e.g. https://www.deezer.com/track/3135556 or https://www.deezer.com/playlist/3155776842). Playlists and albums return the collection record plus one row per track.

## `includeArtistReleases` (type: `boolean`):

When an artist link is pasted, also return one album row per release in their discography (paged). Off by default.

## `includeUserCollections` (type: `boolean`):

When a user-profile link is pasted, also return one playlist row per public playlist they published. Off by default.

## `excludeExplicit` (type: `boolean`):

Drop records flagged explicit. Off by default.

## `minDurationSec` (type: `integer`):

Keep only records at least this many seconds long (tracks, and track rows of playlists/albums). Leave 0 to disable.

## `maxDurationSec` (type: `integer`):

Keep only records at most this many seconds long. Leave 0 to disable.

## `sortBy` (type: `string`):

Relevance keeps the catalog's own ranking (default). Title and Duration sort client-side, ascending.

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

In search mode, also open each track's own endpoint for BPM, the full contributor list, ISRC, release date, disk and track positions, and the per-country availability list. Adds one request per track and a per-track surcharge. Off by default.

## `includeLyrics` (type: `boolean`):

Also return each track's lyrics: plain text, time-synced LRC lines (when Deezer has them), songwriters and publisher. Works in every mode, including album, playlist and chart track rows. Lyrics are licensed per country, so the connection's exit country decides which tracks have them. Read in batches of 25 tracks, so it adds very little run time. Charged per track where lyrics were found; tracks without lyrics are not charged. Off by default.

## `lyricsWordTiming` (type: `boolean`):

With Include lyrics on, also return per-word start and end times (milliseconds) for tracks where Deezer has them, in the lyricsWords field: one entry per line, each with its words. Most popular tracks have word timing. No extra charge; rows get larger. Off by default.

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

Maximum number of records to return across the whole run. This is the run's cap. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum number of result pages read per keyword or link. 0 means no limit, which is the default: the run then stops only at Max records, at the end of the results, or when a page returns nothing new.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large crawl that stopped part-way: this run skips records already collected there and returns only the remaining ones. For recurring monitoring of the same search instead, use Incremental changes below (the two are mutually exclusive once Incremental has saved state).

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching record as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED records, which is how a fan-count jump or a track-listing change is spotted. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the mode, keywords, links and filters, so different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, so never when Max records capped it or when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you want removal tracking.

## `proxy` (type: `object`):

The catalog API is open and reads fine on the default connection; a residential connection is available if you want one for large runs.

## `mcpConnectors` (type: `array`):

Optional. Each selected connector receives a condensed summary per record; the full record always stays in the dataset. Leave empty to skip.

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which record pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on records written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "daft punk"
  ],
  "searchType": "track",
  "source": "search",
  "chartGenreId": 0,
  "urls": [
    {
      "url": "https://www.deezer.com/track/3135556"
    }
  ],
  "includeArtistReleases": false,
  "includeUserCollections": false,
  "excludeExplicit": false,
  "minDurationSec": 0,
  "maxDurationSec": 0,
  "sortBy": "relevance",
  "fetchDetails": false,
  "includeLyrics": false,
  "lyricsWordTiming": false,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "mcpConnectors": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

# 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 = {
    "mode": "search",
    "queries": [
        "daft punk"
    ],
    "searchType": "track",
    "source": "search",
    "chartGenreId": 0,
    "urls": [
        {
            "url": "https://www.deezer.com/track/3135556"
        }
    ],
    "sortBy": "relevance",
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    },
    "mcpConnectors": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/deezer-com-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 = {
    "mode": "search",
    "queries": ["daft punk"],
    "searchType": "track",
    "source": "search",
    "chartGenreId": 0,
    "urls": [{ "url": "https://www.deezer.com/track/3135556" }],
    "sortBy": "relevance",
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
    "mcpConnectors": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "search",
  "queries": [
    "daft punk"
  ],
  "searchType": "track",
  "source": "search",
  "chartGenreId": 0,
  "urls": [
    {
      "url": "https://www.deezer.com/track/3135556"
    }
  ],
  "sortBy": "relevance",
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "mcpConnectors": []
}' |
apify call abotapi/deezer-com-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/deezer-com-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oL6qfg1v312X8vv2g/builds/WoaZcYbx7Zft2B2am/openapi.json