# Open VSX Extension Registry Scraper (`automation-lab/open-vsx-extension-registry-scraper`) Actor

🔎 Scrape Open VSX extension metadata, downloads, ratings, publishers, versions, repositories, licenses, and file URLs from the public registry API.

- **URL**: https://apify.com/automation-lab/open-vsx-extension-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are 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

## Open VSX Extension Registry Scraper

Scrape Open VSX extension metadata from the public Open VSX Registry API.

Use this actor to collect extension names, namespaces, versions, downloads, ratings, reviews, publishers, repositories, licenses, category tags, version counts, and optional file URLs for VSIX packages, manifests, README files, changelogs, icons, signatures, and checksums.

### What does Open VSX Extension Registry Scraper do?

The actor searches `open-vsx.org` and returns structured extension records.

It can:

- 🔎 Search Open VSX by keyword.
- 🎯 Fetch exact extensions by `namespace.name`, `namespace/name`, or URL.
- 📦 Enrich records from the extension detail API.
- ⭐ Capture downloads, ratings, and review counts.
- 🧑‍💻 Extract publisher names and provider metadata.
- 🧾 Include repositories, licenses, homepages, bugs URLs, and taxonomy.
- 🗂️ Optionally include version identifiers and file URLs.

### Who is it for?

#### Extension publishers

Track competing extensions, category visibility, download counts, and rating changes in the open-source IDE ecosystem.

#### Developer-tool marketers

Build lists of Open VSX extensions by language, framework, or theme niche and enrich them for content, outreach, or partnership workflows.

#### OSS intelligence teams

Monitor extension metadata for supply-chain research, package provenance, licensing, repository references, and ecosystem adoption.

#### IDE platform teams

Compare catalog coverage across Open VSX categories and identify popular extensions for curated recommendations.

#### Data analysts

Create repeatable datasets of extension popularity, publisher metadata, and searchable marketplace rankings.

### Why use this actor?

Open VSX is a public extension registry used by VSCodium, Eclipse Theia, Gitpod-style environments, and other VS Code-compatible open-source developer tools.

The website exposes useful JSON endpoints, but analysts still need a repeatable scraper that handles search pagination, exact extension IDs, deduplication, enrichment, and clean dataset output.

This actor packages that workflow into a reusable Apify actor.

### How does it work?

The actor uses the public Open VSX API:

- Search endpoint: `https://open-vsx.org/api/-/search`
- Detail endpoint: `https://open-vsx.org/api/<namespace>/<extension>`

No browser automation is used.

No login is required.

No API key is required for Open VSX.

### Data you can extract

| Field | Description |
| --- | --- |
| `id` | Combined extension ID, such as `ms-python.python` |
| `namespace` | Open VSX namespace |
| `name` | Extension name |
| `displayName` | Human-readable extension title |
| `version` | Latest version returned by Open VSX |
| `downloadCount` | Total download count shown by the registry |
| `averageRating` | Average user rating |
| `reviewCount` | Number of reviews |
| `verified` | Whether the namespace or extension is verified |
| `deprecated` | Whether the extension is deprecated |
| `publisherName` | Publisher display name |
| `license` | License string when available |
| `repository` | Source repository URL |
| `extensionUrl` | Human Open VSX extension page |
| `apiUrl` | Detail API URL |
| `versions` | Optional list of version identifiers |
| `files` | Optional file URL map |

### How much does it cost to scrape Open VSX extensions?

The actor uses pay-per-event pricing.

You pay a small start fee per run and a per-extension fee for each dataset item produced.

Because the actor uses lightweight HTTP API calls and no browser, it is designed for low compute usage and predictable pricing.

For cost control:

- Start with `maxItems: 100`.
- Disable `includeVersions` unless you need version lists.
- Disable `includeFiles` unless you need package or manifest URLs.
- Use exact `extensionIds` for small monitoring jobs.
- Use broader `queries` for market research jobs.

### Input options

#### `queries`

Search terms used for Open VSX discovery.

Examples:

- `python`
- `java`
- `theme`
- `docker`
- `kubernetes`
- `ai`

#### `extensionIds`

Exact extensions to fetch.

Supported formats:

- `ms-python.python`
- `ms-python/python`
- `https://open-vsx.org/extension/ms-python/python`
- `https://open-vsx.org/api/ms-python/python`

#### `maxItems`

Maximum unique extensions to save across all searches and explicit IDs.

#### `includeDetails`

Fetches detail metadata for richer output.

This is enabled by default and recommended.

#### `includeVersions`

