# Guild Wars 2 Items Prices Scraper (`parseforge/guild-wars-2-items-prices-scraper`) Actor

Track the Guild Wars 2 economy by pulling item icons, names, types, rarity, and live Trading Post buy and sell prices from the official GW2 API. Each row carries open order quantities and a precomputed margin. Handy for flipping, price tracking, or community tools.

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

## Pricing

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

## ⚔️ Guild Wars 2 Items & Trading Post Prices Scraper

> 🚀 **Export Guild Wars 2 item data with live Trading Post prices in seconds.** Pull from a catalog of 27,966 tradeable items, each joined to its current buy and sell orders.

> 🕒 **Last updated:** 2026-06-04 · **📊 15 fields** per record · 27,966 tradeable items · Official GW2 API v2

Track the Guild Wars 2 economy without copying numbers by hand. This Actor reads the official Guild Wars 2 API v2, joins item metadata with live Trading Post buy and sell orders, and returns clean, ready to use rows. Every record carries the item icon, name, type, rarity, level, vendor value, current buy and sell prices in copper, the open order quantities on both sides, and a precomputed margin.

**Coverage:** the Trading Post id list currently exposes 27,966 tradeable items. You can list the first items automatically, or pass an exact set of item IDs. Names and descriptions are available in English, Spanish, German, French, and Chinese.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| GW2 traders and flippers | Spotting buy and sell spreads |
| Market analysts and data hobbyists | Tracking item prices over time |
| Guild and community tool builders | Powering price widgets and bots |
| Gaming researchers | Studying a live virtual economy |

### 📋 What the Guild Wars 2 Items & Prices Scraper does

- Resolves a set of tradeable item IDs from the official Trading Post endpoint, or accepts your explicit `itemIds`.
- Fetches item metadata and live commerce prices in batches of up to 200 IDs per call.
- Joins both responses by item ID into a single flat row.
- Computes a `margin` field (sell price minus buy price) so you can scan spreads at a glance.
- Returns the item icon as the first field, ready to render in a table or gallery.
- Lets you keep only items that currently have an open buy or sell order.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `itemIds` | array | Optional list of specific item IDs. Leave empty to auto-list tradeable items. |
| `maxItems` | integer | Free users limited to 10. Paid users up to 1,000,000. |
| `language` | string | Item name and description language (en, es, de, fr, zh). |
| `onlyPriced` | boolean | Keep only items with an open buy or sell order. Default true. |

**Example 1. Auto-list the first priced items:**

