Deezer API for Developers: Endpoints, Auth, and Integration Patterns

What Is the Deezer API?

The Deezer API gives developers programmatic access to Deezer's catalog of over 90 million tracks, curated editorial playlists, real-time charts, and user library data. It exposes RESTful endpoints that return JSON, covering search, track metadata, album details, artist info, playlists, and user favorites. If you are building a music app that needs access to Deezer's catalog or user data, this is your entry point.

Deezer's API stands out for its editorial content. While most streaming services expose basic catalog search and user library access, Deezer surfaces curated editorial playlists and country-specific charts through dedicated endpoints. For developers building discovery features, recommendation engines, or cross-service integrations, this editorial layer adds a data source you will not find elsewhere.

The API follows standard REST conventions. You send GET requests with query parameters, and Deezer returns paginated JSON responses. Authentication uses OAuth 2.0 for user-scoped data (playlists, favorites, listening history) and simple API keys for public catalog access (search, track metadata, charts).

Deezer API Authentication: OAuth 2.0 Basics

Deezer uses OAuth 2.0 for any endpoint that touches user data. Public catalog endpoints (search, track lookup, charts) require only an application ID. User-scoped endpoints (favorites, playlists, listening history) require a full OAuth access token tied to the user's account.

Here is the OAuth flow:

1. Register your app on Deezer's developer portal to get an Application ID and Secret Key.
2. Redirect users to Deezer's authorization URL with your app ID and requested permissions.
3. After the user approves, Deezer redirects back to your callback URL with an authorization code.
4. Exchange that code for an access token using a server-side request that includes your Secret Key.

The access token does not expire by default, but users can revoke it at any time. You should handle token revocation gracefully and prompt re-authorization when API calls return 401 errors.

// Step 1: Redirect user to Deezer's OAuth page
const authUrl = `https://connect.deezer.com/oauth/auth.php?app_id=${APP_ID}&redirect_uri=${REDIRECT_URI}&perms=basic_access,email,manage_library`;

// Step 2: Exchange the authorization code for an access token
const tokenResponse = await fetch(
  `https://connect.deezer.com/oauth/access_token.php?app_id=${APP_ID}&secret=${SECRET_KEY}&code=${authCode}&output=json`
);
const { access_token } = await tokenResponse.json();

Permissions are granular. basic_access covers profile and public data. email grants access to the user's email. manage_library lets you add or remove tracks from their favorites and playlists. Request only the permissions your app actually needs.

One thing to note: if you plan to support multiple streaming services, you will need to implement OAuth flows for each one separately. Each service has different scopes, token formats, and refresh mechanisms. MusicAPI handles this for you with a single unified authentication flow that works across Deezer, Spotify, Apple Music, and more.

Core Endpoints: Search, Tracks, Albums, Playlists

Deezer's API organizes around resource types. Each resource type has its own base endpoint, and most support additional sub-endpoints for related data. Here are the core ones you will use most.

Search returns tracks, albums, artists, or playlists matching a query string. The /search endpoint accepts a q parameter and returns paginated results with 25 items per page by default.

// Search for tracks
const response = await fetch(
  `https://api.deezer.com/search?q=track:"Blinding Lights"&type=track`
);
const results = await response.json();

// Each result includes: id, title, duration, preview URL, album art, artist
console.log(results.data[0].title);     // "Blinding Lights"
console.log(results.data[0].duration);  // 200 (seconds)
console.log(results.data[0].preview);   // 30-second preview MP3 URL

Tracks expose full metadata for individual songs. Hit /track/{id} to get title, artist, album, duration, ISRC, BPM, gain, and a 30-second preview URL.

Albums return track listings, release dates, genres, and cover art in multiple sizes. Use /album/{id}/tracks to get the full tracklist.

Playlists support both reading and writing (with proper OAuth scopes). /playlist/{id} returns metadata and tracks. /user/me/playlists lists the authenticated user's playlists. For playlist operations on Deezer through MusicAPI, check the Deezer playlist info endpoint.

