# Apple Music Scraper (`automation-lab/apple-music-scraper`) Actor

Extract public Apple Music and iTunes catalog metadata from artist, album, song, video URLs, or keyword searches. No Apple account required.

- **URL**: https://apify.com/automation-lab/apple-music-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Apple Music Scraper

Extract public Apple Music and iTunes catalog metadata from artist, album, song, music video URLs, or keyword searches. This actor is built for metadata enrichment and monitoring, not audio downloading.

### What does Apple Music Scraper do?

Apple Music Scraper turns public Apple Music and iTunes catalog pages into structured dataset rows.

It can resolve Apple Music URLs that contain public catalog IDs and it can search the public Apple/iTunes catalog by keyword.

Use it when you need repeatable metadata such as artist names, album titles, track titles, release dates, artwork URLs, genres, previews, prices, and canonical Apple Music links.

The actor runs HTTP-first and does not require an Apple account, Apple developer token, private cookies, or a paid music subscription.

### Who is it for?

Music marketers use it to monitor artist catalogs, new releases, and localized metadata.

Labels and distributors use it to enrich internal release spreadsheets with Apple IDs and canonical URLs.

Playlist researchers use it to collect track metadata for research and lead lists.

Catalog data teams use it to normalize Apple Music and iTunes metadata for matching, QA, and reporting.

Developers use it as a simple API wrapper around public Apple/iTunes catalog metadata.

### Why use this actor?

- 🎵 Works with Apple Music URLs and keyword searches
- 🌍 Supports storefront country codes such as `US`, `GB`, `DE`, `FR`, or `JP`
- 🧾 Outputs clean metadata rows instead of raw HTML
- ⚡ Uses lightweight HTTP requests for low runtime cost
- 🔗 Returns canonical Apple Music/iTunes URLs for downstream workflows
- 🖼️ Includes artwork links and preview URLs when Apple exposes them

### What data can you extract?

| Field | Description |
| --- | --- |
| `entityType` | Artist, album, song, music video, or catalog item |
| `appleId` | Apple/iTunes catalog identifier |
| `artistName` | Artist name |
| `collectionName` | Album or collection name |
| `trackName` | Track name |
| `canonicalUrl` | Apple Music or iTunes URL |
| `primaryGenreName` | Main genre |
| `releaseDate` | Release timestamp |
| `durationSeconds` | Track duration in seconds |
| `artworkUrl600` | High-resolution artwork URL |
| `previewUrl` | Public preview URL when available |
| `currency` | Localized currency |
| `trackPrice` | Localized track price when available |
| `collectionPrice` | Localized album price when available |
| `scrapedAt` | Timestamp for the extraction |

### How much does it cost to scrape Apple Music?

This actor uses pay-per-event pricing.

You pay a small start fee per run and a per-item fee for each catalog row saved to the dataset.

| Plan tier | Per catalog item | 1,000 items |
| --- | ---: | ---: |
| Free | $0.000032263 | $0.0323 |
| Starter / Bronze | $0.000028055 | $0.0281 |
| Silver | $0.000021883 | $0.0219 |
| Gold | $0.000016833 | $0.0168 |
| Platinum | $0.000011222 | $0.0112 |
| Diamond | $0.000010000 | $0.0100 |

There is also a $0.005 run-start event.

The default test input is intentionally small so first runs stay cheap.

For larger monitoring jobs, set `maxItems` to the number of records you actually need.

### Input options

You can provide Apple Music URLs, search terms, or both.

`startUrls` accepts public artist, album, song, and music video URLs from `music.apple.com` or iTunes URLs that contain numeric Apple IDs.

`searchTerms` accepts keywords such as artist names, song names, album titles, labels, or genres.

`country` controls localized storefront data.

`entity` controls what keyword search returns.

`includeAlbumTracks` expands album URLs into track rows.

`includeArtistAlbums` expands artist URLs into album rows.

### Example input: search intent

