# Last.fm Scraper | Music Scrobbles and Artists (`parseforge/last-fm-scraper`) Actor

Scrape Last.fm artists, albums, tracks, tags, and listener counts with biographies, similar artists, top tracks, and play stats. Build music recommendation engines, listening dashboards, and trend research pipelines using one of the largest crowd-sourced music metadata sources.

- **URL**: https://apify.com/parseforge/last-fm-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Social media, Marketing, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎵 Last.fm Scraper - Music Charts, Artist Stats & Scrobble Data

> 🚀 **Export Last.fm top tracks and artists charts in seconds.** Get real-time listener counts, play counts, and genre tags for the **top 20 tracks and artists** from Last.fm's global charts.

> 🕒 **Last updated:** 2026-05-22 · **📊 9 fields** per track record · **10 fields** per artist record · **Real-time data** · **Global charts**

The Last.fm Scraper pulls live chart data directly from Last.fm's public charts pages. For each charting track, you get the listener count, total scrobble count, album name, cover art, and direct URL. For each artist, you get listeners, total scrobbles, genre tags, and artist photo. No API key required - just click Run.

Data is sourced from Last.fm's server-rendered HTML charts at last.fm/charts, the same data powering the official Last.fm music charts used by millions of music fans worldwide. Records are always live, never cached.

### Target Audience / Use Cases

| Who | Why |
|---|---|
| Music researchers | Track which tracks and artists are trending globally right now |
| Playlist curators | Discover the most-scrobbled tracks to build chart-based playlists |
| Music journalists | Get live listener and play count data to back up chart reporting |
| Marketers | Identify trending artists for influencer and sponsorship opportunities |
| Data scientists | Build datasets of music popularity over time |
| Developers | Enrich music apps with real-time chart data from Last.fm |

### 📋 What the Last.fm Scraper does

- Fetches the Top Tracks chart with rank, track name, artist, album, listeners, and scrobble count
- Fetches the Top Artists chart with rank, artist name, listeners, total scrobbles, and genre tags
- Enriches each chart entry with full stats from the individual track or artist detail page
- Upgrades cover art and artist photos to high-resolution 300x300 images
- Processes up to 20 items per chart run (the full Last.fm global chart)
- Exports to CSV, Excel, JSON, or XML for immediate downstream use

> 💡 **Why it matters:** Last.fm has over 300 million registered users and tracks billions of song plays. Its scrobble data represents real listening behavior - not just streams or purchases. This actor gives you programmatic access to that signal in seconds.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `chartType` | select | No | tracks | Which chart: `tracks` or `artists` |
| `maxItems` | integer | No | 10 | Max items to return (free: capped at 10, paid: up to 20) |

