# Polymarket Markets & Events Scraper (`fetch_cat/polymarket-markets-events-scraper`) Actor

Extract public Polymarket market records with questions, odds, outcomes, volume, liquidity, categories, tags, event context, and closing dates.

- **URL**: https://apify.com/fetch\_cat/polymarket-markets-events-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 item processeds

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Polymarket Markets & Events Scraper

Extract public Polymarket market records with questions, outcomes, odds, volume, liquidity, categories, tags, event context, and closing dates. Export results to CSV, JSON, Excel, API, or Apify integrations for research and monitoring workflows.

### At a glance

- **Primary job**: Collect structured public Polymarket markets and event metadata without wallet login.
- **Input**: Choose market status, topic keyword, category/tag filters, volume/liquidity thresholds, sort order, and result limit.
- **Output**: One dataset row per market with IDs, question, URL, outcomes, prices, volume, liquidity, dates, tags, and event context.
- **Best for**: Prediction-market research, dashboards, alerts, newsletters, quant workflows, and historical market exports.

### Who is it for?

- **Market researchers** comparing prediction-market topics, odds, and liquidity across public Polymarket markets.
- **Data teams and analysts** building dashboards, alerts, or archives from structured market records.
- **Newsletter writers and investors** monitoring high-volume or closing-soon markets for timely story ideas and signals.

### Common workflows

- **Active market monitor**: Schedule runs for high-volume open markets and compare odds, volume, and liquidity over time.
- **Topic research**: Track markets about Bitcoin, elections, AI, sports, companies, or any keyword that appears in public market text.
- **Closing-soon feed**: Sort active markets by closing date to find markets nearing resolution.
- **Resolved market export**: Pull recently closed markets for backtesting, reporting, or research archives.

### Input recipes

Use these recipes before public Store examples are available.

#### Active high-volume markets

