# TheAudioDB Music Artist and Album Scraper (`parseforge/theaudiodb-music-scraper`) Actor

Pull artist profiles and album discographies from TheAudioDB by name. Returns genre, country, formed year, label, biography, cover art, album release year, review score, and MusicBrainz ID. Great for catalog enrichment, music apps, and genre research across thousands of artists.

- **URL**: https://apify.com/parseforge/theaudiodb-music-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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)

## 🎵 TheAudioDB Music Scraper

> 🚀 **Pull rich artist and album metadata from TheAudioDB in one run.** Search Radiohead and you get the full profile plus 43 albums, each with cover art, release year, genre, and label.

> 🕒 **Last updated:** 2026-06-04 · **📊 21 fields** per record · Artist profiles and full discographies · Global music catalog

TheAudioDB is a community maintained open database of music metadata covering hundreds of thousands of artists and albums. This Actor turns any list of artist names into clean, structured records. For every name you provide it returns the artist profile (genre, country, formed year, biography, social links, official artwork) and the complete album discography (title, year, genre, label, cover thumbnail, review score).

Coverage spans every major and independent artist catalogued on TheAudioDB, from chart toppers to niche acts, with high resolution thumbnails, logos, and banners attached to most records. Because the data comes from the public TheAudioDB API, there is no login and no proxy needed.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Music app and bot developers | Enrich a catalog with artist and album metadata |
| Data analysts and researchers | Build music trend and genre datasets |
| Playlist and content curators | Populate artist pages with art and bios |
| Media and entertainment teams | Cross reference releases by year, genre, and label |

### 📋 What the TheAudioDB Scraper does

This Actor accepts one or more artist names and queries TheAudioDB for each. It returns two kinds of records, both flagged with a `recordType` field so you can split them easily:

- **Artist records** with name, genre, style, mood, country, formed year, member count, label, biography, website, social handles, and official thumbnail, logo, and banner images.
- **Album records** with title, parent artist, release year, genre, style, label, description, review score, and cover art.

You can toggle artist profiles and albums independently, cap the number of records, and supply your own TheAudioDB key for higher rate limits. The public test key works out of the box.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchArtists` | array | One or more artist names to look up. Required. |
| `includeArtist` | boolean | Return the artist profile record for each name. Default true. |
| `includeAlbums` | boolean | Return the album discography for each name. Default true. |
| `maxItems` | integer | Cap on total records. Free plan is limited to 10. |
| `apiKey` | string | TheAudioDB key. Defaults to the public test key. |

Example, artist profiles plus albums for two bands:

```json
{
  "searchArtists": ["Radiohead", "Coldplay"],
  "includeArtist": true,
  "includeAlbums": true,
  "maxItems": 50
}
````

Example, albums only for a single artist:

