Beatport Scraper: Up to 1,000 Free Results a Month (2026)

Extracting full track metadata across Beatport's catalog costs $5.00 per 1,000 results on the free plan, returning 49 fields per track record including tempo, key, artwork, and preview audio links. The scraper reads live storefront endpoints without requiring user login credentials, mapping all 46 Beatport genres as well as DJ charts, artist pages, and label discographies. Empty fields are omitted directly at extraction time. This tool is built for DJs, record pools, and catalog analysts tracking electronic music trends; it is not for buyers requiring full-length audio downloads, which the store does not offer publicly.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open Beatport Scraper on Apify and run the prefilled example.

How reliable is Beatport Scraper in production?

Across the last 30 days of public runs on the Apify platform, Beatport Scraper recorded 235 runs with the following outcomes.

In the last 30 days, 1.3% of runs failed or timed out, about 1 in a hundred. Scheduling this Actor unattended requires basic timeout handling and modest batch sizes to maintain steady throughput. Retries are unnecessary for aborted tasks, but a scheduled run that hits a timeout should be automatically re-queued after confirming IP reachability.

What does it cost to run Beatport Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. With 1.3% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

Your spend scales directly with maxItems and the boolean expansion flags like includeChartTracks or includeReleaseTracks that swell output datasets. Adjusting maxItems is the primary lever for controlling result charges. To validate schemas at the lowest cost, run a 20-item test using the default prefill, which keeps result charges capped at $0.10.

How do you run Beatport Scraper from the API?

The schema marks 1 of its 18 controls as required: mode. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~beatport-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","startUrls":["https://www.beatport.com/track/the-kid-original-mix/3731110"],"proxyConfiguration":{"useApifyProxy":false},"maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "search",
  "startUrls": [
    "https://www.beatport.com/track/the-kid-original-mix/3731110"
  ],
  "proxyConfiguration": {
    "useApifyProxy": False
  },
  "maxItems": 20
}

