Guide
Spotify API rate limits: the official rolling window, and what each plan here allows
Spotify does not publish a number. This API does: 5 requests per second on RapidAPI, 10 on the direct portal, and a quota per plan — monthly on RapidAPI, per 30-day pack on the direct portal. This page puts the two side by side, shows what a 429 looks like on each, and gives the client code that stays under the limit without thinking about it.
By Eduardo Airaudo, maintainer of the API · Updated 21 October 2026
How Spotify's own limit works
The Web API's rate limit is computed over a rolling 30-second window of calls made by your app, and Spotify states no figure for it. Development-mode apps get a lower allowance than apps in extended quota mode, and the only way to learn where the line is, is to cross it: a 429 Too Many Requests with a Retry-After header giving the seconds to wait.
Development mode also has a quota, enforced separately from the window. Since Spotify's 23 July 2026 update it is counted per developer account rather than per Client ID: all of an account's development-mode apps — up to 25 Client IDs now, where one was allowed before — share one budget, and a 429 for an exhausted quota carries "reason": "QUOTA_EXCEEDED" in its JSON body.
Two things follow. A limit you cannot read cannot be planned for, so every Spotify client needs backoff code from day one. And the allowance is shared — the window across every call your app makes, the quota across every app on your account — so a single busy customer can push every other user into 429s.
The limits here, per plan
Every RapidAPI plan allows 5 requests per second; the plans differ in monthly volume. Every direct key includes 10 requests per second; the portal also sells higher per-second limits on one-time orders. Prices as listed on each platform on 21 October 2026 — the pricing page has the per-request cost at four volumes.
| Route | Plan | Per second | Quota | Price |
|---|---|---|---|---|
| RapidAPI | Basic | 5 req/s | 1,000 requests | $0/mo |
| RapidAPI | Pro | 5 req/s | 20,000 requests | $10/mo |
| RapidAPI | Ultra | 5 req/s | 200,000 requests | $30/mo |
| RapidAPI | Mega | 5 req/s | Unlimited requests | $200/mo |
| Direct portal | 20K requests | 10 req/s | 20K requests | $9/30 days |
| Direct portal | 50K requests | 10 req/s | 50K requests | $13.50/30 days |
| Direct portal | 100K requests | 10 req/s | 100K requests | $18/30 days |
| Direct portal | 200K requests | 10 req/s | 200K requests | $27/30 days |
| Direct portal | 500K requests | 10 req/s | 500K requests | $67.50/30 days |
| Direct portal | 1M requests | 10 req/s | 1M requests | $135/30 days |
| Direct portal | 5M requests | 10 req/s | 5M requests | $675/30 days |
Apify runs are throttled per run rather than per second, and billed per result rather than per month — see the scraper guide. The live demo on this site allows 100 requests per 15 minutes and 500 a day per visitor, inside a budget every visitor shares; it is a demo, not a free tier.
Fewer calls: the batch endpoints
The cheapest request is the one you do not send. These accept a comma-separated ids list, so a batch of lookups, up to each endpoint's cap, is one call against the per-second limit and one against the monthly quota.
- Artist overview (batch)up to 10 per callGET /artist_overview_batch
- Album metadata (batch)up to 20 per callGET /album_metadata_batch
- Track credits (batch)up to 20 per callGET /track_credits_batch
- Track lyrics (batch)up to 10 per callGET /track_lyrics_batch
- Track popularity (batch)up to 50 per callGET /track_popularity_batch
- Get tracksup to 50 per callGET /tracks
- Get artistsup to 50 per callGET /artists
- Get albumsup to 50 per callGET /albums
- Audio featuresup to 100 per callGET /audio_features
Each cap is the one the spec states on that endpoint's ids parameter. Chart endpoints answer with the whole chart in one response, and the demo caches every GET, charts for an hour.
Client code that stays under the limit
Two mechanisms, both small: a token bucket that spaces requests to the plan's per-second rate, and a retry on 429 that honours Retry-After when present and backs off exponentially when it is not. Both send a direct key in x-rapidapi-key to the /spotify-data base. The official SDKs on the Node and Python pages wrap the same endpoints if you would rather not write this yourself, and take a RapidAPI key as well.
| // Paces calls to 10/s and retries 429s, honouring Retry-After. |
| const BASE = "https://spotify-proxy.checkleaked.cc/spotify-data"; |
| const RATE = 10; // requests per second: 10 on every direct key unless you bought more |
| let nextSlot = 0; |
| async function paced(path, params = {}, attempt = 0) { |
| const now = Date.now(); |
| nextSlot = Math.max(nextSlot, now) + 1000 / RATE; |
| await new Promise((r) => setTimeout(r, nextSlot - now - 1000 / RATE)); |
| const url = new URL(BASE + path); // not new URL(path, BASE): that drops /spotify-data |
| url.search = new URLSearchParams(params).toString(); |
| const res = await fetch(url, { headers: { "x-rapidapi-key": process.env.SPOTIFY_API_KEY } }); |
| if (res.status === 429 && attempt < 3) { |
| const retryAfter = Number(res.headers.get("retry-after")); |
| const wait = retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt; |
| await new Promise((r) => setTimeout(r, wait)); |
| return paced(path, params, attempt + 1); |
| } |
| if (!res.ok) throw new Error(`${res.status} ${path}`); |
| return res.json(); |
| } |
| // The spec caps /artist_overview_batch at 10 ids a call: 10 artists, one request. |
| const BATCH = 10; |
| const overviews = []; |
| for (let i = 0; i < ids.length; i += BATCH) { |
| overviews.push(await paced("/artist_overview_batch", { ids: ids.slice(i, i + BATCH).join(",") })); |
| } |
Questions
What is the Spotify Web API rate limit?
Spotify does not publish a figure. The limit is calculated over a rolling 30-second window of your app's calls, is lower for development-mode apps than for extended-quota apps, and is reported only by a 429 response carrying a Retry-After header.
What are the rate limits on this API?
5 requests per second on every RapidAPI plan. Every direct key includes 10 requests per second; the portal also sells higher per-second limits on one-time orders. Plans differ by volume: RapidAPI from 1,000 requests a month free to unlimited, the direct portal in 30-day packs from 20K to 5M ($675), with orders up to 10M.
What happens when I exceed it?
A 429 response. Wait for the Retry-After value when the response carries one, otherwise back off exponentially and retry; the snippets above do both. Monthly quota overruns on RapidAPI are governed by the plan's own overage terms on its pricing page.
Are the limits per key or per app?
Here, per key and per plan: a direct key carries its own per-second rate and quota, and on RapidAPI both come from your plan. On Spotify's side the rolling window is per app, and since its 23 July 2026 update the development-mode quota is per developer account, shared by every Client ID on it (up to 25), which is why one heavy user can rate-limit everyone.
How do I cut the number of requests?
Use the endpoints that take a comma-separated ids list, at the caps the spec gives them — up to 10 per call: /artist_overview_batch and /track_lyrics_batch; up to 20 per call: /album_metadata_batch and /track_credits_batch; up to 50 per call: /track_popularity_batch, /tracks, /artists and /albums; up to 100 per call: /audio_features. Then cache responses that change slowly: charts refresh daily, catalogue metadata rarely.
Is the demo on this site a free tier?
No. It is a demo: 100 requests per 15 minutes and 500 a day per visitor, from a budget every visitor shares, and only from a browser on this site. Scripts get a 403 pointing at the real API, where RapidAPI's Basic plan is free for 1,000 requests a month.
Sources
- Rate Limits — Spotify for Developers — the rolling 30-second window, 429 and Retry-After, development mode versus extended quota.
- Web API quota updates for Development Mode — Spotify for Developers, 23 Jul 2026 — quota counted per developer account, up to 25 Client IDs, and QUOTA_EXCEEDED as the reason on a quota 429.
- Spotify81 pricing on RapidAPI — the four plans and their monthly quotas, as listed by the marketplace.
- Direct portal — the seven volume tiers, 10 requests per second included and higher rates on one-time orders.
More guides
- Spotify Web API alternativeEndpoint-by-endpoint mapping from the official API, including everything Spotify removed on 27 November 2024.
- Spotify API without OAuthOne header instead of the client-credentials flow — and the things a key genuinely cannot do.
- Spotify lyrics APIWhy the Web API has no lyrics endpoint, and how to get line-synced lyrics as JSON, LRC or SRT.
- Spotify charts APIDaily Top 200 and viral charts as JSON: rank movement, stream counts, credits, and how to backfill.
- Spotify monthly listeners APIMonthly listeners, follower counts, world rank and top cities per artist — numbers the Web API never returned.
- Spotify play count APILifetime streams for any track, by Spotify id or ISRC, one or a batch per call — and why a 0 means under 1,000.
- Spotify audio features API after the 2024 deprecationTempo, energy, danceability, recommendations and related artists after Spotify removed them for new apps.
- Spotify scraper on ApifyPlay counts, charts, lyrics and credits as a scheduled run with no API key — and when an API key is the better tool.
What changed in the API and on these pages, and when: What's new.
Pick the plan that fits your volume
5 requests a second from $0 on RapidAPI, 10 a second from $9 on the direct portal, or pay per result on Apify.