```json
{
  "searchArtists": ["Daft Punk"],
  "includeArtist": false,
  "includeAlbums": true,
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** TheAudioDB is community maintained, so optional fields such as `website`, `facebook`, `biography`, `logoUrl`, and album `score` are present for many records but not all. Records always include `imageUrl`, `title`, `genre`, and `id`. Empty values are normalized to null.

### 📊 Output

Each record follows this shape. Artist and album records share the leading fields and differ in a few type specific ones.

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Primary thumbnail (artist photo or album cover) |
| 🏷 `recordType` | `artist` or `album` |
| 📌 `title` | Artist name or album title |
| 🆔 `id` | TheAudioDB record ID |
| 🎵 `genre` | Genre label |
| 🎸 `style` | Broader style descriptor |
| 🌍 `country` | Artist origin (artist records) |
| 📆 `formedYear` | Year the artist formed (artist records) |
| 🎤 `artist` | Parent artist name (album records) |
| 📅 `yearReleased` | Album release year (album records) |
| 🏢 `label` | Record label |
| 📝 `biography` / `description` | Long form text |
| 🌐 `website`, `facebook`, `twitter` | Social and web links (artist records) |
| 🖼 `logoUrl`, `bannerUrl` | Extra artwork (artist records) |
| ⭐ `score` | Album review score (album records) |
| 🧬 `musicBrainzId` | MusicBrainz cross reference ID |
| 🔗 `sourceUrl` | TheAudioDB page for the record |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample, artist record:**

```json
{
  "imageUrl": "https://r2.theaudiodb.com/images/media/artist/thumb/35poth1668098458.jpg",
  "recordType": "artist",
  "title": "Radiohead",
  "id": "111418",
  "genre": "Alternative Rock",
  "style": "Rock/Pop",
  "mood": "Sad",
  "country": "Abingdon, England",
  "formedYear": 1991,
  "members": 5,
  "label": "XL Recordings",
  "website": "radiohead.com",
  "facebook": "www.facebook.com/radiohead",
  "logoUrl": "https://r2.theaudiodb.com/images/media/artist/logo/7ss5y81669340618.png",
  "bannerUrl": "https://r2.theaudiodb.com/images/media/artist/banner/qxpvqr1346162754.jpg",
  "musicBrainzId": "a74b1b7f-71a5-4011-9441-d0b5e4122711",
  "sourceUrl": "https://www.theaudiodb.com/artist/111418",
  "scrapedAt": "2026-06-04T19:33:07.396Z",
  "error": null
}
```

**Real sample, album record:**

```json
{
  "imageUrl": "https://r2.theaudiodb.com/images/media/album/thumb/s6zjn11612966472.jpg",
  "recordType": "album",
  "title": "Hail to the Thief",
  "id": "2112020",
  "artist": "Radiohead",
  "genre": "Alternative Rock",
  "style": "Rock/Pop",
  "yearReleased": 2003,
  "label": "Parlophone",
  "score": 9,
  "musicBrainzId": "5c14fd50-a2f1-3672-9537-b0dad91bea2f",
  "sourceUrl": "https://www.theaudiodb.com/album/2112020",
  "scrapedAt": "2026-06-04T19:33:07.603Z",
  "error": null
}
```

**Real sample, second album record:**

```json
{
  "imageUrl": "https://r2.theaudiodb.com/images/media/album/thumb/xy30ox1761246299.jpg",
  "recordType": "album",
  "title": "The King of Limbs",
  "id": "2112022",
  "artist": "Radiohead",
  "genre": "Alternative Rock",
  "style": "Rock/Pop",
  "yearReleased": 2011,
  "label": "XL Recordings",
  "score": 7.7,
  "musicBrainzId": "899b6d09-807e-4c18-a6d4-3642e00d6a3d",
  "sourceUrl": "https://www.theaudiodb.com/album/2112022",
  "scrapedAt": "2026-06-04T19:33:07.679Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Two record types in one run.** Artist profiles and full discographies come back together, each clearly tagged.
- **Art included.** Most records carry a real thumbnail, and artists often add a logo and banner.
- **No login, no proxy.** The Actor uses the public TheAudioDB API with the built in test key.
- **MusicBrainz IDs attached.** Join your results to MusicBrainz, Discogs, or your own catalog with a stable ID.
- **Honest nulls.** Optional fields that a record lacks come back as null rather than guesses.

### 📈 How it compares to alternatives

| Approach | Artist plus albums | Cover art | Setup |
|---|---|---|---|
| This Actor | Both in one run | Yes | None, public key built in |
| Manual API calls | You wire each endpoint | Yes | Code per endpoint |
| Generic HTML scraper | Fragile, breaks on redesign | Hit or miss | High maintenance |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the TheAudioDB Music Scraper in the Apify Console.
3. Enter one or more artist names in `searchArtists` and choose whether to include artist profiles, albums, or both.
4. Click **Start** and watch records stream into the dataset.
5. Browse the results table or pull them through the Apify API into your own app.

### 💼 Business use cases

#### Catalog enrichment

| Goal | How this helps |
|---|---|
| Fill missing metadata | Attach genre, label, year, and art to your existing track list |
| Standardize artist data | Use MusicBrainz IDs to dedupe and link records |

#### Content and editorial

| Goal | How this helps |
|---|---|
| Build artist pages | Pull bio, country, formed year, and banner art in one call |
| Curate by era or genre | Filter albums by release year and genre |

#### Analytics and research

| Goal | How this helps |
|---|---|
| Study label rosters | Group albums and artists by label |
| Track genre distribution | Aggregate genre and style across many artists |

#### Product and apps

| Goal | How this helps |
|---|---|
| Power a music discovery app | Feed structured artist and album data into your UI |
| Seed a recommendation engine | Use genre, mood, and style as features |

### 🔌 Automating TheAudioDB Scraper

Connect the dataset to the tools you already use:

- **Make** and **Zapier** to trigger downstream workflows on each new run.
- **Slack** to post a digest of new artist or album records.
- **Airbyte** to sync results into your warehouse.
- **GitHub** Actions to schedule periodic catalog refreshes.
- **Google Drive** to archive snapshots of each run.

### 🌟 Beyond business use cases

- **Research.** Build a dataset of bands by country and formation decade.
- **Personal.** Generate a richly illustrated history of your favorite artists.
- **Non-profit.** Compile open music metadata for community archives.
- **Experimentation.** Train models on genre, mood, and style labels.

### 🤖 Ask an AI assistant

Drop the dataset into your favorite assistant and ask it to summarize or analyze:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**Q: Do I need a TheAudioDB account or API key?**
No. The Actor ships with the public test key, so it works with no setup. You can supply your own Patreon key in `apiKey` for higher rate limits.

**Q: What do I provide as input?**
A list of artist names in `searchArtists`. Everything else is optional.

**Q: How many records can I get per artist?**
The artist profile is one record, and a discography can run from a handful to several dozen albums. Radiohead returns 43 albums, Coldplay returns 51.

**Q: Can I get albums without the artist profile?**
Yes. Set `includeArtist` to false and `includeAlbums` to true.

**Q: Why are some fields null?**
TheAudioDB is community maintained, so optional fields such as website, biography, and album score are filled in for many but not all records. Missing values come back as null.

**Q: Are images included?**
Yes. The `imageUrl` field holds a thumbnail for both artists and albums, and artist records often add a logo and banner.

**Q: Can I match results to other music databases?**
Yes. Each record includes a `musicBrainzId` where TheAudioDB has one on file.

**Q: What is the free plan limit?**
Free users receive up to 10 records per run. Paid plans raise the cap up to 1,000,000.

**Q: Does this work for any artist?**
It works for any artist catalogued on TheAudioDB. If a name is not found, the Actor logs a notice and moves on.

**Q: Is a proxy required?**
No. The public API responds without a proxy or login.

**Q: How fresh is the data?**
Each run queries TheAudioDB live, so you always get the current state of the database.

**Q: Is this affiliated with TheAudioDB?**
No. This is an independent tool that reads only publicly available data from the TheAudioDB API.

### 🔌 Integrate with any app

Every run writes to an Apify dataset you can read through the Apify API, webhooks, or scheduled exports, so the data flows straight into your own systems.

### 🔗 Recommended Actors

- [MusicBrainz Scraper](https://apify.com/parseforge/musicbrainz-scraper)
- [Discogs Scraper](https://apify.com/parseforge/discogs-scraper)
- [Last.fm Scraper](https://apify.com/parseforge/last-fm-scraper)
- [Genius Lyrics Scraper](https://apify.com/parseforge/genius-lyrics-scraper)
- [Deezer Music Catalog Scraper](https://apify.com/parseforge/deezer-music-catalog-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

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

> **⚠️ Disclaimer:** This is an independent tool, not affiliated with TheAudioDB. Only publicly available data is collected.

# Actor input Schema

## `searchArtists` (type: `array`):

One or more artist names to look up on TheAudioDB. Each name returns the matched artist profile and, when enabled, that artist's albums.

## `includeAlbums` (type: `boolean`):

When enabled, the discography of each artist is returned as additional album records alongside the artist profile.

## `includeArtist` (type: `boolean`):

When enabled, the artist profile record (biography, country, genre, images) is returned for each search.

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

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

## `apiKey` (type: `string`):

TheAudioDB API key. Leave as the default public test key for keyless access, or enter your own Patreon key for higher rate limits.

## Actor input object example

```json
{
  "searchArtists": [
    "Coldplay"
  ],
  "includeAlbums": true,
  "includeArtist": true,
  "maxItems": 10,
  "apiKey": "2"
}
```

# 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 = {
    "searchArtists": [
        "Coldplay"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/theaudiodb-music-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 = {
    "searchArtists": ["Coldplay"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/theaudiodb-music-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 '{
  "searchArtists": [
    "Coldplay"
  ],
  "maxItems": 10
}' |
apify call parseforge/theaudiodb-music-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TheAudioDB Music Artist and Album Scraper",
        "description": "Pull artist profiles and album discographies from TheAudioDB by name. Returns genre, country, formed year, label, biography, cover art, album release year, review score, and MusicBrainz ID. Great for catalog enrichment, music apps, and genre research across thousands of artists.",
        "version": "0.1",
        "x-build-id": "CA3GwnFIFTKEhGkt1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~theaudiodb-music-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-theaudiodb-music-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~theaudiodb-music-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-theaudiodb-music-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~theaudiodb-music-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-theaudiodb-music-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": [
                    "searchArtists"
                ],
                "properties": {
                    "searchArtists": {
                        "title": "Artist Names",
                        "type": "array",
                        "description": "One or more artist names to look up on TheAudioDB. Each name returns the matched artist profile and, when enabled, that artist's albums.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeAlbums": {
                        "title": "Include Albums",
                        "type": "boolean",
                        "description": "When enabled, the discography of each artist is returned as additional album records alongside the artist profile.",
                        "default": true
                    },
                    "includeArtist": {
                        "title": "Include Artist Profile",
                        "type": "boolean",
                        "description": "When enabled, the artist profile record (biography, country, genre, images) is returned for each search.",
                        "default": true
                    },
                    "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"
                    },
                    "apiKey": {
                        "title": "API Key",
                        "type": "string",
                        "description": "TheAudioDB API key. Leave as the default public test key for keyless access, or enter your own Patreon key for higher rate limits.",
                        "default": "2"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
