# SoundCloud Scraper — Music Data & Artist Emails (`khadinakbar/soundcloud-scraper`) Actor

Scrape public SoundCloud tracks, artists, playlists, catalogs, and search results without cookies. Built for A\&R, music research, outreach, monitoring, and AI workflows. Returns engagement metrics, ISRCs, tags, URLs, and publicly listed contact emails. No audio downloads or private data.

- **URL**: https://apify.com/khadinakbar/soundcloud-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Videos, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 soundcloud result saveds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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 Scraper — Tracks, Artists, Playlists & Public Emails

Scrape public SoundCloud tracks, artist profiles, playlists, artist catalogs, and keyword search results without supplying a SoundCloud login or cookies. The Actor returns a stable dataset row for every saved track, artist, or playlist, including engagement metrics, genres, tags, ISRC/UPC metadata, canonical URLs, and contact emails explicitly published in descriptions.

Use it for A&R research, artist and label discovery, catalog monitoring, music-market analysis, playlist audits, outreach preparation, dashboards, and AI-agent workflows. It is MCP-ready, defaults to a working health-check search, and charges **$0.006 only for each schema-valid row successfully saved**, plus the standard Actor-start event and Apify platform usage.

### What you can collect

- Track search results with title, artist, duration, plays, likes, reposts, comments, genre, tags, label, ISRC, release date, artwork, and waveform URL.
- Artist search results with biography, public contact emails, location, verification, followers, following, track count, playlist count, avatar, and profile URL.
- Direct public track, artist, and playlist URLs.
- Tracks published by one or more artist profiles.
- Playlist metadata plus expanded track rows when `expandPlaylists` is enabled.
- Compact `OUTPUT` and detailed `RUN_SUMMARY` records for automation, billing checks, and debugging.

All dataset rows use the same explicit schema. Fields that do not apply to an entity are `null` or an empty array rather than disappearing, which makes exports easier to use in databases, spreadsheets, and agent tools.

### Quick start

The default input runs a small track search. For a targeted search:

```json
{
  "mode": "searchTracks",
  "searchQueries": ["lofi hip hop", "indie electronic"],
  "maxResults": 25,
  "includeContactEmails": true,
  "dataSource": "auto"
}
````

To scrape direct URLs:

```json
{
  "mode": "scrapeUrls",
  "startUrls": [
    { "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean" },
    { "url": "https://soundcloud.com/kehlanimusic" }
  ],
  "maxResults": 10,
  "expandPlaylists": true,
  "includeContactEmails": true
}
```

To export an artist catalog, set `mode` to `artistTracks` and provide artist profile URLs in `startUrls`.

### Input reference

| Field | Purpose | Default |
|---|---|---|
| `mode` | `searchTracks`, `searchArtists`, `scrapeUrls`, or `artistTracks` | `searchTracks` |
| `searchQueries` | Up to 20 keywords for a search mode | `lofi hip hop` |
| `startUrls` | Up to 50 public SoundCloud URLs | Working public track URL |
| `maxResults` | Global dataset and paid-result cap, from 1 to 1,000 | `25` |
| `includeContactEmails` | Read emails explicitly published in public descriptions | `true` |
| `expandPlaylists` | Save playlist tracks after the playlist row | `true` |
| `dataSource` | `auto`, native `soundcloud`, or `scrapeCreators` fallback | `auto` |

`auto` is recommended. It uses public SoundCloud web data first and can recover supported direct track, artist, or artist-catalog routes through an owner-managed provider. SoundCloud search and playlists remain native because the fallback provider has no equivalent endpoints. You never need to provide a provider key as an Actor user.

### Output example

```json
{
  "entityType": "track",
  "id": "123456789",
  "url": "https://soundcloud.com/artist/example-track",
  "title": "Example Track",
  "artistName": "Example Artist",
  "contactEmails": ["bookings@example.org"],
  "genre": "Electronic",
  "tags": ["electronic", "indie"],
  "durationMs": 218000,
  "playbackCount": 125000,
  "likesCount": 4200,
  "repostsCount": 310,
  "isrc": "USAAA2500123",
  "dataSource": "soundcloud",
  "scrapedAt": "2026-07-15T12:00:00.000Z"
}
```

The actual row also contains every documented nullable field. Open the Dataset schema in Apify Console for the full contract.

### Run through the API

JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/soundcloud-scraper').call({
  mode: 'searchArtists',
  searchQueries: ['indie label london'],
  maxResults: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/soundcloud-scraper").call(run_input={
    "mode": "artistTracks",
    "startUrls": [{"url": "https://soundcloud.com/soundcloud-stories"}],
    "maxResults": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

cURL:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/khadinakbar~soundcloud-scraper/runs?token=$APIFY_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"mode":"scrapeUrls","startUrls":[{"url":"https://soundcloud.com/kehlanimusic"}],"maxResults":5}'
```

### Use with MCP and AI agents

