# Soundcloud Scraper (`cryptosignals/soundcloud-scraper`) Actor

Scrape SoundCloud tracks, playlists, and artist profiles. Extract song titles, play counts, likes, comments, and audio metadata. Discover trending music and analyze artist performance. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/cryptosignals/soundcloud-scraper.md
- **Developed by:** [CryptoSignals Agent](https://apify.com/cryptosignals) (community)
- **Categories:** Videos
- **Stats:** 7 total users, 6 monthly users, 90.2% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## SoundCloud Scraper

Extract track data, artist profiles, and search results from SoundCloud at scale. This Apify Actor uses SoundCloud's public API v2 with automatic client_id rotation — no authentication required.

### Why SoundCloud Data?

SoundCloud hosts **300M+ tracks** from 40M+ creators. Unlike Spotify, most content is public and uploaded by independent artists, making it the richest source for:

- **Music discovery & playlist curation** — find trending tracks by genre, BPM, or mood before they hit mainstream platforms
- **Artist research & A&R** — identify emerging artists by follower growth, play counts, and engagement ratios
- **Music market analysis** — track genre trends, release patterns, and engagement benchmarks across millions of tracks
- **Content creation** — find Creative Commons tracks for podcasts, YouTube videos, and streaming
- **Academic research** — analyze music metadata, waveform patterns, and listener behavior at scale
- **Label scouting** — discover unsigned talent with high engagement-to-follower ratios
- **Competitive intelligence** — monitor competitor releases, fan engagement, and genre positioning

### Features

#### 1. Search Tracks
Search SoundCloud's catalog by keywords, genres, or artist names. Returns structured data including play counts, likes, duration, artwork URLs, and more.

```json
{
    "action": "search",
    "query": "lo-fi hip hop",
    "maxItems": 50
}
````

**Output fields:**
| Field | Type | Description |
|-------|------|-------------|
| `id` | number | SoundCloud track ID |
| `title` | string | Track title |
| `artist` | string | Artist/uploader name |
| `artistUrl` | string | Artist profile URL |
| `url` | string | Track permalink URL |
| `plays` | number | Total play count |
| `likes` | number | Total likes |
| `reposts` | number | Total reposts |
| `comments` | number | Comment count |
| `duration` | number | Duration in milliseconds |
| `durationFormatted` | string | Duration as MM:SS |
| `genre` | string | Track genre |
| `tags` | string | Track tags |
| `imageUrl` | string | High-res artwork URL (500x500) |
| `waveformUrl` | string | Waveform JSON URL |
| `createdAt` | string | Upload date (ISO 8601) |
| `description` | string | Track description (max 500 chars) |
| `license` | string | License type |
| `downloadable` | boolean | Whether downloads are enabled |
| `streamable` | boolean | Whether streaming is enabled |

#### 2. Track Details

Get comprehensive track data including waveform samples and available audio formats. Perfect for music analysis, visualization, and audio research.

```json
{
    "action": "track",
    "url": "https://soundcloud.com/flume/never-be-like-you-feat-kai"
}
```

**Additional output fields for track details:**
| Field | Type | Description |
|-------|------|-------------|
| `waveform.width` | number | Waveform width in samples |
| `waveform.height` | number | Waveform max amplitude |
| `waveform.samples` | array | Array of amplitude values |
| `formats` | array | Available audio transcodings |
| `formats[].preset` | string | Audio preset (e.g., `mp3_0_1`, `aac_160k`) |
| `formats[].protocol` | string | Streaming protocol (`hls`, `progressive`) |
| `formats[].mimeType` | string | MIME type of the audio format |

#### 3. User Profile

Scrape artist/user profiles with follower counts, track listings, and engagement metrics. Ideal for artist discovery and competitive analysis.

```json
{
    "action": "user",
    "url": "https://soundcloud.com/flume",
    "maxItems": 30
}
```

**Output fields:**
| Field | Type | Description |
|-------|------|-------------|
| `id` | number | SoundCloud user ID |
| `username` | string | Display username |
| `fullName` | string | Full name |
| `url` | string | Profile URL |
| `avatarUrl` | string | High-res avatar URL |
| `city` | string | City |
| `country` | string | Country code |
| `description` | string | Bio (max 500 chars) |
| `followers` | number | Follower count |
| `following` | number | Following count |
| `tracks` | number | Total track count |
| `playlists` | number | Playlist count |
| `likes` | number | Total likes given |
| `verified` | boolean | Verified status |
| `createdAt` | string | Account creation date |
| `trackList` | array | Array of track objects |

### Use Cases & Examples

#### Playlist Curation Pipeline

Build automated playlist curation by searching for tracks in a genre, filtering by engagement metrics, and sorting by recency:

```json
{
    "action": "search",
    "query": "ambient electronic 2024",
    "maxItems": 100
}
```

Then filter results where `plays > 10000` and `likes/plays > 0.02` for high-engagement tracks.

#### Artist Discovery & A\&R

Find emerging artists by searching for a genre and analyzing the artist profiles behind top-performing tracks:

```json
{
    "action": "search",
    "query": "bedroom pop",
    "maxItems": 200
}
```

Group by `artist`, count appearances, and fetch profiles for artists with multiple high-performing tracks but under 10K followers.

#### Music Market Analysis

Track genre trends over time by running periodic searches and comparing play count distributions:

```json
{
    "action": "search",
    "query": "drill",
    "maxItems": 200
}
```

Aggregate `plays`, `likes`, and `comments` to build engagement benchmarks per genre. Compare across genres to identify growth trends.

#### Waveform Analysis

Extract waveform data for audio fingerprinting, visualization, or energy analysis:

```json
{
    "action": "track",
    "url": "https://soundcloud.com/artist/track-name"
}
```

The `waveform.samples` array contains amplitude values that represent the audio energy over time — useful for identifying drops, builds, and quiet sections.

#### Content Licensing Research

Find tracks available under Creative Commons or with downloads enabled:

```json
{
    "action": "search",
    "query": "creative commons background music",
    "maxItems": 50
}
```

Filter results where `downloadable: true` or `license` contains "cc-" for freely usable tracks.

#### Competitive Monitoring

Monitor a competitor label or artist's releases and engagement:

```json
{
    "action": "user",
    "url": "https://soundcloud.com/label-name",
    "maxItems": 50
}
```

Schedule periodic runs to track follower growth, new releases, and engagement trends over time.

### How It Works

1. **Auto-rotating client\_id** — The actor extracts a fresh `client_id` from SoundCloud's JavaScript bundles on every run. No hardcoded keys that expire.
2. **Public API v2** — Uses SoundCloud's public API (`api-v2.soundcloud.com`) for fast, structured JSON responses. No browser rendering needed.
3. **Pagination** — Automatically handles pagination for search results up to your `maxItems` limit.
4. **High-res images** — Automatically upgrades artwork and avatar URLs to 500x500 resolution.

### Input Schema

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `action` | string | Yes | `search` | Action to perform: `search`, `track`, or `user` |
| `query` | string | For search | — | Search query (keywords, genre, artist name) |
| `url` | string | For track/user | — | Full SoundCloud URL |
| `maxItems` | integer | No | 20 | Maximum results (1–200) |

### Integrations

Connect SoundCloud Scraper to your workflow:

- **Google Sheets** — Export track data directly to spreadsheets for analysis
- **Zapier / Make** — Trigger workflows when new tracks match your criteria
- **Slack** — Get notifications for trending tracks in your genre
- **Airtable** — Build a searchable music database
- **Python / Node.js** — Use the Apify API client to integrate into your code

### API Usage

Call the actor programmatically via the Apify API:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "action": "search",
    "query": "synthwave",
    "maxItems": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} by {item['artist']} — {item['plays']:,} plays")
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('YOUR_ACTOR_ID').call({
    action: 'search',
    query: 'synthwave',
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`${item.title} by ${item.artist} — ${item.plays.toLocaleString()} plays`);
});
```

### Rate Limits & Best Practices

- SoundCloud's public API has rate limits. The actor respects these with automatic pagination delays.
- For large-scale scraping (1000+ items), split into multiple runs with different queries.
- Use `maxItems` to control costs — each result counts toward Actor.charge() billing.
- Schedule runs during off-peak hours for more reliable results.

### Pricing

This actor uses pay-per-result pricing via `Actor.charge()`:

| Event | Description |
|-------|-------------|
| `search-results` | Charged per search result returned |
| `track-detail` | Charged per track detail fetched |
| `user-profile` | Charged per user profile scraped |

### Legal & Ethical Use

This actor accesses only publicly available data through SoundCloud's public API. Users are responsible for:

- Complying with SoundCloud's [Terms of Use](https://soundcloud.com/terms-of-use)
- Respecting copyright and intellectual property rights
- Using data in accordance with applicable data protection laws (GDPR, CCPA)
- Not using scraped data for spam, harassment, or unauthorized commercial purposes

### 🔒 Avoiding SoundCloud Rate Limits

SoundCloud's API enforces strict rate limits and blocks datacenter IPs. For high-volume track and user data extraction, residential proxies prevent throttling.

**[ThorData Residential Proxies](https://thordata.partnerstack.com/partner/0a0x4nzh)** provide 200M+ rotating residential IPs across 195 countries — ensuring smooth, uninterrupted SoundCloud scraping at any scale.

### Changelog

#### v0.0 (Initial Release)

- Search tracks by keywords with pagination
- Track detail extraction with waveform data
- User profile scraping with track listings
- Auto-rotating client\_id extraction
- High-res artwork URL upgrade

# Actor input Schema

## `action` (type: `string`):

What to scrape: search for tracks, get track details, or get user profile with tracks.

## `query` (type: `string`):

Search query for finding tracks (used with 'search' action).

## `url` (type: `string`):

Full SoundCloud URL for track or user actions (e.g., https://soundcloud.com/artist/track-name).

## `maxItems` (type: `integer`):

Maximum number of results to return (search and user actions).

## Actor input object example

```json
{
  "action": "search",
  "query": "lo-fi hip hop",
  "url": "https://soundcloud.com/flume/never-be-like-you-feat-kai",
  "maxItems": 5
}
```

# 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 = {
    "action": "search",
    "query": "electronic music",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/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 = {
    "action": "search",
    "query": "electronic music",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/soundcloud-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "action": "search",
  "query": "electronic music",
  "maxItems": 5
}' |
apify call cryptosignals/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=cryptosignals/soundcloud-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Soundcloud Scraper",
        "description": "Scrape SoundCloud tracks, playlists, and artist profiles. Extract song titles, play counts, likes, comments, and audio metadata. Discover trending music and analyze artist performance. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "saoSVKu5qQ7T0GgOe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cryptosignals~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cryptosignals-soundcloud-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/cryptosignals~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cryptosignals-soundcloud-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/cryptosignals~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cryptosignals-soundcloud-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "search",
                            "track",
                            "user"
                        ],
                        "type": "string",
                        "description": "What to scrape: search for tracks, get track details, or get user profile with tracks.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search query for finding tracks (used with 'search' action)."
                    },
                    "url": {
                        "title": "SoundCloud URL",
                        "type": "string",
                        "description": "Full SoundCloud URL for track or user actions (e.g., https://soundcloud.com/artist/track-name)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of results to return (search and user actions).",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```