Spotify Web API Compatible: Search, Catalog & Audio Intelligence Without the Deprecation Risk

Spotify Web API compatible search and catalog endpoints: track, album and artist lookups returning clean JSON

In a previous article, we talked about restoring the deprecated audio-features endpoint. That’s the headline. But it’s also where most developers stop reading, and they miss the bigger story.

Because the Spotify Extended Audio Features API is not just an audio-features endpoint with a new coat of paint. It’s a full Spotify-Web-API-compatible catalog surface: search, track/album/artist lookups, batches, artist albums, top tracks, related artists, markets and genre seeds, all returning the exact JSON shapes Spotify gives you…

If you came here searching for a Spotify search API, a Spotify track API, or a Spotify album/artist API that won’t evaporate when Spotify tightens access for new applications, this is the layer you want.

The Problem: Catalog Access Keeps Moving

Building on the official Spotify Web API used to be simple. Then the rules started shifting for new applications: locked endpoints, quota walls, OAuth approval queues, and the ever-present risk that the endpoint you shipped on last quarter is gated next quarter.

The typical result:

1. You wire up search and catalog lookups against Spotify directly.
2. A policy change gates the endpoint for new apps… and your onboarding breaks.
3. You scramble for an alternative, and most of them are flaky one-off hacks.

❌ The result? Code that works in your prototype but can’t be relied on in production, because the surface underneath it can be pulled out from under you at any time.

The Solution: Spotify Extended Audio Features API

The product name says audio features, but the surface is much wider. It’s a drop-in mirror of the Spotify Web API’s catalog and search endpoints: same paths, same query params, same response shapes, running on stable production infrastructure with extended quota.

🎵 Spotify Extended Audio Features API

You point your existing Spotify client code at a new host, and it just works… because the JSON comes back in the shapes you already parse.

Key Features:

• ✅ Catalog lookups: tracks, albums and artists, single or batched, returning the same full objects Spotify does (album, artists, external_ids, popularity, images, the lot).
• ✅ Search: one q + type call across track, album and artist, with limit, offset and market, paging objects keyed exactly like Spotify’s.
• ✅ Artist relationships restored: artists/{id}/albums, artists/{id}/top-tracks and the much-missed artists/{id}/related-artists, back, and ranked.
• ✅ Audio features: per-track acousticness, danceability, energy, key, tempo, valence and the rest, plus seeded recommendations with full min/max/target tuning.
• ✅ Markets & genre seeds: enumerate every available ISO market and every usable recommendation genre seed in one call each.
• ✅ Schema-level parity: responses mirror the Spotify Web API shapes, so existing parsers, models and SDKs keep working with minimal backend changes.
• ✅ Production-grade reliability: stable hosts, predictable JSON, extended quota for production-scale usage, no OAuth refresh dance, no restricted-app approvals.

How to Use This API?

Let’s start where the SEO traffic lands: search. One call, a query string, and a comma-separated type. Here’s a real GET /v1/search against the Spotify Extended product in Python:

import requests

url = "https://spotify-extended-audio-features-api.p.rapidapi.com/v1/search"
querystring = {
    "q": "Daft Punk",
    "type": "album,artist,track",
    "limit": 10,
}
headers = {
    "x-rapidapi-key": "YOUR_API_KEY",
    "x-rapidapi-host": "spotify-extended-audio-features-api.p.rapidapi.com",
}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())

👉 Get your key → https://rapidapi.com/musicae-musicae-default/api/spotify-extended-audio-features-api

The response is keyed by the requested types (tracks, albums, artists), each a standard Spotify paging object:

{
  "tracks": {
    "href": "https://api.spotify.com/v1/search?offset=0&limit=10&query=daft%20punk&type=track",
    "limit": 10,
    "next": "https://api.spotify.com/v1/search?offset=10&limit=10&query=daft%20punk&type=track",
    "offset": 0,
    "previous": null,
    "total": 7,
    "items": [
      {
        "id": "0DiWol3AO6WpXZgp0goxAV",
        "name": "One More Time",
        "popularity": 80,
        "duration_ms": 320357,
        "explicit": false,
        "external_ids": { "isrc": "GBDUW0000053" },
        "uri": "spotify:track:0DiWol3AO6WpXZgp0goxAV",
        "artists": [
          { "id": "4tZwfgrHOc3mvqYlEYSvVi", "name": "Daft Punk", "type": "artist" }
        ],
        "album": {
          "id": "2noRn2Aes5aoNVsU6iWThc",
          "name": "Discovery",
          "album_type": "album",
          "release_date": "2001-03-12",
          "total_tracks": 14
        }
      }
    ]
  }
}

Same q, same type, same paging object you already handle. Drop in type=track for a pure Spotify track search, type=album for albums, type=artist for artists, or all three at once.