Connect the Actor through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp) and select `khadinakbar/soundcloud-scraper`. The compact input, bounded `maxResults`, homogeneous output, and explicit `OUTPUT.outcome` are designed for predictable tool calls. Agents can search a niche, inspect artist profiles, collect public contacts, or export a catalog without parsing SoundCloud pages themselves.

### Pricing and cost controls

| Event | Price |
|---|---:|
| `apify-actor-start` | $0.00005, platform-managed and memory-scaled |
| `soundcloud-result` | $0.006 per successfully saved result |

Before upstream work starts, the run logs its maximum result-event cost. `maxResults`, Apify's paid-dataset-item limit, and the run's maximum-total-charge setting are enforced as independent guards. Invalid, duplicate, and unwritten records are not intentionally billed. `RUN_SUMMARY.chargedEventCounts` reports the observed result-event count.

### Reliability and honest outcomes

SoundCloud can change its public web API and rate limits. The Actor discovers the current public web client identifier at runtime, retries transient failures with backoff, restricts pagination to SoundCloud API hosts, deduplicates records, and validates the complete row before it is written. Direct supported routes can fall back automatically when the native route is unavailable.

Every terminal path writes `OUTPUT` and `RUN_SUMMARY`. A successful empty search is `VALID_EMPTY`; partially recovered or capped work is `PARTIAL`; missing owner configuration is `CONFIG_ERROR`; and a genuine upstream outage is `UPSTREAM_FAILED`. The Actor does not label outages as successful empty results.

### Limits and responsible use

- Public SoundCloud data only. The Actor does not log in, bypass access controls, read private content, or use secret-token URLs.
- It does not download or expose audio streams. `downloadable` only reports SoundCloud's public metadata flag.
- Contact emails are extracted only when the owner publicly wrote them in a profile or track description. Verify relevance and follow applicable privacy, anti-spam, and marketing laws before outreach.
- Counts reflect SoundCloud at scrape time and can change later.
- Very large jobs may encounter platform deadlines or SoundCloud throttling; split them into bounded runs and preserve `RUN_SUMMARY` for audits.
- Use the output in accordance with SoundCloud's terms and applicable law.

### Related music and social Actors