```json
{
  "maxItems": 25,
  "status": "active",
  "minVolume": 10000,
  "sortBy": "volume",
  "includeRaw": false
}
````

#### Keyword/topic market watch

```json
{
  "maxItems": 10,
  "status": "active",
  "query": "bitcoin",
  "sortBy": "volume",
  "includeRaw": false
}
```

#### Closing-soon active markets

```json
{
  "maxItems": 25,
  "status": "active",
  "sortBy": "closingSoon",
  "includeRaw": false
}
```

#### Resolved market research

```json
{
  "maxItems": 10,
  "status": "closed",
  "sortBy": "newest",
  "includeRaw": false
}
```

### What data can you extract?

| Field | Description |
| --- | --- |
| `marketId` | Stable Polymarket market ID. |
| `conditionId` | Market condition ID when available. |
| `question` | Market question/title. |
| `slug` | Public market slug. |
| `url` | Public Polymarket market URL. |
| `eventId`, `eventTitle`, `eventSlug` | Event context returned with the market. |
| `active`, `closed`, `status` | Source status flags and derived status. |
| `outcomes` | Outcome labels with parsed prices and token IDs. |
| `outcomePrices` | Numeric outcome prices/probabilities when available. |
| `bestOutcome` | Outcome with the highest parsed price. |
| `volume`, `volume24hr`, `liquidity` | Public market activity metrics. |
| `startDate`, `endDate` | Market timing fields. |
| `category`, `tags` | Category/tag/event classification when exposed. |
| `clobTokenIds` | Public CLOB token IDs for outcomes. |
| `description`, `resolutionSource` | Market rules and resolution-source text when present. |
| `fetchedAt`, `source` | Collection timestamp and source endpoint. |
| `raw` | Original source record when `includeRaw` is enabled. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Maximum markets | `maxItems` | Cap saved rows and control spend. | `25` |
| Market status | `status` | Choose open, closed, or all markets. | `active` |
| Keyword or phrase | `query` | Filter by question, slug, event title, or description text. | `bitcoin` |
| Category or tag | `categoryOrTag` | Match category, tag, event title, or event slug text. | `crypto` |
| Minimum volume | `minVolume` | Keep only markets with at least this total volume. | `10000` |
| Minimum liquidity | `minLiquidity` | Keep only markets with at least this liquidity. | `1000` |
| Sort markets by | `sortBy` | Sort by volume, liquidity, newest, or closing soon. | `volume` |
| Include raw API record | `includeRaw` | Add the original public source record to each row. | `false` |

### Example input

```json
{
  "maxItems": 10,
  "status": "active",
  "query": "bitcoin",
  "sortBy": "volume",
  "includeRaw": false
}
```

### Example output

```json
{
  "marketId": "681147",
  "conditionId": "0x...",
  "question": "Will a new country buy Bitcoin by December 31, 2026?",
  "slug": "will-a-new-country-buy-bitcoin-by-december-31-2026-135",
  "url": "https://polymarket.com/event/will-a-new-country-buy-bitcoin-by-184/will-a-new-country-buy-bitcoin-by-december-31-2026-135",
  "eventId": "...",
  "eventTitle": "Will a new country buy Bitcoin by 2026?",
  "eventSlug": "will-a-new-country-buy-bitcoin-by-184",
  "active": true,
  "closed": false,
  "status": "active",
  "outcomes": [
    { "name": "Yes", "price": 0.12, "tokenId": "..." },
    { "name": "No", "price": 0.88, "tokenId": "..." }
  ],
  "outcomePrices": [0.12, 0.88],
  "bestOutcome": "No",
  "volume": 22677.96938,
  "volume24hr": 145.2,
  "liquidity": 4588.8849,
  "startDate": "2026-01-01T00:00:00Z",
  "endDate": "2026-12-31T12:00:00Z",
  "category": "Crypto",
  "tags": ["Bitcoin", "Crypto"],
  "clobTokenIds": ["...", "..."],
  "description": "Market resolution rules...",
  "resolutionSource": "",
  "fetchedAt": "2026-07-13T09:20:00.000Z",
  "source": "https://gamma-api.polymarket.com/markets"
}
```

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Item processed | Store tier price per saved market row | Each market saved to the dataset. |

Per-market Store discount tiers: Free `$0.00115`, Bronze `$0.001`, Silver `$0.00078`, Gold `$0.0006`, Platinum `$0.0004`, Diamond `$0.00028`.

Start with small limits while validating your filters. Final platform pricing is verified during QA and kept synchronized with the Actor pricing configuration.

### Tips for best results

- **Start focused**: Use `maxItems: 10-25` with a keyword or volume threshold until you confirm the dataset shape.
- **Use status intentionally**: `active` is best for monitoring; `closed` is best for research and backtesting.
- **Use raw records only when needed**: `includeRaw` is helpful for custom parsing but makes exports larger.
- **Expect empty runs for narrow filters**: Very high volume/liquidity thresholds or uncommon keywords can return zero rows; the run still writes diagnostics to `RUN-SUMMARY`.

### API usage

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/polymarket-markets-events-scraper").call({
  maxItems: 10,
  status: "active",
  query: "bitcoin",
  sortBy: "volume",
  includeRaw: false
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/polymarket-markets-events-scraper").call(run_input={
    "maxItems": 10,
    "status": "active",
    "query": "bitcoin",
    "sortBy": "volume",
    "includeRaw": False,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~polymarket-markets-events-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":10,"status":"active","query":"bitcoin","sortBy":"volume","includeRaw":false}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/polymarket-markets-events-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/polymarket-markets-events-scraper"
    }
  }
}
```

Example prompt: "Run Polymarket Markets & Events Scraper for active Bitcoin markets and summarize the highest-volume results."

### Limits and caveats

- **Public data only**: This Actor extracts public market metadata. It does not trade, place orders, scrape private portfolios, or require wallet login.
- **Changing source data**: Odds, volume, liquidity, and market status can change after a run finishes.
- **Narrow filters**: Some keyword/category combinations legitimately return no matching rows.
- **Large exports**: Broader `all` status exports may take longer because the Actor checks both active and closed markets.

### Legality and responsible use

