# SoundCloud Scraper | Tracks Artists and Playlists (`parseforge/soundcloud-scraper`) Actor

Scrape SoundCloud tracks, artists, playlists, comments, plays, likes, and reposts with titles, descriptions, genres, durations, and stream URLs. Power music discovery apps, creator analytics, audio trend research, and music industry intelligence at scale across the platform.

- **URL**: https://apify.com/parseforge/soundcloud-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Social media, Marketing, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎵 SoundCloud Track Scraper

> 🚀 **Export SoundCloud tracks with play counts, likes, artist data, and metadata in seconds.** No account required - works right out of the box.

> 🕒 **Last updated:** 2026-05-22 · **📊 18 fields** per record · **Unlimited searches** · **Global coverage**

The SoundCloud Track Scraper lets you search SoundCloud and extract structured data for any tracks matching your query. All data is scraped in real time from SoundCloud's public API - no stale cache, no login required.

Each record includes the track's title, artist, play count, likes, comments, reposts, duration, genre, tags, description, artist follower count, artwork URL, and creation date. Data is delivered in JSON, CSV, Excel, or XML via the Apify dataset.

SoundCloud hosts over 300 million tracks across every genre imaginable - from lo-fi beats to underground house, ambient, hip-hop, jazz, and more. This scraper surfaces that catalogue in a structured, machine-readable format you can pipe into analytics tools, dashboards, or your own applications.

### Target Audience and Use Cases

| Who | What they use it for |
|-----|---------------------|
| Music researchers | Track play trends, genre analytics, artist growth |
| Playlist curators | Discover trending tracks by genre or keyword |
| Marketers | Identify rising artists for brand partnerships |
| Data scientists | Build music recommendation training datasets |
| Journalists | Verify streaming stats and viral audio claims |
| Developers | Power music discovery apps and bots |

### 📋 What the SoundCloud Scraper does

- Search SoundCloud by any keyword, genre, artist name, or mood
- Extracts full track metadata: title, artist, play count, likes, comments, reposts, duration, genre, tags
- Converts artwork to high-resolution 500x500 URLs automatically
- Splits raw tag strings into clean arrays
- Paginates automatically to collect up to 1,000,000 results
- Delivers data in JSON, CSV, Excel, or XML - ready to download

> 💡 **Why it matters:** SoundCloud exposes richer metadata than most streaming platforms - including per-track play counts, comment counts, and tag lists - making it ideal for granular music analytics that platforms like Spotify don't offer publicly.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | String | Keywords to search (track title, artist, genre, mood) | `lofi hip hop` |
| `maxItems` | Integer | Maximum tracks to collect (1-1,000,000) | `10` |

