# Eclipse Marketplace Scraper (`crawlerbros/eclipse-marketplace-scraper`) Actor

Scrape Eclipse Marketplace - 1,200+ plugins, tools, and solutions for the Eclipse IDE. Search by keyword, browse by category, or look up specific solutions. Get install counts, categories, tags, Eclipse version compatibility, license, and platform support.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Eclipse Marketplace Scraper

Scrape **Eclipse Marketplace** — the official catalog of 1,200+ plugins, tools, and solutions for the Eclipse IDE. Search by keyword, browse any of 50 categories across all 4 markets (Tools, RCP Applications, Eclipse Project, IoT), pull the curated Featured or Recently-active lists, or look up specific solutions by ID or URL slug. Get install counts, categories, tags, Eclipse version compatibility, license, and platform support. HTTP-only via the public marketplace.eclipse.org XML API. No auth, no proxy.

### What this actor does

- **Five modes:** `search`, `byCategory`, `byIds`, `featured`, `recent`
- **50 categories across all 4 markets** (Tools, RCP Applications, Eclipse Project, IoT) — not just the Tools market
- **Filters:** Eclipse version compatibility (3.4 through 4.40), platform (Windows/Mac/Linux), minimum install count
- **Client-side sort:** by name, total installs, recent installs, or last updated — Eclipse Marketplace has no server-side sort, so the actor sorts the returned results itself
- **Result caps:** `search` / `byCategory` / `featured` / `recent` return up to 10 solutions per query (Eclipse Marketplace's public API doesn't paginate); `byIds` has no upstream cap — it fetches one solution per requested ID
- **Empty fields are omitted**

### Output per solution

- `id` — Eclipse Marketplace node ID (e.g. `1091`)
- `name` — solution title
- `detailUrl` — canonical marketplace page
- `categories[]` — one or more category names
- `tags[]` — free-tagging keywords (when present)
- `owner` — publisher / maintainer name
- `favoritedCount`, `installsTotal`, `installsRecent`
- `shortDescription`, `description` — HTML stripped to plain text
- `createdAt`, `updatedAt` — ISO timestamps
- `isFoundationMember` — whether the publisher is an Eclipse Foundation member
- `homepageUrl`, `supportUrl`, `updateSiteUrl`
- `imageUrl`, `screenshotUrl` (when present)
- `license`, `companyName`, `status`
- `version` — solution's own version string (when declared)
- `eclipseVersions[]` — declared compatible Eclipse releases (when declared)
- `minJavaVersion` (when declared)
- `platforms[]` — Windows / Mac / Linux/GTK (when declared)
- `installableUnitIds[]` — p2 installable-unit feature IDs, for scripted/headless installs via the p2 director (when declared)
- `recordType: "solution"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byIds` / `featured` / `recent` |
| `searchQuery` | string | `java` | Free-text keyword search (mode=search) |
| `market` | string | `31` (Tools) | Market to browse (mode=byCategory): Tools / RCP Applications / Eclipse Project / IoT |
| `categoryId` | string | `17` (Tools) | Category to browse (mode=byCategory) |
| `ids` | array | – | Node IDs, slugs, or detail URLs (mode=byIds) |
| `eclipseVersion` | string | `any` | Only emit solutions compatible with this Eclipse release (3.4–4.40) |
| `platform` | string | `any` | Only emit solutions supporting this platform |
| `minInstalls` | int | – | Drop solutions with fewer total installs |
| `sortBy` | string | `relevance` | `relevance` / `name` / `installsTotal` / `installsRecent` / `updated` |
| `maxItems` | int | `20` | Hard cap (1–300) |

#### Example: browse the Testing category, most-installed first

