# Spotify Public Weekly Charts Scraper (`automation-lab/spotify-public-weekly-charts-scraper`) Actor

Export Spotify's current global weekly Top Songs, Top Albums, and Top Artists rankings with movement, entities, artists, and artwork.

- **URL**: https://apify.com/automation-lab/spotify-public-weekly-charts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Public Weekly Charts Scraper

Export Spotify's current **global weekly Top Songs, Top Albums, and Top Artists** as clean, ranked dataset records.

This Actor reads Spotify's public charts service directly, so it needs no Spotify login, developer token, browser, or proxy. Schedule it every week to build rank history, catch breakouts, track catalog momentum, and feed music-intelligence workflows.

- 🎵 Get official current weekly song rankings
- 💿 Compare album movement and chart longevity
- 🎤 Monitor the artists leading global listening
- 📈 Capture previous rank, peak rank, status, and appearance counters
- 🔗 Export Spotify URIs, web links, credits, and artwork

### What does Spotify Public Weekly Charts Scraper do?

The Actor makes one request to Spotify's anonymous public weekly charts endpoint and converts its nested response into one record per ranked entity.

Choose any combination of:

- **Top Songs — Global**
- **Top Albums — Global**
- **Top Artists — Global**

Each run captures the chart date and current ranking snapshot. Use Apify schedules to run it weekly and append snapshots to your own warehouse, spreadsheet, dashboard, or alerting pipeline.

The v1 product intentionally focuses on the reliable anonymous surface. It does not claim to provide authenticated daily, country-specific, or historical Spotify charts.

### Who is this Spotify charts scraper for?

#### Record labels and A&R teams

Track which songs, albums, and artists enter or climb the global charts. Compare weekly snapshots to prioritize fast-moving releases.

#### Artist managers

Monitor an artist's current position, movement, consecutive appearances, and related album or track momentum without copying chart tables by hand.

#### Music analysts and researchers

Build a reproducible weekly panel from structured records with stable fields, timestamps, Spotify identifiers, and chart metadata.

#### Playlist and market-intelligence teams

Feed current chart leaders into playlist research, trend scoring, catalog analysis, or competitive reports.

#### Data engineers

Schedule a lightweight HTTP Actor and export JSON, CSV, Excel, XML, or RSS through Apify's dataset APIs.

### Why use this Actor?

- ✅ **Official public data surface** — reads Spotify's public charts service.
- ✅ **No account or API key** — no Spotify OAuth setup is required.
- ✅ **Three charts in one run** — songs, albums, and artists share a normalized contract.
- ✅ **Movement-ready records** — current, previous, peak, and calculated rank change are included when Spotify supplies them.
- ✅ **Automation-friendly** — stable JSON, Apify schedules, webhooks, API, and integrations.
- ✅ **Cost efficient** — one HTTP fetch per run, no browser and no proxy.
- ✅ **Fail-closed extraction** — upstream breakage raises an error instead of returning a misleading empty success.

### What Spotify chart data can I extract?

| Field | Meaning |
|---|---|
| `chartAlias` | Spotify's stable chart alias |
| `chartTitle` | Human-readable weekly chart title |
| `chartDate` | Date attached to the current chart snapshot |
| `chartType` | `songs`, `albums`, or `artists` |
| `sourceChartType` | Spotify source dimension such as `TOP_TRACK` |
| `country` | Chart territory, currently `GLOBAL` |
| `recurrence` | Chart recurrence, currently `WEEKLY` |
| `currentRank` | Current position |
| `previousRank` | Previous position when available |
| `peakRank` | Best supplied position when available |
| `rankChange` | Positive for a rise, negative for a fall |
| `entryStatus` | Spotify's entry/movement status |
| `appearancesOnChart` | Total appearance counter supplied by Spotify |
| `consecutiveAppearancesOnChart` | Consecutive appearance counter |
| `entityName` | Track, album, or artist name |
| `entityType` | `track`, `album`, or `artist` |
| `spotifyUri` | Native Spotify URI |
| `spotifyUrl` | Browser-ready open.spotify.com URL |
| `artistNames` | All credited artist names |
| `artistUris` | Credited artist Spotify URIs |
| `artworkUrl` | Spotify artwork image URL |
| `releaseDate` | Release date when supplied |
| `scrapedAt` | UTC extraction timestamp |

Spotify may leave some movement or appearance fields empty or zero in its public response. The Actor preserves meaningful supplied values and does not invent missing history.

### How much does it cost to scrape Spotify weekly charts?

Pricing is pay per event:

- **Run started:** $0.001 once per run
- **Chart entry saved:** tiered by your Apify plan; BRONZE is currently $0.000028297 per record

A 10-entry Top Songs snapshot is about $0.0013 at the BRONZE rate. A complete 50-entry export of all three charts (up to 150 records) is about $0.0052. Higher Apify plans receive lower per-entry prices.

Apify's Free plan credits can cover many small weekly snapshots. The final platform price shown before starting a run is authoritative.

### How to scrape Spotify charts in 5 steps