```json
{
  "searchTerms": ["Taylor Swift", "indie pop"],
  "country": "US",
  "entity": "song",
  "maxItems": 100
}
````

### Example input: source-specific URL extraction

```json
{
  "startUrls": [
    { "url": "https://music.apple.com/us/artist/taylor-swift/159260351" },
    { "url": "https://music.apple.com/us/album/1989-taylors-version-deluxe/1713845538" }
  ],
  "country": "US",
  "includeAlbumTracks": true,
  "includeArtistAlbums": true,
  "maxItems": 75
}
```

### Example input: catalog monitoring workflow

```json
{
  "searchTerms": ["new music friday", "lofi beats", "country hits"],
  "country": "GB",
  "entity": "allTrack",
  "maxItems": 250
}
```

### Example output

```json
{
  "entityType": "song",
  "appleId": "1440935467",
  "artistName": "Taylor Swift",
  "collectionName": "1989 (Deluxe Edition)",
  "trackName": "Blank Space",
  "title": "Blank Space",
  "canonicalUrl": "https://music.apple.com/us/album/blank-space/1440935467?i=1440936016",
  "country": "USA",
  "primaryGenreName": "Pop",
  "releaseDate": "2014-10-27T07:00:00Z",
  "durationSeconds": 232,
  "artworkUrl600": "https://is1-ssl.mzstatic.com/image/thumb/.../600x600bb.jpg",
  "previewUrl": "https://audio-ssl.itunes.apple.com/...",
  "sourceType": "search",
  "sourceValue": "Taylor Swift",
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}
```

### How to run the scraper

1. Open the actor on Apify.
2. Add Apple Music URLs or search terms.
3. Choose a storefront country.
4. Set a safe `maxItems` limit.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or through the API.

### Tips for better results

Use exact artist names for clean song or album searches.

Use album URLs when you need tracklists.

Use artist URLs when you need discography-style album rows.

Use localized storefront countries when pricing or availability matters.

Keep `maxItems` modest during tests and increase it after checking output quality.

### Integrations

Send dataset rows to Google Sheets for release tracking.

Pipe JSON results into a music catalog database for enrichment.

Use canonical URLs in CRM or campaign tools for label and artist research.

Schedule recurring Apify tasks to monitor catalog changes for a list of artists.

Combine this actor with other automation-lab media scrapers for cross-platform music intelligence.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/apple-music-scraper').call({
  searchTerms: ['Taylor Swift'],
  country: 'US',
  entity: 'song',
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/apple-music-scraper').call(run_input={
    'searchTerms': ['Taylor Swift'],
    'country': 'US',
    'entity': 'song',
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~apple-music-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["Taylor Swift"],"country":"US","entity":"song","maxItems":50}'
```

### MCP integration