```json
{
  "maxItems": 5,
  "language": "en",
  "onlyPriced": true
}
````

**Example 2. Fetch specific items by ID:**

```json
{
  "itemIds": ["24", "19684", "30684"],
  "language": "en",
  "onlyPriced": false
}
```

> ⚠️ **Good to Know:** Prices are reported in copper, the base Guild Wars 2 currency (100 copper = 1 silver, 10,000 copper = 1 gold). Some items have a buy or sell side at 0 when no live order exists on that side. Vendor value can legitimately be 0 for many items.

### 📊 Output

| Field | Description |
|---|---|
| 🖼 imageUrl | Item icon image URL |
| 🆔 id | Guild Wars 2 item ID |
| 📌 name | Item name |
| 🏷 type | Item type (Consumable, Armor, Weapon, etc.) |
| 💎 rarity | Rarity tier (Basic to Legendary) |
| 🎚 level | Required character level |
| 🏪 vendorValue | Vendor sell value in copper |
| 🟢 buyPrice | Highest Trading Post buy order in copper |
| 📥 buyQuantity | Quantity wanted at the buy price |
| 🔴 sellPrice | Lowest Trading Post sell order in copper |
| 📤 sellQuantity | Quantity offered at the sell price |
| 📈 margin | Sell price minus buy price in copper |
| 📝 description | Item description (when available) |
| 🕒 scrapedAt | ISO timestamp of collection |
| ❌ error | Error message, null on success |

**Real sample records:**

```json
{
  "imageUrl": "https://render.guildwars2.com/file/1D05D1EE04E16E69710E1EAB11AC466BBF105778/219347.png",
  "id": 24,
  "name": "Sealed Package of Snowballs",
  "type": "Consumable",
  "rarity": "Basic",
  "level": 0,
  "vendorValue": 0,
  "buyPrice": 116,
  "buyQuantity": 123940,
  "sellPrice": 189,
  "sellQuantity": 282044,
  "margin": 73,
  "description": "Open this package to create several snowballs that can hit anyone else holding a snowball.",
  "scrapedAt": "2026-06-04T19:55:39.555Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://render.guildwars2.com/file/F03808FFE89B40044671EED2E427053B389BE0A1/61007.png",
  "id": 68,
  "name": "Mighty Country Coat",
  "type": "Armor",
  "rarity": "Basic",
  "level": 0,
  "vendorValue": 6,
  "buyPrice": 12,
  "buyQuantity": 169,
  "sellPrice": 42,
  "sellQuantity": 586,
  "margin": 30,
  "description": "",
  "scrapedAt": "2026-06-04T19:55:39.617Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://render.guildwars2.com/file/F03808FFE89B40044671EED2E427053B389BE0A1/61007.png",
  "id": 69,
  "name": "Mighty Country Coat",
  "type": "Armor",
  "rarity": "Basic",
  "level": 0,
  "vendorValue": 7,
  "buyPrice": 21,
  "buyQuantity": 901,
  "sellPrice": 49,
  "sellQuantity": 517,
  "margin": 28,
  "description": "",
  "scrapedAt": "2026-06-04T19:55:39.649Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Official source.** Reads the public Guild Wars 2 API v2 directly, no key required for these endpoints.
- **Joined in one pass.** Item metadata and live prices arrive together in a single row.
- **Margin ready.** The spread between buy and sell is computed for you.
- **Icon first.** Every record leads with the item image for instant visual scanning.
- **Multilingual.** Pull names and descriptions in five languages.

### 📈 How it compares to alternatives

| Approach | Item metadata | Live Trading Post prices | Margin precomputed | Icon included |
|---|---|---|---|---|
| This Actor | Yes | Yes | Yes | Yes |
| Manual API calls | Yes | Yes | No | No |
| Copying from in-game UI | Partial | Yes | No | No |
| Third party wiki scrape | Yes | Often stale | No | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) if you do not have one yet.
2. Open the Guild Wars 2 Items & Prices Scraper in the Apify Console.
3. Leave the input empty for an auto-listed sample, or add specific `itemIds`.
4. Click **Start** and watch the run collect items with their prices.
5. Download the results from the dataset or pull them through the API.

### 💼 Business use cases

#### Market making and flipping

| Goal | How this Actor helps |
|---|---|
| Find profitable spreads | Scan the `margin` field across many items |
| Size an order | Read `buyQuantity` and `sellQuantity` for depth |

#### Price monitoring

| Goal | How this Actor helps |
|---|---|
| Track an item over time | Re-run on a schedule and store snapshots |
| Alert on a threshold | Pipe `buyPrice` or `sellPrice` into your own logic |

#### Community tools

| Goal | How this Actor helps |
|---|---|
| Power a price widget | Use `imageUrl`, `name`, and prices directly |
| Feed a Discord bot | Query specific `itemIds` on demand |

#### Research

| Goal | How this Actor helps |
|---|---|
| Study a virtual economy | Collect broad item and price samples |
| Compare rarity to price | Join `rarity` and `sellPrice` for analysis |

### 🔌 Automating Guild Wars 2 Items & Prices Scraper

Connect runs to the tools your team already uses:

- **Make** and **Zapier** to trigger runs and route results.
- **Slack** to post price alerts to a channel.
- **Airbyte** to load datasets into a warehouse.
- **GitHub Actions** to schedule scheduled collections.
- **Google Drive** to archive snapshots automatically.

### 🌟 Beyond business use cases

- **Research:** sample a live in-game economy for coursework or articles.
- **Personal:** keep an eye on the items you trade most.
- **Non-profit:** power a free community price tracker.
- **Experimentation:** prototype a trading model on real data.

