# SoundCloud Tracks, Artists & Playlists Scraper (`xtracto/soundcloud-scraper`) Actor

Scrape SoundCloud tracks, artists, playlists, and charts with full play, like, and repost stats. Resolve any URL, search by keyword, pull an artist's uploads, expand playlists into per-track detail, or grab a genre's trending / top chart. No login, no API key.

- **URL**: https://apify.com/xtracto/soundcloud-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Tracks, Artists & Playlists Scraper

Extract SoundCloud tracks, artists, playlists, and charts — with full play, like, repost, and comment counts — as clean JSON. Resolve any SoundCloud link, search by keyword, pull an artist's uploads, expand a playlist into per-track detail, or grab a genre's trending / top chart.

### Why use this actor

- **No account, no login, no API key** required.
- **Real engagement numbers** — play count, likes, reposts, comments, download count, plus follower / following / track totals for artists.
- **Five ways in** — resolve a URL, keyword search, artist profile + tracks, full playlist expansion, or genre charts.
- **Playlist expansion** — turn one playlist link into a row per track, each with full stats and the artist behind it.
- **Stable JSON output** ready for spreadsheets, databases, dashboards, or data pipelines.
- **Automatic retries**, runs on Apify's schedule, and exports to JSON / CSV / Excel — no scrapers, browsers, or blocks to babysit.

### How it works

1. Pick a **mode** (resolve, search, artist, playlist, or charts).
2. Give it the matching input — a list of SoundCloud URLs, a search keyword, or a chart genre.
3. The actor pulls the matching tracks, artists, and playlists, each with full public stats.
4. Every result is pushed to your dataset as one JSON row, ready to export.

You don't manage any scrapers, browsers, or rate limits — just run it.

### Input

