# UEX Star Citizen Commodities Scraper (`parseforge/uex-star-citizen-commodities-scraper`) Actor

Pull the full UEXcorp commodity economy for Star Citizen with names, codes, kinds, SCU weight, and live buy and sell prices. Filter by commodity kind and enrich each entry with its best buy and sell terminals. Built for trade route planning and in game market tracking.

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

## Pricing

from $19.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

## 🚀 UEX Star Citizen Commodities Scraper

> 🚀 **Export the Star Citizen commodity economy in seconds.** Pull every UEXcorp commodity with names, codes, SCU weight, and live buy and sell prices.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 25 fields** per record · official UEXcorp API 2.0 · live market prices

Turn the UEXcorp commodity economy for Star Citizen into clean, structured records you can drop into a trade-route planner, a market tracker, or a spreadsheet. Pull the whole catalog or filter by commodity kind, and optionally enrich each entry with its best buy and sell terminals drawn from live per-terminal prices.

Coverage is the public UEXcorp commodity catalog as the official API 2.0 publishes it: every commodity with its name, code, kind, SCU weight, average buy and sell prices, and availability flags, plus optional best-terminal enrichment that surfaces where to buy lowest and sell highest. Data is read live, so every run reflects the in-game economy as UEXcorp tracks it.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Traders and haulers | Plan profitable trade routes |
| Tool and overlay builders | Power an in-game market companion |
| Org logistics and analysts | Track the commodity economy over time |
| Spreadsheet planners | Export the full catalog for offline analysis |

### 📋 What the UEX Star Citizen Commodities Scraper does

This Actor calls the official UEXcorp API 2.0 and returns one clean record per commodity:

- **Commodity kind filter** — return only commodities whose kind matches your text (case-insensitive, partial match), for example `Metal`, `Gas`, or `Drug`. Leave empty for the whole catalog.
- **Best trading terminals** — optionally enrich each commodity with its best buy terminal (lowest price) and best sell terminal (highest price) from live per-terminal prices. This makes one extra request per commodity, so it is slower.

You control how many records come back, and every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `kind` | string | Optional filter. Only return commodities whose kind matches this text (case-insensitive, partial match), for example `Metal`, `Gas`, `Drug`, or `Agricultural`. Leave empty to return every kind. |
| `includeTerminalPrices` | boolean | When enabled, each commodity is enriched with its best buy terminal (lowest price) and best sell terminal (highest price) from live per-terminal prices. One extra request per commodity, so it is slower. Defaults to `false`. |
| `maxItems` | integer | How many commodities to return. Free plan is capped at 10. |

