# OSRS Grand Exchange Prices Scraper (`parseforge/osrs-grand-exchange-prices-scraper`) Actor

Track live Old School RuneScape Grand Exchange prices straight from the RuneScape Wiki. Each item returns its name, members flag, buy limit, insta buy and insta sell prices, and calculated margin. Handy for flipping, building a price bot, or studying the in game economy.

- **URL**: https://apify.com/parseforge/osrs-grand-exchange-prices-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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)

## ⚔️ OSRS Grand Exchange Prices Scraper

> 🚀 **Export live Old School RuneScape market prices in one run.** Pull insta-buy and insta-sell prices for any of 4,500+ tradeable items, joined with full item metadata.

> 🕒 **Last updated:** 2026-06-04 · **📊 15 fields** per record · 4,572 mapped items · 4,400+ priced live every run

Track the Old School RuneScape Grand Exchange the way flippers, merchers, and data nerds actually want it. This Actor reads the RuneScape Wiki real-time prices API, joins live trade prices with each item's metadata, and returns one clean row per item with the buy price, sell price, profit margin, buy limit, and alchemy values already calculated for you.

Coverage spans the entire tradeable game economy. The item mapping carries 4,572 items and roughly 4,400 of them have a recent insta-buy and insta-sell price on any given run, so you can list the whole market, filter to a slice like every dragon item, or look up a single item by name or ID.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| OSRS flippers and merchers | Spot buy and sell margins across the market |
| Bot and tool developers | Feed live prices into a Discord bot or web app |
| Spreadsheet and dashboard builders | Build a personal price tracker or watchlist |
| Economy researchers and content creators | Study item value trends and rare item swings |

### 📋 What the OSRS Grand Exchange Prices Scraper does

- Fetches the official item mapping and the latest insta-buy and insta-sell prices, then joins them by item ID.
- Returns 15 fields per item including name, examine text, members flag, buy limit, high and low alchemy, store value, both live prices with timestamps, and a calculated margin.
- Lets you list the whole market, filter by name text or members status, or pull a single item by exact name or numeric ID.
- Sorts listings by alchemy value, margin, insta-buy price, or name, and can skip illiquid items that have no recent price.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `itemName` | string | Look up a single item by exact or partial name, for example `Abyssal whip`. |
| `itemId` | integer | Look up a single item by numeric Grand Exchange ID, for example `4151`. |
| `maxItems` | integer | Cap on returned items. Free plan is limited to 10. |
| `nameFilter` | string | When listing, keep only items whose name contains this text. |
| `membersOnly` | select | `any`, `members`, or `free`. |
| `onlyPriced` | boolean | Skip items with no recent insta-buy and insta-sell price. |
| `sortBy` | select | Order listings by value, margin, insta-buy price, or name. |

Single item by name:

```json
{
    "itemName": "Twisted bow"
}
````

List every dragon item with a live price, highest margin first:

```json
{
    "nameFilter": "dragon",
    "membersOnly": "members",
    "sortBy": "margin",
    "onlyPriced": true,
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** prices are crowd-sourced from real player trades reported to the RuneScape Wiki. Very rare or rarely traded items may show an older timestamp or no recent price. Leave `onlyPriced` on to keep your listing limited to items that are actively trading.

### 📊 Output

| Field | Description |
|---|---|
| 🆔 `id` | Grand Exchange item ID |
| 📌 `name` | Item name |
| 📖 `examine` | In-game examine text |
| 💎 `members` | True if the item is members-only |
| 📦 `buyLimit` | 4-hour Grand Exchange buy limit |
| ✨ `highAlch` | High alchemy value in coins |
| 🔅 `lowAlch` | Low alchemy value in coins |
| 💰 `value` | Base store value in coins |
| 🟢 `instaBuyPrice` | Latest insta-buy price (high) |
| ⏱ `instaBuyTime` | Timestamp of that insta-buy |
| 🔴 `instaSellPrice` | Latest insta-sell price (low) |
| ⏱ `instaSellTime` | Timestamp of that insta-sell |
| 📈 `margin` | Insta-buy minus insta-sell |
| 🕒 `scrapedAt` | When the record was collected |
| ❌ `error` | Error message, or null on success |

Three real sample records from a live run:

```json
{
    "id": 20997,
    "name": "Twisted bow",
    "examine": "A mystical bow carved from the twisted remains of the Great Olm.",
    "members": true,
    "buyLimit": 8,
    "highAlch": 2400000,
    "lowAlch": 1600000,
    "value": 4000000,
    "instaBuyPrice": 1557580190,
    "instaBuyTime": "2026-06-04T19:52:43.000Z",
    "instaSellPrice": 1557580190,
    "instaSellTime": "2026-06-04T19:52:43.000Z",
    "margin": 0,
    "scrapedAt": "2026-06-04T19:55:38.371Z",
    "error": null
}
```

```json
{
    "id": 13190,
    "name": "Old school bond",
    "examine": "This bond can be redeemed for membership.",
    "members": false,
    "buyLimit": 100,
    "highAlch": null,
    "lowAlch": null,
    "value": 2000000,
    "instaBuyPrice": 13962098,
    "instaBuyTime": "2026-06-04T19:55:17.000Z",
    "instaSellPrice": 13010000,
    "instaSellTime": "2026-06-04T19:53:38.000Z",
    "margin": 952098,
    "scrapedAt": "2026-06-04T19:55:38.371Z",
    "error": null
}
```

```json
{
    "id": 11785,
    "name": "Armadyl crossbow",
    "examine": "A weapon originally developed for Armadyl's forces.",
    "members": true,
    "buyLimit": 8,
    "highAlch": 594000,
    "lowAlch": 396000,
    "value": 990000,
    "instaBuyPrice": 32245463,
    "instaBuyTime": "2026-06-04T19:53:44.000Z",
    "instaSellPrice": 32135962,
    "instaSellTime": "2026-06-04T19:52:34.000Z",
    "margin": 109501,
    "scrapedAt": "2026-06-04T19:55:38.371Z",
    "error": null
}
```

### ✨ Why choose this Actor

- **Prices and metadata in one row.** No second lookup to map an ID to a name or buy limit, the join is done for you.
- **Margin already calculated.** Insta-buy minus insta-sell lands in every record so flips jump out at a glance.
- **Whole-market or single-item.** List 4,400+ live items, slice by name or members status, or pull just one item.
- **Honest data.** Built straight on the RuneScape Wiki real-time API with the timestamps it reports, no invented numbers.

### 📈 How it compares to alternatives

| Approach | Live prices | Joined metadata | Margin column | One clean run |
|---|---|---|---|---|
| This Actor | ✅ | ✅ | ✅ | ✅ |
| Calling the raw wiki API yourself | ✅ | ❌ join by hand | ❌ | ❌ stitch two endpoints |
| Manual Grand Exchange website checks | ✅ | partial | ❌ | ❌ |
| Outdated community price sheets | ❌ | partial | ❌ | ✅ |

### 🚀 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 OSRS Grand Exchange Prices Scraper in the Apify Console.
3. Leave the input empty for a curated set of popular items, or set a name, ID, or filter.
4. Click **Start** and wait for the run to finish.
5. Open the dataset to view your items and pull them into your tool of choice.

### 💼 Business use cases

**Flipping and merching**

| Goal | How this helps |
|---|---|
| Find profitable flips | Sort the whole market by margin and skim the top |
| Time a buy | Read the latest insta-buy and insta-sell timestamps |

**Tool and bot development**

| Goal | How this helps |
|---|---|
| Power a Discord price bot | Pull a single item by name on demand |
| Back a price tracker app | List the market and store it on a schedule |

**Content and community**

| Goal | How this helps |
|---|---|
| Report on rare item swings | Track high value items like the Twisted bow |
| Explain the in-game economy | Compare value, alchemy, and live prices side by side |

**Spreadsheets and dashboards**

| Goal | How this helps |
|---|---|
| Maintain a watchlist | Filter by name to a fixed group of items |
| Chart price gaps | Use the margin column as a ready signal |

### 🔌 Automating OSRS Grand Exchange Prices Scraper

Connect this Actor to the tools you already run.

- **Make** and **Zapier** to trigger runs and route items into other apps.
- **Slack** and **Discord** to post price alerts for items you watch.
- **Airbyte** to load items into a warehouse for analysis.
- **GitHub Actions** to run a price pull on a schedule.
- **Google Drive** to archive each run for later comparison.

### 🌟 Beyond business use cases

- **Research:** study how a virtual economy prices scarcity, demand, and supply.
- **Personal:** keep a watchlist of the items you trade most often.
- **Non-profit:** teach data joining and market basics with a dataset learners enjoy.
- **Experimentation:** prototype a margin model or alert bot on free, public data.

### 🤖 Ask an AI assistant

Drop your dataset into an assistant and ask away.

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

Example prompt: "From these OSRS items, list the ten with the highest margin and explain which look like safe flips."

### ❓ Frequently Asked Questions

**Where does the data come from?**
The RuneScape Wiki real-time prices API for Old School RuneScape, which aggregates prices reported from real player trades.

**What do insta-buy and insta-sell mean?**
Insta-buy is the latest high price someone paid to buy instantly, and insta-sell is the latest low price someone accepted to sell instantly. The gap between them is the margin.

**How fresh are the prices?**
Each record carries the exact timestamp the wiki reported for that trade, so you always know how recent a price is.

**Can I get a single item?**
Yes. Set `itemName` to an exact or partial name, or set `itemId` to the numeric Grand Exchange ID.

**How do I list only members items or only free items?**
Use the `membersOnly` field with `members` or `free`. Leave it on `any` for the full market.

**Why is margin sometimes zero?**
When the latest insta-buy and insta-sell prices are equal the margin is zero. This is common for items that traded at one steady price.

**Why are highAlch and lowAlch sometimes empty?**
A few items, such as the Old School bond, have no alchemy value in game, so those fields are empty for them while every price field stays filled.

**Can I sort the results?**
Yes. Sort listings by alchemy value, margin, insta-buy price, or name.

**Does it cover every tradeable item?**
The mapping holds 4,572 items and about 4,400 have a recent live price on a typical run. Keep `onlyPriced` on to list only the actively trading ones.

**Do I need an API key or login for RuneScape?**
No. The source API is public and keyless. You only need your Apify account to run the Actor.

**How many items can I pull?**
Free plans return up to 10 items per run. Paid plans can return far more in a single run.

**Is this affiliated with Jagex or RuneScape?**
No. It is an independent tool that reads publicly available data from the RuneScape Wiki API.

### 🔌 Integrate with any app

Every run lands in an Apify dataset you can pull through the Apify API, share with teammates, or pipe into Make, Zapier, Airbyte, and more. Schedule runs to keep a fresh price feed flowing into your own systems.

### 🔗 Recommended Actors

- [Steam Store Scraper](https://apify.com/parseforge/steam-store-scraper) to track game listings and prices on Steam.
- [GiantBomb Games Scraper](https://apify.com/parseforge/giantbomb-games-scraper) for rich video game metadata.
- [OpenCritic Games Scraper](https://apify.com/parseforge/opencritic-games-scraper) for game review scores and rankings.
- [CoinGecko Scraper](https://apify.com/parseforge/coingecko-scraper) for live cryptocurrency market data.
- [TCGplayer Scraper](https://apify.com/parseforge/tcgplayer-scraper) for trading card prices and listings.

> 💡 **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 RuneScape, Old School RuneScape, or Jagex. Only publicly available data is collected.

# Actor input Schema

## `itemName` (type: `string`):

Look up a single item by its exact or partial name (case insensitive), for example "Abyssal whip". Leave empty to list items.

## `itemId` (type: `integer`):

Look up a single item by its numeric Grand Exchange item ID, for example 4151 for Abyssal whip. Leave empty to list items.

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

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

## `nameFilter` (type: `string`):

When listing items, keep only those whose name contains this text (case insensitive), for example "rune" or "dragon".

## `membersOnly` (type: `string`):

Restrict listed items to members-only items, free-to-play items, or all items.

## `onlyPriced` (type: `boolean`):

When listing items, skip items that have no recent insta-buy and insta-sell price. Keeps the output clean of illiquid items.

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

Order used when listing items before applying the item limit.

## Actor input object example

```json
{
  "maxItems": 10,
  "membersOnly": "any",
  "onlyPriced": true,
  "sortBy": "value"
}
```

# 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/osrs-grand-exchange-prices-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/osrs-grand-exchange-prices-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/osrs-grand-exchange-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OSRS Grand Exchange Prices Scraper",
        "description": "Track live Old School RuneScape Grand Exchange prices straight from the RuneScape Wiki. Each item returns its name, members flag, buy limit, insta buy and insta sell prices, and calculated margin. Handy for flipping, building a price bot, or studying the in game economy.",
        "version": "0.1",
        "x-build-id": "7dpbxa6M9n9sT1Oam"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~osrs-grand-exchange-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-osrs-grand-exchange-prices-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~osrs-grand-exchange-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-osrs-grand-exchange-prices-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~osrs-grand-exchange-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-osrs-grand-exchange-prices-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": {
                    "itemName": {
                        "title": "Item Name",
                        "type": "string",
                        "description": "Look up a single item by its exact or partial name (case insensitive), for example \"Abyssal whip\". Leave empty to list items."
                    },
                    "itemId": {
                        "title": "Item ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Look up a single item by its numeric Grand Exchange item ID, for example 4151 for Abyssal whip. Leave empty to list items."
                    },
                    "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"
                    },
                    "nameFilter": {
                        "title": "Name Filter",
                        "type": "string",
                        "description": "When listing items, keep only those whose name contains this text (case insensitive), for example \"rune\" or \"dragon\"."
                    },
                    "membersOnly": {
                        "title": "Members Filter",
                        "enum": [
                            "any",
                            "members",
                            "free"
                        ],
                        "type": "string",
                        "description": "Restrict listed items to members-only items, free-to-play items, or all items.",
                        "default": "any"
                    },
                    "onlyPriced": {
                        "title": "Only Items With Live Prices",
                        "type": "boolean",
                        "description": "When listing items, skip items that have no recent insta-buy and insta-sell price. Keeps the output clean of illiquid items.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort Listed Items By",
                        "enum": [
                            "value",
                            "margin",
                            "instaBuyPrice",
                            "name"
                        ],
                        "type": "string",
                        "description": "Order used when listing items before applying the item limit.",
                        "default": "value"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