#### Resolve mode — look up any SoundCloud URLs
```json
{
  "mode": "resolve",
  "urls": [
    "https://soundcloud.com/eldjkb/get-lucky-original-version",
    "https://soundcloud.com/eldjkb"
  ],
  "maxItems": 200,
  "maxItemsPerSource": 200,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

#### Search mode — find tracks, artists, or playlists by keyword

```json
{
  "mode": "search",
  "query": "daft punk",
  "searchType": "tracks",
  "maxItems": 200,
  "maxItemsPerSource": 200
}
```

#### Artist mode — an artist profile plus their uploads

```json
{ "mode": "artist", "urls": ["https://soundcloud.com/eldjkb"], "maxItemsPerSource": 200 }
```

#### Playlist mode — a playlist / album expanded into its tracks

```json
{
  "mode": "playlist",
  "urls": ["https://soundcloud.com/soaverecords/sets/summer-lounge-2025-chill-vibes"],
  "hydratePlaylistTracks": true
}
```

#### Charts mode — a genre's trending or top chart

```json
{ "mode": "charts", "genre": "all-music", "chartType": "trending", "maxItems": 200 }
```

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | `resolve`, `search`, `artist`, `playlist`, or `charts`. |
| `urls` | array | SoundCloud URLs. Used by `resolve` (any track/artist/playlist), `artist` (artist profiles), and `playlist` (playlists/albums). |
| `query` | string | Keyword to search for (`search` mode). |
| `searchType` | string | `tracks`, `users` (artists), or `playlists` (`search` mode). |
| `genre` | string | Genre slug for charts, e.g. `all-music`, `hiphoprap`, `house`, `pop` (`charts` mode). |
| `chartType` | string | `trending` (hot right now) or `top` (`charts` mode). |
| `hydratePlaylistTracks` | boolean | If true, return every track in a playlist with full detail. Default `true`. |
| `maxItems` | integer | Max rows for the whole run (0 = no limit). Default 200. |
| `maxItemsPerSource` | integer | Max rows per URL / query / chart (0 = no limit). Default 200. |
| `proxyConfiguration` | object | Optional. Off by default; SoundCloud data is public. |

### Output

Every row carries a small header — `_source` (which mode produced it), `_scrapedAt`, `_input` (the URL/query it came from), and `_entityKind` (`track`, `user`, or `playlist`) — followed by the full SoundCloud object.

#### Track (resolve / search / artist / playlist / charts)

```json
{
  "_source": "resolve",
  "_scrapedAt": "2026-07-10T20:05:58Z",
  "_input": "https://soundcloud.com/eldjkb/get-lucky-original-version",
  "_entityKind": "track",
  "id": 88335161,
  "title": "Get Lucky [Original Version] - Daft Punk",
  "permalink_url": "https://soundcloud.com/eldjkb/get-lucky-original-version",
  "duration": 246381,
  "full_duration": 246382,
  "genre": "Disco Electronic",
  "tag_list": "leaked original version daft punk get lucky 2013 pharrell williams",
  "created_at": "2013-04-17T22:05:25Z",
  "display_date": "2013-04-17T22:05:25Z",
  "playback_count": 20625528,
  "likes_count": 300958,
  "reposts_count": 3313,
  "comment_count": 4989,
  "download_count": 0,
  "license": "all-rights-reserved",
  "urn": "soundcloud:tracks:88335161",
  "waveform_url": "https://wave.sndcdn.com/XBV0hffTtBI4_m.json",
  "artwork_url": "https://i1.sndcdn.com/artworks-000045765973-c2x8ko-large.jpg",
  "user": { "id": 8882898, "username": "DJ KB", "followers_count": 6487, "verified": true, "… ": "… more" }
}
```

Each track row also includes the full artist object under `user`. In `charts` mode a `_chartScore` field is added (the chart-ranking score, e.g. `0.857`).

#### Artist / user (resolve / artist / search users)

```json
{
  "_source": "resolve",
  "_input": "https://soundcloud.com/eldjkb",
  "_entityKind": "user",
  "id": 8882898,
  "username": "DJ KB",
  "permalink_url": "https://soundcloud.com/eldjkb",
  "followers_count": 6487,
  "followings_count": 69,
  "track_count": 69,
  "playlist_count": 7,
  "likes_count": 108,
  "verified": true,
  "city": "",
  "country_code": null,
  "description": "Es un colombiano, DJ y productor, desde Medellín, Colombia. A los dieciséis años comenzó a publicar…",
  "avatar_url": "https://i1.sndcdn.com/avatars-000394976541-fi0tut-large.jpg"
}
```

#### Playlist / album (resolve / playlist / search playlists)

```json
{
  "_source": "playlist",
  "_input": "https://soundcloud.com/soaverecords/sets/summer-lounge-2025-chill-vibes",
  "_entityKind": "playlist",
  "id": 1941279431,
  "title": "Ibiza Summer Mix 2026 🍓 Best Of Tropical Deep House Music Chill Out Mix",
  "permalink_url": "https://soundcloud.com/soaverecords/sets/summer-lounge-2025-chill-vibes",
  "track_count": 300,
  "duration": 46954156,
  "genre": "",
  "likes_count": 14273,
  "reposts_count": 223,
  "is_album": false,
  "set_type": ""
}
```

With `hydratePlaylistTracks` on, the playlist row is followed by one full **track** row per song (`_source: "playlist-track"`), for example:

```json
{
  "_source": "playlist-track",
  "_entityKind": "track",
  "id": 1649402727,
  "title": "Stumblin' In",
  "permalink_url": "https://soundcloud.com/cyrilriley/stumblin-in-cyril-remix",
  "playback_count": 4465477,
  "likes_count": 78203,
  "genre": "Dance"
}
```

#### Chart track (charts mode)

```json
{
  "_source": "charts-trending",
  "_input": "charts:trending:all-music",
  "_entityKind": "track",
  "_chartScore": 0.857,
  "id": 2320209185,
  "title": "GOOSE COAT",
  "permalink_url": "https://soundcloud.com/user-10135919/surf7-goose-coat",
  "genre": "Hip Hop/Rap",
  "playback_count": 1269220,
  "likes_count": 33594,
  "reposts_count": 214
}
```

| Field | Type | Description |
| --- | --- | --- |
| `_source` | string | Which mode produced the row (`resolve`, `search`, `artist-tracks`, `playlist`, `playlist-track`, `charts-trending`, …). |
| `_entityKind` | string | `track`, `user`, or `playlist`. |
| `id` / `urn` | number / string | SoundCloud's numeric id and full resource identifier. |
| `title` | string | Track or playlist title. |
| `username` | string | Artist display name (on artist rows; also nested under `user` on tracks). |
| `permalink_url` | string | Public SoundCloud link. |
| `playback_count` | number | Total plays (tracks). |
| `likes_count` / `reposts_count` / `comment_count` | number | Engagement totals. |
| `followers_count` / `followings_count` / `track_count` / `playlist_count` | number | Artist totals. |
| `duration` / `full_duration` | number | Length in milliseconds. |
| `genre` / `tag_list` | string | Genre label and free-text tags. |
| `created_at` / `display_date` / `release_date` | string | Timestamps. |
| `artwork_url` / `avatar_url` / `waveform_url` | string | Image and waveform links. |
| `verified` | boolean | Whether the artist is verified. |
| `_chartScore` | number | Chart-ranking score (charts mode only). |

### Notes & limits

- **Keyword search returns up to ~200 results per query.** For more coverage, use several narrower queries.
- **Artist tracks, playlists, and charts** page through everything available up to your `maxItems` / `maxItemsPerSource` caps.
- **Playlists** can be large (hundreds of tracks). Set `maxItemsPerSource` to keep runs small, or turn `hydratePlaylistTracks` off to return just the playlist summary.
- Some artist fields (like `city` or `country_code`) are blank when the artist hasn't set them.
- SoundCloud data is public, so **no proxy is needed**; you can still enable Apify Proxy if you prefer.

# Actor input Schema

## `mode` (type: `string`):

What to pull. 'resolve' = look up each SoundCloud URL and return the full track / artist / playlist it points to (uses 'urls'). 'search' = find tracks, artists, or playlists by keyword (uses 'query' + 'searchType'). 'artist' = an artist profile plus their uploaded tracks (uses 'urls'). 'playlist' = a playlist / album with its tracks (uses 'urls'). 'charts' = the trending or top chart for a genre (uses 'genre' + 'chartType').

## `urls` (type: `array`):

Used when mode = 'resolve', 'artist', or 'playlist'. Full soundcloud.com URLs. For 'resolve' mix any track / artist / playlist URLs; for 'artist' use artist profile URLs; for 'playlist' use playlist or album URLs.

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

Used when mode = 'search'. Free-text keyword (artist name, track title, etc.).

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

Used when mode = 'search'. Whether to search for tracks, artists, or playlists.

## `genre` (type: `string`):

Used when mode = 'charts'. Genre slug, e.g. 'all-music', 'all-audio', 'hiphoprap', 'house', 'electronic', 'pop', 'rock'. Use 'all-music' for the overall music chart.

## `chartType` (type: `string`):

Used when mode = 'charts'. 'trending' = what's hot right now; 'top' = the most-played all-time-style chart.

## `hydratePlaylistTracks` (type: `boolean`):

Used when mode = 'playlist' or when a resolved URL is a playlist. If checked, every track in the playlist is returned with full details (play / like counts, artist, artwork). If unchecked, only the playlist record itself is returned.

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

Maximum records to push to the dataset across the whole run (0 = no cap).

## `maxItemsPerSource` (type: `integer`):

Cap per individual URL / search query / chart (0 = no cap). Note: keyword search returns at most ~200 results per query regardless of this value.

## `proxyConfiguration` (type: `object`):

Optional. SoundCloud data is public and needs no proxy, so this is off by default. Enable it (Residential recommended) only if you want requests routed through Apify Proxy.

## Actor input object example

```json
{
  "mode": "resolve",
  "urls": [
    "https://soundcloud.com/eldjkb/get-lucky-original-version",
    "https://soundcloud.com/eldjkb"
  ],
  "query": "daft punk",
  "searchType": "tracks",
  "genre": "all-music",
  "chartType": "trending",
  "hydratePlaylistTracks": true,
  "maxItems": 200,
  "maxItemsPerSource": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "mode": "resolve",
    "urls": [
        "https://soundcloud.com/eldjkb/get-lucky-original-version",
        "https://soundcloud.com/eldjkb"
    ],
    "query": "daft punk",
    "searchType": "tracks",
    "genre": "all-music",
    "chartType": "trending",
    "maxItems": 200,
    "maxItemsPerSource": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/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 = {
    "mode": "resolve",
    "urls": [
        "https://soundcloud.com/eldjkb/get-lucky-original-version",
        "https://soundcloud.com/eldjkb",
    ],
    "query": "daft punk",
    "searchType": "tracks",
    "genre": "all-music",
    "chartType": "trending",
    "maxItems": 200,
    "maxItemsPerSource": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/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 '{
  "mode": "resolve",
  "urls": [
    "https://soundcloud.com/eldjkb/get-lucky-original-version",
    "https://soundcloud.com/eldjkb"
  ],
  "query": "daft punk",
  "searchType": "tracks",
  "genre": "all-music",
  "chartType": "trending",
  "maxItems": 200,
  "maxItemsPerSource": 200
}' |
apify call xtracto/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Tracks, Artists & Playlists Scraper",
        "description": "Scrape SoundCloud tracks, artists, playlists, and charts with full play, like, and repost stats. Resolve any URL, search by keyword, pull an artist's uploads, expand playlists into per-track detail, or grab a genre's trending / top chart. No login, no API key.",
        "version": "0.1",
        "x-build-id": "SPZwSOnbFvyShYuny"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-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/xtracto~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-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/xtracto~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-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",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "resolve",
                            "search",
                            "artist",
                            "playlist",
                            "charts"
                        ],
                        "type": "string",
                        "description": "What to pull. 'resolve' = look up each SoundCloud URL and return the full track / artist / playlist it points to (uses 'urls'). 'search' = find tracks, artists, or playlists by keyword (uses 'query' + 'searchType'). 'artist' = an artist profile plus their uploaded tracks (uses 'urls'). 'playlist' = a playlist / album with its tracks (uses 'urls'). 'charts' = the trending or top chart for a genre (uses 'genre' + 'chartType').",
                        "default": "resolve"
                    },
                    "urls": {
                        "title": "SoundCloud URLs",
                        "type": "array",
                        "description": "Used when mode = 'resolve', 'artist', or 'playlist'. Full soundcloud.com URLs. For 'resolve' mix any track / artist / playlist URLs; for 'artist' use artist profile URLs; for 'playlist' use playlist or album URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Used when mode = 'search'. Free-text keyword (artist name, track title, etc.)."
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "tracks",
                            "users",
                            "playlists"
                        ],
                        "type": "string",
                        "description": "Used when mode = 'search'. Whether to search for tracks, artists, or playlists.",
                        "default": "tracks"
                    },
                    "genre": {
                        "title": "Chart genre",
                        "type": "string",
                        "description": "Used when mode = 'charts'. Genre slug, e.g. 'all-music', 'all-audio', 'hiphoprap', 'house', 'electronic', 'pop', 'rock'. Use 'all-music' for the overall music chart."
                    },
                    "chartType": {
                        "title": "Chart type",
                        "enum": [
                            "trending",
                            "top"
                        ],
                        "type": "string",
                        "description": "Used when mode = 'charts'. 'trending' = what's hot right now; 'top' = the most-played all-time-style chart.",
                        "default": "trending"
                    },
                    "hydratePlaylistTracks": {
                        "title": "Include full track details for playlists",
                        "type": "boolean",
                        "description": "Used when mode = 'playlist' or when a resolved URL is a playlist. If checked, every track in the playlist is returned with full details (play / like counts, artist, artwork). If unchecked, only the playlist record itself is returned.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max records (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to push to the dataset across the whole run (0 = no cap).",
                        "default": 200
                    },
                    "maxItemsPerSource": {
                        "title": "Max records per source (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap per individual URL / search query / chart (0 = no cap). Note: keyword search returns at most ~200 results per query regardless of this value.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. SoundCloud data is public and needs no proxy, so this is off by default. Enable it (Residential recommended) only if you want requests routed through Apify Proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```