# Spotify Scraper (`fetch_cat/spotify-scraper`) Actor

Extract public Spotify artist, track, album, playlist, and search metadata without an API key. Export IDs, names, images, release dates, durations, monthly listeners, and saves when visible.

- **URL**: https://apify.com/fetch\_cat/spotify-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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

## Spotify Scraper

Extract public Spotify artists, albums, tracks, playlists, and search-page metadata from Spotify URLs without using the official Spotify API.

### What does Spotify Scraper do?

Spotify Scraper turns public Spotify pages into a structured dataset.

It accepts artist, album, track, playlist, and search URLs, plus optional search queries.

The actor saves normalized metadata such as names, descriptions, Spotify IDs, image URLs, artists, albums, playlist owners, track counts, monthly listeners, likes or saves when visible, release dates, and duration for tracks.

Use it when you need repeatable Spotify research data in CSV, JSON, Excel, XML, or API form.

### Who is it for?

- 🎧 Music marketers monitoring public artist and playlist presence.
- 📈 Labels and managers tracking catalog metadata and playlist context.
- 🔎 Playlist researchers collecting public playlist snapshots.
- 🧑‍🎤 Creator agencies building artist discovery workflows.
- 🧪 Data analysts comparing public Spotify metadata across many URLs.
- 🤖 Automation builders feeding Spotify data into dashboards and alerts.

### Why use this actor?

- ✅ Scrape public Spotify pages without an API key.
- ✅ Mix artists, albums, tracks, playlists, and search pages in one run.
- ✅ Export clean rows instead of copying data manually.
- ✅ Limit results for predictable cost.
- ✅ Use optional Apify Proxy settings when needed.
- ✅ Schedule recurring monitoring on Apify.
- ✅ Connect results to webhooks, Zapier, Make, Google Sheets, or BI tools.

### Common use cases

- Build a public artist watchlist.
- Collect Spotify track metadata for campaign reports.
- Monitor public playlist titles, owners, saves, and item counts.
- Create catalog enrichment tables for internal tools.
- Compare album release dates and track counts.
- Feed dashboards with public Spotify URLs and images.
- Archive public metadata snapshots over time.

### Supported Spotify URLs

- Artist pages such as `https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02`.
- Track pages such as `https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI`.
- Album pages such as `https://open.spotify.com/album/1Mo4aZ8pdj6L1jx8zSwJnt`.
- Playlist pages such as `https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M`.
- Search pages such as `https://open.spotify.com/search/taylor%20swift`.
- Search queries entered directly in the input.

### What data can you extract from Spotify?

| Field | Description |
| --- | --- |
| `type` | Spotify entity type: artist, album, track, playlist, search, or unknown. |
| `id` | Spotify ID parsed from the URL. |
| `url` | Canonical public Spotify URL. |
| `name` | Public entity name or page title. |
| `description` | Public Spotify description text. |
| `artistNames` | Artist names when visible in public metadata. |
| `albumName` | Album name for tracks when visible. |
| `ownerName` | Playlist owner name when visible. |
| `trackCount` | Album or playlist item count when visible. |
| `monthlyListeners` | Artist monthly listeners when visible. |
| `likes` | Playlist saves or likes when visible. |
| `followers` | Reserved for follower counts when visible. |
| `durationMs` | Track duration in milliseconds when available. |
| `releaseDate` | Track or album release date when available. |
| `imageUrl` | Public cover or profile image URL. |
| `explicit` | Whether explicit labeling is visible. |
| `isrc` | Reserved for ISRC when public metadata exposes it. |
| `searchQuery` | Original search query for query-generated URLs. |
| `sourceUrl` | Input URL used for the request. |
| `scrapedAt` | ISO timestamp of extraction. |

### How much does it cost to scrape Spotify metadata?

Spotify Scraper uses pay-per-event pricing.

You pay a $0.005 start fee for each run and then a tiered per-record fee for each saved Spotify metadata row.

The formula-derived BRONZE per-record price is $0.000047832. Other tiers are FREE $0.000055007, SILVER $0.000037309, GOLD $0.000028699, PLATINUM $0.000019133, and DIAMOND $0.000013393 per record.

The input prefill is intentionally small so your first run is inexpensive.

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

### How to use Spotify Scraper

1. Open the actor on Apify.
2. Paste Spotify URLs into **Spotify URLs**.
3. Optionally add terms to **Search queries**.
4. Set **Maximum records**.
5. Leave proxy disabled unless your environment needs it.
6. Click **Start**.
7. Download results from the Dataset tab.

### Input example

```json
{
  "startUrls": [
    { "url": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02" },
    { "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI" },
    { "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M" }
  ],
  "searchQueries": ["taylor swift"],
  "maxItems": 10,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Output example

```json
{
  "type": "track",
  "id": "1dGr1c8CrMLDpV6mPbImSI",
  "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI",
  "name": "Lover",
  "description": "Taylor Swift · Lover · Song · 2019",
  "artistNames": ["Taylor Swift"],
  "albumName": "Lover",
  "durationMs": 221000,
  "releaseDate": "2019-08-23",
  "imageUrl": "https://i.scdn.co/image/...",
  "scrapedAt": "2026-06-21T00:00:00.000Z"
}
```

### Tips for best results

- 🎯 Prefer direct Spotify URLs when you know the exact artist, track, album, or playlist.
- 📋 Use search queries for lightweight discovery or recurring search-page snapshots.
- 🔢 Keep `maxItems` close to the number of URLs you provide.
- 🧪 Test a small batch before scheduling a large recurring run.
- 🧹 Deduplicate your URL list before running repeated monitoring jobs.
- 🌐 Use proxies only when you see network-level blocking.

### Scheduling Spotify monitoring

You can schedule the actor to run daily, weekly, or monthly.

Recurring runs are useful for public artist watchlists, playlist monitoring, release reports, and catalog QA.

Each run creates a fresh timestamped dataset so you can compare changes over time.

### Integrations

- Send new dataset items to Google Sheets.
- Trigger webhooks when a scheduled run finishes.
- Connect Apify datasets to Make or Zapier.
- Pull results into a BI warehouse with the Apify API.
- Use dataset exports in CSV, JSON, Excel, XML, RSS, or HTML.

### 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('fetch_cat/spotify-scraper').call({
  startUrls: [{ url: 'https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02' }],
  maxItems: 5
});

console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/spotify-scraper').call(run_input={
    'startUrls': [{'url': 'https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M'}],
    'maxItems': 5,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~spotify-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI"}],"maxItems":5}'
```