**Example 1 — every metal commodity with best terminals**
```json
{
    "kind": "Metal",
    "includeTerminalPrices": true,
    "maxItems": 50
}
````

**Example 2 — the full catalog, prices only**

```json
{
    "kind": "",
    "includeTerminalPrices": false,
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** turning on `includeTerminalPrices` adds the best buy and sell terminal for each commodity but makes one extra request per item, so runs take longer. Leave it off for a fast catalog pull with average prices only. The `kind` filter is a partial, case-insensitive match.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 📌 `name` | Commodity name |
| 🏷 `code` | Commodity code |
| 🗂 `kind` | Commodity kind (Metal, Gas, Drug, etc.) |
| 🆔 `id` | UEXcorp commodity ID |
| ⚖️ `weightScu` | Weight per SCU |
| 🟢 `priceBuy` | Average buy price |
| 🔴 `priceSell` | Average sell price |
| ✅ `isAvailable` | Whether the commodity is currently available |
| 🛒 `isBuyable` | Whether the commodity can be bought |
| 💱 `isSellable` | Whether the commodity can be sold |
| ⛏ `isMineral` | Mineral flag |
| 🔧 `isRefined` | Refined flag |
| 🪨 `isRaw` | Raw flag |
| 🌾 `isHarvestable` | Harvestable flag |
| 🚫 `isIllegal` | Illegal flag |
| ⛽ `isFuel` | Fuel flag |
| 📖 `wiki` | Wiki link where available |
| 📍 `bestBuyTerminal` | Terminal with the lowest buy price (when enrichment is on) |
| 🟢 `bestBuyPrice` | Lowest buy price across terminals |
| 📍 `bestSellTerminal` | Terminal with the highest sell price (when enrichment is on) |
| 💰 `bestSellPrice` | Highest sell price across terminals |
| 🔢 `terminalCount` | Number of terminals priced (when enrichment is on) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — a commodity with terminal enrichment**

```json
{
    "name": "Laranite",
    "code": "LARA",
    "kind": "Metal",
    "id": 18,
    "weightScu": 100,
    "priceBuy": 2660,
    "priceSell": 3094,
    "isAvailable": true,
    "isBuyable": true,
    "isSellable": true,
    "isMineral": true,
    "isRefined": true,
    "isRaw": false,
    "isHarvestable": false,
    "isIllegal": false,
    "isFuel": false,
    "wiki": "https://uexcorp.space/commodities/info/name/laranite",
    "bestBuyTerminal": "ArcCorp Mining Area 045",
    "bestBuyPrice": 2598,
    "bestSellTerminal": "Area18 IO North",
    "bestSellPrice": 3180,
    "terminalCount": 42,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — a commodity without terminal enrichment**

```json
{
    "name": "Agricium",
    "code": "AGRI",
    "kind": "Metal",
    "id": 1,
    "weightScu": 100,
    "priceBuy": 2598,
    "priceSell": 2790,
    "isAvailable": true,
    "isBuyable": true,
    "isSellable": true,
    "isMineral": true,
    "isRefined": true,
    "isRaw": false,
    "isHarvestable": false,
    "isIllegal": false,
    "isFuel": false,
    "wiki": "https://uexcorp.space/commodities/info/name/agricium",
    "bestBuyTerminal": null,
    "bestBuyPrice": null,
    "bestSellTerminal": null,
    "bestSellPrice": null,
    "terminalCount": null,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official UEXcorp API 2.0, not a scraped HTML page.
- The full commodity economy in one run, with average and best-terminal prices.
- Best buy and sell terminals make trade-route planning trivial.
- Rich boolean flags (mineral, refined, raw, illegal, fuel) for filtering.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Best terminals | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Reading the UEXcorp site by hand | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | 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 UEX Star Citizen Commodities Scraper.
3. Optionally set a `kind` filter and turn on `includeTerminalPrices`.
4. Set `maxItems` to the number of commodities you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Trade route planning

| Goal | How this helps |
|---|---|
| Find the best buy and sell spots | Turn on terminal enrichment |
| Compare margins by commodity | Read `priceBuy` against `priceSell` |

#### Tools and overlays

| Goal | How this helps |
|---|---|
| Power a market companion | Feed it the full commodity catalog |
| Surface live prices | Re-run on a schedule |

#### Org logistics

| Goal | How this helps |
|---|---|
| Plan bulk hauls | Use SCU weight and availability flags |
| Avoid illegal cargo | Filter on the `isIllegal` flag |

#### Analysis and planning

| Goal | How this helps |
|---|---|
| Track the economy over time | Snapshot prices on a schedule |
| Build a trade spreadsheet | Export the catalog to CSV or Excel |

### 🔌 Automating UEX Star Citizen Commodities Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route prices into sheets or databases.
- **Slack** or **Discord** to post a price digest 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 a player-driven sim economy moves.
- **Personal:** build your own trade cheat sheet.
- **Non-profit:** power a community trading resource for an org.
- **Experimentation:** prototype a market 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 commodities by margin, build a trade route, or list the most profitable legal hauls.

### ❓ Frequently Asked Questions

**Do I need an account or API key?**
No. The Actor reads the public UEXcorp API 2.0, which needs no login or key.

**How do I filter by commodity kind?**
Set the `kind` field to text like `Metal`, `Gas`, or `Drug`. It is a partial, case-insensitive match.

**What does best-terminal enrichment do?**
With `includeTerminalPrices` on, each commodity gains its best buy terminal (lowest price) and best sell terminal (highest price) from live per-terminal prices.

**Why is enrichment slower?**
It makes one extra request per commodity to load per-terminal prices, so larger runs take longer.

**Why are the best-terminal fields null?**
They are only populated when `includeTerminalPrices` is enabled. Without it, you still get average buy and sell prices.

**What is SCU weight?**
The cargo weight per Standard Cargo Unit, useful for planning hauls.

**How fresh is the data?**
Every run reads live from UEXcorp, so it reflects the economy as UEXcorp tracks it at run time.

**Can I export to Excel or CSV?**
Yes. Apify lets you download the dataset as CSV, Excel, JSON, or XML.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the economy on any cadence.

**Is this affiliated with UEXcorp or Star Citizen?**
No. This is an independent tool that reads only publicly available data.

### 🔌 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

- [Warframe Market Prices Scraper](https://apify.com/parseforge)
- [Brawlify Brawl Stars Database Scraper](https://apify.com/parseforge)
- More game and market 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 UEXcorp, Cloud Imperium Games, or Star Citizen. Only publicly available data is collected.

# Actor input Schema

## `kind` (type: `string`):

Optional filter. Only return commodities whose kind matches this text (case insensitive, partial match allowed), for example 'Metal', 'Gas', 'Drug' or 'Agricultural'. Leave empty to return every commodity kind.

## `includeTerminalPrices` (type: `boolean`):

When enabled, each commodity is enriched with its best buy terminal (lowest price) and best sell terminal (highest price) drawn from live per-terminal prices. This makes one extra request per commodity, so it is slower.

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

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

## Actor input object example

```json
{
  "includeTerminalPrices": false,
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/uex-star-citizen-commodities-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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "UEX Star Citizen Commodities Scraper",
        "description": "Pull the full UEXcorp commodity economy for Star Citizen with names, codes, kinds, SCU weight, and live buy and sell prices. Filter by commodity kind and enrich each entry with its best buy and sell terminals. Built for trade route planning and in game market tracking.",
        "version": "0.1",
        "x-build-id": "j5PfsbDkurEdnP1X2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~uex-star-citizen-commodities-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-uex-star-citizen-commodities-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~uex-star-citizen-commodities-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-uex-star-citizen-commodities-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~uex-star-citizen-commodities-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-uex-star-citizen-commodities-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": {
                    "kind": {
                        "title": "Commodity kind",
                        "type": "string",
                        "description": "Optional filter. Only return commodities whose kind matches this text (case insensitive, partial match allowed), for example 'Metal', 'Gas', 'Drug' or 'Agricultural'. Leave empty to return every commodity kind."
                    },
                    "includeTerminalPrices": {
                        "title": "Include best trading terminals",
                        "type": "boolean",
                        "description": "When enabled, each commodity is enriched with its best buy terminal (lowest price) and best sell terminal (highest price) drawn from live per-terminal prices. This makes one extra request per commodity, so it is slower.",
                        "default": false
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```