# Bandcamp Scraper (`crawlerbros/bandcamp-scraper`) Actor

Scrape Bandcamp, the artist-first music marketplace. Search albums, tracks, artists, labels; fetch any album/track/artist page; browse by tag/genre or the discover feed. Returns title, artist, label, release date, tracks, prices, cover art, and audio stream URLs.

- **URL**: https://apify.com/crawlerbros/bandcamp-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 16 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 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.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

## Bandcamp Scraper

Scrape **Bandcamp** — the artist-first music marketplace — for albums, tracks, artists, labels, and discover-feed releases. Returns clean structured data including title, artist, label, release date, track listings, prices, cover art, and audio stream URLs.

### What this actor extracts

For every emitted record (album / track / artist / label):

- `title` / `name` — album title or artist/label name
- `artistName`, `artistUrl`, `artistImageUrl`
- `labelName`, `labelUrl` — for releases on a label
- `description`, `credits`
- `releaseDate`, `originalReleaseDate` (ISO-8601 UTC)
- `tags` — Bandcamp tag list (top 30)
- `coverUrl` — high-resolution album / track artwork (`f4.bcbits.com/img/aXXXXXXXXXX_10.jpg`)
- `imageUrl` / `artistImageUrl` — high-res band photo when available
- Pricing: `price`, `minimumPrice`, `isFree`
- `tracks[]` — track number, title, duration (seconds + ISO-8601), audio stream URL, lyrics
- `numTracks`
- `hasAudio`, `isPreorder`
- IDs: `albumId`, `trackId`, `bandId`, `artId`, `featuredTrackId`
- `url` — canonical bandcamp.com URL
- `recordType` — one of `album`, `track`, `artist`, `label`

For artist records: `discography[]` with each release's title, type, URL, cover, release date.

For discover-feed records: `genre`, `location`, `featuredTrack` (sample stream).

### Modes

| Mode            | Input                                              | Output |
|-----------------|----------------------------------------------------|--------|
| `byUrl`         | `url` or `urls[]` — any bandcamp.com URL           | Auto-routed: album/track/artist/tag |
| `searchAlbum`   | `query`                                            | Albums matching the query |
| `searchTrack`   | `query`                                            | Tracks matching the query |
| `searchArtist`  | `query`                                            | Artists/bands matching the query |
| `searchBand`    | `query`                                            | Alias of `searchArtist` |
| `searchLabel`   | `query`                                            | Labels matching the query |
| `byArtist`      | `artistUrl` or `artistSubdomain`                   | Artist record + discography |
| `byAlbum`       | `url` or `artistSubdomain` + `albumSlug`           | Full album with tracklist |
| `byTrack`       | `url` or `artistSubdomain` + `trackSlug`           | Single track record |
| `byTag`         | `tag` (e.g. `electronic`, `lo-fi`)                 | Releases curated under the tag |
| `byGenre`       | `genre` (curated dropdown)                         | Same as `byTag` for top-level genres |
| `discover`      | `genre`, `sortBy` (`top`/`new`/`rec`)              | Bandcamp's front-page discover feed |

### Filters

| Filter             | Description |
|--------------------|-------------|
| `minPrice`         | Drop records with listed price below this (USD). Records without pricing pass. |
| `maxPrice`         | Drop records with listed price above this (USD). Records without pricing pass. |
| `onlyWithAudio`    | Only emit records that have a streamable audio URL or featured track. |
| `onlyFree`         | Only emit name-your-price-zero / free items. |
| `maxItems`         | Hard cap on emitted records (1-1000). |

### Reliability

- HTTP-first via `httpx` with browser-like headers.
- Auto-escalates to Apify proxy on 403 / 429 if `autoEscalateOnBlock=true` (default).
- Retries on 5xx / 429 with exponential backoff up to 4 attempts.
- Bandcamp's public search and discover APIs (`bcsearch_public_api`, `discover/3`) are used — no auth required.

### Cover-art URLs

Album / track artwork is rehosted-style stable: every cover is built from the
canonical `art_id` against `f4.bcbits.com/img/a<art_id>_10.jpg` (size 10 = full
quality, ~1500×1500). These URLs are publicly accessible without referer or
cookies.

### FAQ

**Do I need a Bandcamp account or login?**
No. All exposed endpoints are public.

**Does the actor download the actual audio files?**
No — it returns `streamUrl` (a 128 kbps MP3 preview) per track, but does not
download the bytes. Use the URL with your own client if you need the audio.