run = client.actor("crawlerbros~beatport-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "search",
  "startUrls": [
    "https://www.beatport.com/track/the-kid-original-mix/3731110"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxItems": 20
}

const run = await client.actor('crawlerbros~beatport-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Beatport Scraper inputs matter, and which can you skip?

The required control is mode, which sets the operational target between search, genre browsing, DJ charts, release feeds, artist profiles, label catalogues, or direct URLs. The parameters that dictate volume are maxItems along with includeReleaseTracks and includeChartTracks. First-time users should leave proxyConfiguration alone unless their runtime environment encounters initial 401 rejections.

• mode (string): What to fetch from Beatport. Default: "search".
• startUrls (array): Track, chart, artist, label, release or genre URLs, e.g. https://www.beatport.com/track/the-kid-original-mix/3731110. Default: [].
• proxyConfiguration (object): Optional. If api.beatport.com returns 401s from your IP range (environment-level block), enable Apify proxy (AUTO datacenter is free) to route API + token requests through an allowed network.
• maxItems (integer): Hard cap on emitted records. Default: 50.
• searchQuery (string): Free-text query (mode=search). Default: "tech house".
• searchType (string): Entity type to return for the search (mode=search). Default: "tracks".
• genre (string): Beatport genre to browse (mode=browseByGenre; also narrows topCharts). Default: "tech-house".
• chartType (string): Which chart ranking to fetch (mode=topCharts). Default: "latest".
• releaseSort (string): How to order releases (mode=browseReleases). Default: "newest".
• labelId (integer): Beatport label ID, e.g. 20670. Found in the label page URL: beatport.com/label//.
• artistId (integer): Beatport artist ID, e.g. 406088. Found in the artist page URL: beatport.com/artist//.
• minBpm (integer): Drop tracks below this tempo.

The other 6 controls, with their defaults, are listed in the input schema on Beatport Scraper on Apify.

Fixed-choice controls: mode accepts search (Search tracks), browseByGenre (Browse by genre), topCharts (Top DJ charts), browseByLabel (Browse by label), browseByArtist (Browse by artist), browseReleases (Browse releases), byUrl (Fetch by URL); searchType accepts tracks, artists, labels, charts; genre accepts 46 values (default tech-house), including tech-house (Tech House), techno-peak-time-driving (Techno (Peak Time / Driving)), techno-raw-deep-hypnotic (Techno (Raw / Deep / Hypnotic)), house; chartType accepts latest (newly published), trending (recently changed), popular (most tracks); releaseSort accepts newest (Newest first), oldest (Oldest first), name (By name), trackCount (Most tracks), recentlyEncoded (Recently encoded).

What does Beatport Scraper return?

The dataset delivers structured track records containing BPM, Camelot keys, ISRC values, release dates, prices, artwork links, and 30 to 60 second MP3 preview URLs. The records are designed for set planning and catalog analytics. They do not contain downloadable full-length tracks or uncompressed audio masters.

Output per track

• id, title, mixName, artists[], primaryArtist, remixers[]
• label, releaseId, releaseName, genre (id/name/slug), subGenre
• bpm, key (name, Camelot number/letter)
• duration (e.g. 6:42), durationMs, trackNumber
• price (value, currency, display), catalogNumber, isrc
• releaseDate, newReleaseDate, encodedDate
• previewUrl - MP3 sample, sampleStartMs, sampleEndMs
• artworkUrl, availableWorldwide, isExplicit, preOrder, isAvailableForStreaming
• audioFormat, desc, saleType, currentStatus, labelTrackIdentifier
• isDjEdit, isHype, isClassic, isUgcRemix, exclusive, wasEverExclusive
• freeDownloads, freeDownloadStartDate, freeDownloadEndDate, preOrderDate
• apiUrl - canonical catalog API resource
• chartRank / chartName (when fetched inside a chart)
• sourceUrl, recordType: "track", scrapedAt

Output per chart

• id, name, slug, description, person, artist
• genres[], trackCount, price, publishDate, addDate, changeDate
• rank (position in the listing), chartType
• imageUrl, apiUrl, sourceUrl, recordType: "chart", scrapedAt

Output per release

• id, name, slug, artists[], primaryArtist, remixers[], label
• catalogNumber, upc, trackCount, bpmRange
• publishDate, newReleaseDate, encodedDate, updated, desc
• price, imageUrl, isExplicit, isDjEdit, isHype, isUgcRemix, exclusive, preOrder
• apiUrl, sourceUrl, recordType: "release", scrapedAt

Output per artist / label

• id, name, bio, website, djAssociation (artists)
• imageUrl, latestActivePublishDate, created, updated
• hasExclusiveContract, hypeActive, isAvailableForPreOrder, isAvailableForBundleSubscription, isIncludedInRightsflow (labels)
• sourceUrl, recordType, scrapedAt

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Beatport Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run once with mode set to browseByGenre, genre set to tech-house, and maxItems set to 5 to confirm network connectivity and anonymous session negotiation.
2. Verify that the dataset contains 5 records with recordType set to track and that bpm and key are populated on these test items.
3. Switch mode to your target extraction path, such as topCharts, browseReleases, browseByLabel, or search.
4. Set musical constraints using minBpm, maxBpm, and key if you need to filter tracks before writing to the dataset.
5. Enable includeChartTracks or includeReleaseTracks if you need granular track items instead of high-level chart or release containers.
6. Check proxyConfiguration if the Actor finishes cleanly with zero records due to 401 response codes on an untrusted IP range.
7. Scale maxItems up to your target batch size and schedule the task across your desired cadence.

How do you apply it? Three worked playbooks

These are Beatport Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: DJs & producers

Outcome: Research tracks by BPM and key for harmonic mixing

Configure: mode=browseByGenre, genre=tech-house, minBpm=124, maxBpm=128, key=A Minor, maxItems=50

Working method: Select a target genre and narrow the tempo window around your current set velocity. Set the key selector to the specific musical key needed for your transition. Inspect the initial batch of track records to confirm that bpm and key match your criteria before downloading the previewUrl MP3 samples.

Deliverable: A structured dataset of harmonically compatible tracks with BPM, key identifiers, Camelot notation, and preview URLs.

Stop condition: The returned records contain empty key fields or zero tracks match the restrictive BPM filter.

Use case 2: Music analytics

Outcome: Price, BPM, key and release-date data for catalog research

Configure: mode=browseReleases, genre=melodic-house-techno, releaseSort=newest, includeReleaseTracks=true, maxItems=100

Working method: Execute an extraction targeting newly cataloged releases across specific genres. Compare price, releaseDate, catalogNumber, and track-level metadata across records. Normalize currency values and track counts across releases into your data warehouse.

Deliverable: A historical catalog snapshot containing release metadata paired with nested track prices, dates, and label identifiers.

Stop condition: The release catalog stops returning pricing data or omits releaseDate timestamps on consecutive items.

Use case 3: Record pools

Outcome: Track new releases by genre or label weekly

Configure: mode=browseByLabel, labelId=20670, releasedAfter=2026-09-01, maxItems=200

Working method: Schedule weekly runs targeting curated label IDs or specific genres using the releasedAfter parameter. Compare extracted catalog items against your historical database to identify brand-new releases. Feed the new ISRC and previewUrl entries into curation queues.

Deliverable: A weekly diff feed of new label releases containing catalog numbers, artwork CDN links, and sample preview URLs.

Stop condition: Consecutive runs yield duplicate catalog numbers already flagged in the prior week.

What breaks, and how do you design around it?

• Track search is capped by Beatport's API - track search caps at 10 results per page (any per_page value returns 10) and pages become unstable after the first one or two; the actor requests the real 10-page cap, dedupes by track id and stops once the API repeats itself. A search run therefore emits every unique track Beatport offers for the query (typically ~10-20) with no duplicates. Genre, label, artist and release endpoints are unaffected and honor full pages.
• 401 on some IP ranges - the catalog API can reject an entire network; the actor re-mints its anonymous token and retries once, then finishes cleanly with a status message. Re-running from another network (or with Apify proxy) usually resolves it.
• Fields are omitted when Beatport omits them - e.g. BPM or ISRC on certain tracks; only the data Beatport actually provides is output.
• API is rate-limited - the actor pages politely and retries on throttling (429).
• No audio downloads - only metadata and the short 30-60 second preview URLs that Beatport publishes on every track page.

Beatport's track search endpoint hard-caps output to approximately 10 to 20 unique tracks before pagination loops, so you should use genre browsing or release listings when collecting large catalogs. If an IP range triggers a 401 error, activate the proxy configuration to route catalog and token requests through an alternate network. Because Beatport omits empty attributes, design ingestion parsers to handle missing fields without throwing errors.

When should you not use Beatport Scraper?

Do not use this Actor if you require full-length audio tracks, offline FLAC/WAV downloads, or consumer playlist metadata. Beatport only serves 30 to 60 second preview samples and store metadata. If your goal is consumer streaming tracking across broader genres, use SoundCloud Scraper to extract play counts, waveforms, and public streams, or query iTunes Search Scraper for multi-region retail catalog data. If you require complete discographies and physical release editions beyond electronic music, query the official release database via Discogs Scraper. Avoid this Actor when running bulk text searches, as the API restricts track query results to small sets.

What should you check before trusting the output?

• Verify that recordType matches the expected entity string (track, chart, release, artist, or label).
• Check that previewUrl is present and starts with Beatport CDN domain geo-samples.beatport.com when tracks are extracted.
• Flag any track record missing both bpm and key, as Beatport omits empty attributes rather than providing null fields.
• Halt downstream ingestion if a mode run produces zero dataset items alongside a 401 network status.
• Confirm that track search extractions do not exceed the ~10 to 20 unique items returned before Beatport search pagination loops.

None of this proves a record is correct. It gives a scheduled Beatport Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the cost per 1,000 results for Beatport Scraper?

Results are priced at $0.005 per item, which is $5.00 per 1,000 results on the free plan. Higher-tier paid Apify plans pay lower per-result rates. Platform usage is billed separately on top of result and run-start charges. Apify provides $5.00 of monthly usage on the free plan, which covers up to 1,000 results.

Why does track search only return 10 to 20 items?

Beatport's internal search API limits track search responses to 10 items per page and begins repeating result sets after the first couple of pages. The Actor requests the maximum available depth, removes duplicates by track ID, and halts cleanly when results repeat. For broad catalog collection, browse by genre or releases instead.

Does Beatport Scraper download full MP3 music files?

No. The scraper only collects public store metadata along with URLs for the 30 to 60 second MP3 preview snippets hosted on Beatport's CDN. It does not bypass store paywalls or extract full-length retail audio files.

How reliable is the scraper during unattended automated runs?

In the last 30 days, 231 of 235 runs succeeded (98.3%). Across that period, 0 runs failed and 3 timed out. Together, 1.3% of runs failed or timed out, about 1 in a hundred, making it dependable for scheduled batch scraping.

What should I do if the Actor finishes with zero records and a 401 error?

A persistent 401 indicates that Beatport's catalog API is rejecting your runtime IP address block. The Actor automatically invalidates and retries its anonymous session token once. If the block remains, enable Apify proxy in proxyConfiguration to route requests through a permitted network.

Where to go next

When you are ready to run it, open Beatport Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Beatport Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• iTunes Search Scraper: Scrape the iTunes Search API - search Apple's catalog of music tracks, albums, podcasts, movies, TV shows, audiobooks, and ebooks across 100+ country storefronts.
• Bandcamp Scraper: Scrape Bandcamp, the artist-first music marketplace.
• SoundCloud Scraper: Scrape SoundCloud with search tracks and artists, browse top/trending charts, fetch all tracks from an artist, or fetch any track/playlist/user URL.
• Last.fm Scraper: Scrape Last.fm music data with search artists, tracks, and albums; get weekly top charts; browse by genre/tag; fetch artist top tracks.
• Discogs Scraper: Scrape Discogs, the world's largest music database and marketplace.
• Loaded (CDKeys) Game Key Store Scraper: Scrape Loaded.com (formerly CDKeys.com) - search game keys, browse by platform (PC/PlayStation/Xbox/Nintendo), deals, new releases, gift cards and franchises.

Related guides:

• Kworb Music Charts Scraper: Workflows and Practical Use Cases

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-26.

• Actor last updated by its maintainers on 2026-08-14.

• Run outcome figures cover the 30 day public window ending 2026-09-26.

• Beatport Scraper on Apify