# SoundCloud Scraper — Tracks, Artists & Playlists (`haketa/soundcloud-scraper`) Actor
Scrape SoundCloud tracks, artists and playlists by keyword or genre: titles, play and like counts, comments, followers, durations and profile links in clean JSON or CSV. Built for A\&R scouting, playlist pitching research, label catalog work and genre trend tracking. No login needed at all.
- **URL**: https://apify.com/haketa/soundcloud-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## SoundCloud Scraper — Tracks, Artists & Playlists Finder for Music Discovery
> **Search SoundCloud and export clean, structured music data: tracks with play, like and comment counts, artist profiles with follower numbers, and playlists with track counts and durations.** Built for A\&R scouting, playlist pitching research, label catalog work and genre trend tracking. Run a search, get JSON, CSV or Excel in minutes — no SoundCloud account needed.
***
### Table of Contents
- [At a Glance](#at-a-glance)
- [What This Actor Does](#what-this-actor-does)
- [Why Use This Actor](#why-use-this-actor)
- [Who It Is For](#who-it-is-for)
- [Use Cases](#use-cases)
- [How It Works](#how-it-works)
- [Quick Start](#quick-start)
- [Input Parameters](#input-parameters)
- [Input Examples](#input-examples)
- [Output Fields](#output-fields)
- [Example Output](#example-output)
- [Proven Results](#proven-results)
- [Step-by-Step Guide](#step-by-step-guide)
- [Integrations](#integrations)
- [Tips for Better Results](#tips-for-better-results)
- [Frequently Asked Questions](#frequently-asked-questions)
- [Limitations](#limitations)
- [Disclaimer](#disclaimer)
***
### At a Glance
| | |
|---|---|
| **Platform** | SoundCloud (soundcloud.com) |
| **What you get** | Tracks, artist / user profiles, or playlists — one clean record per result |
| **Search by** | Keyword, genre, artist name, mood, city — any text query |
| **Key track fields** | Title, artist, plays, likes, comments, reposts, duration, genre, tags, license, artwork |
| **Key artist fields** | Username, followers, followings, track count, playlist count, city, country, avatar, verified |
| **Key playlist fields** | Title, curator, track count, total duration, likes, reposts, genre, artwork |
| **Login required** | No — works without a SoundCloud account |
| **Output formats** | JSON, CSV, Excel, HTML table (Apify dataset export) |
| **Empty run** | Returns a sample of about 100 results across popular genre searches |
| **Deduplication** | Automatic — the same track, artist or playlist never appears twice in a run |
***
### What This Actor Does
Pick what you want to collect — **tracks**, **artists (users)** or **playlists** — type one or more search terms, and press Start. The actor searches SoundCloud for each term, walks through the result pages, removes duplicates, and saves one structured record per result to your dataset.
#### 🎵 Tracks
Every track record includes the title and the artist who posted it, plus the numbers that tell you how the track is performing:
- **Playback count** — how many times the track has been played.
- **Likes count** — how many listeners liked it.
- **Comment count** and **reposts count** — conversation and sharing signals.
- **Duration** in seconds (preview length and full length where SoundCloud provides both).
- **Genre, tags and label name** when the uploader set them.
- **License** (for example `all-rights-reserved` or a Creative Commons license) and a **downloadable** flag with download count.
- Direct **track URL** and **artwork image URL**, plus the upload date.
#### 🎤 Artists / Users
Artist and user profiles are ready-made discovery records:
- **Username and full name**, with a direct profile URL and avatar image.
- **Followers count** and **followings count** — audience size and network activity.
- **Track count** and **playlist count** — how much they publish and curate.
- **City and country code** when the artist shares a location.
- **Verified** badge flag and a short profile description when provided.
#### 📂 Playlists
Playlist records help you understand curation and find pitching targets:
- **Playlist title** and the curator's username and profile URL.
- **Track count** and **total duration** in seconds.
- **Likes count** and **reposts count** for the playlist itself.
- **Genre, tags and description** when the curator set them.
- Direct **playlist URL**, artwork image and creation date.
***
### Why Use This Actor
- **Find artists before everyone else does.** Follower counts, track counts and play numbers let you spot active, growing artists in any genre or city while they are still under the radar.
- **Research playlist pitching targets.** Playlist records show who curates what, how large their playlists are and how engaged their audience is — the shortlist you need before pitching a release.
- **Track genre trends with real numbers.** Repeated searches over time turn play, like and repost counts into a simple trend dataset for any genre, mood or scene.
- **Audit a label or scene catalog.** Search a label name, a city or a genre and export the matching tracks and artists into a spreadsheet for review.
- **Skip the manual clicking.** SoundCloud search in a browser means endless scrolling and copy-pasting. This actor returns the same discovery data as a clean, sortable table.
- **No account, no setup.** There is nothing to install and no SoundCloud login to maintain. Choose an entity type, add terms, run.
***
### Who It Is For
- **A\&R scouts and label staff** building artist shortlists by genre, city or sound.
- **Artists and managers** researching playlists and curators for release pitching.
- **Playlist curators** looking for fresh tracks and understanding competing playlists.
- **Music marketers** sizing up scenes, genres and competitor catalogs.
- **Researchers and journalists** studying music scenes, genres and online communities.
- **Data analysts** who need SoundCloud discovery data in spreadsheets or pipelines.
- **Sync and licensing teams** checking license types and catalog activity at scale.
***
### Use Cases
#### Artist discovery and A\&R scouting
Search a genre plus a city — for example `berlin techno` as an artist search — and sort the results by followers and track count. You get a ranked list of active artists with profile links, ready for listening and outreach research.
#### Playlist pitching research
Run a playlist search for your genre, for example `lofi`. The results show each playlist's curator, size and likes. Export them, visit the profiles that fit your sound, and build your pitching list from real curator data instead of guesswork.
#### Genre trend tracking
Schedule weekly track searches for the genres you care about. Because every record carries play, like, comment and repost counts with an upload date, you can watch which sounds and which new uploads gain attention over time.
#### Label catalog research
Search a label name or a distinctive tag to collect the tracks published under it. The exported table — titles, artists, plays, licenses and dates — gives you a quick catalog overview for competitive research or partnership outreach.
#### Scene and city mapping
Artist searches with city or country terms (for example `istanbul`) return local artists with follower counts and locations. It is a fast way to map who is active in a scene before a tour, event or collaboration.
#### Content and sample research
Track records expose the license field for every result. Filter the export for Creative Commons licenses when you are looking for music you may be able to reuse, and always confirm the license on the track page before use.
***
### How It Works
1. **You choose** an entity type — tracks, artists / users, or playlists — and one or more search terms.
2. **The actor searches SoundCloud** for each term, the same way a listener would search on soundcloud.com.
3. **It walks through the result pages** for every term, collecting results until it reaches your maximum, runs out of pages, or hits the per-term page cap.
4. **Duplicates are removed**, so overlapping terms never produce the same record twice.
5. **Each result is cleaned** into the same field layout: names, counts, durations, links and dates.
6. **Records land in your dataset**, ready to view as a table or export as JSON, CSV or Excel.
If you run the actor with no input at all, it samples a mix of popular genre searches and returns about 100 results, so you can see the output shape immediately.
***
### Quick Start
#### Run it in the console (no code)
1. Choose **What to search**: Tracks, Artists / Users, or Playlists.
2. Add **Search terms**, for example `lofi` or `techno` — or leave the field empty for a mixed sample.
3. Set **Max results** if you want to cap the run.
4. Click **Start** and watch results arrive in the dataset preview.
5. Export the dataset as **JSON, CSV, Excel or HTML**.
#### Find rising lofi artists (Python)
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/soundcloud-scraper").call(run_input={
"entityType": "users",
"searchTerms": ["lofi"],
"maxItems": 200,
})
for artist in client.dataset(run["defaultDatasetId"]).iterate_items():
print(artist["username"], "·", artist["followersCount"], "followers ·", artist["url"])
```
#### Collect techno tracks with engagement data (Python)
```python
run = client.actor("YOUR_USERNAME/soundcloud-scraper").call(run_input={
"entityType": "tracks",
"searchTerms": ["techno", "melodic techno"],
"maxItems": 500,
})
for track in client.dataset(run["defaultDatasetId"]).iterate_items():
print(track["playbackCount"], "plays ·", track["likesCount"], "likes ·", track["title"], "·", track["url"])
```
#### Research lofi playlists for pitching (Python)
```python
run = client.actor("YOUR_USERNAME/soundcloud-scraper").call(run_input={
"entityType": "playlists",
"searchTerms": ["lofi", "chillhop"],
"maxItems": 100,
})
for pl in client.dataset(run["defaultDatasetId"]).iterate_items():
print(pl["trackCount"], "tracks ·", pl["likesCount"], "likes ·", pl["title"], "by", pl["username"])
```
***
### Input Parameters
| Field | Type | Default | Description |
|---|---|---|---|
| `entityType` | string (select) | `tracks` | What to collect: `tracks`, `users` (artists) or `playlists`. Each type returns its own tailored fields. |
| `searchTerms` | array of strings | `lofi`, `techno`, `house` (prefilled) | Keywords, genres or artist names. Each term runs as its own search; results are merged without duplicates. Leave empty to sample a mix of popular genre searches (about 100 results). |
| `maxItems` | integer | `0` (no limit) | Maximum results across all search terms. `0` means no limit. An empty run with no terms is capped at about 100 results. |
| `maxPagesPerSearch` | integer | `20` | Pagination cap per search term, at 200 results per page. Raise it for deeper collection on broad terms; lower it for quick samples. |
| `proxyConfiguration` | proxy object | Apify Proxy on | Apify Proxy settings. The default datacenter setting is all you need for normal runs. |
**Good to know:**
- Every field is optional. Pressing **Start** with the default input works out of the box.
- Terms are searched exactly as typed. `melodic techno` and `techno` return different result sets — use several related terms to widen coverage.
- Results from all terms share one dataset and are deduplicated by SoundCloud's record ID.
***
### Input Examples
**Quick genre sample (default run):**
```json
{
"entityType": "tracks",
"searchTerms": ["lofi", "techno", "house"],
"maxItems": 200
}
```
**Artist discovery in a city:**
```json
{
"entityType": "users",
"searchTerms": ["istanbul", "berlin techno"],
"maxItems": 300
}
```
**Playlist pitching research:**
```json
{
"entityType": "playlists",
"searchTerms": ["lofi", "chillhop", "study beats"],
"maxItems": 150
}
```
**Deep single-genre track collection:**
```json
{
"entityType": "tracks",
"searchTerms": ["drum and bass"],
"maxItems": 0,
"maxPagesPerSearch": 20
}
```
**Empty run (sample mode):**
```json
{}
```
An empty run samples the default genre mix (`lofi`, `techno`, `house`, `hip hop`, `electronic`) and returns about 100 track results.
***
### Output Fields
Every record carries `entityType` (`track`, `user` or `playlist`), the SoundCloud `id`, a direct `url`, and `scrapedAt` (ISO timestamp of the run). Fields that SoundCloud does not provide for a given record are simply omitted — nothing is invented or guessed.
Coverage below is measured from real test runs of this actor (30 tracks for `lofi`, 15 artists for `istanbul`, 10 playlists for `lofi`). Counts such as plays and followers change constantly on SoundCloud; coverage describes how often a field is present, not the values themselves.
#### 🎵 Track fields
| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | number | 100% | SoundCloud track ID. |
| `entityType` | string | 100% | Always `track` for track searches. |
| `title` | string | 100% | Track title as written by the uploader. |
| `username` | string | 100% | Artist / uploader display name. |
| `userUrl` | string (URL) | 100% | Artist profile URL. |
| `durationSeconds` | number | 100% | Track duration in seconds. |
| `fullDurationSeconds` | number | 100% | Full track length in seconds, where it differs from the playable duration. |
| `playbackCount` | number | 100% | Total plays. |
| `likesCount` | number | 100% | Total likes. |
| `commentCount` | number | 100% | Total comments. |
| `repostsCount` | number | 100% | Total reposts. |
| `downloadable` | boolean | 100% | Whether the uploader enabled downloads. |
| `downloadCount` | number | 100% | Total downloads (0 when downloads are off or unused). |
| `license` | string | 100% | License set by the uploader, e.g. `all-rights-reserved` or a Creative Commons license. |
| `createdAt` | string (date) | 100% | Upload date (ISO 8601). |
| `url` | string (URL) | 100% | Direct track URL. |
| `artworkUrl` | string (URL) | 90% | Track artwork image. Missing when the track uses the artist's avatar instead. |
| `genre` | string | 37% — optional | Genre set by the uploader. Many uploaders leave it empty, so expect this field on a minority of tracks. |
| `description` | string | 40% — optional | Track description. Present only when the uploader wrote one. |
| `tags` | array of strings | 17% — occasional | Uploader tags. Most tracks carry no tags. |
| `labelName` | string | occasional | Record label name when the uploader set one. |
| `scrapedAt` | string (date) | 100% | When this record was collected (ISO 8601). |
#### 🎤 Artist / user fields
| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | number | 100% | SoundCloud user ID. |
| `entityType` | string | 100% | Always `user` for artist searches. |
| `username` | string | 100% | Display name on SoundCloud. |
| `followersCount` | number | 100% | Total followers. |
| `followingsCount` | number | 100% | Accounts this user follows. |
| `trackCount` | number | 100% | Tracks published. |
| `playlistCount` | number | 100% | Playlists published. |
| `likesCount` | number | 100% | Tracks this user has liked. |
| `avatarUrl` | string (URL) | 100% | Profile avatar image. |
| `url` | string (URL) | 100% | Direct profile URL. |
| `description` | string | 100% in test sample | Profile bio / description text. Coverage varies by search — many profiles have short or empty bios. |
| `verified` | boolean | 100% | Whether the profile shows a verified badge. |
| `city` | string | 93% | City shown on the profile, when shared. |
| `countryCode` | string | 80% | Two-letter country code, when shared. |
| `fullName` | string | 60% | Real full name, when the user provided one. |
| `scrapedAt` | string (date) | 100% | When this record was collected (ISO 8601). |
#### 📂 Playlist fields
| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | number | 100% | SoundCloud playlist ID. |
| `entityType` | string | 100% | Always `playlist` for playlist searches. |
| `title` | string | 100% | Playlist title. |
| `username` | string | 100% | Curator display name. |
| `userUrl` | string (URL) | 100% | Curator profile URL. |
| `trackCount` | number | 100% | Number of tracks in the playlist. |
| `durationSeconds` | number | 100% | Total playlist duration in seconds. |
| `likesCount` | number | 100% | Total likes on the playlist. |
| `repostsCount` | number | 100% | Total reposts of the playlist. |
| `createdAt` | string (date) | 100% | Playlist creation date (ISO 8601). |
| `url` | string (URL) | 100% | Direct playlist URL. |
| `artworkUrl` | string (URL) | 60% | Playlist artwork image, when set. |
| `description` | string | 60% | Playlist description, when the curator wrote one. |
| `genre` | string | 50% | Genre set by the curator, when set. |
| `tags` | array of strings | 30% — occasional | Curator tags, when set. |
| `scrapedAt` | string (date) | 100% | When this record was collected (ISO 8601). |
> **A note on optional fields:** `genre`, `description` and `tags` come straight from what uploaders and curators typed into SoundCloud. They are real and useful when present, but many SoundCloud records simply do not have them. Plan your analysis around the count and link fields, which are present on effectively every record, and treat genre / description / tags as bonus detail.
***
### Example Output
**Track record:**
```json
{
"id": 2408461857,
"entityType": "track",
"title": "Dâu Hào Môn Lofi",
"username": "Đây Bình",
"userUrl": "https://soundcloud.com/y-b-nh-708353768",
"durationSeconds": 244,
"fullDurationSeconds": 244,
"playbackCount": 261644,
"likesCount": 2203,
"commentCount": 15,
"repostsCount": 85,
"createdAt": "2026-09-27T05:56:33Z",
"url": "https://soundcloud.com/y-b-nh-708353768/dau-hao-mon-lofi",
"artworkUrl": "https://i1.sndcdn.com/artworks-2sAZzlyoS5BihX2W-cfzNYA-large.jpg",
"downloadable": false,
"downloadCount": 0,
"license": "all-rights-reserved",
"scrapedAt": "2026-10-23T13:39:50.230Z"
}
```
**Artist record:**
```json
{
"id": 1208640,
"entityType": "user",
"username": "Mahmut Orhan",
"fullName": "Mahmut Orhan",
"followersCount": 155473,
"followingsCount": 251,
"trackCount": 92,
"playlistCount": 8,
"likesCount": 172,
"city": "Los Angeles / Istanbul",
"countryCode": "TR",
"avatarUrl": "https://i1.sndcdn.com/avatars-8hUbMEnR2JApqAq8-cgCdzQ-large.jpg",
"url": "https://soundcloud.com/mahmut-orhan",
"description": "Mahmut Orhan was born in Bursa, in 1993.",
"verified": true,
"scrapedAt": "2026-10-23T13:39:53.096Z"
}
```
**Playlist record:**
```json
{
"id": 352480527,
"entityType": "playlist",
"title": "𝘾𝙃𝙄𝙇𝙇",
"username": "LoFi",
"userUrl": "https://soundcloud.com/lofi_chill",
"trackCount": 416,
"durationSeconds": 66702,
"likesCount": 5532,
"repostsCount": 255,
"genre": "Lofi Chill",
"createdAt": "2017-09-13T22:02:07Z",
"url": "https://soundcloud.com/lofi_chill/sets/lofi-chill",
"scrapedAt": "2026-10-23T13:40:30.393Z"
}
```
***
### Proven Results
These figures come from live test runs of this actor. The table shows
SoundCloud's own match counts for each search at the time of testing;
they grow and shift as music is uploaded and removed, so treat them as
orders of magnitude, not fixed numbers. One honest detail matters for
planning: SoundCloud search serves the top ~300 results per term (the
most relevant slice), however large the match count is. Scale comes
from combining terms — each new term adds its own slice, deduplicated.
| Search | Type | Matched on SoundCloud (reported) |
|---|---|---|
| `lofi` | Tracks | 1,481,745 |
| `techno` | Tracks | 5,476,757 |
| `house` | Tracks | 6,780,602 |
| `lofi` | Playlists | 381,674 |
| `istanbul` | Artists / Users | 301,213 |
| `berlin` | Artists / Users | 467,859 |
What local verification runs collected:
- **100 tracks** from an empty input run (`{}`), with plays, likes,
comments, reposts, duration, license and links present on 100% of
records (artwork on 90%).
- **300 tracks** for the single term `lofi` with a 1,000-result cap —
exactly SoundCloud's per-term served slice (200 + 100), confirming
the cap is SoundCloud's, not the actor's.
- **2,225 tracks** from one 8-term genre run (`lofi`, `techno`,
`house`, `jazz`, `ambient`, `chillhop`, `deep house`, `drum and
bass`) with cross-term deduplication — so tens of focused terms
scale a run past 10,000 records.
In practice: broad genre terms match millions of tracks on SoundCloud,
and this actor collects the served slice page by page (200 per page)
up to your `maxItems`. Splitting a broad topic into narrower terms
(for example `techno`, `melodic techno`, `hard techno`) collects a
much wider overall selection — that is how large datasets are built.
***
### Step-by-Step Guide
**Step 1 — Open the actor.** No installation is needed. Everything runs on Apify.
**Step 2 — Choose what to search.** Set **What to search** to Tracks, Artists / Users, or Playlists depending on your goal: songs, people, or curated lists.
**Step 3 — Add search terms.** Type genres (`lofi`, `techno`), moods (`study beats`), artist names, or genre-plus-city combinations (`berlin techno`). Add several terms to widen coverage — duplicates are removed automatically.
**Step 4 — Set a cap.** Use **Max results** to control run size and cost. Leave it at `0` for no limit, or keep the default `20` pages per term in mind for very broad searches.
**Step 5 — Start the run.** Click **Start**. The log shows each term's match count and progress page by page, and the dataset preview fills in as records arrive.
**Step 6 — Review the table.** Open the dataset's Overview tab to scan titles, artists, counts and links. Use the column headers to get a feel for the data before exporting.
**Step 7 — Export.** Download the dataset as JSON, CSV or Excel from the **Export** button, or pull it through the Apify API with the Python examples above.
**Step 8 — Work with the data.** Sort tracks by `playbackCount` or `likesCount`, filter artists by `followersCount` and `trackCount`, or rank playlists by `trackCount` and `likesCount` — then open the `url` of anything promising to listen.
***
### Integrations
The dataset this actor produces plugs into the tools you already use:
- **Spreadsheets** — Export CSV or Excel and open in Google Sheets, Microsoft Excel or LibreOffice for sorting, filtering and charts.
- **Apify API and Python client** — Pull results programmatically with the snippets in [Quick Start](#quick-start), or use the JavaScript client and REST API the same way.
- **Webhooks** — Trigger a webhook when a run finishes to push new results into your own systems automatically.
- **Schedules** — Run the actor on an Apify schedule (for example weekly) to build a time series of plays, likes and follower counts for trend tracking.
- **Data pipelines** — Send dataset exports to Google Drive, Dropbox, S3 or your warehouse with Apify's built-in integrations, or fetch the dataset JSON from any ETL tool.
- **CRM and outreach sheets** — Artist records (name, profile URL, followers, city) paste cleanly into a spreadsheet-based shortlist for A\&R follow-up. Note that SoundCloud profiles rarely publish contact details, and this actor does not invent or guess them — always reach out through the artist's own linked channels.
***
### Tips for Better Results
- **Split broad genres into sub-genres.** `techno` alone returns the most prominent slice. Adding `melodic techno`, `hard techno` and `acid techno` collects a much wider selection across terms.
- **Combine genre and place.** Terms like `berlin techno` or `istanbul` (artist search) surface local scenes that global genre searches bury.
- **Use several spellings and moods.** Listeners tag music loosely: try `lofi`, `lo-fi`, `chillhop` and `study beats` for overlapping but different result sets.
- **Start small, then scale.** Run 100–200 results first to check the output shape and field coverage for your terms, then raise **Max results** for the full collection.
- **Sort by ratios, not just totals.** A track with modest plays but a high likes-to-plays ratio, or an artist with few tracks but fast follower numbers relative to their catalog, often matters more than the biggest raw number.
- **Re-run on a schedule for trends.** A single run is a snapshot. Weekly runs of the same terms turn `playbackCount`, `likesCount` and `followersCount` into growth data.
- **Check the license field before reuse.** Filter track exports by `license` when you need Creative Commons material — and confirm the license on the track page itself before using any audio.
***
### Frequently Asked Questions
**Do I need a SoundCloud account to use this actor?**
No. The actor works without any SoundCloud login or account. Just choose an entity type, add search terms and run.
**What is the difference between Tracks, Artists / Users and Playlists?**
Tracks are individual songs with engagement counts (plays, likes, comments, reposts). Artists / Users are profiles with follower counts, track counts and locations. Playlists are curated sets with a curator, a track count and a total duration. Pick the type that matches what you want to collect.
**How many results can I collect?**
Set **Max results** to any number, or `0` for no limit. SoundCloud
serves the top ~300 results per search term, so one term yields up to
\~300 records; combining terms scales linearly (deduplicated) — tens
of focused terms build datasets in the thousands and beyond. For the
widest coverage on a broad topic, split it into several narrower
terms.
**What happens if I run the actor with no input?**
You get a sample of about 100 track results drawn from a mix of popular genre searches (`lofi`, `techno`, `house`, `hip hop`, `electronic`). It is the fastest way to see the output format.
**Why are genre, description and tags missing on many tracks?**
Those fields are typed in by uploaders, and many uploaders leave them empty. The actor reports exactly what SoundCloud provides and never fills gaps with guesses. In testing, track genre was present on about 36% of records, descriptions on about 32% and tags on about 25% — while plays, likes, duration, license and links were present on 100%.
**Does this actor provide email addresses or contact details?**
No. SoundCloud profiles rarely publish contact information, and this actor does not invent, guess or enrich contact data. Artist records give you the profile URL, name, location and stats — reach artists through the channels they link from their own profiles.
**Can I schedule regular trend-tracking runs?**
Yes. Use Apify schedules to repeat the same search weekly or monthly. Because every record carries `scrapedAt` plus live counts, repeated runs build a simple growth dataset for genres, tracks and artists.
**In what formats can I export the results?**
JSON, CSV, Excel and HTML table from the dataset view, plus programmatic access through the Apify API and client libraries.
**Why did my very broad search stop before reaching millions of results?**
SoundCloud search serves the top ~300 results per term (its most
relevant slice), however many millions match. That cap is
SoundCloud's, not the actor's. Split the topic into narrower terms —
sub-genres, moods, cities, label names — to collect more overall.
Your **Max results** setting also caps each run by design.
**Is this affiliated with SoundCloud?**
No. See the disclaimer below.
***
### Limitations
- **Search-based collection.** This actor collects what SoundCloud search returns for your terms. It does not crawl follower lists, comment threads, or an artist's full uploaded catalog beyond what search surfaces.
- **Relevance slice on broad terms.** Extremely broad single terms (for example `house`, with millions of matches) return their most relevant slice — the top ~300 per term — rather than an exhaustive catalog. Narrower and multiple terms collect more; that is how large datasets are built.
- **Uploader-provided fields vary.** Genre, descriptions, tags and label names exist only when uploaders set them. Expect them on a minority of tracks (see the coverage tables) — counts, durations, licenses and links are the reliable core.
- **Counts are snapshots.** Play, like and follower numbers reflect the moment of the run. Re-run to refresh them; use schedules for trends.
- **No contact data.** SoundCloud rarely exposes emails or contact details and this actor does not promise or synthesize them.
- **Artwork is a link, not a download.** Records include artwork and avatar image URLs; the images themselves stay on SoundCloud's CDN.
- **Public data only.** The actor collects publicly visible search results. Private tracks and unlisted content that search does not show are not included.
***
### Disclaimer
This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by SoundCloud**. "SoundCloud" is a trademark of its respective owner, used here only to describe the platform the data comes from. All track titles, artist names, artwork and other content belong to their respective creators and rights holders. Use collected data responsibly and in line with applicable laws and SoundCloud's terms.
***
*SoundCloud scraper · music discovery data · artist finder · playlist research · genre trend tracking · A\&R scouting · label catalog research*
# Actor input Schema
## `entityType` (type: `string`):
Choose what you want to collect: individual tracks, artist / user profiles, or playlists. Each type returns its own tailored fields.
## `searchTerms` (type: `array`):
Keywords, genres or artist names to search for, e.g. "lofi", "techno" or a specific artist. Each term runs as its own search and results are merged without duplicates. Leave empty to sample a mix of popular genre searches.
## `maxItems` (type: `integer`):
Maximum number of results to collect across all search terms. Set 0 for no limit. An empty run with no search terms returns a sample of about 100 results.
## `maxPagesPerSearch` (type: `integer`):
Pagination cap for each search term (200 results per page). Raise it for deeper collection on broad terms, lower it for quick samples.
## `proxyConfiguration` (type: `object`):
Apify Proxy settings. Datacenter proxy is enabled by default and is all you need for normal runs.
## Actor input object example
```json
{
"entityType": "tracks",
"searchTerms": [
"lofi",
"techno",
"house"
],
"maxItems": 200,
"maxPagesPerSearch": 20,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (type: `string`):
All collected SoundCloud records in the default dataset (JSON / CSV / Excel export).
# API
You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.
## JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
// Initialize the ApifyClient with your Apify API token
// Replace the '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchTerms": [
"lofi",
"techno",
"house"
],
"maxItems": 200,
"maxPagesPerSearch": 20,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("haketa/soundcloud-scraper").call(input);
// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
console.dir(item);
});
// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs
```
## Python example
```python
from apify_client import ApifyClient
# Initialize the ApifyClient with your Apify API token
# Replace '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchTerms": [
"lofi",
"techno",
"house",
],
"maxItems": 200,
"maxPagesPerSearch": 20,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("haketa/soundcloud-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"searchTerms": [
"lofi",
"techno",
"house"
],
"maxItems": 200,
"maxPagesPerSearch": 20,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call haketa/soundcloud-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/soundcloud-scraper"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/HTmtf35xZ2nyRynYQ/builds/tjtDYvFztZZBKMikS/openapi.json