**Can I scrape a fan/profile page?**
Not in v1 — fan profiles require login. Open an issue if you need this.

**How fresh are the results?**
The discover feed and search index update every few minutes; album / track
pages are server-rendered and reflect what's live on Bandcamp at request time.

**Why is the `price` field missing on some records?**
Many Bandcamp items are name-your-price; in that case we emit `isFree=true` if
the minimum is zero, or only `minimumPrice`. Free / no-pricing records pass
the `minPrice`/`maxPrice` filters.

### Limitations

- Fan-only / login-walled pages are not supported.
- Merch-only pages return what the album page exposes (no shipping logic).
- Pre-orders and live streams are emitted with `isPreorder=true`.

# Actor input Schema

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

What to fetch.
## `url` (type: `string`):

A bandcamp.com URL — album, track, artist subdomain, or tag page. Used by mode=byUrl/byAlbum/byTrack/byArtist.
## `urls` (type: `array`):

Multiple bandcamp.com URLs. Album/track/artist/tag URLs are auto-routed.
## `query` (type: `string`):

Free-text query for the search modes.
## `artistSubdomain` (type: `string`):

Artist subdomain on bandcamp.com (the part before `.bandcamp.com`). Combine with `albumSlug` or `trackSlug` to build a URL.
## `artistUrl` (type: `string`):

Full URL of the artist's bandcamp.com homepage.
## `albumSlug` (type: `string`):

Album slug — the part after `/album/` in the URL.
## `trackSlug` (type: `string`):

Track slug — the part after `/track/` in the URL.
## `tag` (type: `string`):

Bandcamp tag slug, e.g. `electronic`, `lo-fi`, `synthwave`.
## `genre` (type: `string`):

One of the curated Bandcamp top-level genres. Used by mode=byGenre and mode=discover.
## `sortBy` (type: `string`):

Sort order for the discover feed.
## `minPrice` (type: `number`):

Drop records with a listed price below this value. Records without pricing data pass.
## `maxPrice` (type: `number`):

Drop records with a listed price above this value. Records without pricing data pass.
## `onlyWithAudio` (type: `boolean`):

Only emit records that have a streamable audio URL or featured track.
## `onlyFree` (type: `boolean`):

Only emit records that are name-your-price-zero or explicitly free.
## `useProxy` (type: `boolean`):

Route requests through Apify proxy. Bandcamp is normally accessible without a proxy.
## `autoEscalateOnBlock` (type: `boolean`):

If direct fetches return 403/429, retry through Apify proxy automatically.
## `proxyConfiguration` (type: `object`):

Optional Apify proxy configuration override.
## `maxItems` (type: `integer`):

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byUrl",
  "url": "https://godspeedyoublackemperor.bandcamp.com/album/lift-your-skinny-fists-like-antennas-to-heaven",
  "urls": [],
  "query": "ambient",
  "sortBy": "top",
  "onlyWithAudio": false,
  "onlyFree": false,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "maxItems": 50
}
````

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped Bandcamp records.