Use the Apify MCP server to run this actor from Claude Desktop, Claude Code, or other MCP-compatible clients.

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/apple-music-scraper
```

Claude Code setup:

```bash
claude mcp add apify-apple-music "https://mcp.apify.com/?tools=automation-lab/apple-music-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-apple-music": {
      "url": "https://mcp.apify.com/?tools=automation-lab/apple-music-scraper"
    }
  }
}
```

Example prompts:

- "Run the Apple Music Scraper for Taylor Swift songs in the US storefront and summarize the top metadata fields."
- "Extract album tracks from this Apple Music album URL and return a CSV-ready table."
- "Monitor these artist URLs and show new album metadata since last week."

### What this actor does not do

It does not download songs.

It does not bypass Apple DRM.

It does not scrape private account libraries.

It does not require or store Apple credentials.

It does not guarantee that every storefront has the same catalog availability.

### Legality and ethical use

This actor extracts publicly available catalog metadata.

Use the results responsibly and respect Apple Music, iTunes, and Apify terms.

Do not use this actor to infringe copyrights or redistribute audio.

For large recurring jobs, use reasonable limits and schedules.

### Troubleshooting

If a URL returns no rows, check that the URL contains a numeric Apple catalog ID.

If localized prices look different from your browser, verify the `country` storefront code.

If keyword search returns too many unrelated rows, switch `entity` from `allTrack` to `song`, `album`, or `musicArtist`.

If you need more rows, increase `maxItems` and add more specific search terms.

### FAQ

#### Can I scrape Apple Music without login?

Yes. This actor uses public Apple Music/iTunes metadata endpoints and public catalog IDs.

#### Can I download tracks?

No. The actor is metadata-only. It may return Apple-provided preview URLs when publicly exposed.

#### Can I search multiple countries?

Run separate tasks with different `country` values when you need country-by-country comparisons.

#### Can I scrape playlists?

Playlist pages may expose limited public page metadata, but this MVP focuses on artists, albums, songs, music videos, and keyword search results.

### Related scrapers

Use other automation-lab actors when you need adjacent music, media, or web metadata workflows:

- https://apify.com/automation-lab/genius-scraper
- https://apify.com/automation-lab/spotify-scraper
- https://apify.com/automation-lab/youtube-scraper

### Changelog

Initial private build: Apple Music URL lookup, keyword search, album track expansion, artist album expansion, and structured catalog metadata output.

# Actor input Schema

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

Artist, album, song, or music video URLs from music.apple.com or iTunes. The actor resolves the numeric Apple catalog ID from each URL.

## `searchTerms` (type: `array`):

Artist names, song titles, albums, labels, genres, or keyword phrases to search in the public Apple/iTunes catalog.

## `country` (type: `string`):

Two-letter Apple storefront/country code used for localized catalog availability, prices, and URLs.

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

Maximum dataset records to save across all URLs and searches. Keep low for test runs; raise for monitoring or enrichment jobs.

## `entity` (type: `string`):

Entity type used for keyword searches. URL lookups automatically infer artist, album, song, or video from the URL.

## `includeAlbumTracks` (type: `boolean`):

When an album URL is supplied, include public track rows from that album.

## `includeArtistAlbums` (type: `boolean`):

When an artist URL is supplied, include public album rows returned by Apple/iTunes lookup.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://music.apple.com/us/artist/taylor-swift/159260351"
    },
    {
      "url": "https://music.apple.com/us/album/1989-taylors-version-deluxe/1713845538"
    }
  ],
  "searchTerms": [
    "Taylor Swift",
    "indie pop"
  ],
  "country": "US",
  "maxItems": 20,
  "entity": "song",
  "includeAlbumTracks": true,
  "includeArtistAlbums": true
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://music.apple.com/us/artist/taylor-swift/159260351"
        },
        {
            "url": "https://music.apple.com/us/album/1989-taylors-version-deluxe/1713845538"
        }
    ],
    "searchTerms": [
        "Taylor Swift",
        "indie pop"
    ],
    "country": "US",
    "maxItems": 20,
    "entity": "song",
    "includeAlbumTracks": true,
    "includeArtistAlbums": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apple-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 = {
    "startUrls": [
        { "url": "https://music.apple.com/us/artist/taylor-swift/159260351" },
        { "url": "https://music.apple.com/us/album/1989-taylors-version-deluxe/1713845538" },
    ],
    "searchTerms": [
        "Taylor Swift",
        "indie pop",
    ],
    "country": "US",
    "maxItems": 20,
    "entity": "song",
    "includeAlbumTracks": True,
    "includeArtistAlbums": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apple-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 '{
  "startUrls": [
    {
      "url": "https://music.apple.com/us/artist/taylor-swift/159260351"
    },
    {
      "url": "https://music.apple.com/us/album/1989-taylors-version-deluxe/1713845538"
    }
  ],
  "searchTerms": [
    "Taylor Swift",
    "indie pop"
  ],
  "country": "US",
  "maxItems": 20,
  "entity": "song",
  "includeAlbumTracks": true,
  "includeArtistAlbums": true
}' |
apify call automation-lab/apple-music-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Music Scraper",
        "description": "Extract public Apple Music and iTunes catalog metadata from artist, album, song, video URLs, or keyword searches. No Apple account required.",
        "version": "0.1",
        "x-build-id": "VvcwnkLaJUIf0dfca"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apple-music-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apple-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/automation-lab~apple-music-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apple-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/automation-lab~apple-music-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apple-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",
                "properties": {
                    "startUrls": {
                        "title": "Apple Music URLs",
                        "type": "array",
                        "description": "Artist, album, song, or music video URLs from music.apple.com or iTunes. The actor resolves the numeric Apple catalog ID from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Artist names, song titles, albums, labels, genres, or keyword phrases to search in the public Apple/iTunes catalog.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Storefront country",
                        "minLength": 2,
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter Apple storefront/country code used for localized catalog availability, prices, and URLs.",
                        "default": "US"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records to save across all URLs and searches. Keep low for test runs; raise for monitoring or enrichment jobs.",
                        "default": 20
                    },
                    "entity": {
                        "title": "Search entity",
                        "enum": [
                            "song",
                            "album",
                            "musicArtist",
                            "musicVideo",
                            "allArtist",
                            "allTrack"
                        ],
                        "type": "string",
                        "description": "Entity type used for keyword searches. URL lookups automatically infer artist, album, song, or video from the URL.",
                        "default": "song"
                    },
                    "includeAlbumTracks": {
                        "title": "Expand album URLs to tracks",
                        "type": "boolean",
                        "description": "When an album URL is supplied, include public track rows from that album.",
                        "default": true
                    },
                    "includeArtistAlbums": {
                        "title": "Expand artist URLs to albums",
                        "type": "boolean",
                        "description": "When an artist URL is supplied, include public album rows returned by Apple/iTunes lookup.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