Catalog Lookups: Tracks, Albums, Artists (and Batches)

Once search hands you an ID, you pull the full object. Every lookup has a single-ID form and a batched form, so you can hydrate a whole screen in one round trip:

GET /v1/tracks/{id}
GET /v1/tracks?ids=<up to 50, comma-separated>
GET /v1/albums/{id}
GET /v1/albums?ids=<up to 20, comma-separated>
GET /v1/albums/{id}/tracks?limit=20&offset=0
GET /v1/artists/{id}
GET /v1/artists?ids=<up to 50, comma-separated>

Each returns the same full Spotify object: a track carries its nested album, artists, external_ids.isrc, popularity and preview_url; an album carries copyrights, label, genres, external_ids.upc and its first page of tracks; an artist carries followers, genres, images and popularity. Pass an optional market (ISO 3166-1 alpha-2) on any of them to relink to a region.

Artist Albums, Top Tracks & Related Artists (Restored)

This is the part most alternatives can’t give you. The artist-relationship endpoints, including the one Spotify gated for new apps, are all here:

GET /v1/artists/{id}/albums?include_groups=album,single,compilation,appears_on&limit=20
GET /v1/artists/{id}/top-tracks?market=FR
GET /v1/artists/{id}/related-artists

• artists/{id}/albums pages the artist’s discography, filterable by include_groups (album, single, compilation, appears_on), with each item carrying its album_group.
• artists/{id}/top-tracks returns the artist’s most popular tracks (up to 10), ordered by popularity, wrapped under tracks.
• artists/{id}/related-artists is back: up to 20 similar artists wrapped under artists, ranked by a weighted blend of genre similarity, popularity-tier proximity and collaboration overlap. The discovery primitive you lost, returned in the shape you already parse.

Markets & Genre Seeds

Two small but essential helpers round out the surface, the ones you call once and cache:

GET /v1/markets
GET /v1/recommendations/available-genre-seeds

markets returns every available ISO market code under markets; available-genre-seeds returns every genre name usable in the seed_genres parameter of recommendations, under genres. Together they tell you exactly which regions you can relink to and which seeds the recommender will accept, so you build your dropdowns from live data instead of a stale hard-coded list.

And Yes, Audio Features & Recommendations Too

The namesake endpoints are still front and center. Per-track features and seeded, fully tunable recommendations:

GET /v1/audio-features/{id}
GET /v1/audio-features?ids=<up to 5, comma-separated>
GET /v1/recommendations?seed_genres=house&target_energy=0.8&min_tempo=120

recommendations takes 1 to 5 seeds (any mix of seed_artists, seed_genres, seed_tracks) and fine-tunes the result with min_ / max_ / target_ constraints across every audio attribute. The features come back as the same audio_features objects Spotify returned (acousticness, danceability, energy, key, tempo, valence, and the rest), so anything you built on the original payload keeps working.

Batch Caps & ID Formats

The API mirrors the Spotify Web API: same paths, same params, same response shapes, so existing client code drops in cleanly. Two quick integration details:

• The catalog lookups key on 22-character base62 Spotify IDs (not ISRCs). Search hands you those IDs; feed them straight into the lookup endpoints.
• The batch audio-features cap is 5 IDs per call (singles, tracks and artists batch larger, up to 50; albums up to 20). Chunk your feature requests in fives and you’re set.

Get Started

The full Musicae stack is available through RapidAPI and Apify. Whether you need search, catalog data, analysis, or downloads, there is a product for it.

Website

📖 Docs, live examples & every API in one place

• 👉 https://api.musicae.io

RapidAPI

🎵 Spotify Extended Audio Features API

• 👉 https://rapidapi.com/musicae-musicae-default/api/spotify-extended-audio-features-api

🎛️ DJ Track Audio Analysis API

• 👉 https://rapidapi.com/musicae-musicae-default/api/dj-track-audio-analysis-api

⬇️ High Quality Spotify Downloader API (320 kbps MP3 / AAC)

• 👉 https://rapidapi.com/musicae-musicae-default/api/high-quality-spotify-downloader-api

Apify

🕷️ Spotify Extended Scraper (Apify Actor)

• 👉 https://apify.com/musicae/spotify-extended-scraper

🎛️ DJ Track Audio Analyzer (Apify Actor)

• 👉 https://apify.com/musicae/dj-track-audio-analyzer

The Spotify Audio Features, Recommendations and Downloader actors are also available on Apify.

Search, lookup, relate, recommend… the whole catalog surface, in the shapes you already speak. If you’re building anything that touches Spotify’s data, you don’t want an endpoint that might vanish. You want a layer that won’t.

Don’t build on an endpoint that can be taken away. Build on one that won’t.