# JetBrains Marketplace Plugins Scraper (`parseforge/jetbrains-marketplace-plugins-scraper`) Actor

Pull plugins from the JetBrains Marketplace by keyword or plugin ID. Returns each plugin's name, description, vendor, rating, download count, tags, and compatible IDE builds like IntelliJ IDEA, PyCharm, and WebStorm. Great for ecosystem research, discovery, and dev tooling analytics.

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

## Pricing

from $9.95 / 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)

## 🧩 JetBrains Marketplace Plugins Scraper

> 🚀 **Export JetBrains Marketplace plugin data in one run.** Pull plugin names, vendors, ratings, download counts, tags, and compatible IDE builds straight from the official Marketplace API.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 21 fields** per record · 2 modes · live Marketplace data

Turn the JetBrains Marketplace into clean, structured plugin records you can drop into a spreadsheet, a competitive tracker, or an internal tooling catalog. Search by keyword or fetch specific plugins by their numeric ID, and get one tidy record per plugin with its icon, description, vendor, rating, downloads, tags, and the IDEs it supports.

Coverage is whatever the public Marketplace API exposes for each plugin: identity (id, xmlId, name), the vendor behind it, a real per-plugin rating computed from the vote histogram, lifetime download count, the latest published version, and the list of compatible JetBrains IDEs such as IntelliJ IDEA, PyCharm, WebStorm, GoLand, and Rider.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Plugin developers | Track competitors, ratings, and download trends |
| Dev tooling teams | Build an internal catalog of approved plugins |
| Ecosystem researchers | Map the JetBrains plugin landscape by tag |
| IDE platform analysts | Study adoption across IntelliJ-based IDEs |

### 📋 What the JetBrains Marketplace Plugins Scraper does

This Actor calls the public JetBrains Marketplace API and returns one clean record per plugin. You choose how plugins are selected:

- **Search by keyword** — give a query like `python` or `theme` and the Actor resolves matching plugins, then enriches each one.
- **By plugin IDs** — give a list of numeric Marketplace IDs (the number in the plugin page URL) and the Actor fetches exactly those.

For every plugin the Actor combines three Marketplace endpoints: the plugin detail (identity, vendor, downloads, tags), the rating histogram (turned into a true weighted average), and the latest update (version and compatible IDE builds). Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | How plugins are selected. One of `search` or `ids`. Defaults to `search`. |
| `query` | string | Keyword to search the Marketplace. Used when `mode` is `search`. |
| `ids` | array | List of numeric plugin IDs. Used when `mode` is `ids`. |
| `maxItems` | integer | How many plugin records to return. Free plan is capped at 10. |