### 🤖 Ask an AI assistant

Paste a dataset into your favorite assistant and ask it to summarize trends:

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

### ❓ Frequently Asked Questions

**Do I need a Guild Wars 2 API key?**
No. The item and commerce price endpoints used here are public and keyless.

**What currency are prices in?**
Copper. 100 copper equals 1 silver, and 10,000 copper equals 1 gold.

**Why is a buy or sell price sometimes 0?**
That side of the market had no open order at scrape time. The value 0 is real, not missing data.

**Why is vendorValue 0 on some items?**
Many items genuinely have no vendor sell value. The API returns 0 for them.

**Can I scrape specific items?**
Yes. Provide their IDs in the `itemIds` field.

**How many items can I pull?**
Free accounts return up to 10 items. Paid accounts can return up to 1,000,000.

**How fresh are the prices?**
They reflect the Trading Post at the moment of the run. Re-run to refresh.

**Which languages are supported?**
English, Spanish, German, French, and Chinese for names and descriptions.

**Can I keep only items that are actively traded?**
Yes. Leave `onlyPriced` enabled to drop items with no open orders.

**What does the margin field mean?**
It is the sell price minus the buy price in copper, a quick read on the spread.

**Is this affiliated with ArenaNet?**
No. It is an independent tool that reads the publicly documented Guild Wars 2 API.

**How do I track prices over time?**
Schedule recurring runs and store each dataset as a snapshot.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API, webhooks, or any of the integrations above. Wire it into spreadsheets, dashboards, bots, or your own backend.

### 🔗 Recommended Actors

- [Steam Store Scraper](https://apify.com/parseforge/steam-store-scraper)
- [GiantBomb Games Scraper](https://apify.com/parseforge/giantbomb-games-scraper)
- [OpenCritic Games Scraper](https://apify.com/parseforge/opencritic-games-scraper)
- [Rebrickable LEGO Scraper](https://apify.com/parseforge/rebrickable-lego-scraper)
- [Valorant Game Content Scraper](https://apify.com/parseforge/valorant-game-content-scraper)

> 💡 **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 Guild Wars 2 or ArenaNet. Only publicly available data is collected.

# Actor input Schema

## `itemIds` (type: `array`):

Optional list of specific Guild Wars 2 item IDs to fetch (for example 24, 19684, 30684). Leave empty to list the first tradeable items from the Trading Post automatically.

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

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

## `language` (type: `string`):

Language for item names and descriptions.

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

When enabled, only return items that currently have a buy or sell order on the Trading Post.

## Actor input object example

```json
{
  "itemIds": [],
  "maxItems": 10,
  "language": "en",
  "onlyPriced": true
}
```

# 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 = {
    "itemIds": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/guild-wars-2-items-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 = {
    "itemIds": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/guild-wars-2-items-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 '{
  "itemIds": [],
  "maxItems": 10
}' |
apify call parseforge/guild-wars-2-items-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Guild Wars 2 Items Prices Scraper",
        "description": "Track the Guild Wars 2 economy by pulling item icons, names, types, rarity, and live Trading Post buy and sell prices from the official GW2 API. Each row carries open order quantities and a precomputed margin. Handy for flipping, price tracking, or community tools.",
        "version": "0.1",
        "x-build-id": "qsLvzZpyj97O7frhs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~guild-wars-2-items-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-guild-wars-2-items-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~guild-wars-2-items-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-guild-wars-2-items-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~guild-wars-2-items-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-guild-wars-2-items-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": {
                    "itemIds": {
                        "title": "Item IDs",
                        "type": "array",
                        "description": "Optional list of specific Guild Wars 2 item IDs to fetch (for example 24, 19684, 30684). Leave empty to list the first tradeable items from the Trading Post automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "de",
                            "fr",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Language for item names and descriptions.",
                        "default": "en"
                    },
                    "onlyPriced": {
                        "title": "Only items with prices",
                        "type": "boolean",
                        "description": "When enabled, only return items that currently have a buy or sell order on the Trading Post.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```