# SoundCloud Plays & Followers Tracker - Likes, Reposts, Changes (`neverempty/soundcloud-plays-followers-tracker`) Actor

Followers of any SoundCloud artist and the plays, likes, reposts and comments of their tracks, albums and playlists, as exact numbers. Paste profile, track or playlist links or artist names. Turn monitoring on and later runs return only what changed, with the difference. No login.

- **URL**: https://apify.com/neverempty/soundcloud-plays-followers-tracker.md
- **Developed by:** [NeverEmpty](https://apify.com/neverempty) (community)
- **Categories:** Social media, For creators, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 item returneds

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 Plays & Followers Tracker - Likes, Reposts, Changes

**Track SoundCloud numbers for any artist, track or playlist: this Actor returns a profile's followers and each track's plays, likes, reposts and comments as one flat row, with no login and no SoundCloud API key.** Run it on a schedule with monitoring mode on and it returns only the profiles, tracks and playlists whose numbers moved since the last run, with the previous figure and the difference.

On 2026-10-23 the example input below (two profile links and one artist name) returned 26 rows in 6 seconds on Apify: 2 profiles, 23 tracks and 1 album with all 13 of its tracks. Asking for the 60 latest uploads of one profile took 3 seconds.

- **Followers and every track's plays, likes, reposts and comments** in one run: a profile row, then its popular tracks or latest uploads, each as its own row.
- **Only what changed, on a schedule.** Monitoring mode remembers the numbers and returns `followersChange`, `playCountChange`, `likeCountChange` and the other differences next to the previous figure. An item that did not move is not returned and not charged as a row.
- **Profile links, track links, playlists, albums, short links or plain names.** `https://soundcloud.com/flume`, `flume`, `@flume`, an `on.soundcloud.com` short link, a `soundcloud:tracks:` URN or an artist name like `Billie Eilish` all work.
- **Exact numbers, never guessed.** Counts are the integers SoundCloud publishes (50687504, not "50.6M"). A number SoundCloud does not give is `null`, never `0`, so a change is never invented.
- **Playlists and albums with every track** in playlist order, and the total plays of all tracks when every track was read.
- **Release details on tracks**: ISRC, label, album title, genre, tags, release date, duration, license and downloads, where the uploader filled them in.
- **Fewer rows come with the reason.** A missing profile, an ambiguous name, a private link or a page that could not be read gets a free row that says why. These rows are never charged.

Unofficial and not affiliated with SoundCloud. It reads only what soundcloud.com shows to any visitor without logging in: no private tracks, no private share links, no messages, nothing behind a login.

### What people use it for

- **Artist growth tracking**: follow your own or a client's followers and plays every day, and keep the history in a dataset, a spreadsheet or your own database.
- **Release monitoring**: schedule a run after a release and see how many plays, likes and reposts the new track gained since the last check.
- **A\&R and talent scouting**: compare followers and play counts of many artists in one run, and spot the tracks that are moving.
- **Label and playlist reporting**: export every track of an album or playlist with its plays, likes and ISRC for a weekly report.
- **Data for AI and analytics pipelines**: one clean JSON row per profile, track or playlist, numbers as plain integers.

### How to track SoundCloud plays and followers

1. Put the profiles, tracks, playlists or names in `targets`, one per line.
2. Choose how many tracks to add under each profile (`tracksPerProfile`, 5 by default) and whether they are the popular tracks or the latest uploads.
3. Click **Start**, then download the dataset as CSV, Excel or JSON, or read it from the Apify API, Python or Node.js.
4. To receive only changes, turn on `monitoringMode` and add a schedule (for example once a day) in Apify. The first monitoring run returns every item once; later runs return only items whose numbers moved.

### Input

| Field | Default | What it does |
| --- | --- | --- |
| `targets` | none | Profile, track, playlist or album links, `on.soundcloud.com` short links, `soundcloud:tracks:123` URNs, profile names (`flume`, `@flume`) or artist names (`Billie Eilish`). One per line, up to 1,000. |
| `profileTracks` | `popular` | `popular` = the tracks on the profile's Popular tracks tab, in SoundCloud's order (at most 25). `latest` = the newest uploads first. |
| `tracksPerProfile` | `5` | Tracks returned under each profile, 0 to 200. 0 returns the profile row only. |
| `tracksPerPlaylist` | `50` | Tracks returned for each playlist or album, in playlist order, 0 to 500. 0 returns the playlist row only. |
| `maxItems` | `200` | With monitoring off, the run stops after this many rows and names what it did not read in a free row. |
| `monitoringMode` | `false` | On = return only items whose numbers changed since the last run, with the previous figure and the difference. |
| `monitorMode` | `any-change` | `any-change` = any tracked number moved. `headline-change` = only followers (profile), plays (track) or likes (playlist). |
| `resetMonitoringState` | `false` | Forget the remembered numbers, so the next monitoring run returns each item once again. |
| `useProxy` | `true` | Retry through an Apify residential proxy only if SoundCloud answers 403 or 429. Off = no proxy is used or paid for. |

```json
{
    "targets": [
        "https://soundcloud.com/flume",
        "https://soundcloud.com/flume/sets/palaces",
        "Billie Eilish"
    ],
    "tracksPerProfile": 5,
    "monitoringMode": true
}
```

A name is matched only when a profile has exactly that name. When several profiles share it and none is verified or has at least ten times the followers of the next one, a free `ambiguous-name` row lists the candidates instead of guessing; paste the profile link you want.

### Output

Each row has `rowType`: `profile`, `track` or `playlist`. This track row was read from Apify on 2026-10-23 (UTC) with the example input:

```json
{
    "rowType": "track",
    "name": "Disclosure - You & Me (Flume Remix)",
    "url": "https://soundcloud.com/flume/disclosure-you-me-flume-remix",
    "playCount": 78196094,
    "likeCount": 1200067,
    "repostCount": 184900,
    "commentCount": 14596,
    "downloadCount": 0,
    "durationSec": 283,
    "genre": "OrchestralCrunkwave",
    "uploadedAt": "2013-06-11T07:18:00Z",
    "isrc": "GBUM71305972",
    "license": "all-rights-reserved",
    "artworkUrl": "https://i1.sndcdn.com/artworks-000050305011-e8ynd4-t500x500.jpg",
    "soundcloudId": 96379023,
    "urn": "soundcloud:tracks:96379023",
    "profileName": "Flume",
    "profileUrl": "https://soundcloud.com/flume",
    "profileFollowers": 2228620,
    "profileVerified": true,
    "status": "ok",
    "input": "https://soundcloud.com/flume",
    "foundVia": "profile-popular",
    "parentUrl": "https://soundcloud.com/flume",
    "position": 2,
    "change": null,
    "previousPlayCount": null,
    "playCountChange": null,
    "scrapedAt": "2026-10-23T13:15:27.368Z",
    "description": "(the uploader's text, as written)"
}
```

Notes on the columns:

- **Profile rows** have `followers`, `followings`, `trackCount`, `playlistCount`, `likesGiven`, `verified`, `proPlan`, `fullName`, `city`, `countryCode`, `avatarUrl` and `profileCreatedAt`.
- **Track rows** have `playCount`, `likeCount`, `repostCount`, `commentCount`, `downloadCount`, `durationSec`, `genre`, `tags`, `releaseDate`, `uploadedAt`, `isrc`, `albumTitle`, `labelName`, `license`, `artworkUrl` and the owner's `profileName` and `profileFollowers`. `parentUrl` and `position` say which profile or playlist the track came from and its place there.
- **Playlist rows** have `trackCount`, `likeCount`, `repostCount`, `setType` (album, EP, single or playlist), `isAlbum`, `durationSec`, `releaseDate` and `tracksPlayCountTotal`. The total is filled in only when every track of the playlist was read; otherwise it is `null` rather than a partial sum.
- **Monitoring columns**: `change` (`first-check` or `changed`), `changedFields`, `previousCheckedAt`, and for each tracked number its `previous...` value and `...Change` difference. When the previous figure was not available the difference is `null`.
- `soundcloudId` and `urn` identify the item; use them as a key when you store the history.
- Image links point to the 500 × 500 artwork.

### FAQ

**How do I see how many plays a SoundCloud track has?**
Put the track link in `targets` and click Start. The row has `playCount`, `likeCount`, `repostCount` and `commentCount` as plain integers, exactly as SoundCloud publishes them.

**How can I track SoundCloud followers every day?**
Put the profiles in `targets`, turn on `monitoringMode` and add a daily schedule in Apify. Each run returns only the profiles and tracks whose numbers moved, with `followersChange` or `playCountChange` and the previous figure.

**Can I get SoundCloud stats without the SoundCloud API or a login?**
Yes. The Actor reads only what soundcloud.com shows to any visitor, with no login, no cookies and no API key of your own. You can call it like an API from the Apify API, Python or Node.js and get JSON back.

**Can I export all tracks of a SoundCloud playlist or album with their plays?**
Yes. Put the playlist or album link in `targets` and set `tracksPerPlaylist` (up to 500). Every track comes back in playlist order with its plays, likes and ISRC, and the playlist row has the total plays of all tracks.

**Can I search by artist name instead of a link?**
Yes. A name such as `Billie Eilish` is matched to the profile with exactly that name. If several profiles share the name and none stands out, a free row lists them so you can paste the right link.

**How much does it cost to track SoundCloud stats?**
You pay per row returned: $3.50 per 1,000 rows on the Apify Free plan and $2.40 per 1,000 on Gold and higher plans, plus a start fee of $0.02 or less per run. The example input (26 rows) costs about $0.11 on the Free plan. In monitoring mode an unchanged item costs only the check fee of $0.40 per 1,000 items or less, so a daily check of 100 tracks that did not move costs about $0.06 including the start fee.

### Rows that are never charged

| Status | Meaning |
| --- | --- |
| `not-found` | SoundCloud has no public profile, track or playlist at this address. |
| `ambiguous-name` | Several profiles have exactly this name, so none was picked. The row lists the candidates. |
| `no-change` | Monitoring mode: nothing you listed moved since the last run. |
| `invalid-input` | The line is not a SoundCloud address or name the Actor reads (for example a private share link or a search page). |
| `duplicate-input` | The same profile, track or playlist was already returned from an earlier line. |
| `unreadable` | The item could not be read, or SoundCloud answered with something other than the item asked for. |
| `blocked` | SoundCloud refused the request (403 or 429) even through the proxy. The run stops asking and names what it did not read. |
| `no-web-key` | SoundCloud did not accept the public web key. The run stops and nothing is charged. |
| `not-read` / `budget-reached` | `maxItems` or the run's maximum total charge was reached; the row names the lines and tracks that were left out. |

### Pricing

Pay per event. Rows that explain why something is missing are free.

| Event | Free plan | Bronze | Silver | Gold and higher |
| --- | --- | --- | --- | --- |
| Row returned (profile, track or playlist) | $3.50 / 1,000 | $3.10 / 1,000 | $2.70 / 1,000 | $2.40 / 1,000 |
| Item checked (monitoring mode only) | $0.40 / 1,000 | $0.36 / 1,000 | $0.33 / 1,000 | $0.30 / 1,000 |
| Run start | $0.02 | $0.015 | $0.012 | $0.01 |

The check fee is charged only in monitoring mode, once per item that was read and compared, whether it changed or not. Set **Maximum total charge** in the run options to cap what one run can cost; the run stops there and names what it did not read.

### Good to know

- Unofficial. Public data only. This Actor is not affiliated with SoundCloud.
- Numbers are read at the moment of the run. SoundCloud's own counters can differ slightly between two requests made at the same time.
- Private tracks and private share links (`/s-...`) are not read.
- SoundCloud lists at most 25 popular tracks for a profile, in its own order (not sorted by plays). Choose `latest` to go further back through a profile's uploads.
- Numbers are remembered per item, not per list, so adding a track to `targets` does not return the others again. Do not put the same item in two schedules that run at the same moment.

### Thanks for using this Actor

We build these tools for people who run them every day, and we improve them from what users tell us.

- **Missing a field, or need another filter?** Tell us in the **Issues** tab. If the data is there, we add it.
- **Found a bug or a wrong value?** Post the run ID in the **Issues** tab. Wrong data is the thing we fix first.

If this Actor saved you time, a short review helps other people find it.

# Actor input Schema

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

One per line. Profile links (https://soundcloud.com/flume), track links (https://soundcloud.com/flume/never-be-like-you-feat-kai), playlist or album links (https://soundcloud.com/flume/sets/palaces), on.soundcloud.com short links, soundcloud:tracks:123 URNs, profile names (flume or @flume) or artist names (Billie Eilish). A name is matched only when a profile has exactly that name; if several do and none stands out, the row lists them and is not charged. Private share links are not read.

## `profileTracks` (type: `string`):

Popular = the tracks on the profile's Popular tracks tab, in SoundCloud's order (at most 25). Latest = the newest uploads first.

## `tracksPerProfile` (type: `integer`):

How many tracks to return under each profile, each as its own row with plays, likes, reposts and comments. 0 returns the profile row only. SoundCloud lists at most 25 popular tracks for a profile; choose Latest uploads to go further back.

## `tracksPerPlaylist` (type: `integer`):

How many tracks of each playlist or album to return, in playlist order. 0 returns the playlist row only. The total plays of all tracks is filled in when every track of the playlist was read.

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

With monitoring off, the run stops after this many rows (profiles, tracks and playlists together) and names what it did not read in a row that is not charged. Monitoring mode ignores this and checks everything you listed.

## `monitoringMode` (type: `boolean`):

Off = return every row, charged per row. On = the numbers are remembered and later runs return a profile, track or playlist only when a number differs from the remembered one, together with the previous figure and the difference. In monitoring mode each item that was read is charged as one check (item-checked), and an item that is returned is also charged as one row (item-returned). The first monitoring run returns every item once. Numbers are remembered per item, not per list, so adding a track does not return the others again. Do not put the same item in two schedules that run at the same moment.

## `monitorMode` (type: `string`):

Any change = followers or track count for a profile; plays, likes, reposts or comments for a track; likes, reposts or track count for a playlist. Headline number only = followers for a profile, plays for a track, likes for a playlist.

## `resetMonitoringState` (type: `boolean`):

Clears every remembered number for this Actor on your account, so the next monitoring run returns each item once again. This affects all your monitoring runs, because numbers are remembered per item rather than per list.

## `useProxy` (type: `boolean`):

Requests go directly to SoundCloud. If SoundCloud answers HTTP 403 or 429, the request is sent again through an Apify residential proxy and, if it is refused again, the run stops asking and names what it did not read. Turn this off to never use a proxy.

## Actor input object example

```json
{
  "targets": [
    "https://soundcloud.com/flume",
    "https://soundcloud.com/flume/sets/palaces",
    "Billie Eilish"
  ],
  "profileTracks": "popular",
  "tracksPerProfile": 5,
  "tracksPerPlaylist": 50,
  "maxItems": 200,
  "monitoringMode": false,
  "monitorMode": "any-change",
  "resetMonitoringState": false,
  "useProxy": true
}
```

# Actor output Schema

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

One row per SoundCloud profile, track or playlist: followers, track count and verified badge for a profile; plays, likes, reposts, comments, downloads, genre, tags, ISRC and release date for a track; likes, reposts, track count and the total plays of all its tracks for a playlist or album. Each row names the profile it belongs to. In monitoring mode rows also carry the previous figures and the difference. Links SoundCloud has no page for, lines that are not SoundCloud links, items that could not be read and runs where nothing changed come back as their own rows and are not charged.

# 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": [
        "https://soundcloud.com/flume",
        "https://soundcloud.com/flume/sets/palaces",
        "Billie Eilish"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/soundcloud-plays-followers-tracker").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": [
        "https://soundcloud.com/flume",
        "https://soundcloud.com/flume/sets/palaces",
        "Billie Eilish",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("neverempty/soundcloud-plays-followers-tracker").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 '{
  "targets": [
    "https://soundcloud.com/flume",
    "https://soundcloud.com/flume/sets/palaces",
    "Billie Eilish"
  ]
}' |
apify call neverempty/soundcloud-plays-followers-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/soundcloud-plays-followers-tracker"
        }
    }
}
```

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/qJFBTdOkp3fLMNebG/builds/z5aMINiqZP5dzDr21/openapi.json