1. Open the Actor on Apify.
2. Select **Top Songs**, **Top Albums**, **Top Artists**, or any combination.
3. Set the maximum entries per selected chart from 1 to 50.
4. Click **Start** and wait for the dataset link.
5. Export the results or schedule the same input weekly.

For a cheap first run, keep the prefilled input: Top Songs with 10 entries.

### Input parameters

#### `chartTypes`

An array containing one or more chart names:

- `songs`
- `albums`
- `artists`

If omitted through the API, all three current weekly charts are selected. An empty array or unknown value fails validation.

#### `maxItemsPerChart`

An integer from 1 to 50. The limit applies independently to each selected chart.

For example, selecting songs and artists with a limit of 20 can produce up to 40 records.

### Input examples

#### Current Top Songs, first 10

```json
{
  "chartTypes": ["songs"],
  "maxItemsPerChart": 10
}
````

#### All complete current weekly charts

```json
{
  "chartTypes": ["songs", "albums", "artists"],
  "maxItemsPerChart": 50
}
```

#### Albums and artists for a weekly intelligence report

```json
{
  "chartTypes": ["albums", "artists"],
  "maxItemsPerChart": 25
}
```

### Output example

```json
{
  "chartAlias": "REGIONAL_GLOBAL_WEEKLY",
  "chartTitle": "Weekly Top Songs: Global",
  "chartDate": "2026-07-16",
  "chartType": "songs",
  "sourceChartType": "TOP_TRACK",
  "country": "GLOBAL",
  "recurrence": "WEEKLY",
  "currentRank": 1,
  "previousRank": 1,
  "rankChange": 0,
  "entryStatus": "NO_CHANGE",
  "entityName": "Example track",
  "entityType": "track",
  "spotifyUri": "spotify:track:example",
  "spotifyUrl": "https://open.spotify.com/track/example",
  "artistNames": ["Example artist"],
  "artistUris": ["spotify:artist:example"],
  "artworkUrl": "https://i.scdn.co/image/example",
  "scrapedAt": "2026-07-22T00:00:00.000Z"
}
```

Actual names, dates, ranks, and IDs come from the live current chart.

### Understanding rank movement

`rankChange` is calculated as `previousRank - currentRank`:

- `5` means the entity rose five places.
- `0` means the rank did not change.
- `-3` means the entity fell three places.

For a new entry without a meaningful previous rank, `previousRank` and `rankChange` are omitted. Check `entryStatus` for Spotify's source status.

Do not interpret an absent `peakRank` as a claim that the current rank is the all-time peak. The Actor only reports a peak when the public source supplies a meaningful positive value.

### Tips for reliable weekly monitoring

- 🗓️ Schedule the Actor once per week after Spotify refreshes the public chart.
- 🧱 Store snapshots in a named dataset or external warehouse for long-term history.
- 🔑 Use `spotifyUri` as the entity key across weekly runs.
- 🧮 Combine `chartAlias`, `chartDate`, and `spotifyUri` for a snapshot-level unique key.
- 📊 Calculate velocity from multiple snapshots rather than one week's movement alone.
- 💸 Use a small per-chart limit for alerts and 50 for complete current snapshots.

### Scheduling and webhooks

Create an Apify schedule with the desired input to collect the chart automatically. A weekly schedule is usually enough because this Actor's public v1 source is weekly.

Attach a webhook to the successful-run event to:

- send the dataset to a data warehouse;
- trigger a Slack or email breakout alert;
- refresh a dashboard;
- start a downstream enrichment Actor;
- archive the snapshot in object storage.

If a run fails because Spotify changed its response, use the failed-run webhook rather than treating a missing dataset as a quiet no-change week.

### Integrations for music intelligence

#### Google Sheets or Airtable

Export each weekly dataset and compare current rank with the previous imported snapshot. Add conditional formatting for positive `rankChange` values.

#### BigQuery, Snowflake, or PostgreSQL

Upsert on chart alias, date, and Spotify URI. Build week-over-week models without scraping presentation HTML.

#### Slack and Microsoft Teams

Filter for `entryStatus` values representing new entries or large positive movement, then post only those records to a trend channel.

#### Zapier and Make

Use the finished-run webhook to export the dataset and fan records into CRM, editorial, or research workflows.

#### Other Apify Actors

Feed Spotify URLs into [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) when you need broader entity metadata beyond the official weekly ranking snapshot.

### Run through the Apify API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/spotify-public-weekly-charts-scraper').call({
  chartTypes: ['songs', 'albums', 'artists'],
  maxItemsPerChart: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### Run through the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/spotify-public-weekly-charts-scraper').call(
    run_input={
        'chartTypes': ['songs'],
        'maxItemsPerChart': 20,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### Run through the API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~spotify-public-weekly-charts-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"chartTypes":["artists"],"maxItemsPerChart":10}'
```

Use the returned run ID to fetch run status and the default dataset.