**Example 1 — search by keyword**
```json
{
    "mode": "search",
    "query": "python",
    "maxItems": 20
}
````

**Example 2 — specific plugins by ID**

```json
{
    "mode": "ids",
    "ids": ["7322", "631", "10080"],
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** The plugin ID is the number at the start of the URL slug, for example `7322` in `plugins.jetbrains.com/plugin/7322-python-community-edition`. The `rating` field is a true weighted average derived from the public vote histogram, and `ratingVotes` tells you how many votes back it.

### 📊 Output

Each plugin record looks like this:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Plugin icon URL |
| 📌 `name` | Plugin name |
| 🔗 `url` | Marketplace plugin page |
| 🆔 `id` | Numeric Marketplace ID |
| 🏷 `xmlId` | Stable plugin XML ID |
| 📝 `description` | Plugin description (HTML stripped) |
| 🏢 `vendorName` | Vendor or author name |
| 🌐 `vendorUrl` | Vendor website |
| ✅ `vendorIsVerified` | Whether the vendor is verified |
| ⭐ `rating` | Weighted average rating (1 to 5) |
| 🗳 `ratingVotes` | Number of votes behind the rating |
| ⬇ `downloads` | Lifetime download count |
| 💲 `pricingModel` | FREE, FREEMIUM, or PAID |
| 👪 `family` | Plugin family (e.g. intellij) |
| 🔢 `latestVersion` | Latest published version |
| 🟢 `since` | Minimum compatible build |
| 🔴 `until` | Maximum compatible build |
| 🗓 `updatedAt` | Latest update timestamp |
| 🗂 `tags` | Marketplace tags |
| 💻 `compatibleIdes` | Compatible JetBrains IDE codes |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — .env files**

```json
{
    "imageUrl": "https://plugins.jetbrains.com/files/9525/1068043/icon/default.svg",
    "name": ".env files",
    "url": "https://plugins.jetbrains.com/plugin/9525--env-files",
    "id": 9525,
    "xmlId": "ru.adelf.idea.dotenv",
    "description": "Homepage | Github | Issues . Sponsor: The most productive Laravel development environment. Learn more . Features Environment variables completion based on .env, Dockerfile and docker-compose.yml files.",
    "vendorName": "JetBrains",
    "vendorUrl": "https://www.jetbrains.com/",
    "vendorIsVerified": true,
    "rating": 4.84,
    "ratingVotes": 37,
    "downloads": 25050309,
    "pricingModel": "FREE",
    "family": "intellij",
    "latestVersion": "262.7132.31",
    "since": "262.7132",
    "until": "262.7132.*",
    "updatedAt": "2026-06-05T14:42:23.000Z",
    "tags": ["Framework"],
    "compatibleIdes": ["IDEA", "PYCHARM", "WEBSTORM", "GOLAND", "RIDER", "CLION", "RUBYMINE", "PHPSTORM"],
    "scrapedAt": "2026-06-08T17:39:14.000Z",
    "error": null
}
```

**Real sample — Rainbow Brackets**

```json
{
    "imageUrl": "https://plugins.jetbrains.com/files/10080/1066043/icon/default.svg",
    "name": "Rainbow Brackets",
    "url": "https://plugins.jetbrains.com/plugin/10080-rainbow-brackets",
    "id": 10080,
    "xmlId": "izhangzhihao.rainbow.brackets",
    "description": "Rainbow Brackets for IntelliJ based IDEs/Android Studio/HUAWEI DevEco Studio Core Features Rainbowify various types brackets.",
    "vendorName": "izhangzhihao",
    "vendorUrl": "https://izhangzhihao.github.io",
    "vendorIsVerified": true,
    "rating": 4.58,
    "ratingVotes": 603,
    "downloads": 24226796,
    "pricingModel": "FREEMIUM",
    "family": "intellij",
    "latestVersion": "2025.3.12",
    "since": "241.0",
    "until": null,
    "updatedAt": "2026-06-04T00:41:10.000Z",
    "tags": ["User Interface", "Code Tools", "Fun Stuff", "Editor", "Productivity"],
    "compatibleIdes": ["IDEA", "PYCHARM", "WEBSTORM", "GOLAND", "RIDER", "CLION", "PHPSTORM", "ANDROID_STUDIO"],
    "scrapedAt": "2026-06-08T17:39:15.000Z",
    "error": null
}
```

**Real sample — Python**

```json
{
    "imageUrl": "https://plugins.jetbrains.com/files/631/1066671/icon/default.svg",
    "name": "Python",
    "url": "https://plugins.jetbrains.com/plugin/631-python",
    "id": 631,
    "xmlId": "Pythonid",
    "description": "The Python plug-in provides smart editing for Python scripts. The feature set of the plugin corresponds to PyCharm IDE with a Pro subscription.",
    "vendorName": "JetBrains",
    "vendorUrl": "https://www.jetbrains.com/",
    "vendorIsVerified": true,
    "rating": 3.31,
    "ratingVotes": 54,
    "downloads": 11884611,
    "pricingModel": "FREE",
    "family": "intellij",
    "latestVersion": "262.7132.23",
    "since": "262.7132",
    "until": "262.7132.*",
    "updatedAt": "2026-06-04T14:51:54.000Z",
    "tags": ["Programming Language"],
    "compatibleIdes": ["IDEA_PRO"],
    "scrapedAt": "2026-06-08T17:39:16.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per plugin, with the icon placed first for instant previews.
- A true per-plugin rating, computed from the public vote histogram, not a misleading global average.
- Compatible IDE builds expanded into a clear list, so you know exactly where a plugin runs.
- Two selection modes in one Actor, sharing a single consistent record shape.
- No JetBrains account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Ratings included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes, weighted | None on your side |
| Copying from plugin pages | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | You compute it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the JetBrains Marketplace Plugins Scraper.
3. Pick a `mode` (search by keyword or by plugin IDs).
4. Enter a `query` or a list of `ids`, then set `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Plugin development

| Goal | How this helps |
|---|---|
| Watch competitors | Track their ratings, downloads, and versions |
| Spot gaps in a category | Group plugins by tag and compare |

#### Dev tooling and platform teams

| Goal | How this helps |
|---|---|
| Maintain an approved-plugin catalog | Fetch a fixed list of IDs on a schedule |
| Check IDE compatibility | Read the compatible IDE list per plugin |

#### Market and ecosystem research

| Goal | How this helps |
|---|---|
| Map the Marketplace by topic | Search a keyword and pull the matches |
| Measure plugin popularity | Use download counts and vote-backed ratings |

#### Content and analysis

| Goal | How this helps |
|---|---|
| Build "best plugins" roundups | Sort search results by rating and downloads |
| Track release cadence | Watch the latest version and update date |

### 🔌 Automating JetBrains Marketplace Plugins Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how the JetBrains plugin ecosystem grows over time.
- **Personal:** build a shortlist of plugins for your own IDE setup.
- **Non-profit:** curate plugin recommendations for a coding community.
- **Experimentation:** prototype a plugin discovery app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to rank plugins by rating, group them by tag, or shortlist the best options for a given IDE.

### ❓ Frequently Asked Questions

**Do I need a JetBrains account?**
No. The Actor reads the public JetBrains Marketplace API, which needs no login.

**Do I need an API key?**
No key is required. The Actor sends a descriptive User-Agent and nothing else.

**How do I find a plugin ID?**
It is the number at the start of the plugin page URL, for example `7322` in `plugins.jetbrains.com/plugin/7322-python-community-edition`.

**How is the rating calculated?**
From the plugin's public vote histogram. The Actor computes a weighted average of the 1 to 5 star votes, which matches the rating shown in Marketplace search.

**Why is `ratingVotes` included?**
So you can judge how meaningful a rating is. A 5.0 from three votes is different from a 4.6 from six hundred.

**Which IDEs are covered in `compatibleIdes`?**
Whatever the plugin's latest update declares, using JetBrains IDE codes like IDEA, PYCHARM, WEBSTORM, GOLAND, RIDER, CLION, and more.

**Can I pull paid plugins too?**
Yes. The `pricingModel` field shows FREE, FREEMIUM, or PAID. The Actor reads public metadata only.

**Why is `until` sometimes null?**
Some plugins declare an open-ended upper compatibility bound, so the source leaves `until` empty. The Actor passes through what the source provides.

**How fresh is the data?**
Each run pulls live from the Marketplace, so it reflects ratings, downloads, and versions at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot a keyword search or a fixed list of plugin IDs on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- [Brawlify Brawl Stars Database Scraper](https://apify.com/parseforge)
- More developer and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with JetBrains. Only publicly available data is collected.

# Actor input Schema

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

How to select plugins. 'Search by keyword' finds plugins matching a query string. 'By plugin IDs' fetches specific plugins by their numeric Marketplace ID.

## `query` (type: `string`):

Only used when Mode is 'Search by keyword'. A keyword to search the JetBrains Marketplace, for example 'python', 'kotlin', or 'theme'. Leave empty when fetching by IDs.

## `ids` (type: `array`):

Only used when Mode is 'By plugin IDs'. A list of numeric plugin IDs from the Marketplace, for example 7322 (Python) or 631 (Markdown). Find the ID in the plugin page URL.

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

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

## Actor input object example

```json
{
  "mode": "search",
  "query": "python",
  "ids": [
    "7322",
    "631"
  ],
  "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 = {
    "query": "python",
    "ids": [
        "7322",
        "631"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jetbrains-marketplace-plugins-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 = {
    "query": "python",
    "ids": [
        "7322",
        "631",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jetbrains-marketplace-plugins-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 '{
  "query": "python",
  "ids": [
    "7322",
    "631"
  ],
  "maxItems": 10
}' |
apify call parseforge/jetbrains-marketplace-plugins-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JetBrains Marketplace Plugins Scraper",
        "description": "Pull plugins from the JetBrains Marketplace by keyword or plugin ID. Returns each plugin's name, description, vendor, rating, download count, tags, and compatible IDE builds like IntelliJ IDEA, PyCharm, and WebStorm. Great for ecosystem research, discovery, and dev tooling analytics.",
        "version": "0.1",
        "x-build-id": "z5Zwp5g33jr6UYoAS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jetbrains-marketplace-plugins-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jetbrains-marketplace-plugins-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~jetbrains-marketplace-plugins-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jetbrains-marketplace-plugins-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~jetbrains-marketplace-plugins-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jetbrains-marketplace-plugins-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "ids"
                        ],
                        "type": "string",
                        "description": "How to select plugins. 'Search by keyword' finds plugins matching a query string. 'By plugin IDs' fetches specific plugins by their numeric Marketplace ID.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Only used when Mode is 'Search by keyword'. A keyword to search the JetBrains Marketplace, for example 'python', 'kotlin', or 'theme'. Leave empty when fetching by IDs."
                    },
                    "ids": {
                        "title": "Plugin IDs",
                        "type": "array",
                        "description": "Only used when Mode is 'By plugin IDs'. A list of numeric plugin IDs from the Marketplace, for example 7322 (Python) or 631 (Markdown). Find the ID in the plugin page URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
