# 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, Lead generation
- **Features:** Limited permissions
- **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

> **This SoundCloud scraper searches SoundCloud and exports 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 — scrape SoundCloud in minutes with no login and no coding.

Export to **JSON, CSV, Excel, or API**.

<p align="center">
  <a href="#"><img src="https://img.shields.io/badge/SoundCloud-Tracks%20%2B%20Artists%20%2B%20Playlists-fb8500" alt="SoundCloud tracks, artists and playlists"></a>
  <a href="#"><img src="https://img.shields.io/badge/Music%20Discovery-A%26R%20%2F%20Playlists%20%2F%20Trends-8250df" alt="Music discovery, A&R, playlists, trends"></a>
  <a href="#"><img src="https://img.shields.io/badge/No%20Login-Required-2da44e" alt="No login required"></a>
  <a href="#"><img src="https://img.shields.io/badge/Export-JSON%20%2F%20CSV%20%2F%20Excel-0b5394" alt="Export JSON, CSV or Excel"></a>
</p>

> Built for **A\&R scouts, label staff, artist managers, playlist curators, music marketers, researchers and data analysts** who need SoundCloud discovery data as a clean, sortable dataset instead of endless manual scrolling.

***

### Table of Contents

- [At a Glance](#at-a-glance)
- [Why scrape SoundCloud?](#-why-scrape-soundcloud)
- [What this SoundCloud scraper does](#-what-this-soundcloud-scraper-does)
- [Use cases](#-use-cases)
- [Input](#-input)
- [Output](#-output)
- [Pagination & scale](#-pagination--scale)
- [How to use](#️-how-to-use)
- [Tips](#-tips)
- [FAQ](#-faq)
- [Related scrapers](#-related-scrapers)
- [Limitations](#limitations)
- [Changelog](#-changelog)

***

### At a Glance

| | |
|---|---|
| **Platform** | [SoundCloud](https://soundcloud.com) (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, label, 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, API |
| **Fresh verification** | 500 unique tracks collected in ~86 s, 0 duplicates, core fields 100% |
| **Deduplication** | Automatic — the same track, artist or playlist never appears twice in a run |

***

### 🔎 Why scrape SoundCloud?

[SoundCloud](https://soundcloud.com) is the largest open audio platform for independent artists, producers and curators — the place new sounds surface long before they reach streaming charts. Every track carries public engagement signals (plays, likes, comments, reposts), every artist profile shows follower numbers and catalog size, and every playlist reveals who curates what and how big their audience is. Taken together, that is a live map of music discovery.

Collecting this by hand is painful. SoundCloud search in a browser means endless scrolling, lazy-loaded results, and copy-pasting numbers that change by the hour. There is no official bulk export, and the figures you care about — plays, followers, track counts — are scattered across pages. For anyone doing A\&R, playlist research or genre analysis at any real volume, manual collection does not scale.

This **SoundCloud scraper** turns that search into a structured dataset. Pick an entity type, type a few terms, and get a clean, deduplicated, sortable table of **SoundCloud data** ready for a spreadsheet, a pipeline or an API — no login, no coding.

**Common reasons people scrape SoundCloud:**

- **Discover rising artists** in a genre, mood or city before they break out.
- **Build playlist-pitching shortlists** from real curator and audience data.
- **Track genre trends** by snapshotting play, like and repost counts over time.
- **Audit a label or scene catalog** by keyword, tag or label name.
- **Size up a scene** — who is active, how big their following is, where they are based.
- **Research licensing and samples** by filtering on the track `license` field.
- **Feed music dashboards and analytics** with fresh SoundCloud discovery data.

***

### ✨ What this SoundCloud scraper 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.

- ✅ **Three collection modes** — search for **tracks**, **artists / users**, or **playlists**, each with its own tailored field set.
- ✅ **Multi-term search** — pass many keywords, genres, moods, cities or artist names; each runs as its own SoundCloud search and results merge into one dataset.
- ✅ **Automatic pagination** — walks SoundCloud's result pages (200 per page) per term and returns hundreds to thousands of **de-duplicated** records, controlled by `maxItems` and `maxPagesPerSearch`.
- ✅ **Cross-term deduplication** — overlapping terms never produce the same track, artist or playlist twice (dedup on SoundCloud's own record ID).
- ✅ **Rich engagement data** — tracks carry **plays, likes, comments, reposts, duration, genre, tags, license, label and artwork**; artists carry **followers, followings, track/playlist counts, city, country, verified badge**; playlists carry **track count, total duration, likes, reposts and an `isAlbum` flag**.
- ✅ **Clean, typed fields** — counts come back as numbers, dates as ISO 8601, URLs fully qualified. Empty fields are omitted, never invented.
- ✅ **No login, no account** — nothing to install and no SoundCloud credentials to maintain.
- ✅ **Fast & reliable** — pure HTTP collection on Apify's datacenter proxy with automatic retry; the fresh verification run pulled 500 tracks in about 86 seconds.
- ✅ **Export anywhere** — JSON, CSV, Excel, HTML table, or straight through the Apify API.

***

### 🎯 Use cases

- **A\&R scouts & label staff** — build artist shortlists by genre, city or sound, ranked by followers and catalog size.
- **Artists & managers** — research playlists and curators for release pitching, with real audience numbers.
- **Playlist curators** — find fresh tracks and benchmark competing playlists in your niche.
- **Music marketers** — size up scenes, genres and competitor catalogs with play and follower data.
- **Researchers & journalists** — study music scenes, genres and online communities with reproducible snapshots.
- **Data analysts & engineers** — pull SoundCloud discovery data into spreadsheets, dashboards or warehouses.
- **Sync & licensing teams** — check `license` types and catalog activity at scale before clearing audio.
- **Trend & growth teams** — schedule repeat runs to turn plays, likes and followers into a growth time series.

***

### 📥 Input

Every field is optional — pressing **Start** with the defaults works out of the box. Configure the run with these parameters:

| Field | Type | Description |
|---|---|---|
| `entityType` | string (select) | What to collect: `tracks`, `users` (artists) or `playlists`. Each type returns its own tailored fields. Default `tracks`. |
| `searchTerms` | array of strings | Keywords, genres, moods or artist names to search for, e.g. `lofi`, `techno`, `berlin techno`. Each term runs as its own search; results merge without duplicates. Leave empty to sample a mix of popular genre searches (~100 results). |
| `maxItems` | integer | Maximum results across all search terms. `0` means no limit. An empty run with no terms is capped at ~100 results. Default `0`. |
| `maxPagesPerSearch` | integer | Pagination cap per search term, at 200 results per page. Raise it for deeper collection on broad terms; lower it for quick samples. Default `20`. |
| `proxyConfiguration` | proxy object | Apify Proxy settings. **Datacenter proxy is enabled by default and is all you need** for normal runs. |

**Example input — collect techno & lofi tracks with engagement data:**

```json
{
  "entityType": "tracks",
  "searchTerms": ["lofi", "techno"],
  "maxItems": 200,
  "maxPagesPerSearch": 20,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

**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
}
```

**Empty run (sample mode):** `{}` samples the default genre mix (`lofi`, `techno`, `house`, `hip hop`, `electronic`) and returns about 100 track results — the fastest way to see the output shape.

***

### 📤 Output

Each result is saved as one structured record. Every record carries `entityType` (`track`, `user` or `playlist`), the SoundCloud `id`, a direct `url`, and `scrapedAt` (ISO timestamp of the run). Fields SoundCloud does not provide for a record are simply omitted — nothing is invented or guessed.

**Example track record** (from the fresh verification run):

```json
{
  "id": 143581807,
  "entityType": "track",
  "title": "DZ - House Every Weekend (Original Mix)",
  "username": "David Zowie (DZ)",
  "userUrl": "https://soundcloud.com/davidzowie",
  "genre": "House",
  "durationSeconds": 219,
  "fullDurationSeconds": 219,
  "playbackCount": 24035751,
  "likesCount": 410018,
  "commentCount": 1907,
  "repostsCount": 43148,
  "createdAt": "2014-04-07T20:40:49Z",
  "url": "https://soundcloud.com/davidzowie/house-every-weekend-original-mix",
  "artworkUrl": "https://i1.sndcdn.com/artworks-000110380527-7vkqel-large.jpg",
  "downloadable": false,
  "downloadCount": 0,
  "license": "all-rights-reserved",
  "tags": ["house", "mix", "promo", "DZ", "David", "Zowie", "edm", "festival", "deep house", "defected", "ministry of sound"],
  "labelName": "Virgin EMI",
  "scrapedAt": "2026-11-02T02:01:37.852Z"
}
```

**Example 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-11-02T02:01:53.096Z"
}
```

**Example playlist record:**

```json
{
  "id": 352480527,
  "entityType": "playlist",
  "title": "CHILL",
  "username": "LoFi",
  "userUrl": "https://soundcloud.com/lofi_chill",
  "trackCount": 416,
  "durationSeconds": 66702,
  "likesCount": 5532,
  "repostsCount": 255,
  "isAlbum": false,
  "genre": "Lofi Chill",
  "createdAt": "2017-09-13T22:02:07Z",
  "url": "https://soundcloud.com/lofi_chill/sets/lofi-chill",
  "scrapedAt": "2026-11-02T02:01:30.393Z"
}
```

#### 🎵 Track field reference

Coverage below is measured from the **fresh verification run (500 tracks, November 2026)**. Counts such as plays and likes change constantly on SoundCloud; coverage describes how often a field is *present*, not the values themselves.

| Field | Coverage | Description |
|---|---|---|
| `id` | 100% | SoundCloud track ID (numeric). Natural key for deduplication. |
| `entityType` | 100% | Always `track` for track searches. |
| `title` | 100% | Track title as written by the uploader. |
| `username` | 100% | Artist / uploader display name. |
| `userUrl` | 100% | Artist profile URL. |
| `durationSeconds` | 100% | Playable duration in seconds. |
| `fullDurationSeconds` | 100% | Full track length in seconds (equals `durationSeconds` unless a preview is shorter). |
| `playbackCount` | 100% | Total plays. |
| `likesCount` | 100% | Total likes. |
| `commentCount` | 100% | Total comments. |
| `repostsCount` | 100% | Total reposts. |
| `downloadable` | 100% | Whether the uploader enabled downloads (boolean). |
| `downloadCount` | 100% | Total downloads (0 when downloads are off). |
| `license` | 100% | License set by the uploader, e.g. `all-rights-reserved` or a Creative Commons license. |
| `createdAt` | 100% | Upload date (ISO 8601). |
| `url` | 100% | Direct track URL. |
| `artworkUrl` | ~93% | Track artwork image. Present when available; missing tracks reuse the artist's avatar. |
| `genre` | ~57% | Genre set by the uploader. Present when available. |
| `description` | ~40% | Track description. Present when the uploader wrote one. |
| `tags` | ~39% | Uploader tags (array; multi-word tags kept intact, de-duplicated). Present when available. |
| `labelName` | ~7% | Record label name. Present when the uploader set one. |
| `scrapedAt` | 100% | When this record was collected (ISO 8601). |

#### 🎤 Artist / user field reference

| Field | Description |
|---|---|
| `id` | SoundCloud user ID. |
| `entityType` | Always `user` for artist searches. |
| `username` | Display name on SoundCloud. |
| `fullName` | Real full name, present when the user provided one. |
| `followersCount` | Total followers. |
| `followingsCount` | Accounts this user follows. |
| `trackCount` | Tracks published. |
| `playlistCount` | Playlists published. |
| `likesCount` | Tracks this user has liked. |
| `city` | City on the profile, present when shared. |
| `countryCode` | Two-letter country code, present when shared. |
| `avatarUrl` | Profile avatar image URL. |
| `url` | Direct profile URL. |
| `description` | Profile bio text, present when written. |
| `verified` | Whether the profile shows a verified badge (boolean). |
| `createdAt` | Account creation date (ISO 8601). |
| `scrapedAt` | When this record was collected (ISO 8601). |

#### 📂 Playlist field reference

| Field | Description |
|---|---|
| `id` | SoundCloud playlist ID. |
| `entityType` | Always `playlist` for playlist searches. |
| `title` | Playlist title. |
| `username` | Curator display name. |
| `userUrl` | Curator profile URL. |
| `trackCount` | Number of tracks in the playlist. |
| `durationSeconds` | Total playlist duration in seconds. |
| `likesCount` | Total likes on the playlist. |
| `repostsCount` | Total reposts of the playlist. |
| `isAlbum` | `true` for a released album, `false` for a curated playlist. SoundCloud playlist search mixes both — this flag separates them. |
| `setType` | Release type when SoundCloud marks one: `album`, `ep` or `single`. Present occasionally; empty for ordinary playlists. |
| `genre` | Genre set by the curator, present when available. |
| `createdAt` | Playlist creation date (ISO 8601). |
| `url` | Direct playlist URL. |
| `artworkUrl` | Playlist artwork image, present when set. |
| `description` | Playlist description, present when written. |
| `tags` | Curator tags (array), present when set. |
| `scrapedAt` | When this record was collected (ISO 8601). |

> **A note on optional fields:** `genre`, `description`, `tags` and `labelName` 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, duration and link fields — present on effectively every record — and treat genre / description / tags / label as bonus detail.

***

### 🔁 Pagination & scale

The actor paginates each search term independently through SoundCloud's search API, **200 results per page**, advancing by offset until a term runs out of results, hits `maxItems`, or reaches `maxPagesPerSearch`. Results from all terms land in one dataset and are **deduplicated on SoundCloud's record ID** (`entityType:id`), so overlapping terms never double-count.

One honest detail matters for planning: **SoundCloud search serves its top relevance slice (~300 results) per term**, however many millions match the query. That ceiling is SoundCloud's, not the actor's. **Scale comes from combining terms** — each additional term (a sub-genre, mood, city or label) adds its own deduplicated slice. Splitting a broad topic (`techno`) into narrower terms (`melodic techno`, `hard techno`, `acid techno`, `berlin techno`) is how runs grow into the thousands and beyond. Use `maxItems` to cap total run size and cost; use `maxPagesPerSearch` to tune per-term depth.

In the **fresh verification run**, an 8-term track search (`lofi`, `techno`, `house`, `hip hop`, `jazz`, `ambient`, `drum and bass`, `deep house`) with `maxItems: 500` returned exactly **500 unique tracks in ~86 seconds with 0 duplicates** — confirming pagination and cross-term dedup work cleanly.

***

### ⚙️ How to use

1. **Open the actor** on the Apify Console — no installation needed.
2. **Choose what to search** — set `entityType` to Tracks, Artists / Users, or Playlists.
3. **Add search terms** — genres, moods, artist names, or genre-plus-city combinations. Add several to widen coverage; duplicates are removed automatically.
4. **Set a cap** — use `maxItems` to control run size, or leave `0` for no limit.
5. **Click Start** and watch records fill the dataset preview; the log shows each term's match count and page-by-page progress.
6. **Export** as JSON, CSV, Excel or HTML, or pull results through the **Apify API** / client libraries.
7. **Automate it** — run on an Apify **schedule** (e.g. weekly) and connect the output to **Make, Zapier, Google Sheets, a webhook**, Google Drive, S3 or your warehouse.

#### Pull results with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("haketa/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"])
```

***

### 💡 Tips

- **Split broad genres into sub-genres.** `techno` alone returns only its top 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.
- **Try several spellings and moods.** Listeners tag loosely: `lofi`, `lo-fi`, `chillhop` and `study beats` return overlapping but different result sets.
- **Start small, then scale.** Run 100–200 results first to check output shape and field coverage for your terms, then raise `maxItems` 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 fast follower growth relative to a small 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 (every record carries `scrapedAt`).
- **Check `license` before reuse.** Filter track exports by `license` when you need Creative Commons material — and always confirm the license on the track page before using any audio.

***

### ❓ FAQ

**Is scraping SoundCloud legal?**
This SoundCloud scraper collects only **publicly visible search results** — the same data any visitor sees without logging in. It does not access private, unlisted or login-gated content, and it never invents data. As with any scraping, use the collected data responsibly, respect copyright and SoundCloud's terms, and do not use it to spam or infringe. This tool is not affiliated with SoundCloud.

**Do I need a SoundCloud account or login?**
No. The **SoundCloud scraper** works with no account, no login and no API key. Choose an entity type, add search terms, and run.

**How many results can I collect, and how fast?**
Set `maxItems` to any number, or `0` for no limit. SoundCloud serves its top ~300 results per term, so one term yields up to ~300 records; combining terms scales linearly (deduplicated) into the thousands. The fresh verification run collected **500 unique tracks in ~86 seconds**.

**Do I need proxies?**
Apify **datacenter proxy is on by default and is all you need** for normal runs — residential proxies are not required. The actor fetches over plain HTTP with automatic retry and session refresh.

**Is there an API?**
Yes. Run the actor and fetch its dataset through the **Apify API** or the Python / JavaScript clients (see the code example above). You can also trigger runs programmatically and stream results to a webhook.

**In what formats can I export the data?**
**JSON, CSV, Excel and HTML table** from the dataset view, plus programmatic access through the Apify API and client libraries.

**How fresh is the SoundCloud data?**
Every run is live — counts reflect the moment of collection, and each record carries a `scrapedAt` timestamp. Re-run (or schedule) to refresh numbers and build trend series.

**Can I filter by genre, city or artist?**
You filter by what you type into `searchTerms`: genres (`techno`), cities (`berlin techno`, `istanbul`), moods (`study beats`) or artist names. The returned `genre` field (present on ~57% of tracks) lets you filter further after export.

**What is the difference between Tracks, Artists / Users and Playlists?**
**Tracks** are individual songs with engagement counts. **Artists / Users** are profiles with follower counts, track counts and locations. **Playlists** are curated sets with a curator, track count and total duration. Set `entityType` to match what you want.

**Can I tell albums apart from curated playlists?**
Yes. A playlist search returns both. Every playlist record carries an `isAlbum` boolean (and a `setType` of `album`, `ep` or `single` when SoundCloud marks it). Filter on `isAlbum` to keep only albums or only playlists.

**Why are genre, description and tags missing on some tracks?**
Those fields are typed in by uploaders, and many leave them empty. The actor reports exactly what SoundCloud provides and never fills gaps with guesses. In the fresh run, `genre` was present on ~57% of tracks, `description` on ~40% and `tags` on ~39% — 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.

***

### 🔗 Related scrapers

Building a music, audio or creator dataset? Pair this **SoundCloud scraper** with other music-data actors to enrich artists, tracks and releases across platforms:

- [Podchaser Scraper](https://apify.com/haketa/podchaser-scraper) — podcast shows, episodes and creator data for audio and spoken-word research.
- [Genius Scraper](https://apify.com/haketa/genius-scraper) — song lyrics, annotations, artists and album metadata to add songwriting and credits context to your SoundCloud tracks.
- [Discogs Scraper](https://apify.com/haketa/discogs-scraper) — release, artist and label discography data with marketplace pricing for catalog and resell research.

Browse the full collection on the [haketa Apify profile](https://apify.com/haketa).

***

### Limitations

- **Search-based collection.** The actor collects what SoundCloud search returns for your terms. It does not crawl follower lists, comment threads, or an artist's full catalog beyond what search surfaces.
- **Relevance slice on broad terms.** Extremely broad single terms return their top ~300 relevance slice 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 (see coverage above). 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 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.** Private tracks and unlisted content that search does not show are not included.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Deep pagination unlocked**: Added automatic and unlimited pagination support (`maxPagesPerSearch: 0`) governed by user-defined `maxItems` limits, enabling 1,000+ track and artist extractions without manual page cap restrictions.
- **Optimized default run**: Expanded default genre search pool (20 distinct music genres) to guarantee robust volume scaling up to 1,000+ items on empty query runs.
- **Faster prefill execution**: Tuned default prefill to 100 items for high-speed verification (<60s runtime).
- **Field normalization**: Strengthened tag quote-aware parsing, enhanced engagement counter fallback handling, and verified strict schema alignment.

#### v1.1 (2026-10)

- **Multi-entity extraction**: Added support for searching tracks, artist profiles, and curated playlists/albums via unified `entityType` switch.
- **Smart session management**: Built-in automatic session recovery and token cycling for uninterrupted large catalog extractions.
- **Cross-term deduplication**: Integrated real-time track and profile deduplication across multiple simultaneous search terms.

#### v1.0 (2026-09)

- Initial release with keyword-based track extraction, engagement metrics (plays, likes, reposts, comments), duration calculation, and multi-format exports.

***

*SoundCloud scraper · scrape SoundCloud · SoundCloud API · SoundCloud data · music discovery · artist finder · playlist research · genre trend tracking · A\&R scouting · label catalog research*

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/soundcloud-scraper/changelog.md

# 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`):

Maximum pages to scrape per search term (up to 200 items per page). Set to 0 (default) for automatic / unlimited pagination governed by Max results.

## `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": 100,
  "maxPagesPerSearch": 0,
  "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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "lofi",
        "techno",
        "house"
    ],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": [
        "lofi",
        "techno",
        "house",
    ],
    "maxItems": 100,
    "maxPagesPerSearch": 0,
    "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": 100,
  "maxPagesPerSearch": 0,
  "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 <APIFY_API_TOKEN>` 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/3CmN9etmAoT3AhCzP/openapi.json