Adds the `versions` array and `versionCount`.

Use it for version monitoring or compatibility research.

#### `includeFiles`

Adds file URLs such as VSIX download, manifest, README, license, changelog, icon, signature, and checksum URLs when Open VSX exposes them.

### Example input: keyword search

```json
{
  "queries": ["python", "java"],
  "maxItems": 100,
  "includeDetails": true,
  "includeVersions": false,
  "includeFiles": false
}
````

### Example input: exact extensions

```json
{
  "extensionIds": ["ms-python.python", "redhat.java", "vscodevim.vim"],
  "maxItems": 25,
  "includeDetails": true,
  "includeVersions": true,
  "includeFiles": false
}
```

### Example input: deep metadata workflow

```json
{
  "queries": ["theme", "material", "dark"],
  "maxItems": 150,
  "includeDetails": true,
  "includeVersions": true,
  "includeFiles": true
}
```

### Output example

```json
{
  "id": "ms-python.python",
  "namespace": "ms-python",
  "name": "python",
  "displayName": "Python",
  "version": "2026.4.0",
  "downloadCount": 50805072,
  "averageRating": 3.8,
  "reviewCount": 15,
  "verified": true,
  "deprecated": false,
  "license": "MIT",
  "repository": "https://github.com/Microsoft/vscode-python.git",
  "extensionUrl": "https://open-vsx.org/extension/ms-python/python",
  "apiUrl": "https://open-vsx.org/api/ms-python/python",
  "searchQuery": "python",
  "inputSource": "search"
}
```

### Tips for better results

Use short, concrete search terms.

Combine language and category terms for broad market maps.

Use exact IDs for recurring monitoring.

Set `includeVersions` only when version history matters.

Set `includeFiles` only when you need package artifacts or manifest links.

Raise `maxItems` gradually for large discovery jobs.

### Integrations

You can connect the dataset to:

- Google Sheets for extension market reports.
- Airtable for publisher tracking.
- Slack alerts for new or deprecated extensions.
- Data warehouses for ecosystem intelligence.
- BI tools for category and download trend dashboards.
- Compliance workflows that review licenses and repository links.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/open-vsx-extension-registry-scraper').call({
  queries: ['python'],
  maxItems: 100,
  includeDetails: true
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/open-vsx-extension-registry-scraper').call(run_input={
    'queries': ['theme'],
    'maxItems': 100,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~open-vsx-extension-registry-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["python"],"maxItems":100,"includeDetails":true}'
```

### Using with MCP and AI agents

You can expose this actor to MCP-compatible tools through Apify MCP.

Claude Code command:

```bash
claude mcp add --transport http apify-open-vsx-extension-registry-scraper "https://mcp.apify.com/?tools=automation-lab/open-vsx-extension-registry-scraper"
```

