# VS Code Marketplace Scraper — Extensions, Stats & Reviews (`freshactors/vscode-marketplace-scraper`) Actor

Reliable, always-fresh VS Code Marketplace data: extension details with install counts and trending stats, search, and reviews. Monitored daily. By FreshActors.

- **URL**: https://apify.com/freshactors/vscode-marketplace-scraper.md
- **Developed by:** [Freshactors](https://apify.com/freshactors) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 extension details fetcheds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## VS Code Marketplace Scraper — Extension Stats, Search & Reviews (No API Key)

Scrape the **Visual Studio Code Marketplace** into clean, structured JSON — extension details with **install counts, rating stats, and trending scores**, keyword/category **search**, and user **reviews**. No account, no login, no API key. Built for devtool builders, market researchers, and anyone tracking the VS Code extension ecosystem.

![VS Code Marketplace Scraper — extension stats, search and reviews](https://raw.githubusercontent.com/Freshactors/freshactors-assets/main/vscode-screenshot.png)

> ✅ **Last verified working: 2026-06-11.** Monitored by an automated daily canary. When the Marketplace changes its API, we patch fast and log it in the changelog below — so your pipeline doesn't silently break.

---

### Why this VS Code Marketplace scraper

The Marketplace hosts **80,000+ extensions** and is the de-facto market map of the developer-tools world — but there's no public stats dashboard and no official data API for bulk analysis. This actor reads the Marketplace's own gallery JSON service and returns what the website shows (and more):

- **Install counts + trending velocity** on every record — `installs`, `trendingDaily/Weekly/Monthly` — the numbers that tell you which extensions (and categories) are growing *right now*.
- **Three modes, one actor** — `details` (exact lookups), `search` (keyword and/or category, sortable by installs/rating/updated), `reviews` (user reviews with rating + text).
- **Verified-publisher signal** — `publisherVerified` + `publisherDomain` on every row.
- **Per-item isolation + retries** — a bad ID or transient error is skipped and logged; it never crashes the run.
- **Stable, versioned output** (`_schemaVersion`) + a **daily canary** — that "last verified working" date is real.

### What data you get

**Details / search rows** (one per extension):

| Field | Type | Description |
|---|---|---|
| `extensionId` | string | `publisher.extension` (e.g. `ms-python.python`). |
| `name` | string | Display name. |
| `publisher` / `publisherDisplayName` | string | Publisher ID and display name. |
| `publisherVerified` | boolean | Domain-verified publisher badge. |
| `publisherDomain` | string \| null | Verified domain, when set. |
| `shortDescription` | string \| null | Listing summary. |
| `installs` | number | Install count (the Marketplace's own counter). |
| `averageRating` | number \| null | Average rating (0–5, 2 decimals). |
| `ratingCount` | number \| null | Number of ratings. |
| `trendingDaily` / `trendingWeekly` / `trendingMonthly` | number \| null | The Marketplace's trending velocity scores — compare across extensions to spot momentum. |
| `version` | string | Latest version. |
| `lastUpdated` / `releaseDate` / `publishedDate` | string \| null | ISO timestamps. |
| `categories` | string[] | Marketplace categories. |
| `tags` | string[] | Author tags (internal `__` tags filtered out). |
| `repositoryUrl` | string \| null | Source-repo link when the author publishes one. |
| `marketplaceUrl` | string | Public listing URL. |

**Review rows:** `extensionId`, `reviewId`, `user`, `rating` (1–5), `text`, `extensionVersion`, `updatedAt`.

Search rows also carry `_searchTerm` / `_category` so multi-term runs stay traceable.

### Use cases

- **Devtool competitive intelligence.** Track your competitors' installs, rating trajectory, update cadence, and review sentiment — or scan a whole category sorted by installs to map a niche before you build in it.
- **Extension market research.** Which categories are crowded? What do top extensions have in common? Pull a category (e.g. *Themes*: 18,000+ entries, or *Data Science*) sorted by installs and analyze.
- **Lead generation.** Verified publishers with big installs are companies investing in developer experience — `publisherDomain` gives you the company behind the extension.
- **Monitoring your own listing.** Schedule a daily run on your extension IDs and alert on rating drops, review spikes, or competitor releases.

### Input

| Field | Type | Required | Notes |
|---|---|---|---|
| `mode` | string | ✅ | `details` (default) / `search` / `reviews`. |
| `extensionIds` | string[] | for details/reviews | `publisher.extension` IDs (e.g. `ms-python.python`) or marketplace URLs. |
| `searchTerms` | string[] | for search | Free-text queries; one result set per term. |
| `category` | string | — | Search-mode category filter (e.g. `Themes`, `Programming Languages`, `Linters`). Combine with terms or use alone to browse a category. |
| `sortBy` | string | — | `relevance` (default), `installs`, `rating`, or `updated`. |
| `maxSearchResults` | integer | — | Cap per term/category (1–500). Default `25`. |
| `maxReviewsPerExtension` | integer | — | Cap per extension (1–100), newest first. Default `50`. The Marketplace's public reviews endpoint serves at most the 100 most recent. |

```json
{
  "mode": "details",
  "extensionIds": ["ms-python.python", "esbenp.prettier-vscode", "github.copilot"]
}
````

### Output sample

A real record from the default run:

```json
{
  "_type": "extension",
  "_schemaVersion": "1.0",
  "_source": "vscode-marketplace",
  "extensionId": "ms-python.python",
  "name": "Python",
  "publisher": "ms-python",
  "publisherDisplayName": "Microsoft",
  "publisherDomain": "https://microsoft.com",
  "publisherVerified": true,
  "shortDescription": "Python language support with extension access points for IntelliSense (Pylance), Debugging (Python Debugger), linting, formatting, refactoring, unit tests, and more.",
  "installs": 222361795,
  "averageRating": 4.2,
  "ratingCount": 630,
  "trendingDaily": 0.0021508348092437704,
  "trendingWeekly": 0.4154368098847741,
  "trendingMonthly": 2.0595825958151837,
  "version": "2026.5.2026061001",
  "lastUpdated": "2026-06-10T11:13:22.933Z",
  "releaseDate": "2016-01-19T15:03:11.337Z",
  "publishedDate": "2016-01-19T15:03:11.337Z",
  "categories": ["Programming Languages", "Debuggers", "Data Science", "Machine Learning"],
  "tags": ["debuggers", "django", "python", "..."],
  "repositoryUrl": "https://github.com/Microsoft/vscode-python",
  "marketplaceUrl": "https://marketplace.visualstudio.com/items?itemName=ms-python.python",
  "_scrapedAt": "2026-06-11T12:19:11.413Z"
}
```

### Use with AI agents (MCP)

This scraper is callable as a tool by AI agents via the **[Apify MCP server](https://mcp.apify.com)** — so assistants like **Claude, Cursor, and VS Code** can run it and use the structured results mid-conversation, with no glue code.

Simplest path: in a recent **Claude Desktop**, add the hosted server `https://mcp.apify.com` under **Settings → Connectors** and authorize with OAuth. For any config-file client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Then ask in plain language, e.g. *"Compare the install counts and ratings of the top 10 VS Code Python extensions."* — the agent calls **`freshactors/vscode-marketplace-scraper`** with the right input and reads back the JSON. Full setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Pricing

Pay-per-event — **no subscription**, no per-run start fee. You pay only for the rows you receive:

| Event | Price (USD) | When it fires |
|---|---|---|
| **Extension details fetched** | **$0.0025** | Once per extension details record returned. |
| **Search result fetched** | **$0.001** | Once per search result row returned. |
| **Review fetched** | **$0.0001** | Once per review returned. |

**Worked examples:**

- Full details on **50 extensions**: 50 × $0.0025 = **$0.125**
- A category scan of **100 search results**: 100 × $0.001 = **$0.10**
- **200 reviews** across 2 extensions: 200 × $0.0001 = **$0.02**

(Apify platform usage is billed separately per their standard rates.)

### FAQ

**Is scraping the VS Code Marketplace legal?**
This actor reads **public, non-personal** listing data from the Marketplace's own public gallery service — the same data the website shows any visitor. Review records contain only the public display name a reviewer chose to publish. Use responsibly and in line with applicable terms and laws.

**Do I need an API key or login?**
No. The gallery service is public; no Microsoft account, token, or key is involved.

**How do I find an extension's ID?**
It's `publisher.extension` — visible in the marketplace URL: `marketplace.visualstudio.com/items?itemName=`**`ms-python.python`**. You can also just paste the full URL.

**What do the trending scores mean?**
They're the Marketplace's own trending velocity metrics (the same signal that powers its "Trending" sort). The absolute numbers are unitless — use them to *compare* extensions or track one extension over time.

**How many reviews can I get per extension?**
Up to the **100 most recent** — that's the public endpoint's hard window (verified at launch), so we cap honestly rather than promise more. `ratingCount` in details mode still reflects *all* ratings ever.

**Can I get every extension in a category?**
Search mode paginates 100 per page up to `maxSearchResults` (max 500 per run/term). For very large categories, segment by search term or sort to target the slice you need.

**Which sort orders are supported?**
`relevance`, `installs`, `rating`, and `updated` — each one verified working at launch. Sorts the gallery doesn't support aren't offered.

**How often is the data updated?**
It's live — every run queries the Marketplace's current data. The actor itself is monitored by a daily canary so parsing stays correct as the API evolves.

### Other FreshActors tools

| FreshActors actor | What it scrapes |
|---|---|
| [App Store Scraper](https://apify.com/freshactors/app-store-scraper) | Apple App Store — app details, search, reviews |
| [Google Play Scraper](https://apify.com/freshactors/google-play-scraper) | Google Play — app details + reviews |
| [Microsoft Store Scraper](https://apify.com/freshactors/microsoft-store-scraper) | Microsoft Store — app details, rating windows, search, reviews |
| [Shopify App Store Scraper](https://apify.com/freshactors/shopify-app-store-scraper) | Shopify App Store — app details, reviews, discovery |
| [Redfin Scraper](https://apify.com/freshactors/redfin-scraper) | Redfin — US real-estate listings |
| [Greenhouse & Lever Jobs Scraper](https://apify.com/freshactors/greenhouse-lever-jobs-scraper) | Greenhouse + Lever — normalized job postings |
| [Workable Jobs Scraper](https://apify.com/freshactors/workable-jobs-scraper) | Workable — normalized job postings, full descriptions |
| [SmartRecruiters Jobs Scraper](https://apify.com/freshactors/smartrecruiters-jobs-scraper) | SmartRecruiters — normalized job postings, full descriptions |
| [Recruitee Jobs Scraper](https://apify.com/freshactors/recruitee-jobs-scraper) | Recruitee — normalized job postings, full descriptions + salary |
| [Teamtailor Jobs Scraper](https://apify.com/freshactors/teamtailor-jobs-scraper) | Teamtailor — normalized job postings, full descriptions |
| [Personio Jobs Scraper](https://apify.com/freshactors/personio-jobs-scraper) | Personio — normalized job postings, departments + seniority |

### Reliability

A scheduled **daily canary** queries the gallery, validates the normalized schema (installs numeric, ratings in range, reviews parsing), and alerts the moment a parse changes. When Microsoft shifts the gallery API, we patch fast and record it in the changelog below. Every record carries `_schemaVersion` and `_scrapedAt`.

**Changelog**

- **2026-06-11** — v1.0 launch. Details/search/reviews over the official gallery JSON service; install + trending statistics on every row; category browse; verified-publisher fields; honest 100-review window; per-item isolation; daily canary monitoring.

**Legal note:** Reads public, non-personal listing data from the Marketplace's public gallery service (the same data the website serves any visitor). No login, no private data. Use responsibly and in line with applicable terms and laws.

*Found a problem? Open an issue on the actor — issues are answered fast.*

# Actor input Schema

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

What to scrape: details (full record per extension), search (query the marketplace), or reviews (user reviews per extension).

## `extensionIds` (type: `array`):

Extensions as publisher.extension (e.g. ms-python.python) or marketplace URLs. Used by details and reviews modes.

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

Free-text queries for search mode (e.g. python, markdown, docker). One result set per term.

## `category` (type: `string`):

Optional marketplace category filter for search mode (e.g. Themes, Programming Languages, Linters, Snippets, Debuggers, Formatters, Testing, Data Science). Combine with searchTerms or use alone to browse a category.

## `sortBy` (type: `string`):

Order of search results: relevance (default), installs (most installed first), rating (highest average rating first), or updated (most recently updated first).

## `maxSearchResults` (type: `integer`):

Cap on search results returned per term/category (1–500).

## `maxReviewsPerExtension` (type: `integer`):

Cap on reviews returned per extension (1–100), newest first. The Marketplace's public reviews endpoint serves at most the 100 most recent reviews per extension.

## Actor input object example

```json
{
  "mode": "details",
  "extensionIds": [
    "ms-python.python",
    "esbenp.prettier-vscode",
    "github.copilot"
  ],
  "sortBy": "relevance",
  "maxSearchResults": 25,
  "maxReviewsPerExtension": 50
}
```

# Actor output Schema

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

Extension details / search results / reviews, depending on the selected mode.

# 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 = {
    "extensionIds": [
        "ms-python.python",
        "esbenp.prettier-vscode",
        "github.copilot"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("freshactors/vscode-marketplace-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 = { "extensionIds": [
        "ms-python.python",
        "esbenp.prettier-vscode",
        "github.copilot",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("freshactors/vscode-marketplace-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 '{
  "extensionIds": [
    "ms-python.python",
    "esbenp.prettier-vscode",
    "github.copilot"
  ]
}' |
apify call freshactors/vscode-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VS Code Marketplace Scraper — Extensions, Stats & Reviews",
        "description": "Reliable, always-fresh VS Code Marketplace data: extension details with install counts and trending stats, search, and reviews. Monitored daily. By FreshActors.",
        "version": "1.0",
        "x-build-id": "FXlMSg4rrHqiZzKOZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/freshactors~vscode-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-freshactors-vscode-marketplace-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/freshactors~vscode-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-freshactors-vscode-marketplace-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/freshactors~vscode-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-freshactors-vscode-marketplace-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "details",
                            "search",
                            "reviews"
                        ],
                        "type": "string",
                        "description": "What to scrape: details (full record per extension), search (query the marketplace), or reviews (user reviews per extension).",
                        "default": "details"
                    },
                    "extensionIds": {
                        "title": "Extension IDs",
                        "type": "array",
                        "description": "Extensions as publisher.extension (e.g. ms-python.python) or marketplace URLs. Used by details and reviews modes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Free-text queries for search mode (e.g. python, markdown, docker). One result set per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Optional marketplace category filter for search mode (e.g. Themes, Programming Languages, Linters, Snippets, Debuggers, Formatters, Testing, Data Science). Combine with searchTerms or use alone to browse a category."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "installs",
                            "rating",
                            "updated"
                        ],
                        "type": "string",
                        "description": "Order of search results: relevance (default), installs (most installed first), rating (highest average rating first), or updated (most recently updated first).",
                        "default": "relevance"
                    },
                    "maxSearchResults": {
                        "title": "Max search results per term",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on search results returned per term/category (1–500).",
                        "default": 25
                    },
                    "maxReviewsPerExtension": {
                        "title": "Max reviews per extension",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on reviews returned per extension (1–100), newest first. The Marketplace's public reviews endpoint serves at most the 100 most recent reviews per extension.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