### MCP integration for Spotify workflows

Use Spotify Scraper through Apify MCP when you want Claude or another MCP client to launch runs and inspect datasets.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/spotify-scraper
```

Claude Code example:

```bash
claude mcp add apify-spotify https://mcp.apify.com/?tools=fetch_cat/spotify-scraper
```

Claude Desktop example:

```json
{
  "mcpServers": {
    "apify-spotify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/spotify-scraper"
    }
  }
}
```

Example prompts for Spotify Scraper MCP usage:

- "Use the `fetch_cat/spotify-scraper` MCP tool to scrape these Spotify artist URLs and summarize their public monthly listener counts."
- "Run Spotify Scraper through MCP for this playlist URL, wait for the Apify run to finish, and show the dataset export link."
- "Use MCP to compare metadata from these Spotify album URLs and return release dates, cover images, and track counts."

### Data freshness

Spotify pages can change at any time.

Every run fetches the current public page content and includes `scrapedAt` so you can track when a value was collected.

For repeatable monitoring, schedule the actor and compare datasets by URL and timestamp.

### Limits and caveats

- The actor only extracts public data visible without logging in.
- Private libraries, user-only playlists, and account data are not supported.
- Some fields are available only for certain entity types.
- Spotify may change page formatting, which can affect field availability.
- Search-query rows represent public search pages, not private personalized results.

### Legality and ethical use

This actor is designed for public Spotify metadata.

Do not use it to collect private account data, bypass access controls, or violate Spotify terms.

You are responsible for ensuring your use case complies with applicable laws, platform terms, and privacy requirements.

### Troubleshooting

#### Why is a field empty?

Some values are not visible on every public Spotify page. For example, track duration is usually available on tracks, while playlist saves are available on playlists.

#### Why did my URL return no item?

Check that the URL is public and starts with `https://open.spotify.com/`. Private or removed content may not expose public metadata.

#### Should I enable proxies?

Start with proxies disabled. If your run receives network errors or blocking from your environment, enable Apify Proxy and retry a small batch.

### FAQ

#### Can I scrape Spotify without an API key?

Yes. This actor works with public Spotify web pages and does not require a Spotify API key.

#### Can it scrape play counts?

This MVP focuses on public metadata visible without login. Play counts are not guaranteed on all public pages.

#### Can it scrape playlists?

Yes. Public playlist pages are supported and can return owner, item count, image, and saves when visible.

#### Can I export the data?

Yes. Apify datasets can be exported as JSON, CSV, Excel, XML, HTML, and RSS.

### Related actors

- https://apify.com/fetch\_cat/youtube-channel-videos-scraper
- https://apify.com/fetch\_cat/tiktok-profile-scraper
- https://apify.com/fetch\_cat/reddit-scraper
- https://apify.com/fetch\_cat/google-news-scraper

### Support

If you find a public Spotify page that should work but does not, open an issue with the input URL and run ID.

Small, reproducible examples help us improve extraction quickly.

# Actor input Schema

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

Public Spotify artist, album, track, playlist, or search URLs to scrape.

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

Optional Spotify search terms. Each query is converted to a public Spotify search URL and saved as a search metadata row.

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

Maximum number of metadata records to save across all URLs and search queries.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. The default usually works for public Spotify pages; enable proxies if your environment is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02"
    },
    {
      "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI"
    },
    {
      "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M"
    }
  ],
  "searchQueries": [
    "taylor swift"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02"
        },
        {
            "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI"
        },
        {
            "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M"
        }
    ],
    "searchQueries": [
        "taylor swift"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/spotify-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://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02" },
        { "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI" },
        { "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M" },
    ],
    "searchQueries": ["taylor swift"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/spotify-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://open.spotify.com/artist/06HL4z0CvFAxyc27GXpf02"
    },
    {
      "url": "https://open.spotify.com/track/1dGr1c8CrMLDpV6mPbImSI"
    },
    {
      "url": "https://open.spotify.com/playlist/37i9dQZF1DXcBWIGoYBM5M"
    }
  ],
  "searchQueries": [
    "taylor swift"
  ]
}' |
apify call fetch_cat/spotify-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Scraper",
        "description": "Extract public Spotify artist, track, album, playlist, and search metadata without an API key. Export IDs, names, images, release dates, durations, monthly listeners, and saves when visible.",
        "version": "0.1",
        "x-build-id": "N2JVKZm9gM9vJeVLA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~spotify-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-spotify-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/fetch_cat~spotify-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-spotify-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/fetch_cat~spotify-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-spotify-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": "Spotify URLs",
                        "type": "array",
                        "description": "Public Spotify artist, album, track, playlist, or search URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Spotify search terms. Each query is converted to a public Spotify search URL and saved as a search metadata row.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of metadata records to save across all URLs and search queries.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. The default usually works for public Spotify pages; enable proxies if your environment is blocked.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```