Combine this Actor with [Spotify All-in-One Scraper](https://apify.com/khadinakbar/spotify-all-in-one-scraper), [Spotify Artist Scraper](https://apify.com/khadinakbar/spotify-artist-scraper), [Spotify Monthly Listeners Scraper](https://apify.com/khadinakbar/spotify-monthly-listeners-scraper), [Spotify Play Count Scraper](https://apify.com/khadinakbar/spotify-play-count-scraper), [YouTube Search Scraper](https://apify.com/khadinakbar/youtube-search-scraper), [YouTube Channel Scraper](https://apify.com/khadinakbar/youtube-channel-scraper), [YouTube Trending Videos Scraper](https://apify.com/khadinakbar/youtube-trending-videos-scraper), [TikTok Sound Scraper](https://apify.com/khadinakbar/tiktok-sound-scraper), [Instagram Audio Scraper](https://apify.com/khadinakbar/instagram-audio-scraper), [Twitch Channel Scraper](https://apify.com/khadinakbar/twitch-channel-scraper), and [Social Media Sentiment Analyzer](https://apify.com/khadinakbar/social-media-sentiment-analyzer).

# Actor input Schema

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

Choose what the Actor should collect. Track and artist search use Search Queries; direct URL mode accepts tracks, artists, and playlists; artist catalog mode returns tracks from artist profile URLs. Search modes require the native SoundCloud route because the fallback provider does not expose search. The default is a track search that works as a health check.

## `searchQueries` (type: `array`):

Enter up to 20 SoundCloud search keywords or phrases. Each query is processed until the global Max Results limit is reached. This field is used only by Search tracks and Search artists. Try genres, moods, artists, labels, or track names.

## `startUrls` (type: `array`):

Add up to 50 public soundcloud.com URLs. Direct URL mode accepts track, artist, and playlist URLs; artist catalog mode accepts artist profile URLs only. Playlist URLs can produce one playlist row plus their track rows when expansion is enabled. Private, secret-token, and non-SoundCloud URLs are not supported.

## `maxResults` (type: `integer`):

Set the global maximum number of dataset rows and paid result events. The Actor stops across all queries and URLs when this cap is reached. A playlist row counts as one result, and each expanded track counts as another. Use a small value while testing cost and output shape.

## `includeContactEmails` (type: `boolean`):

Extract email addresses that artists publicly place in profile or track descriptions. This may make an extra public artist-profile request for track rows. The Actor never accesses private account information or guesses email addresses. Disable it when you only need catalog and engagement data.

## `expandPlaylists` (type: `boolean`):

When a playlist URL is resolved, save its track rows after the playlist row. Incomplete embedded tracks are hydrated through SoundCloud's public web API. All rows still obey the global result and cost cap. Disable this to return playlist metadata only.

## `dataSource` (type: `string`):

Auto tries public SoundCloud web data first and uses the owner-managed ScrapeCreators fallback for supported direct track or artist routes. SoundCloud forces native extraction and never uses the paid fallback. ScrapeCreators forces the fallback and requires the Actor owner's configured secret. Search and playlist extraction are available only with Auto or SoundCloud.

## Actor input object example

```json
{
  "mode": "searchTracks",
  "searchQueries": [
    "lofi hip hop",
    "indie electronic"
  ],
  "startUrls": [
    {
      "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean"
    },
    {
      "url": "https://soundcloud.com/kehlanimusic"
    }
  ],
  "maxResults": 10,
  "includeContactEmails": true,
  "expandPlaylists": true,
  "dataSource": "auto"
}
```

# Actor output Schema

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

Validated track, artist, and playlist records from the default dataset.

## `output` (type: `string`):

Stable terminal outcome with persisted, failed, invalid, and charged counts.

## `runSummary` (type: `string`):

Provider telemetry, fallback decisions, cost-cap state, validation diagnostics, and storage identifiers.

# 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 = {
    "searchQueries": [
        "lofi hip hop",
        "indie electronic"
    ],
    "startUrls": [
        {
            "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean"
        },
        {
            "url": "https://soundcloud.com/kehlanimusic"
        }
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": [
        "lofi hip hop",
        "indie electronic",
    ],
    "startUrls": [
        { "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean" },
        { "url": "https://soundcloud.com/kehlanimusic" },
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "lofi hip hop",
    "indie electronic"
  ],
  "startUrls": [
    {
      "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean"
    },
    {
      "url": "https://soundcloud.com/kehlanimusic"
    }
  ],
  "maxResults": 10
}' |
apify call khadinakbar/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Scraper — Music Data & Artist Emails",
        "description": "Scrape public SoundCloud tracks, artists, playlists, catalogs, and search results without cookies. Built for A&R, music research, outreach, monitoring, and AI workflows. Returns engagement metrics, ISRCs, tags, URLs, and publicly listed contact emails. No audio downloads or private data.",
        "version": "1.0",
        "x-build-id": "tgMwcBC6bhzU1wUvI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": "Scraping Mode",
                        "enum": [
                            "searchTracks",
                            "searchArtists",
                            "scrapeUrls",
                            "artistTracks"
                        ],
                        "type": "string",
                        "description": "Choose what the Actor should collect. Track and artist search use Search Queries; direct URL mode accepts tracks, artists, and playlists; artist catalog mode returns tracks from artist profile URLs. Search modes require the native SoundCloud route because the fallback provider does not expose search. The default is a track search that works as a health check.",
                        "default": "searchTracks"
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Enter up to 20 SoundCloud search keywords or phrases. Each query is processed until the global Max Results limit is reached. This field is used only by Search tracks and Search artists. Try genres, moods, artists, labels, or track names.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "lofi hip hop"
                        ]
                    },
                    "startUrls": {
                        "title": "SoundCloud URLs",
                        "type": "array",
                        "description": "Add up to 50 public soundcloud.com URLs. Direct URL mode accepts track, artist, and playlist URLs; artist catalog mode accepts artist profile URLs only. Playlist URLs can produce one playlist row plus their track rows when expansion is enabled. Private, secret-token, and non-SoundCloud URLs are not supported.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Public SoundCloud track, artist, or playlist URL."
                                }
                            },
                            "required": [
                                "url"
                            ]
                        },
                        "default": [
                            {
                                "url": "https://soundcloud.com/kehlanimusic/lights-on-feat-big-sean"
                            }
                        ]
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Set the global maximum number of dataset rows and paid result events. The Actor stops across all queries and URLs when this cap is reached. A playlist row counts as one result, and each expanded track counts as another. Use a small value while testing cost and output shape.",
                        "default": 25
                    },
                    "includeContactEmails": {
                        "title": "Extract Public Contact Emails",
                        "type": "boolean",
                        "description": "Extract email addresses that artists publicly place in profile or track descriptions. This may make an extra public artist-profile request for track rows. The Actor never accesses private account information or guesses email addresses. Disable it when you only need catalog and engagement data.",
                        "default": true
                    },
                    "expandPlaylists": {
                        "title": "Expand Playlist Tracks",
                        "type": "boolean",
                        "description": "When a playlist URL is resolved, save its track rows after the playlist row. Incomplete embedded tracks are hydrated through SoundCloud's public web API. All rows still obey the global result and cost cap. Disable this to return playlist metadata only.",
                        "default": true
                    },
                    "dataSource": {
                        "title": "Data Source Strategy",
                        "enum": [
                            "auto",
                            "soundcloud",
                            "scrapeCreators"
                        ],
                        "type": "string",
                        "description": "Auto tries public SoundCloud web data first and uses the owner-managed ScrapeCreators fallback for supported direct track or artist routes. SoundCloud forces native extraction and never uses the paid fallback. ScrapeCreators forces the fallback and requires the Actor owner's configured secret. Search and playlist extraction are available only with Auto or SoundCloud.",
                        "default": "auto"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