### Use Spotify charts with MCP and AI agents

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/spotify-public-weekly-charts-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/spotify-public-weekly-charts-scraper"
    }
  }
}
```

Example prompts:

- "Get this week's top 20 global Spotify songs and summarize the biggest risers."
- "Export the current Top Albums and Top Artists charts, then group albums by artist."
- "Compare this Spotify weekly chart dataset with last week's file and flag new entries."

### Data quality and limitations

The Actor reports what Spotify's anonymous public charts response currently provides.

- The public endpoint currently returns the current global weekly song, album, and artist charts.
- Each chart currently exposes up to 50 records through this surface.
- Daily, historical, genre, city, and country chart controls are outside v1.
- Some rank-history counters may be zero or absent in Spotify's response.
- Spotify may rename aliases or fields; total extraction failure causes a failed run for visibility.
- Artwork URLs are hosted by Spotify and may change independently of this Actor.

The Actor never fabricates daily history or expands the scope using unofficial approximations.

### Is it legal to scrape public Spotify charts?

This Actor accesses a public, anonymous structured endpoint and exports factual chart records. You are responsible for using the data in compliance with applicable laws, Spotify's terms, intellectual-property rights, and your organization's policies.

Do not use the Actor to evade access controls, impersonate users, or redistribute protected artwork beyond your rights. For legal advice about a specific use case, consult qualified counsel.

### FAQ

#### Does this Actor require Spotify OAuth?

No. The supported current global weekly charts are available anonymously.

#### Can it scrape historical or daily charts?

Not in v1. The Actor deliberately avoids claiming access to authenticated daily and historical surfaces.

#### Why are some previous or peak ranks missing?

Spotify may supply zero or empty values for those fields. The Actor omits meaningless values rather than presenting zero as a real rank.

#### Why did I get fewer than 150 records?

The result count equals selected chart types multiplied by `maxItemsPerChart`, up to what Spotify currently exposes. One chart with a limit of 10 returns up to 10 records.

#### What if the run fails with an upstream response error?

Retry later and check Spotify's public charts availability. A schema-changing upstream response intentionally fails the run instead of returning an empty successful dataset.

#### How do I track changes over months?

Schedule weekly runs and persist each dataset in your warehouse or spreadsheet. Use Spotify URI plus chart alias and date as the snapshot key.

### Related Spotify scrapers

- [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) — scrape broader Spotify tracks, artists, albums, playlists, and search results.
- [Spotify Play Count Scraper](https://apify.com/automation-lab/spotify-play-count-scraper) — collect track play-count signals when that metric is the primary workflow.
- [Spotify Song Downloader](https://apify.com/automation-lab/spotify-song-downloader) — use only when your workflow requires supported media-download functionality rather than chart ranks.

Choose this Actor when the official current **weekly chart position** is the core record. Choose a related Actor when you need deep entity metadata, counts, or media rather than rankings.

### Support

If a run fails or output appears inconsistent with Spotify's visible current weekly charts, open an issue from the Actor page and include:

- the run URL;
- the exact input;
- the affected chart type;
- the expected rank or entity;
- when you observed the discrepancy.

That evidence helps distinguish an upstream chart refresh from a parser regression quickly.

# Actor input Schema

## `chartTypes` (type: `array`):

Select one or more current global weekly charts: Top Songs, Top Albums, or Top Artists.

## `maxItemsPerChart` (type: `integer`):

Set how many top-ranked entries to save from each selected chart. Spotify currently exposes up to 50 per chart.

## Actor input object example

```json
{
  "chartTypes": [
    "songs"
  ],
  "maxItemsPerChart": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset API URL for songs, albums, and artists with ranks, movement, Spotify links, credits, and chart metadata.

# 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 = {
    "chartTypes": [
        "songs"
    ],
    "maxItemsPerChart": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/spotify-public-weekly-charts-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 = {
    "chartTypes": ["songs"],
    "maxItemsPerChart": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/spotify-public-weekly-charts-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 '{
  "chartTypes": [
    "songs"
  ],
  "maxItemsPerChart": 10
}' |
apify call automation-lab/spotify-public-weekly-charts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Public Weekly Charts Scraper",
        "description": "Export Spotify's current global weekly Top Songs, Top Albums, and Top Artists rankings with movement, entities, artists, and artwork.",
        "version": "0.1",
        "x-build-id": "FgURiB2xtcWyuvZYc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~spotify-public-weekly-charts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-spotify-public-weekly-charts-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~spotify-public-weekly-charts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-spotify-public-weekly-charts-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~spotify-public-weekly-charts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-spotify-public-weekly-charts-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": {
                    "chartTypes": {
                        "title": "Chart types",
                        "type": "array",
                        "description": "Select one or more current global weekly charts: Top Songs, Top Albums, or Top Artists.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "songs",
                                "albums",
                                "artists"
                            ],
                            "enumTitles": [
                                "Top Songs",
                                "Top Albums",
                                "Top Artists"
                            ]
                        },
                        "default": [
                            "songs",
                            "albums",
                            "artists"
                        ]
                    },
                    "maxItemsPerChart": {
                        "title": "Maximum entries per chart",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Set how many top-ranked entries to save from each selected chart. Spotify currently exposes up to 50 per chart.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```