Claude Code MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/open-vsx-extension-registry-scraper
```

Claude Desktop, Cursor, or VS Code MCP JSON config:

```json
{
  "mcpServers": {
    "apify-open-vsx-extension-registry-scraper": {
      "url": "https://mcp.apify.com/?tools=automation-lab/open-vsx-extension-registry-scraper"
    }
  }
}
```

Example prompts:

- "Find the top Open VSX Python extensions and summarize their publishers."
- "Compare Open VSX theme extensions by downloads and ratings."
- "Extract metadata for ms-python.python, redhat.java, and vscodevim.vim."

### Common workflows

#### Competitive extension research

Run searches for your language, framework, and category keywords.

Sort by downloads and ratings.

Review publishers, repositories, and license data.

#### Extension catalog monitoring

Run exact `extensionIds` daily or weekly.

Store the output in a database.

Detect version, download, rating, or deprecation changes.

#### Compliance and provenance checks

Enable detail enrichment.

Collect repository, license, publisher, and file URLs.

Review records with missing license or suspicious repository metadata.

### Related scrapers

You may also find these automation-lab actors useful:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/github-repository-scraper
- https://apify.com/automation-lab/domain-to-company-enricher

### Limitations

The actor only returns data exposed by Open VSX public APIs.

Some fields may be missing for older or minimally maintained extensions.

Search ranking is controlled by Open VSX and can change over time.

The actor does not download VSIX files; it only returns URLs when `includeFiles` is enabled.

### Troubleshooting

#### Why did I get fewer items than expected?

Open VSX may return duplicate extensions across queries, and the actor deduplicates by namespace and name. Increase `maxItems` or add more search terms.

#### Why are license or repository fields missing?

Not every extension publishes complete manifest metadata. The actor returns these fields when Open VSX exposes them.

#### Should I enable version and file enrichment?

Enable it for monitoring, package analysis, or compliance workflows. Keep it disabled for lightweight popularity or search visibility reports.

### Legality

Open VSX exposes public registry metadata through public API endpoints. You should still use the data responsibly, respect Open VSX terms, and avoid collecting or redistributing data in ways that violate applicable laws or third-party rights.

### FAQ

#### Can I scrape exact Open VSX extension URLs?

Yes. Add Open VSX page URLs, API URLs, `namespace.name`, or `namespace/name` values to `extensionIds`.

#### Does the actor download VSIX packages?

No. It extracts package and file URLs when `includeFiles` is enabled, but it does not download binary VSIX files.

### Data freshness

Every run fetches current data from Open VSX at execution time.

Use scheduled Apify tasks for recurring monitoring.

### Support

If a field is missing, check whether Open VSX exposes it on the extension page or API response.

If you need additional fields from the Open VSX API, open an issue on the actor page with an example extension URL and the desired field.

### Changelog

Initial version supports keyword search, exact extension IDs, detail enrichment, optional version lists, optional file URLs, and pay-per-extension output.

# Actor input Schema

## `queries` (type: `array`):

Open VSX search terms to discover extensions, such as languages, frameworks, categories, or publisher names.

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

Optional explicit extensions to fetch. Supports namespace.name, namespace/name, or Open VSX extension/API URLs.

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

Maximum unique extensions to save across searches and explicit IDs.

## `includeDetails` (type: `boolean`):

Fetch the extension detail endpoint for publisher, versions, file links, tags, categories, repository, and license fields when available.

## `includeVersions` (type: `boolean`):

Include all available version identifiers. Disable for smaller datasets when version history is not needed.

## `includeFiles` (type: `boolean`):

Include VSIX, manifest, README, license, icon, changelog, signature, and checksum URLs when exposed by Open VSX.

## Actor input object example

```json
{
  "queries": [
    "python",
    "theme",
    "java"
  ],
  "extensionIds": [
    "ms-python.python",
    "redhat.java"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "includeVersions": false,
  "includeFiles": false
}
```

# Actor output Schema

## `extensions` (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 = {
    "queries": [
        "python",
        "theme",
        "java"
    ],
    "extensionIds": [
        "ms-python.python",
        "redhat.java"
    ],
    "maxItems": 20,
    "includeDetails": true,
    "includeVersions": false,
    "includeFiles": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/open-vsx-extension-registry-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 = {
    "queries": [
        "python",
        "theme",
        "java",
    ],
    "extensionIds": [
        "ms-python.python",
        "redhat.java",
    ],
    "maxItems": 20,
    "includeDetails": True,
    "includeVersions": False,
    "includeFiles": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/open-vsx-extension-registry-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 '{
  "queries": [
    "python",
    "theme",
    "java"
  ],
  "extensionIds": [
    "ms-python.python",
    "redhat.java"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "includeVersions": false,
  "includeFiles": false
}' |
apify call automation-lab/open-vsx-extension-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open VSX Extension Registry Scraper",
        "description": "🔎 Scrape Open VSX extension metadata, downloads, ratings, publishers, versions, repositories, licenses, and file URLs from the public registry API.",
        "version": "0.1",
        "x-build-id": "OYp5tcOBqsrZg6dQa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~open-vsx-extension-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-open-vsx-extension-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~open-vsx-extension-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-open-vsx-extension-registry-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~open-vsx-extension-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-open-vsx-extension-registry-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": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Open VSX search terms to discover extensions, such as languages, frameworks, categories, or publisher names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extensionIds": {
                        "title": "Specific extensions",
                        "type": "array",
                        "description": "Optional explicit extensions to fetch. Supports namespace.name, namespace/name, or Open VSX extension/API URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum extensions",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique extensions to save across searches and explicit IDs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch detail metadata",
                        "type": "boolean",
                        "description": "Fetch the extension detail endpoint for publisher, versions, file links, tags, categories, repository, and license fields when available.",
                        "default": true
                    },
                    "includeVersions": {
                        "title": "Include version list",
                        "type": "boolean",
                        "description": "Include all available version identifiers. Disable for smaller datasets when version history is not needed.",
                        "default": false
                    },
                    "includeFiles": {
                        "title": "Include file URLs",
                        "type": "boolean",
                        "description": "Include VSIX, manifest, README, license, icon, changelog, signature, and checksum URLs when exposed by Open VSX.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
