# Spotify Catalog & Podcast Scraper (`xtracto/spotify-scraper`) Actor

Scrape Spotify tracks, albums, artists, podcasts and episodes as clean JSON. Look up any Spotify URL or search by keyword for play counts, monthly listeners, followers, show ratings, episode descriptions and audio previews. No login, no API key.

- **URL**: https://apify.com/xtracto/spotify-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Spotify Catalog & Podcast Scraper

Extract Spotify **tracks, albums, artists, podcasts, and episodes** as clean JSON — with play counts, monthly listeners, followers, show ratings, episode descriptions, and 30-second audio previews. Look up any Spotify link, or search the whole catalog by keyword.

### Why use this actor

- **No account, no login, no API key** required.
- **Real numbers** — track play counts, artist followers and monthly listeners, podcast show ratings, playlist follower counts.
- **Podcasts included** — show metadata (publisher, rating, description) plus a stream of every episode with its description and release date.
- **Two ways in** — resolve a list of Spotify URLs / IDs, or search by keyword across six result types (tracks, albums, artists, playlists, podcasts, episodes).
- **Audio previews** — each track can be enriched with its 30-second preview URL.
- **Stable JSON output** ready for spreadsheets, databases, dashboards, or data pipelines, with automatic retries and export to JSON / CSV / Excel.

### How it works

1. Pick a **mode** — `detail` (look up URLs) or `search` (by keyword).
2. Give it the matching input: a list of Spotify links / IDs, or a search term plus the result types you want.
3. The actor fetches each track, album, artist, podcast, episode, or playlist with its full public metadata.
4. Every result is pushed to your dataset as one JSON row, ready to export.

You don't manage any scrapers, browsers, or rate limits — just run it.

### Input