User favorites include liked tracks, albums, and artists. The /user/me/tracks endpoint returns the user's favorite tracks. You can also access these through MusicAPI's Deezer favorite tracks endpoint.

Deezer's Unique Data: Editorial Playlists and Charts

Deezer's editorial team curates playlists by genre, mood, and activity. The /editorial endpoint exposes these curated collections, and /chart returns real-time popularity rankings for tracks, albums, artists, and playlists.

// Get top charts
const charts = await fetch('https://api.deezer.com/chart');
const chartData = await charts.json();

// Get editorial selections
const editorial = await fetch('https://api.deezer.com/editorial');
const editorialData = await editorial.json();

// Get genre-specific editorial content
const popEditorial = await fetch('https://api.deezer.com/editorial/132/charts');

These endpoints are publicly accessible (no OAuth required) and update frequently. They are useful for building trending sections, genre browsers, or music discovery features. Country-specific charts are available through the /chart/{country_id} pattern, giving you localized popularity data without extra configuration.

Deezer API Rate Limits and Quotas

Deezer enforces rate limits to protect its infrastructure. The current limits are 50 API calls every 5 seconds per endpoint per access token. If you exceed this limit, the API returns an HTTP 429 response with a Retry-After header.

Here is what that means in practice:

Metric	Limit
Requests per token	50 per 5 seconds
Requests per IP (no token)	50 per 5 seconds
Search queries	Subject to stricter limits during peak hours
Batch operations	No native batch endpoint

A few practical tips for managing rate limits:

• Cache aggressively. Track metadata, album details, and artist info change rarely. Cache these for at least 24 hours.
• Debounce search. If you are building autocomplete, wait 300ms after the user stops typing before sending a request.
• Use exponential backoff. When you hit a 429, wait and retry with increasing delays.
• Queue requests. For batch operations (importing a playlist with 500 tracks), process items sequentially with delays rather than firing all requests at once.

When you integrate multiple streaming services, rate limit management gets complex fast. Each service has different limits, different headers, and different backoff expectations. MusicAPI's rate limiting layer handles this across all supported services, so you do not need to build per-service throttling logic.

How to Integrate Deezer Alongside Spotify and Apple Music

Most production music apps need to support more than one streaming service. Your users have different subscriptions, and limiting your app to a single service limits your addressable market. The challenge is that every streaming API has its own authentication flow, data schema, rate limits, and endpoint structure.

Here is what building multi-service support looks like without an abstraction layer:

• Three separate OAuth implementations with different token lifetimes and refresh mechanisms.
• Three different response schemas for the same conceptual data (track, album, playlist).
• Three rate limiting strategies with different thresholds and backoff patterns.
• Three sets of error codes with different meanings and retry behavior.

This is where a unified music API saves months of development time. MusicAPI provides a single REST API that normalizes requests and responses across Deezer, Spotify, Apple Music, YouTube Music, Tidal, and more. One authentication flow. One response format. One set of rate limits to manage.

Code Example: Searching Tracks Across Deezer and Spotify via MusicAPI

Instead of writing separate integrations for each service, you make one call to MusicAPI and get normalized results from all connected services.

// Search across Deezer and Spotify with a single request
const response = await fetch('https://api.musicapi.com/api/v1/search', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_MUSICAPI_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    query: 'Daft Punk Get Lucky',
    type: 'track',
    limit: 10
  })
});

const results = await response.json();

// Results come back in a unified schema regardless of source service
results.data.forEach(track => {
  console.log(`${track.title} by ${track.artist}`);
  console.log(`  Service: ${track.service}`);
  console.log(`  Duration: ${track.duration}ms`);
  console.log(`  ISRC: ${track.isrc}`);
});

import requests