Use this Actor for lawful access to public Polymarket market data. Respect Apify's terms, Polymarket's terms, and applicable laws. Do not use the data for unlawful trading, market manipulation, privacy-invasive profiling, or attempts to bypass access controls.

### Related actors

- [Google Trends Scraper](https://apify.com/fetch_cat/google-trends-scraper)
- [StockTwits Scraper](https://apify.com/fetch_cat/stocktwits-scraper)
- [GitHub Repository Search Scraper](https://apify.com/fetch_cat/github-repository-search-scraper)

### FAQ

#### Does this Actor require a Polymarket account or wallet?

No. It collects public market and event metadata only.

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

Some markets do not expose every optional metric or event field. The Actor returns `null` or an empty array instead of guessing.

#### Does it include live order books or trading actions?

No. V1 is read-only market metadata. Live order book enrichment and trading/order placement are outside this Actor's public-data scope.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and a reproducible public URL or market example.

# Actor input Schema

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

Maximum number of market records to save.

## `status` (type: `string`):

Choose active/open markets, closed/resolved markets, or both.

## `query` (type: `string`):

Optional case-insensitive search across question, slug, event title, and description.

## `categoryOrTag` (type: `string`):

Optional category, tag, event slug, or event title text to match, such as crypto, politics, sports, or elections.

## `minVolume` (type: `number`):

Only keep markets with total volume at or above this value. Leave empty to disable.

## `minLiquidity` (type: `number`):

Only keep markets with liquidity at or above this value. Leave empty to disable.

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

Sort the saved records after filtering.

## `includeRaw` (type: `boolean`):

Append the original Polymarket API record to each dataset item for debugging or custom downstream parsing.

## Actor input object example

```json
{
  "maxItems": 10,
  "status": "active",
  "query": "bitcoin",
  "sortBy": "volume",
  "includeRaw": false
}
```

# Actor output Schema

## `datasetUrl` (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,
    "status": "active",
    "query": "bitcoin",
    "sortBy": "volume",
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/polymarket-markets-events-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,
    "status": "active",
    "query": "bitcoin",
    "sortBy": "volume",
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/polymarket-markets-events-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,
  "status": "active",
  "query": "bitcoin",
  "sortBy": "volume",
  "includeRaw": false
}' |
apify call fetch_cat/polymarket-markets-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket Markets & Events Scraper",
        "description": "Extract public Polymarket market records with questions, odds, outcomes, volume, liquidity, categories, tags, event context, and closing dates.",
        "version": "0.1",
        "x-build-id": "fZzphg2SwX3OwZjoS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~polymarket-markets-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-polymarket-markets-events-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/fetch_cat~polymarket-markets-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-polymarket-markets-events-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/fetch_cat~polymarket-markets-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-polymarket-markets-events-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": {
                    "maxItems": {
                        "title": "Maximum markets",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of market records to save.",
                        "default": 10
                    },
                    "status": {
                        "title": "Market status",
                        "enum": [
                            "active",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose active/open markets, closed/resolved markets, or both.",
                        "default": "active"
                    },
                    "query": {
                        "title": "Keyword or phrase",
                        "type": "string",
                        "description": "Optional case-insensitive search across question, slug, event title, and description."
                    },
                    "categoryOrTag": {
                        "title": "Category or tag",
                        "type": "string",
                        "description": "Optional category, tag, event slug, or event title text to match, such as crypto, politics, sports, or elections."
                    },
                    "minVolume": {
                        "title": "Minimum volume",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only keep markets with total volume at or above this value. Leave empty to disable."
                    },
                    "minLiquidity": {
                        "title": "Minimum liquidity",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only keep markets with liquidity at or above this value. Leave empty to disable."
                    },
                    "sortBy": {
                        "title": "Sort markets by",
                        "enum": [
                            "volume",
                            "liquidity",
                            "newest",
                            "closingSoon"
                        ],
                        "type": "string",
                        "description": "Sort the saved records after filtering.",
                        "default": "volume"
                    },
                    "includeRaw": {
                        "title": "Include raw API record",
                        "type": "boolean",
                        "description": "Append the original Polymarket API record to each dataset item for debugging or custom downstream parsing.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