```json
{
  "mode": "byCategory",
  "categoryId": "16",
  "sortBy": "installsTotal",
  "maxItems": 50
}
````

#### Example: search for Git tooling compatible with a specific Eclipse release

```json
{
  "mode": "search",
  "searchQuery": "git",
  "eclipseVersion": "4.19",
  "maxItems": 30
}
```

#### Example: lookup specific solutions

```json
{
  "mode": "byIds",
  "ids": ["1091", "atlassian-clover-eclipse", "https://marketplace.eclipse.org/content/wetator-test-editor-wte"]
}
```

#### Example: browse the IoT market

```json
{
  "mode": "byCategory",
  "market": "4396",
  "categoryId": "4397"
}
```

#### Example: curated Featured / Recently-active lists

```json
{ "mode": "featured" }
```

```json
{ "mode": "recent" }
```

### Use cases

- **Tooling research** — discover Eclipse plugins for a specific development need (testing, modeling, database tooling)
- **Compatibility auditing** — find plugins verified against a specific Eclipse release before a version upgrade
- **Ecosystem analysis** — track install counts and publisher activity across the Eclipse plugin ecosystem
- **Migration planning** — check platform support (Windows/Mac/Linux) before standardizing team tooling
- **Competitive intelligence** — monitor category leaders and new entrants in developer tooling

### FAQ

**What is Eclipse Marketplace?** The official Eclipse Foundation directory of installable plugins, tools, and solutions for Eclipse-based IDEs. See [marketplace.eclipse.org](https://marketplace.eclipse.org).

**Is this affiliated with the Eclipse Foundation?** No — this is a third-party actor built on Eclipse Marketplace's public listing API.

**Why do some solutions have no `eclipseVersions` or `platforms`?** These fields are self-declared by each publisher. Older or less-maintained listings often omit them; the actor only emits what the publisher provided.

**Does Eclipse Marketplace expose star ratings?** No — despite showing a rating icon in the UI, the underlying data does not include a numeric rating value, so this actor does not fabricate one.

**Why is `categoryId` a number instead of a name?** Eclipse Marketplace's category taxonomy uses numeric IDs internally; the dropdown shows the human-readable name and passes the correct ID automatically.

**What is `market`?** Eclipse Marketplace groups listings into 4 markets — Tools (the default, ~2,000 listings), RCP Applications, Eclipse Project, and IoT — each with its own category taxonomy sharing the same category IDs (except IoT, which only has one category: Eclipse Kura, ID `4397`). `categoryId` only makes sense within the selected `market`.

**How is `sortBy` applied if the source doesn't support sorting?** The actor sorts whatever results the API returns (up to 10 for `search`/`byCategory`/`featured`/`recent`) client-side before truncating to `maxItems`.

**Why do `search`, `byCategory`, `featured` and `recent` only return 10 results even with a high `maxItems`?** Eclipse Marketplace's public API ignores its own `page` parameter — every page returns the same first ~10 results. This is a confirmed upstream limitation, not a bug in this actor. Use `byIds` with known solution IDs for bulk retrieval beyond 10 results.

**What eclipseVersion range is supported?** `3.4` through `4.40`, matching every value observed live across a broad sample of the catalog. (An earlier revision of this actor's filter also listed Eclipse's date-based release-train names like `2024-03` — those were removed after confirming the underlying `eclipseversion` field never actually contains that format; only the numeric `4.x` form is used, so those entries could never have matched anything.)

**Does `mode=recent` return newly-published solutions?** Not exactly — it mirrors Eclipse Marketplace's own "Recent" list, which is ranked by most-recent update activity (new releases, edits) rather than original publish date. Many long-running, actively-maintained solutions from years ago appear here because they were updated recently. Use `sortBy=updated` combined with `search`/`byCategory` if you specifically need publish-date ordering on a narrower result set.

**How fresh is the data?** Real-time — every run queries the live marketplace.eclipse.org API.

# Actor input Schema

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

What to fetch. `recent` mirrors Eclipse Marketplace's own 'Recent' list, which is ranked by most-recent update activity, not by original publish date.

## `searchQuery` (type: `string`):

Free-text keyword search (mode=search).

## `market` (type: `string`):

Which Eclipse Marketplace market to browse categories in. Most solutions are in Tools; the others are smaller, specialized markets. Not every categoryId exists in every market.

## `categoryId` (type: `string`):

Eclipse Marketplace category to browse. `4397` (Eclipse Kura) is the only category in the IoT market — pick it only when market=4396.

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

Eclipse Marketplace numeric node IDs (e.g. `1091`), URL slugs (e.g. `atlassian-clover-eclipse`), or full detail-page URLs.

## `eclipseVersion` (type: `string`):

Only emit solutions that declare compatibility with this Eclipse release. Matches against the solution's declared version-compatibility list.

## `platform` (type: `string`):

Only emit solutions that declare support for this platform. Solutions without any declared platform list always pass through.

## `minInstalls` (type: `integer`):

Drop solutions with fewer total installs than this.

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

Eclipse Marketplace does not support server-side sorting; this actor sorts the fetched result window client-side.

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

Hard cap on emitted records. Note: Eclipse Marketplace's search, category, featured and recent APIs do not paginate (no working `page` param upstream), so mode=search, mode=byCategory, mode=featured and mode=recent can only ever return up to 10 results per query regardless of this value. Set higher for mode=byIds, which fetches one solution per requested ID.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "java",
  "market": "31",
  "categoryId": "17",
  "ids": [],
  "eclipseVersion": "any",
  "platform": "any",
  "sortBy": "relevance",
  "maxItems": 10
}
```

# Actor output Schema

## `solutions` (type: `string`):