**Example - search for lo-fi tracks:**
```json
{
    "searchQuery": "lofi hip hop",
    "maxItems": 100
}
````

**Example - search for a specific artist:**

```json
{
    "searchQuery": "Nujabes",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** Free plan users are limited to 10 tracks per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 tracks per search.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | String | High-resolution artwork URL (500x500) |
| 🎵 `title` | String | Track title |
| 🎤 `artist` | String | Artist/uploader username |
| 🔗 `url` | String | Track permalink URL |
| 🆔 `trackId` | Integer | SoundCloud internal track ID |
| 👤 `artistUrl` | String | Artist profile URL |
| ▶️ `playCount` | Integer | Total play count |
| ❤️ `likesCount` | Integer | Total likes |
| 💬 `commentCount` | Integer | Total comments |
| 🔁 `repostsCount` | Integer | Total reposts |
| ⏱️ `duration` | Integer | Track duration in seconds |
| 🎼 `genre` | String | Track genre label |
| 🏷️ `tags` | Array | Tag list as array |
| 📝 `description` | String | Track description (first 300 chars) |
| 👥 `artistFollowers` | Integer | Artist follower count |
| 📅 `createdAt` | String | Track upload timestamp (ISO 8601) |
| 🕐 `scrapedAt` | String | Scrape timestamp (ISO 8601) |
| ❌ `error` | String | Error message if scraping failed |

**Sample record:**

```json
{
    "imageUrl": "https://i1.sndcdn.com/artworks-6Yo5NytmbWj9LeL0-nUs8tQ-t500x500.png",
    "title": "Dean Lofi - Winter Night ( Lofi Hip Hop )",
    "artist": "Dean Lofi",
    "url": "https://soundcloud.com/deanlofi/winter-night-lofi-hip-hop",
    "trackId": 2226939302,
    "artistUrl": "https://soundcloud.com/deanlofi",
    "playCount": 16984,
    "likesCount": 39,
    "commentCount": 2,
    "repostsCount": 2,
    "duration": 138,
    "genre": "Christmas Lofi",
    "tags": ["Chill", "Hip Hop", "Lofi Hip Hop"],
    "description": "Stream on Spotify: https://open.spotify.com/album/1cY6URSvZVrPDODiLJl5Jx",
    "artistFollowers": 1222,
    "createdAt": "2025-12-09T22:36:49Z",
    "scrapedAt": "2026-05-22T02:13:07.954Z"
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🔑 No login required | Works instantly, no SoundCloud account needed |
| 📡 Real-time data | All data scraped live - never cached or stale |
| 🏷️ Structured tags | Raw tag strings converted to clean arrays automatically |
| 🖼️ High-res artwork | Artwork URLs upgraded to 500x500 automatically |
| 📄 Multi-format export | JSON, CSV, Excel, XML - ready for any tool |
| ♾️ Unlimited scale | Paginate through millions of results |
| ⚡ Fast extraction | SoundCloud's public API is fast and reliable |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---------|-----------|-----------------|----------------|
| Play count | ✅ | Tedious | Sometimes |
| Tags as array | ✅ | No | Rarely |
| Artist followers | ✅ | Manual | Sometimes |
| Pagination | ✅ Automatic | No | Varies |
| Output formats | ✅ JSON/CSV/Excel/XML | No | Varies |
| No login required | ✅ | ✅ | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the SoundCloud Track Scraper in Apify Store
3. Enter your search query (artist name, genre, mood, or keywords)
4. Set your `maxItems` limit
5. Click **Start** and wait for results
6. Download your dataset as JSON, CSV, or Excel

### 💼 Business use cases

#### Music Trend Analysis

Track which genres and artists are gaining traction on SoundCloud. Monitor play count growth, likes velocity, and comment engagement over time to spot emerging trends before they hit mainstream charts.

#### Artist Research and Outreach

Build comprehensive databases of artists in specific niches. Extract follower counts, track output, and engagement rates to identify rising talent for record label signings, sync licensing, or brand partnerships.

#### Playlist Curation and Discovery

Automate the discovery of new tracks for curated playlists. Filter by genre, sort by play count or likes, and surface hidden gems in any niche from ambient to drum and bass.

#### Audio Content Intelligence

Analyze the SoundCloud catalogue for content gaps, production trends, and audience preferences. Use scraped metadata to inform content strategies for podcasts, music blogs, or streaming platforms.

### 🔌 Automating SoundCloud Scraper

Connect the SoundCloud Scraper to your favorite tools using Apify's native integrations:

- **Make (Integromat)** - Trigger a SoundCloud search and send results to Google Sheets, Airtable, or Slack
- **Zapier** - Automatically add new trending tracks to a CRM or email list
- **Slack** - Post daily trending track reports directly to a Slack channel
- **Google Sheets** - Build live music dashboards that refresh on a schedule
- **Webhooks** - Push scraped data to any custom endpoint

### 🌟 Beyond business use cases

#### Academic Research

Music scholars can study genre evolution, cross-cultural music exchange, and the geography of sound. SoundCloud's metadata gives researchers a window into grassroots music production at a global scale.

#### Creative Projects

Musicians and producers can map the sonic landscape of any genre - understanding what tags, descriptions, and presentation styles correlate with higher engagement.

#### Non-Profit and Community Use

Community radio stations, music education programs, and non-profits can use this scraper to discover local artists and underrepresented voices without expensive music data subscriptions.

#### Experimentation and Learning

Developers learning data pipelines and ML engineers building music recommendation systems can use this as a clean, structured training dataset.

### 🤖 Ask an AI assistant about this scraper

Want to analyze your SoundCloud dataset with AI? Export your results as JSON and upload to Claude, ChatGPT, or Gemini. Ask things like:

- "Which genres have the highest average play counts?"
- "Show me artists with under 1,000 followers but over 10,000 plays per track"
- "Cluster these tracks by tag patterns"

The structured output from this scraper is AI-ready out of the box.

### ❓ Frequently Asked Questions

**❓ Do I need a SoundCloud account to use this scraper?**
No. The scraper uses SoundCloud's public API - no login or account required.

**❓ How many tracks can I scrape?**
Free users: up to 10 tracks per run. Paid users: up to 1,000,000 tracks per search.

**❓ Can I search by artist name?**
Yes. Enter the artist's name or username as the search query.

**❓ Is the play count real-time?**
Yes. All data is fetched live from SoundCloud's API at the time of the run.

**❓ Can I filter by genre?**
The search query accepts genre keywords. Enter "lofi", "jazz", "techno", etc. as your search query to get genre-specific results.

**❓ What does the tags field contain?**
The `tags` field is a structured array parsed from SoundCloud's raw tag string. Each tag is a separate entry.

**❓ Why is the artwork URL 500x500?**
The scraper automatically upgrades SoundCloud's default artwork URLs from 100x100 to 500x500 for high-resolution output.

**❓ Can I get the actual audio stream URL?**
SoundCloud's streaming URLs require authentication. This scraper provides all public metadata but not authenticated stream URLs.

**❓ How fast does it run?**
A search for 100 tracks typically completes in under 30 seconds. Larger runs of 10,000+ tracks may take a few minutes.

**❓ Does it handle pagination automatically?**
Yes. The scraper follows SoundCloud's `next_href` pagination cursor automatically until your `maxItems` limit is reached.

**❓ What if a track has no artwork?**
If the track has no artwork, the scraper falls back to the artist's avatar URL (also upgraded to 500x500).

**❓ How often can I run it?**
As often as you need. There are no rate limits enforced on your end - the scraper handles all API courtesy automatically.

### 🔌 Integrate with any app

The SoundCloud Track Scraper works with any app that accepts JSON, CSV, or webhooks:

**Spreadsheets** - Google Sheets, Microsoft Excel, Airtable

**Databases** - PostgreSQL, MySQL, MongoDB, BigQuery

**Analytics** - Tableau, Power BI, Looker, Metabase

**Automation** - Make, Zapier, n8n, Activepieces

**AI Tools** - Claude, ChatGPT, Gemini (upload JSON export)

**Storage** - Google Drive, Dropbox, AWS S3

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Spotify Scraper](https://apify.com/parseforge) | Extract Spotify track and artist data |
| [YouTube Scraper](https://apify.com/parseforge) | Scrape YouTube video metadata and stats |
| [Instagram Scraper](https://apify.com/parseforge) | Extract Instagram posts, reels, and profiles |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering music, social media, marketplaces, and more.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This actor is an independent tool, not affiliated with, endorsed by, or sponsored by SoundCloud. It accesses only publicly available data through SoundCloud's public API. Use in accordance with SoundCloud's Terms of Service and applicable laws.

# Actor input Schema

## `searchQuery` (type: `string`):

Search query for SoundCloud tracks (e.g. 'lofi hip hop', 'jazz', 'artist name')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "searchQuery": "lofi hip hop",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQuery": "lofi hip hop",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "searchQuery": "lofi hip hop",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "searchQuery": "lofi hip hop",
  "maxItems": 10
}' |
apify call parseforge/soundcloud-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SoundCloud Scraper | Tracks Artists and Playlists",
        "description": "Scrape SoundCloud tracks, artists, playlists, comments, plays, likes, and reposts with titles, descriptions, genres, durations, and stream URLs. Power music discovery apps, creator analytics, audio trend research, and music industry intelligence at scale across the platform.",
        "version": "0.1",
        "x-build-id": "FO3woxlhjayc5abHS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~soundcloud-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~soundcloud-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~soundcloud-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-soundcloud-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search query for SoundCloud tracks (e.g. 'lofi hip hop', 'jazz', 'artist name')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```