Beatport APIbeatport.com ↗
Access Beatport track metadata, BPM, musical key, artist profiles, release details, genre charts, and Top 10 data via a structured REST API.
What is the Beatport API?
The Beatport API covers 10 endpoints for searching and retrieving electronic music metadata from Beatport.com, including tracks, releases, artists, labels, and genre charts. The get_top10 endpoint returns the current top-charting tracks for any genre with full metadata including BPM, Camelot key notation, sample preview URL, and pricing. Search endpoints cover the full track, release, and artist catalogs with paginated results.
curl -X GET 'https://api.parse.bot/scraper/2231dc97-b277-482d-9311-07a167c10460/search_tracks?page=1&query=techno' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace beatport-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Beatport Music API — discover tracks, artists, and genres."""
from parse_apis.beatport_music_api import Beatport, NotFound
client = Beatport()
# List genres and get top 10 tracks for the first one
genres = client.genres.list(limit=5)
for genre in genres:
print(genre.name, genre.slug)
# Construct a genre by ID and fetch its top tracks
techno = client.genre(id=6)
for track in techno.top_tracks(limit=3):
print(track.name, track.bpm, track.sample_url)
# Search tracks and drill into detail
result = client.tracksummaries.search(query="adam beyer", limit=1).first()
if result:
detail = result.details()
print(detail.name, detail.bpm, detail.sample_url)
# Search artists and list their tracks
artist_hit = client.artistsummaries.search(query="charlotte de witte", limit=1).first()
if artist_hit:
full_artist = artist_hit.details()
print(full_artist.name, full_artist.bio)
for t in full_artist.tracks.list(limit=3):
print(t.track_name, t.bpm, t.label)
# Typed error handling on a bad resource lookup
try:
bad_artist = client.artistsummaries.search(query="zzzznonexistent999", limit=1).first()
if bad_artist:
bad_artist.details()
except NotFound as exc:
print(f"Not found: {exc}")
print("exercised: genres.list / genre.top_tracks / tracksummaries.search / details / artistsummaries.search / artist.tracks.list")Full-text search over Beatport's track catalog. Matches against track name, artist, and label. Returns paginated results with track metadata including BPM, genre, artists, label, and pricing. Each result is a summary; use get_track for full details including sample URL and musical key.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination. |
| queryrequired | string | Search keyword to match against tracks. |
{
"type": "object",
"fields": {
"data": "array of track summary objects with track_id, track_name, bpm, artists, genre, label, price, downloads, and plays"
},
"sample": {
"data": {
"data": [
{
"bpm": 128,
"genre": [
{
"genre_id": 6,
"genre_name": "Techno (Peak Time / Driving)"
}
],
"label": {
"label_id": 10819,
"label_name": "Rebeat"
},
"plays": 834,
"price": {
"code": "USD",
"value": 1.49,
"display": "$1.49"
},
"artists": [
{
"artist_id": 121438,
"artist_name": "Techno"
}
],
"mix_name": "Original Mix",
"track_id": 1216245,
"downloads": 67,
"track_name": "Techno"
}
]
},
"status": "success"
}
}About the Beatport API
Track and Release Data
The search_tracks endpoint accepts a query string and an optional page integer, returning arrays of track summary objects that include track_id, bpm, artists, genre, label, price, downloads, and plays. For complete metadata on a single track, get_track takes a required track_id and returns fields like key (with camelot_number and camelot_letter), mix_name, length, sample_url for audio preview, and nested release and artists objects. The search_releases and get_release endpoints mirror this pattern for albums, EPs, and singles — get_release additionally exposes catalog_number, publish_date, and a tracks array of track API URLs.
Artists and Labels
search_artists returns paginated artist summaries with artist_id, genre, downloads, and image URIs. Calling get_artist with a numeric artist_id returns the full profile including bio, website, and image (with uri and dynamic_uri). For labels, get_label takes a label_id and returns the label's name, bio, slug, and image object. The slug parameter on all detail endpoints is optional and only affects URL construction — any value or omission works.
Genre Charts and Full Artist Catalogs
list_genres takes no inputs and returns a complete list of genre objects (id, name, slug) — these IDs and slugs feed directly into get_top10, which returns up to 10 fully detailed track objects per genre including sample_url, bpm, key, release, artists, and price. For bulk artist track retrieval, get_artist_tracks automatically paginates through an artist's full catalog and returns a flat list with fields including mix_name, remixers, label, key, release_date, and track_url. This endpoint can be slow for artists with large catalogs.
The Beatport API is a managed, monitored endpoint for beatport.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when beatport.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official beatport.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a BPM and key-aware playlist tool using
get_trackfields includingbpm,camelot_number, andcamelot_letter - Monitor label release activity by polling
search_releaseswith a label name and reviewingpublish_dateandcatalog_numberfromget_release - Construct genre-specific charts dashboards using
list_genresandget_top10to display current Top 10 tracks with pricing and preview URLs - Aggregate an artist's full discography including remixer credits using
get_artist_trackswithremixers,mix_name, andrelease_datefields - Index Beatport metadata for a DJ track management app using
search_tracksfiltered by genre and sorted by BPM range - Populate an artist directory with biography and social links by calling
get_artistforbioandwebsitefields - Enrich a music catalog database with label imagery and descriptions using
get_labelforbio,image.uri, andslug
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Beatport have an official developer API?+
What does get_top10 return and how do I find valid genre IDs?+
list_genres first — it returns all genre objects with id, name, and slug. Pass the numeric id as genre_id to get_top10, which returns up to 10 track objects per genre. Each track includes bpm, key (with Camelot notation), artists, sample_url, release, and price.Does get_track return a playable audio preview URL?+
get_track endpoint includes a sample_url field in its response, which points to a short audio preview of the track. The search_tracks endpoint returns summary objects only and does not include the sample URL; you need to call get_track with the specific track_id to get it.Does the API expose user data such as wish lists, purchase history, or account playlists?+
Are there pagination limits or slowness issues I should plan for?+
search_tracks, search_releases, and search_artists endpoints all accept a page integer for pagination, but the API does not expose a total page count in the summary response — you need to paginate until results are exhausted. The get_artist_tracks endpoint auto-paginates internally but is noted as potentially slow for artists with large catalogs.