**Top tracks example:**
```json
{
  "chartType": "tracks",
  "maxItems": 10
}
````

**Top artists example:**

```json
{
  "chartType": "artists",
  "maxItems": 20
}
```

> ⚠️ **Good to Know:** Last.fm's global charts reflect real-time scrobbling activity. The top 20 positions update frequently - especially during album releases and major events. The actor captures whatever is ranked at the moment of the run.

### 📊 Output

#### Track fields

| Field | Format | Description |
|---|---|---|
| 🖼️ `imageUrl` | URL | Album cover art (300x300) |
| 🎵 `trackName` | string | Track title |
| 🎤 `artistName` | string | Artist name |
| 💿 `albumName` | string | Album the track belongs to |
| 🏆 `rank` | integer | Chart position (1 = highest) |
| 👥 `listeners` | integer | Unique Last.fm listeners |
| 🔁 `playCount` | integer | Total scrobbles (all-time play count) |
| 🔗 `url` | URL | Last.fm track page URL |
| 🕵️ `scrapedAt` | ISO 8601 | When the record was collected |
| ❌ `error` | string | Error message if this item failed (null on success) |

#### Artist fields

| Field | Format | Description |
|---|---|---|
| 🖼️ `imageUrl` | URL | Artist photo (300x300) |
| 🎤 `artistName` | string | Artist name |
| 🏆 `rank` | integer | Chart position (1 = highest) |
| 👥 `listeners` | integer | Unique Last.fm listeners |
| 🔁 `playCount` | integer | Total scrobbles (all-time play count) |
| 🏷️ `tags` | string\[] | Genre tags (e.g. \["k-pop", "pop", "kpop"]) |
| 🔗 `url` | URL | Last.fm artist page URL |
| 🕵️ `scrapedAt` | ISO 8601 | When the record was collected |
| ❌ `error` | string | Error message if this item failed (null on success) |

**Sample track records (from live cloud run 2026-05-22):**

```json
[
  {
    "imageUrl": "https://lastfm.freetls.fastly.net/i/u/300x300/89799c9f5b5d06b42af8eb129d68896e.jpg",
    "trackName": "SWIM",
    "artistName": "BTS",
    "albumName": "ARIRANG",
    "rank": 1,
    "listeners": 448286,
    "playCount": 179272535,
    "url": "https://www.last.fm/music/BTS/_/SWIM",
    "scrapedAt": "2026-05-22T03:33:52.788Z",
    "error": null
  },
  {
    "imageUrl": "https://lastfm.freetls.fastly.net/i/u/300x300/89799c9f5b5d06b42af8eb129d68896e.jpg",
    "trackName": "Merry Go Round",
    "artistName": "BTS",
    "albumName": "ARIRANG",
    "rank": 2,
    "listeners": 317539,
    "playCount": 45975072,
    "url": "https://www.last.fm/music/BTS/_/Merry+Go+Round",
    "scrapedAt": "2026-05-22T03:33:58.728Z",
    "error": null
  },
  {
    "imageUrl": "https://lastfm.freetls.fastly.net/i/u/300x300/89799c9f5b5d06b42af8eb129d68896e.jpg",
    "trackName": "FYA",
    "artistName": "BTS",
    "albumName": "ARIRANG",
    "rank": 4,
    "listeners": 352116,
    "playCount": 47826021,
    "url": "https://www.last.fm/music/BTS/_/FYA",
    "scrapedAt": "2026-05-22T03:34:07.584Z",
    "error": null
  }
]
```

**Sample artist records (from live cloud run 2026-05-22):**

```json
[
  {
    "imageUrl": "https://lastfm.freetls.fastly.net/i/u/300x300/6d8a76d7769646d336561e6d13abf894.jpg",
    "artistName": "Drake",
    "rank": 2,
    "listeners": 6770303,
    "playCount": 1196974300,
    "tags": ["hip-hop", "rap", "drake", "rnb", "hip hop"],
    "url": "https://www.last.fm/music/Drake",
    "scrapedAt": "2026-05-22T03:34:50.519Z",
    "error": null
  },
  {
    "imageUrl": "https://lastfm.freetls.fastly.net/i/u/300x300/22801885c5e71903aa0172f4c4318620.jpg",
    "artistName": "Charli xcx",
    "rank": 3,
    "listeners": 3805189,
    "playCount": 730839362,
    "tags": ["pop", "synthpop", "electronic", "electropop", "bubblegum bass"],
    "url": "https://www.last.fm/music/Charli+xcx",
    "scrapedAt": "2026-05-22T03:34:55.222Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🔓 No API key required | Run immediately - no Last.fm account or API registration needed |
| 📊 Real scrobble counts | Listener counts and total play counts from actual listening data |
| 🏷️ Genre tags | Per-artist genre taxonomy from Last.fm's community tagging system |
| 🖼️ High-res images | Album art and artist photos at 300x300 (upgraded from chart thumbnails) |
| 📡 Live data | Chart positions and stats reflect real-time listening - not cached |
| 📦 Export-ready | CSV, Excel, JSON, XML output with no post-processing needed |

### 📈 How it compares to alternatives

| Feature | This Actor | Last.fm API | Manual scraping |
|---|---|---|---|
| API key required | No | Yes (registration) | No |
| Listeners + scrobbles | Yes | Yes | Manual |
| Genre tags | Yes | Yes | Manual |
| Chart position | Yes | Yes (separate call) | Manual |
| High-res images | Yes | Varies | Manual |
| Export to CSV/Excel | Yes | No | No |
| Pay-per-use pricing | Yes | Free (rate limited) | Free |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. Open the Last.fm Scraper actor page
3. Set `chartType` to `tracks` or `artists`
4. Set `maxItems` (1-20, default 10)
5. Click **Start** and wait for the run to complete (typically under 60 seconds)
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Music industry analytics

Label A\&R teams use chart data to identify breakout tracks before they peak. Monitoring weekly chart positions alongside listener-to-scrobble ratios reveals whether a track has a loyal core fanbase or broad casual appeal.

#### Streaming playlist curation

Playlist curators at DSPs and editorial teams use Last.fm scrobble data as a proxy for deep engagement - a track with high scrobbles relative to listeners is being replayed constantly, a strong signal for "lean-back" playlist placement.

#### Music journalism and reporting

Journalists covering music trends can verify listener counts and chart positions with a single click, embedding live stats directly into articles without manually checking Last.fm for each artist.

#### Marketing and influencer identification

Brands partnering with artists can use listener counts as a baseline for audience size estimation. Genre tags help segment artists by niche for targeted campaign planning.

### 🔌 Automating Last.fm Scraper

Connect this actor to your workflow tools:

- **Make (Integromat):** Schedule daily runs and pipe new chart entries into a Google Sheet
- **Zapier:** Trigger a Slack notification whenever a new artist enters the top 5
- **Webhook:** POST results to your own endpoint for real-time dashboard updates
- **Apify Scheduler:** Set up automated runs to capture chart snapshots at regular intervals

### 🌟 Beyond business use cases

#### Music research and academia

Researchers studying music consumption patterns, genre evolution, or regional trends can use scrobble data as a quantitative measure of listening engagement over time.

#### Personal music discovery

Music fans can run the scraper to discover what the global Last.fm community is listening to right now - a signal based on actual plays rather than algorithmic recommendations.

#### Developer projects

Build a personal chart tracker, embed live stats into a Discord bot, or populate a music visualization project with real scrobble data without writing a scraper yourself.

#### Non-profit and education

Music educators and non-profits studying popular culture can access structured chart data without needing a Last.fm API key or technical scraping knowledge.

### 🤖 Ask an AI assistant about this scraper

Not sure what field you need or how to use the data? Try asking:

- "What does the `playCount` field represent in Last.fm data?"
- "How is `listeners` different from `playCount`?"
- "Can I use this scraper to track chart changes over time?"
- "What genre tags are typically returned for hip-hop artists?"

### ❓ Frequently Asked Questions

#### 🔑 Does this require a Last.fm API key?

No. The actor scrapes Last.fm's public chart pages - no API key or account needed.

#### 📊 How many items can I get?

Last.fm shows 20 items per chart. Free users get up to 10 items. Paid users can request up to 20.

#### ⏱️ How long does a run take?

A typical run of 5-10 items completes in under 30 seconds. A full 20-item run takes about 60 seconds.

#### 🔄 How often does the chart update?

Last.fm charts update in near real-time based on scrobbling activity. Running the actor at different times will capture different rankings.

#### 🎤 Can I get artist details like biography?

The actor provides listeners, total scrobbles, genre tags, and artist photo. Biography text is loaded via JavaScript on Last.fm and is not included in the current version.

#### 🌍 Is this global or regional data?

The current version scrapes the global charts. Last.fm also has country-specific charts which may be added in a future version.

#### 💿 What is the difference between listeners and playCount?

`listeners` is the number of unique Last.fm users who have scrobbled the track/artist. `playCount` is the total number of times it has been played across all users (scrobbles).

#### 📸 What resolution are the images?

Cover art and artist photos are returned at 300x300 pixels, upgraded from the smaller thumbnails shown in the chart table.

#### 🏷️ What are tags?

Tags (artists only) are genre and descriptive labels applied by the Last.fm community. They reflect community consensus about an artist's genre, style, or era.

#### 🆓 Is the data available for commercial use?

The data comes from Last.fm's publicly accessible pages. Review Last.fm's terms of service for commercial usage policies. This actor is a data extraction tool - responsibility for how you use the data rests with you.

#### ❌ What happens if a track or artist page returns an error?

The actor includes retry logic. If a page fails after 3 attempts, the item is recorded with the `error` field populated. The run continues with remaining items.

### 🔌 Integrate with any app

Last.fm chart data can be connected to hundreds of tools via Apify's integration ecosystem:

**Productivity & Spreadsheets:** Google Sheets, Microsoft Excel, Airtable, Notion
**Workflow Automation:** Make (Integromat), Zapier, n8n, Pipedream
**Business Intelligence:** Power BI, Tableau, Google Looker Studio, Metabase
**Data Pipelines:** Snowflake, BigQuery, PostgreSQL, MongoDB
**Communication:** Slack, Microsoft Teams, Discord
**Storage:** AWS S3, Google Drive, Dropbox
**Custom:** REST API, Webhooks, Python/JavaScript SDK

### 🔗 Recommended Actors

Pair this actor with other ParseForge scrapers for a complete music and entertainment dataset:

| Actor | Description |
|---|---|
| [Bandcamp Scraper](https://apify.com/parseforge/bandcamp-scraper) | Scrape albums, tracks, and artist pages from Bandcamp by genre or tag |
| [Chess.com Scraper](https://apify.com/parseforge/chess-com-scraper) | Pull player ratings, game history, and profile data from Chess.com |
| [BoardGameGeek Scraper](https://apify.com/parseforge/boardgamegeek-scraper) | Extract board game ratings, reviews, and stats from BGG |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ specialized data scrapers across music, sports, finance, travel, and more.

***

*This actor scrapes publicly accessible pages on Last.fm. It does not access private data, user accounts, or any data behind authentication. Use in accordance with Last.fm's Terms of Service.*

# Actor input Schema

## `chartType` (type: `string`):

Which chart to scrape: top tracks or top artists.

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

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

## Actor input object example

```json
{
  "chartType": "tracks",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "chartType": "tracks",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/last-fm-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 = {
    "chartType": "tracks",
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Last.fm Scraper | Music Scrobbles and Artists",
        "description": "Scrape Last.fm artists, albums, tracks, tags, and listener counts with biographies, similar artists, top tracks, and play stats. Build music recommendation engines, listening dashboards, and trend research pipelines using one of the largest crowd-sourced music metadata sources.",
        "version": "0.1",
        "x-build-id": "K3hbbLcIixqSgzR6h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~last-fm-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-last-fm-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~last-fm-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-last-fm-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~last-fm-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-last-fm-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": {
                    "chartType": {
                        "title": "Chart Type",
                        "enum": [
                            "tracks",
                            "artists"
                        ],
                        "type": "string",
                        "description": "Which chart to scrape: top tracks or top artists.",
                        "default": "tracks"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