# Same search, same result format, multiple services
response = requests.post(
    'https://api.musicapi.com/api/v1/search',
    headers={
        'Authorization': 'Bearer YOUR_MUSICAPI_TOKEN',
        'Content-Type': 'application/json'
    },
    json={
        'query': 'Daft Punk Get Lucky',
        'type': 'track',
        'limit': 10
    }
)

results = response.json()
for track in results['data']:
    print(f"{track['title']} by {track['artist']} [{track['service']}]")

No separate SDKs. No per-service OAuth. No response normalization code. You write it once, and it works across every supported service.

Ready to skip months of OAuth and SDK work? Start your free MusicAPI trial and connect Deezer, Spotify, Apple Music, and more with one unified API.

Deezer API Feature Comparison Table

Here is how Deezer's API capabilities stack up across key integration areas:

Feature	Deezer API (Direct)	Via MusicAPI
Authentication	OAuth 2.0 (Deezer-specific)	Unified OAuth across 10+ services
Search	/search?q= with type filters	Single endpoint, all services
Track metadata	Full (title, artist, album, ISRC, BPM, preview)	Normalized schema across services
Playlist read/write	Yes (with manage_library scope)	Yes, unified format
User favorites	/user/me/tracks, /user/me/albums	Unified favorites endpoint
Editorial content	Charts, editorial playlists, genre browsing	Accessible through Deezer connection
Rate limits	50 req / 5 sec per token	Managed automatically
Response format	Deezer-specific JSON schema	Normalized JSON across all services
30-sec previews	Yes (MP3 URL in track data)	Passed through from source
Webhooks	No	Service-level event support
SDK support	JavaScript SDK (community-maintained)	REST API (language-agnostic)

The direct API gives you full access to Deezer-specific features like editorial content and charts. MusicAPI gives you normalized access to Deezer alongside every other major streaming service, with authentication, rate limiting, and response normalization handled for you.

FAQ

How do I get started with the Deezer API?

Register an application on Deezer's developer portal. You will receive an Application ID and Secret Key. Use the Application ID for public catalog requests (search, track lookup, charts). For user data access, implement the OAuth 2.0 flow to obtain access tokens. If you need multi-service support from day one, MusicAPI provides a faster path with a single integration that covers Deezer and 10+ other services.

Is the Deezer API free to use?

Yes. The Deezer API is free for development and production use. There are no per-request charges or monthly fees from Deezer itself. You do need to comply with their terms of service, which include attribution requirements and restrictions on caching full tracks. Rate limits apply to all apps equally.

What data can I access without user authentication?

Public catalog data is accessible with just your Application ID. This includes search results, track metadata, album details, artist information, charts, and editorial playlists. User-specific data (favorites, personal playlists, listening history) requires OAuth authentication with appropriate permission scopes.

How does the Deezer API compare to other streaming APIs?

Deezer offers strong editorial content access (curated playlists, country-specific charts) and straightforward OAuth. Its rate limits (50 requests per 5 seconds) are reasonable for most use cases. The 30-second preview URLs included in track data are a useful feature for building preview players. The main challenge comes when you need to support Deezer alongside other services, as each API has its own schema and auth flow.

Can I play full tracks through the Deezer API?

The API provides 30-second preview URLs for tracks. Full playback requires the Deezer Web SDK or a Deezer Premium account integration. The preview URLs are MP3 files that you can stream directly, making them suitable for discovery features and track previews.

What is the best way to integrate Deezer with other streaming services?

Building separate integrations for each service is possible but time-consuming. You need different OAuth flows, different response parsers, and different rate limit handlers for each one. MusicAPI provides a single API layer that normalizes access across Deezer, Spotify, Apple Music, YouTube Music, Tidal, and more. One integration, one auth flow, one response format.

Does the Deezer API support playlist creation?

Yes. With the manage_library OAuth permission, you can create playlists, add tracks, remove tracks, and update playlist metadata through the API. MusicAPI also supports playlist operations on Deezer through its unified endpoint.

---

Ready to skip months of OAuth and SDK work? Start your free MusicAPI trial and connect 10+ streaming services with one unified API.