# SoundCloud Scraper (`maximedupre/soundcloud-scraper`) Actor

Scrape public SoundCloud tracks, artists, playlists, albums, and comments. Export titles, URLs, engagement counts, artist details, media metadata, and timestamps.

- **URL**: https://apify.com/maximedupre/soundcloud-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 soundcloud items

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/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 for public music data

SoundCloud Scraper collects public data from [SoundCloud](https://soundcloud.com/) tracks, artists, playlists, albums, and comments. Add SoundCloud URLs, profile handles, or search terms, then export clean rows with titles, URLs, artist details, engagement counts, media metadata, source URLs, and scrape timestamps.

Use this SoundCloud scraper for music catalog research, artist discovery, playlist analysis, trend tracking, and data workflows where copying track pages by hand would be slow. The Actor works with public SoundCloud data and does not ask for SoundCloud cookies, login details, or API keys.

For a quick first run, keep the prefilled `dnb` search target, set `Search for` to `Tracks`, and run the Actor. You can raise the result limits once the output shape matches what you need.

### ✅ What this Actor does

- Searches SoundCloud for public tracks, artists, playlists, albums, or all supported result types.
- Accepts SoundCloud URLs, profile handles such as `@dnballstars`, and plain search terms.
- Saves one dataset item for each accepted SoundCloud result.
- Adds track duration, genre, tags, dates, public status, streamable/downloadable flags, and engagement counts when SoundCloud provides them.
- Adds artist/profile details for track, playlist, and album rows when available.
- Adds artwork, waveform, and public media transcoding metadata when enabled.
- Can save public comments as separate rows linked back to the parent track.
- Stops at your total and per-target result limits.

Unavailable fields are saved as `null` or empty arrays instead of guessed values, so downstream scripts can tell the difference between missing data and scraped data.

### 📦 Data you can export

Each output item has a `rowType` of `track`, `artist`, `playlist`, `album`, or `comment`. Common fields include:

- `soundcloudId`, `urn`, `title`, and `url`
- `sourceTarget`, `sourceTargetIndex`, and `sourceUrl`
- `description`, `createdAt`, `displayDate`, and `lastModified`
- `durationMs`, `genre`, `tags`, and `license`
- `isPublic`, `isStreamable`, `isDownloadable`, and `availabilityStatus`
- `engagement` with plays, likes, reposts, comments, downloads, or followers when SoundCloud returns them
- `artist` profile details
- `media` metadata such as artwork, waveform, stream URL metadata, and downloadable status
- `comment` details for comment rows
- `scrapedAt`

You can open the dataset in Apify, export it as JSON, CSV, Excel, XML, or RSS, call it through the Apify API, schedule runs, or connect it to webhooks and integrations.

### 🛠️ How to run it

1. Add one or more SoundCloud targets.
2. Choose whether search terms should return tracks, artists, playlists, albums, or all supported result types.
3. Set the total result limit and the limit per target.
4. Leave comments at `0` if you only need primary SoundCloud results, or increase the comment limit to collect public track comments.
5. Run the Actor and open the dataset.

Targets can be mixed in one run:

```json
{
	"targets": ["dnb", "https://soundcloud.com/dnballstars", "@dnballstars"],
	"searchType": "tracks",
	"maxItems": 100,
	"maxItemsPerTarget": 50,
	"maxCommentsPerTrack": 0,
	"includeArtistDetails": true,
	"includeMediaMetadata": true,
	"dedupeResults": true
}
````

### 🔎 Input options

`targets` are the SoundCloud URLs, handles, or search terms to scrape. Use a search term like `ambient techno` for discovery, a profile URL to collect public profile content, or a handle such as `@dnballstars` when you already know the artist or label.

`searchType` controls only plain search terms. Direct SoundCloud URLs and handles are resolved from the target itself.

`maxItems` is the total number of rows to save across the run. `maxItemsPerTarget` keeps a single target from using the whole run budget.

`maxCommentsPerTrack` saves public comments as extra rows. Keep it at `0` when you only need tracks, artists, playlists, or albums.

`includeArtistDetails` and `includeMediaMetadata` add richer nested objects when SoundCloud exposes the data publicly.

`dedupeResults` avoids saving the same SoundCloud item more than once in a run.

### 📄 Output example

```json
{
	"rowType": "track",
	"soundcloudId": 123456789,
	"title": "Example Track",
	"url": "https://soundcloud.com/example/example-track",
	"sourceTarget": "dnb",
	"sourceTargetIndex": 0,
	"sourceUrl": "https://api-v2.soundcloud.com/search/tracks?q=dnb",
	"description": "Public track description",
	"durationMs": 180000,
	"genre": "Drum & Bass",
	"tags": ["dnb", "bass"],
	"engagement": {
		"playbackCount": 12000,
		"likesCount": 500,
		"repostsCount": 20,
		"commentCount": 10,
		"downloadCount": null,
		"followersCount": null
	},
	"artist": {
		"id": 987654321,
		"username": "example-artist",
		"displayName": "Example Artist",
		"url": "https://soundcloud.com/example-artist"
	},
	"scrapedAt": "2026-05-24T00:00:00.000Z"
}
```

The real dataset may include more fields or `null` values depending on what SoundCloud returns for each item.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each saved SoundCloud item, which can be a track, artist, playlist, album, or comment. There is no separate Actor-start charge.

### ⚠️ Limits and caveats

- Results depend on what SoundCloud exposes publicly at run time.
- Private, deleted, blocked, or unavailable SoundCloud targets may return no rows.
- Some media fields are metadata URLs or stream descriptors, not guaranteed direct downloads.
- Search ordering is controlled by SoundCloud.
- The Actor is not affiliated with SoundCloud and is not an official SoundCloud API client.

### ❓ FAQ

#### Do I need a SoundCloud account or API key?

No. This Actor works with public SoundCloud data and does not ask for cookies, login details, or an API key.

#### Can it scrape SoundCloud comments?

Yes. Increase `Comments per track` to save public track comments as separate rows. Keep it at `0` to collect only primary SoundCloud results.

#### Can I use it as a SoundCloud API?

Yes, through Apify. You can run the Actor via the Apify API, schedule it, and fetch the dataset from your own scripts or integrations.

#### Does it download MP3 files?

No. The Actor extracts public SoundCloud data and media metadata. It does not promise direct audio downloads.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~soundcloud-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public YouTube channel profiles and video rows.
- [TikTok Keywords Discovery Tool ↗](https://apify.com/maximedupre/tiktok-keywords-discovery-tool) - Collect TikTok autocomplete keyword ideas for content research.
- [TikTok Transcript Scraper ↗](https://apify.com/maximedupre/tiktok-transcript-scraper) - Extract public captions and transcripts from TikTok video URLs.
- [Telegram Channel Messages Scraper ↗](https://apify.com/maximedupre/telegram-channel-messages-scraper) - Save public Telegram channel posts as clean dataset rows.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Collect image search results from Unsplash keywords.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter SoundCloud URLs, profile handles like @dnballstars, playlist or album URLs, or search terms like ambient techno. Each target is processed separately.

## `searchType` (type: `string`):

Choose which SoundCloud data to collect when a target is a search term. Direct URLs and handles are resolved from the target itself.

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

Maximum SoundCloud items to save across the whole run.

## `maxItemsPerTarget` (type: `integer`):

Maximum SoundCloud items to save from each target before moving to the next one.

## `maxCommentsPerTrack` (type: `integer`):

Set to 0 to skip comments. Increase this to save public SoundCloud track comments as separate items linked to the parent track.

## `includeArtistDetails` (type: `boolean`):

Add public artist/profile fields to track, playlist, and album items when SoundCloud provides them.

## `includeMediaMetadata` (type: `boolean`):

Add public artwork, waveform, and media transcoding metadata when SoundCloud provides them.

## `dedupeResults` (type: `boolean`):

Avoid saving the same SoundCloud item more than once in a run.

## Actor input object example

```json
{
  "targets": [
    "dnb"
  ],
  "searchType": "tracks",
  "maxItems": 100,
  "maxItemsPerTarget": 50,
  "maxCommentsPerTrack": 0,
  "includeArtistDetails": true,
  "includeMediaMetadata": true,
  "dedupeResults": true
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with SoundCloud tracks, artists, playlists, albums, comments, source URLs, engagement metrics, media metadata, and scrape timestamps.

# 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 = {
    "targets": [
        "dnb"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/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 = { "targets": ["dnb"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/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 '{
  "targets": [
    "dnb"
  ]
}' |
apify call maximedupre/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Scraper",
        "description": "Scrape public SoundCloud tracks, artists, playlists, albums, and comments. Export titles, URLs, engagement counts, artist details, media metadata, and timestamps.",
        "version": "0.1",
        "x-build-id": "ATyp1okqqZZsSLR5c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-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/maximedupre~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-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/maximedupre~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "SoundCloud targets",
                        "type": "array",
                        "description": "Enter SoundCloud URLs, profile handles like @dnballstars, playlist or album URLs, or search terms like ambient techno. Each target is processed separately.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "tracks",
                            "artists",
                            "playlists",
                            "albums",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose which SoundCloud data to collect when a target is a search term. Direct URLs and handles are resolved from the target itself.",
                        "default": "tracks"
                    },
                    "maxItems": {
                        "title": "Total result limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum SoundCloud items to save across the whole run.",
                        "default": 100
                    },
                    "maxItemsPerTarget": {
                        "title": "Items per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum SoundCloud items to save from each target before moving to the next one.",
                        "default": 50
                    },
                    "maxCommentsPerTrack": {
                        "title": "Comments per track",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set to 0 to skip comments. Increase this to save public SoundCloud track comments as separate items linked to the parent track.",
                        "default": 0
                    },
                    "includeArtistDetails": {
                        "title": "Include artist details",
                        "type": "boolean",
                        "description": "Add public artist/profile fields to track, playlist, and album items when SoundCloud provides them.",
                        "default": true
                    },
                    "includeMediaMetadata": {
                        "title": "Include media metadata",
                        "type": "boolean",
                        "description": "Add public artwork, waveform, and media transcoding metadata when SoundCloud provides them.",
                        "default": true
                    },
                    "dedupeResults": {
                        "title": "Skip duplicates",
                        "type": "boolean",
                        "description": "Avoid saving the same SoundCloud item more than once in a run.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