# 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": "byUrl",
    "url": "https://godspeedyoublackemperor.bandcamp.com/album/lift-your-skinny-fists-like-antennas-to-heaven",
    "urls": [],
    "query": "ambient",
    "sortBy": "top",
    "onlyWithAudio": false,
    "onlyFree": false,
    "useProxy": false,
    "autoEscalateOnBlock": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    },
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/bandcamp-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": "byUrl",
    "url": "https://godspeedyoublackemperor.bandcamp.com/album/lift-your-skinny-fists-like-antennas-to-heaven",
    "urls": [],
    "query": "ambient",
    "sortBy": "top",
    "onlyWithAudio": False,
    "onlyFree": False,
    "useProxy": False,
    "autoEscalateOnBlock": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/bandcamp-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": "byUrl",
  "url": "https://godspeedyoublackemperor.bandcamp.com/album/lift-your-skinny-fists-like-antennas-to-heaven",
  "urls": [],
  "query": "ambient",
  "sortBy": "top",
  "onlyWithAudio": false,
  "onlyFree": false,
  "useProxy": false,
  "autoEscalateOnBlock": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  },
  "maxItems": 50
}' |
apify call crawlerbros/bandcamp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bandcamp Scraper",
        "description": "Scrape Bandcamp, the artist-first music marketplace. Search albums, tracks, artists, labels; fetch any album/track/artist page; browse by tag/genre or the discover feed. Returns title, artist, label, release date, tracks, prices, cover art, and audio stream URLs.",
        "version": "1.0",
        "x-build-id": "jqniAI1udWsogqNed"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~bandcamp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-bandcamp-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/crawlerbros~bandcamp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-bandcamp-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/crawlerbros~bandcamp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-bandcamp-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byUrl",
                            "searchAlbum",
                            "searchTrack",
                            "searchArtist",
                            "searchBand",
                            "searchLabel",
                            "byArtist",
                            "byAlbum",
                            "byTrack",
                            "byTag",
                            "byGenre",
                            "discover"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "byUrl"
                    },
                    "url": {
                        "title": "URL",
                        "type": "string",
                        "description": "A bandcamp.com URL — album, track, artist subdomain, or tag page. Used by mode=byUrl/byAlbum/byTrack/byArtist.",
                        "default": "https://godspeedyoublackemperor.bandcamp.com/album/lift-your-skinny-fists-like-antennas-to-heaven"
                    },
                    "urls": {
                        "title": "URLs (mode=byUrl, batch)",
                        "type": "array",
                        "description": "Multiple bandcamp.com URLs. Album/track/artist/tag URLs are auto-routed.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search query (mode=search*)",
                        "type": "string",
                        "description": "Free-text query for the search modes.",
                        "default": "ambient"
                    },
                    "artistSubdomain": {
                        "title": "Artist subdomain (mode=byArtist/byAlbum/byTrack)",
                        "type": "string",
                        "description": "Artist subdomain on bandcamp.com (the part before `.bandcamp.com`). Combine with `albumSlug` or `trackSlug` to build a URL."
                    },
                    "artistUrl": {
                        "title": "Artist URL (mode=byArtist)",
                        "type": "string",
                        "description": "Full URL of the artist's bandcamp.com homepage."
                    },
                    "albumSlug": {
                        "title": "Album slug (mode=byAlbum)",
                        "type": "string",
                        "description": "Album slug — the part after `/album/` in the URL."
                    },
                    "trackSlug": {
                        "title": "Track slug (mode=byTrack)",
                        "type": "string",
                        "description": "Track slug — the part after `/track/` in the URL."
                    },
                    "tag": {
                        "title": "Tag (mode=byTag)",
                        "type": "string",
                        "description": "Bandcamp tag slug, e.g. `electronic`, `lo-fi`, `synthwave`."
                    },
                    "genre": {
                        "title": "Genre (mode=byGenre / discover)",
                        "enum": [
                            "all",
                            "electronic",
                            "rock",
                            "metal",
                            "alternative",
                            "hip-hop-rap",
                            "experimental",
                            "punk",
                            "folk",
                            "pop",
                            "ambient",
                            "soundtrack",
                            "world",
                            "jazz",
                            "acoustic",
                            "funk",
                            "r-and-b-soul",
                            "devotional",
                            "classical",
                            "reggae",
                            "podcasts",
                            "country",
                            "spoken-word",
                            "comedy",
                            "blues",
                            "kids",
                            "audiobooks",
                            "latin"
                        ],
                        "type": "string",
                        "description": "One of the curated Bandcamp top-level genres. Used by mode=byGenre and mode=discover."
                    },
                    "sortBy": {
                        "title": "Sort (mode=discover)",
                        "enum": [
                            "top",
                            "new",
                            "rec"
                        ],
                        "type": "string",
                        "description": "Sort order for the discover feed.",
                        "default": "top"
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Drop records with a listed price below this value. Records without pricing data pass."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Drop records with a listed price above this value. Records without pricing data pass."
                    },
                    "onlyWithAudio": {
                        "title": "Audio stream required",
                        "type": "boolean",
                        "description": "Only emit records that have a streamable audio URL or featured track.",
                        "default": false
                    },
                    "onlyFree": {
                        "title": "Only free items",
                        "type": "boolean",
                        "description": "Only emit records that are name-your-price-zero or explicitly free.",
                        "default": false
                    },
                    "useProxy": {
                        "title": "Use Apify proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify proxy. Bandcamp is normally accessible without a proxy.",
                        "default": false
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to proxy on block",
                        "type": "boolean",
                        "description": "If direct fetches return 403/429, retry through Apify proxy automatically.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration override.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