Dataset containing all scraped Eclipse Marketplace solutions.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "search",
    "searchQuery": "java",
    "market": "31",
    "categoryId": "17",
    "ids": [],
    "eclipseVersion": "any",
    "platform": "any",
    "sortBy": "relevance",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/eclipse-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 = {
    "mode": "search",
    "searchQuery": "java",
    "market": "31",
    "categoryId": "17",
    "ids": [],
    "eclipseVersion": "any",
    "platform": "any",
    "sortBy": "relevance",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/eclipse-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 '{
  "mode": "search",
  "searchQuery": "java",
  "market": "31",
  "categoryId": "17",
  "ids": [],
  "eclipseVersion": "any",
  "platform": "any",
  "sortBy": "relevance",
  "maxItems": 10
}' |
apify call crawlerbros/eclipse-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eclipse Marketplace Scraper",
        "description": "Scrape Eclipse Marketplace - 1,200+ plugins, tools, and solutions for the Eclipse IDE. Search by keyword, browse by category, or look up specific solutions. Get install counts, categories, tags, Eclipse version compatibility, license, and platform support.",
        "version": "1.0",
        "x-build-id": "G73mDCg1QWrp6MCyZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~eclipse-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-eclipse-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/crawlerbros~eclipse-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-eclipse-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/crawlerbros~eclipse-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-eclipse-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": [
                            "search",
                            "byCategory",
                            "byIds",
                            "featured",
                            "recent"
                        ],
                        "type": "string",
                        "description": "What to fetch. `recent` mirrors Eclipse Marketplace's own 'Recent' list, which is ranked by most-recent update activity, not by original publish date.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword search (mode=search).",
                        "default": "java"
                    },
                    "market": {
                        "title": "Market (mode=byCategory)",
                        "enum": [
                            "31",
                            "33",
                            "3891",
                            "4396"
                        ],
                        "type": "string",
                        "description": "Which Eclipse Marketplace market to browse categories in. Most solutions are in Tools; the others are smaller, specialized markets. Not every categoryId exists in every market.",
                        "default": "31"
                    },
                    "categoryId": {
                        "title": "Category (mode=byCategory)",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6",
                            "7",
                            "8",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "29",
                            "30",
                            "36",
                            "37",
                            "38",
                            "39",
                            "40",
                            "42",
                            "1963",
                            "1964",
                            "1965",
                            "1966",
                            "1967",
                            "1968",
                            "1969",
                            "1970",
                            "1971",
                            "1972",
                            "1973",
                            "1974",
                            "3574",
                            "6812",
                            "4397"
                        ],
                        "type": "string",
                        "description": "Eclipse Marketplace category to browse. `4397` (Eclipse Kura) is the only category in the IoT market — pick it only when market=4396.",
                        "default": "17"
                    },
                    "ids": {
                        "title": "Solution IDs or slugs (mode=byIds)",
                        "type": "array",
                        "description": "Eclipse Marketplace numeric node IDs (e.g. `1091`), URL slugs (e.g. `atlassian-clover-eclipse`), or full detail-page URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "eclipseVersion": {
                        "title": "Compatible with Eclipse version",
                        "enum": [
                            "any",
                            "3.4",
                            "3.5",
                            "3.6",
                            "3.7",
                            "3.8",
                            "4.1",
                            "4.2",
                            "4.3",
                            "4.4",
                            "4.5",
                            "4.6",
                            "4.7",
                            "4.8",
                            "4.9",
                            "4.10",
                            "4.11",
                            "4.12",
                            "4.13",
                            "4.14",
                            "4.15",
                            "4.16",
                            "4.17",
                            "4.18",
                            "4.19",
                            "4.20",
                            "4.21",
                            "4.22",
                            "4.23",
                            "4.24",
                            "4.25",
                            "4.26",
                            "4.27",
                            "4.28",
                            "4.29",
                            "4.30",
                            "4.31",
                            "4.32",
                            "4.33",
                            "4.34",
                            "4.35",
                            "4.36",
                            "4.37",
                            "4.38",
                            "4.39",
                            "4.40"
                        ],
                        "type": "string",
                        "description": "Only emit solutions that declare compatibility with this Eclipse release. Matches against the solution's declared version-compatibility list.",
                        "default": "any"
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "any",
                            "Windows",
                            "Mac",
                            "Linux/GTK"
                        ],
                        "type": "string",
                        "description": "Only emit solutions that declare support for this platform. Solutions without any declared platform list always pass through.",
                        "default": "any"
                    },
                    "minInstalls": {
                        "title": "Min total installs",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop solutions with fewer total installs than this."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "name",
                            "installsTotal",
                            "installsRecent",
                            "updated"
                        ],
                        "type": "string",
                        "description": "Eclipse Marketplace does not support server-side sorting; this actor sorts the fetched result window client-side.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Note: Eclipse Marketplace's search, category, featured and recent APIs do not paginate (no working `page` param upstream), so mode=search, mode=byCategory, mode=featured and mode=recent can only ever return up to 10 results per query regardless of this value. Set higher for mode=byIds, which fetches one solution per requested ID.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