#### Detail mode — look up any Spotify URLs
```json
{
  "mode": "detail",
  "urls": [
    "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
    "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
    "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk"
  ],
  "includeSSRPreview": true,
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

#### Search mode — find catalog items by keyword

```json
{
  "mode": "search",
  "searchTerm": "daft punk",
  "searchTypes": ["tracks"],
  "limit": 20,
  "maxItems": 100
}
```

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | `detail` (look up URLs) or `search` (keyword). |
| `urls` | array | Spotify links (`detail` mode). Mix any track / album / artist / show / episode / playlist URLs. |
| `uris` | array | Optional. Direct IDs like `spotify:track:69kOkLUCkxIZYexIgSG8rq` (`detail` mode). |
| `searchTerm` | string | Keyword to search for (`search` mode). |
| `searchTypes` | array | Any of `tracks`, `albums`, `artists`, `playlists`, `podcasts`, `episodes` (`search` mode). |
| `limit` | integer | Results per page (search, album/playlist tracks). Max 50. Default 20. |
| `offset` | integer | Where to start paging from. Default 0. |
| `maxItems` | integer | Max rows for the whole run (0 = no limit). Default 100. |
| `includeSSRPreview` | boolean | Add each track's 30-second audio preview URL. Default `true`. |
| `proxyConfiguration` | object | Optional. Off by default; Spotify catalog data is public. |

### Output

Every row carries a small header — `_source`, `_scrapedAt`, `_input` (the URL/term it came from), and `_entityType` (`track`, `album`, `artist`, `show`, `episode`, or `playlist`) — followed by the full Spotify object.

#### Track (detail mode, with audio preview)

```json
{
  "_source": "api",
  "_scrapedAt": "2026-07-11T00:14:05Z",
  "_input": "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
  "_entityType": "track",
  "previewUrl": "https://p.scdn.co/mp3-preview/6de52dda0d37a0646987856c3b9f7da075d965b4",
  "name": "Get Lucky (feat. Pharrell Williams and Nile Rodgers)",
  "id": "69kOkLUCkxIZYexIgSG8rq",
  "uri": "spotify:track:69kOkLUCkxIZYexIgSG8rq",
  "playcount": "698527246",
  "duration": { "totalMilliseconds": 369626 },
  "trackNumber": 8,
  "contentRating": { "label": "NONE" },
  "albumOfTrack": { "name": "Random Access Memories", "…": "… more" },
  "firstArtist": { "items": [ { "profile": { "name": "Daft Punk" }, "uri": "spotify:artist:4tZwfgrHOc3mvqYlEYSvVi" } ] }
}
```

#### Artist (detail mode)

```json
{
  "_source": "api",
  "_input": "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
  "_entityType": "artist",
  "profile": { "name": "Daft Punk" },
  "stats": {
    "followers": 11583500,
    "monthlyListeners": 29350001,
    "worldRank": 226,
    "topCities": { "items": [ { "city": "Mexico City", "country": "MX", "numberOfListeners": 713083 } ] }
  },
  "discography": { "albums": { "…": "… full album/single/EP list" } }
}
```

#### Album (detail mode)

```json
{
  "_source": "api",
  "_entityType": "album",
  "name": "Random Access Memories",
  "label": "Columbia",
  "type": "ALBUM",
  "date": { "isoString": "2013-05-20T00:00:00Z", "precision": "DAY" },
  "copyright": { "items": [ { "text": "(P) 2013 Daft Life Limited under exclusive license to Columbia Records…", "type": "P" } ] },
  "tracksV2": { "totalCount": 13, "items": [ "… track list" ] }
}
```

#### Podcast show (detail mode) — followed by its episodes

```json
{
  "_source": "api",
  "_entityType": "show",
  "name": "The Joe Rogan Experience",
  "publisher": { "name": "Joe Rogan" },
  "mediaType": "MIXED",
  "description": "The official podcast of comedian Joe Rogan.",
  "rating": { "averageRating": { "average": 4.6576, "totalRatings": 950496, "showAverage": true } }
}
```

A `show` URL streams the show record above, then one row per episode (`_recordType: "SHOW_EPISODE"`, `_entityType: "episode"`) up to your `maxItems` cap, for example:

```json
{
  "_entityType": "episode",
  "_recordType": "SHOW_EPISODE",
  "name": "#2524 - Rupert Lowe",
  "releaseDate": { "isoString": "2026-07-09T17:00:00Z", "precision": "MINUTE" }
}
```

#### Episode (detail mode) — with chapter timestamps when the creator provides them

```json
{
  "_source": "api",
  "_entityType": "episode",
  "name": "Essentials: The Science & Treatment of Obsessive Compulsive Disorder (OCD)",
  "releaseDate": { "isoString": "2026-07-09T08:00:00Z", "precision": "MINUTE" },
  "duration": { "totalMilliseconds": 2133184 },
  "descriptionChapters": [
    { "timestamp": "00:00:00", "startSeconds": 0, "title": "Obsessive-Compulsive Disorder (OCD)" },
    { "timestamp": "00:01:54", "startSeconds": 114, "title": "Categories: Checking, Repetition & Order; Contamination & Disgust" },
    { "timestamp": "00:05:20", "startSeconds": 320, "title": "Sponsor: AG1" }
  ]
}
```

#### Playlist (detail mode)

```json
{
  "_source": "api",
  "_entityType": "playlist",
  "name": "Today’s Top Hits",
  "uri": "spotify:playlist:37i9dQZF1DXcBWIGoYBM5M",
  "description": "The hottest 50. Cover: Ella Langley",
  "ownerV2": { "data": { "name": "Spotify" } },
  "followers": 34194298,
  "content": { "items": [ "… track list" ] }
}
```

#### Search result (search mode)

```json
{
  "_source": "api",
  "_entityType": "track",
  "_recordType": "SEARCH_RESULT",
  "_input": "search:tracks:daft punk",
  "name": "Get Lucky (feat. Pharrell Williams and Nile Rodgers)",
  "uri": "spotify:track:69kOkLUCkxIZYexIgSG8rq",
  "artists": { "items": [ { "profile": { "name": "Daft Punk" } } ] },
  "albumOfTrack": { "name": "Random Access Memories", "…": "… more" },
  "duration": { "totalMilliseconds": 369626 }
}
```

| Field | Type | Description |
| --- | --- | --- |
| `_source` | string | `api` for catalog data, `none` for error rows. |
| `_entityType` | string | `track`, `album`, `artist`, `show`, `episode`, or `playlist`. |
| `_recordType` | string | `SHOW_EPISODE` (episode streamed from a show) or `SEARCH_RESULT`. |
| `name` | string | Track / album / show / episode / playlist name. |
| `uri` / `id` | string | Spotify resource identifier. |
| `playcount` | string | Total plays (track detail). |
| `duration` | object | Length in milliseconds. |
| `previewUrl` | string | 30-second audio preview (tracks, when enabled). |
| `stats` | object | Artist followers, monthly listeners, world rank, top cities. |
| `rating` | object | Podcast show average rating and total rating count. |
| `descriptionChapters` | array | Chapter timestamps parsed from an episode's description (when present). |
| `releaseDate` / `date` | object | Release timestamp. |
| `label` / `copyright` | string / object | Album label and copyright line. |
| `ownerV2` / `followers` | object / number | Playlist owner and follower count. |

### Notes & limits

- **Keyword search returns up to 1000 results per type.** For more coverage, use several narrower terms.
- **Podcast chapters:** Spotify does not expose structured chapters for podcasts (that field is empty for shows). This actor recovers the chapter timestamps creators write into the episode description into `descriptionChapters` — present for shows like Huberman Lab, empty for shows that don't list them (e.g. most JRE episodes). For chaptered music/DJ mixes the native `segments` field is passed through when Spotify provides it.
- **Not available on the public catalog:** ISRC codes and audio-analysis figures (danceability, tempo, energy, etc.) are not part of this data and are not returned.
- **Album and playlist tracks** are returned per page (`limit`, max 50); increase `limit` or `offset` to page further.
- Spotify catalog data is public, so **no proxy is needed**; you can still enable Apify Proxy if you prefer.

# Actor input Schema

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

What to do. 'detail' = look up each Spotify URL / URI and return the full track, album, artist, podcast show, episode, or playlist it points to (uses 'urls' / 'uris'). 'search' = find tracks, albums, artists, playlists, podcasts, or episodes by keyword (uses 'searchTerm' + 'searchTypes').

## `urls` (type: `array`):

Used when mode = 'detail'. Full open.spotify.com links. Mix any track / album / artist / show (podcast) / episode / playlist URLs.

## `uris` (type: `array`):

Optional alternative to 'urls' in 'detail' mode. Direct identifiers like 'spotify:track:69kOkLUCkxIZYexIgSG8rq'.

## `searchTerm` (type: `string`):

Used when mode = 'search'. Free-text keyword (artist, track, show, etc.).

## `searchTypes` (type: `array`):

Used when mode = 'search'. Which kinds of results to return.

## `limit` (type: `integer`):

Results per request page (search results, album / playlist tracks). Max 50.

## `offset` (type: `integer`):

Where to start paging from (search results, album / playlist tracks).

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

Maximum records to push to the dataset for the whole run (0 = no cap). Keyword search returns at most 1000 results per type.

## `includeSSRPreview` (type: `boolean`):

When on, each track in 'detail' mode is enriched with its 30-second audio preview URL.

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

Optional. Spotify catalog data is public and needs no proxy, so this is off by default. Enable it (Residential recommended) only if you want requests routed through Apify Proxy.

## Actor input object example

```json
{
  "mode": "detail",
  "urls": [
    "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
    "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
    "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk"
  ],
  "uris": [],
  "searchTerm": "daft punk",
  "searchTypes": [
    "tracks"
  ],
  "limit": 20,
  "offset": 0,
  "maxItems": 100,
  "includeSSRPreview": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "detail",
    "urls": [
        "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
        "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
        "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk"
    ],
    "uris": [],
    "searchTerm": "daft punk",
    "searchTypes": [
        "tracks"
    ],
    "limit": 20,
    "offset": 0,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/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 = {
    "mode": "detail",
    "urls": [
        "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
        "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
        "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk",
    ],
    "uris": [],
    "searchTerm": "daft punk",
    "searchTypes": ["tracks"],
    "limit": 20,
    "offset": 0,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/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 '{
  "mode": "detail",
  "urls": [
    "https://open.spotify.com/track/69kOkLUCkxIZYexIgSG8rq",
    "https://open.spotify.com/artist/4tZwfgrHOc3mvqYlEYSvVi",
    "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk"
  ],
  "uris": [],
  "searchTerm": "daft punk",
  "searchTypes": [
    "tracks"
  ],
  "limit": 20,
  "offset": 0,
  "maxItems": 100
}' |
apify call xtracto/spotify-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Catalog & Podcast Scraper",
        "description": "Scrape Spotify tracks, albums, artists, podcasts and episodes as clean JSON. Look up any Spotify URL or search by keyword for play counts, monthly listeners, followers, show ratings, episode descriptions and audio previews. No login, no API key.",
        "version": "0.1",
        "x-build-id": "xvyhLwIX514PeGQqe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~spotify-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-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/xtracto~spotify-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-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/xtracto~spotify-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "detail",
                            "search"
                        ],
                        "type": "string",
                        "description": "What to do. 'detail' = look up each Spotify URL / URI and return the full track, album, artist, podcast show, episode, or playlist it points to (uses 'urls' / 'uris'). 'search' = find tracks, albums, artists, playlists, podcasts, or episodes by keyword (uses 'searchTerm' + 'searchTypes').",
                        "default": "detail"
                    },
                    "urls": {
                        "title": "Spotify URLs",
                        "type": "array",
                        "description": "Used when mode = 'detail'. Full open.spotify.com links. Mix any track / album / artist / show (podcast) / episode / playlist URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "uris": {
                        "title": "Spotify URIs (optional)",
                        "type": "array",
                        "description": "Optional alternative to 'urls' in 'detail' mode. Direct identifiers like 'spotify:track:69kOkLUCkxIZYexIgSG8rq'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Used when mode = 'search'. Free-text keyword (artist, track, show, etc.)."
                    },
                    "searchTypes": {
                        "title": "Search result types",
                        "type": "array",
                        "description": "Used when mode = 'search'. Which kinds of results to return.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tracks",
                                "albums",
                                "artists",
                                "playlists",
                                "podcasts",
                                "episodes"
                            ],
                            "enumTitles": [
                                "Tracks",
                                "Albums",
                                "Artists",
                                "Playlists",
                                "Podcasts",
                                "Episodes"
                            ]
                        },
                        "default": [
                            "tracks"
                        ]
                    },
                    "limit": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Results per request page (search results, album / playlist tracks). Max 50.",
                        "default": 20
                    },
                    "offset": {
                        "title": "Start offset",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Where to start paging from (search results, album / playlist tracks).",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max records (0 = all)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records to push to the dataset for the whole run (0 = no cap). Keyword search returns at most 1000 results per type.",
                        "default": 100
                    },
                    "includeSSRPreview": {
                        "title": "Include track audio preview URL",
                        "type": "boolean",
                        "description": "When on, each track in 'detail' mode is enriched with its 30-second audio preview URL.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. Spotify catalog data is public and needs no proxy, so this is off by default. Enable it (Residential recommended) only if you want requests routed through Apify Proxy.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```