# Polymarket Scraper: Track Prediction Markets by Category (`scrapemint/polymarket-market-monitor`) Actor

Scrape Polymarket prediction markets by category, keyword, min volume, liquidity, and price move. Returns deduped JSON with question, outcomes, prices, 24h volume, and end date. Uses the official Polymarket Gamma API.

- **URL**: https://apify.com/scrapemint/polymarket-market-monitor.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** Automation, Developer tools, News
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Polymarket Scraper: Track Prediction Markets by Category, Keyword, and Volume

Scrape Polymarket prediction markets by category (politics, crypto, sports, tech), keyword, 24h volume, liquidity, and price move. Every market and its outcome prices lands in your Apify dataset as a clean JSON row. Deduped across runs. Official Polymarket Gamma API. Pay per item.

**Searches this actor ranks for:** Polymarket scraper, Polymarket API, Polymarket data feed, prediction market tracker, Polymarket price alert, Polymarket odds monitor, Polymarket volume scanner, prediction market JSON feed.

---

### How it works in 30 seconds

```mermaid
flowchart LR
    A[Category or<br/>keyword] --> B[Polymarket Gamma API]
    B --> C[Filter: volume,<br/>liquidity, price move]
    C --> D[Deduped JSON<br/>one row per market]
    D --> E[Webhook or<br/>trading bot]
````

Pick a category or keyword. Set a volume or liquidity floor. Get a clean JSON row for every matching Polymarket market, outcome prices included.

***

### Who this Polymarket scraper is for

| You are a... | You use this to... |
|---|---|
| **Prediction market trader** | Catch new markets in your category before volume piles in and the edge disappears. |
| **Crypto quant** | Feed Polymarket odds into a model alongside CEX prices, or build an arb scanner vs Kalshi. |
| **Election analyst** | Track every political market, price move, and volume surge in one deduped JSON stream. |
| **Journalist** | Quote the crowd on breaking news. Every price is a number you can cite. |
| **Fintech builder** | Back a prediction market widget with clean API data, zero licensing fee. |

***

### How to scrape Polymarket

```mermaid
flowchart TD
    A[Category or tag ID] --> B[Gamma markets API]
    B --> C[Apply filters<br/>volume, liquidity, keyword]
    C --> D[Push to dataset<br/>dedupe by market ID]
```

1. Pass a category shortcut (`politics`, `crypto`, `sports`, `tech`) or a raw tag ID.
2. The actor calls `gamma-api.polymarket.com/markets` with the tag, volume floor, and sort.
3. Client side filters apply: keyword, 24h volume, liquidity, price change, time to resolution.
4. Matches push to the dataset with outcome prices, volume, liquidity, and direct URL.

Schedule every 5 minutes for near real time price tracking. Set `dedupe: false` for fresh snapshots every run.

***

### Quick start

**Active political markets with over $10k daily volume:**

```json
{
  "categories": ["politics"],
  "minVolume24h": 10000,
  "sortBy": "volume24hr"
}
```

**Trump related markets across every category:**

```json
{
  "searchQueries": ["trump"],
  "minLiquidity": 5000
}
```

**Markets moving 10+ points in the last week:**

```json
{
  "categories": ["politics", "crypto"],
  "minPriceChangePct": 10,
  "minVolume24h": 5000,
  "dedupe": false
}
```

From the command line:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~polymarket-market-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["politics"],"minVolume24h":10000}'
```

***

### Category shortcuts

| Shortcut | Polymarket tag |
|---|---|
| `politics` | Politics |
| `crypto` | Crypto |
| `sports` | Sports |
| `tech` | Technology |
| `elections` | USA Election |
| `music` | Music |
| `basketball` | Basketball |
| `football` | Football |

Need another tag? Pass the raw ID in `tagIds`. Browse all tags at `gamma-api.polymarket.com/tags`.

***

### Polymarket scraper vs the alternatives

| | Polymarket web UI | Dune dashboards | **This actor** |
|---|---|---|---|
| Pricing | Free, manual | Free to $420 / mo | Pay per item, first 50 free |
| Keyword filter | No | SQL only | Yes |
| Price move alert | No | You build it | Built in |
| Schedule | N/A | Daily refresh | Every 1 minute |
| Output | Browser | Dashboard | JSON, CSV, Excel, webhook |

***

### Sample output

```json
{
  "kind": "market",
  "id": "540816",
  "slug": "will-trump-win-the-2028-election",
  "question": "Will Trump win the 2028 election?",
  "url": "https://polymarket.com/market/will-trump-win-the-2028-election",
  "outcomes": [
    { "name": "Yes", "price": 0.12 },
    { "name": "No", "price": 0.88 }
  ],
  "lastTradePrice": 0.12,
  "bestBid": 0.12,
  "bestAsk": 0.13,
  "volume24hr": 42815.23,
  "volumeTotal": 1250412.88,
  "liquidity": 88431.12,
  "oneWeekPriceChange": -0.03,
  "endDate": "2028-11-07T12:00:00Z",
  "active": true
}
```

Every field drops into a trading bot, Google Sheet, Slack channel, or Notion database.

***

### Pricing

First 50 items per run are free. After that you pay per extracted market. A 200 market snapshot lands well under $1.

***

### FAQ

**Does Polymarket have a public API?**
Yes. The Gamma API at `gamma-api.polymarket.com` is public and requires no authentication for reads. This actor wraps the `/markets` and `/events` endpoints with pagination, client side filters, and dedup.

**What is the difference between a market and an event?**
A **market** is one question with binary or categorical outcomes (e.g., "Will Trump win 2028?" Yes/No). An **event** is a group of related markets under one theme (e.g., "2028 US Presidential Election" grouping 20+ candidate markets). Set `itemType` to `markets` or `events`.

**Can I track price moves over time?**
Yes. Set `dedupe: false` and schedule every few minutes. You get a fresh snapshot per run with `lastTradePrice`, `bestBid`, `bestAsk`, and `oneWeekPriceChange`. Feed that into a time series store.

**How do I filter for liquid markets only?**
Set `minLiquidity: 5000` and `minVolume24h: 1000`. This drops thin markets with no resting size or dead order flow.

**How do I monitor a candidate or topic?**
Use `searchQueries` with terms like `trump`, `bitcoin`, `fed`, `super bowl`. The actor matches the question and description. Combine with `categories` to narrow.

**How fast is it after a new market lists?**
Gamma indexes new markets within seconds. Schedule every 1 to 5 minutes and you catch listings near real time.

**Is scraping Polymarket allowed?**
Yes. The Gamma API is public and designed for programmatic read access. This actor uses the official endpoints. No headless browser, no HTML scraping.

***

### Related Scrapemint actors

- **SEC Form 4 Insider Trading Tracker** for every insider buy and sell
- **SEC 8-K Event Tracker** for earnings, exec changes, and M\&A filings
- **GitHub Issue Monitor** for devtool category mentions and bug reports
- **Stack Overflow Lead Monitor** for dev question tracking by tag
- **Hacker News Scraper** for stories and comments by keyword
- **Reddit Lead Monitor** for subreddit and brand mention tracking
- **Product Hunt Launch Tracker** for competitor launch monitoring

Stack these to cover every public financial, prediction, and developer signal surface one desk touches.

# Actor input Schema

## `searchQueries` (type: `array`):

Only keep markets whose question or description contains any of these keywords. Case insensitive. Leave empty to keep everything the API returned.

## `categories` (type: `array`):

Shortcut for top level Polymarket categories. Options: politics, crypto, sports, technology, music, entertainment, elections, basketball, football, blockchain. Internally resolves to tag IDs. Combine with tagIds below.

## `tagIds` (type: `array`):

Raw Polymarket tag IDs if you need a tag outside the category shortcuts. Example: 180 for Israel, 169 for Javier Milei. Browse tags at gamma-api.polymarket.com/tags.

## `itemType` (type: `string`):

Markets returns one row per individual market (question + outcomes). Events returns one row per event group (a basket of related markets, like 'Who will win the 2028 election').

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

Active is the default. Closed returns resolved markets. All returns both.

## `minVolume24h` (type: `integer`):

Drop markets with less than this much volume in the last 24 hours. Useful when you only want liquid, actively traded markets.

## `minLiquidity` (type: `integer`):

Drop markets with less than this much resting liquidity on the CLOB. Filters thin books.

## `minTotalVolume` (type: `integer`):

Drop markets with less than this much lifetime traded volume. Filters toy markets.

## `minPriceChangePct` (type: `integer`):

Only keep markets whose 1 week or 1 month price has moved by at least this many percentage points (absolute value). Set to 0 to disable. Example: 10 returns only markets that moved 10+ points. Applies to markets, not events.

## `minutesUntilEnd` (type: `integer`):

Drop markets ending sooner than this many minutes from now. Set to 0 to keep everything. Useful to exclude markets too close to resolution for your strategy.

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

Sort markets before filtering. volume24hr ranks by last 24 hours traded. liquidity ranks by depth. endDate ranks by closest to resolution. startDate returns newest first.

## `maxItemsPerSource` (type: `integer`):

Per tag cap on items processed. Polymarket Gamma returns up to 100 per page; the actor paginates.

## `maxItemsTotal` (type: `integer`):

Hard cap on items pushed to the dataset per run. Controls total cost.

## `dedupe` (type: `boolean`):

Skip market IDs pushed on previous runs. Stored in the key value store under SEEN\_IDS. Turn off to snapshot every run, useful when tracking price moves over time.

## `proxyConfiguration` (type: `object`):

Apify proxy settings. The Polymarket Gamma API is public and does not IP rate limit aggressively, so proxy is rarely needed.

## Actor input object example

```json
{
  "searchQueries": [
    "trump"
  ],
  "categories": [],
  "tagIds": [],
  "itemType": "markets",
  "status": "active",
  "minVolume24h": 0,
  "minLiquidity": 0,
  "minTotalVolume": 0,
  "minPriceChangePct": 0,
  "minutesUntilEnd": 0,
  "sortBy": "volume24hr",
  "maxItemsPerSource": 100,
  "maxItemsTotal": 200,
  "dedupe": true
}
```

# 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 = {
    "searchQueries": [
        "trump"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/polymarket-market-monitor").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 = { "searchQueries": ["trump"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/polymarket-market-monitor").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 '{
  "searchQueries": [
    "trump"
  ]
}' |
apify call scrapemint/polymarket-market-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket Scraper: Track Prediction Markets by Category",
        "description": "Scrape Polymarket prediction markets by category, keyword, min volume, liquidity, and price move. Returns deduped JSON with question, outcomes, prices, 24h volume, and end date. Uses the official Polymarket Gamma API.",
        "version": "0.1",
        "x-build-id": "rqLcB1dzb78HrRajk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~polymarket-market-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-polymarket-market-monitor",
                "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/scrapemint~polymarket-market-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-polymarket-market-monitor",
                "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/scrapemint~polymarket-market-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-polymarket-market-monitor",
                "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": {
                    "searchQueries": {
                        "title": "Keyword search (title or description)",
                        "type": "array",
                        "description": "Only keep markets whose question or description contains any of these keywords. Case insensitive. Leave empty to keep everything the API returned.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category shortcut",
                        "type": "array",
                        "description": "Shortcut for top level Polymarket categories. Options: politics, crypto, sports, technology, music, entertainment, elections, basketball, football, blockchain. Internally resolves to tag IDs. Combine with tagIds below.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tagIds": {
                        "title": "Tag IDs (advanced)",
                        "type": "array",
                        "description": "Raw Polymarket tag IDs if you need a tag outside the category shortcuts. Example: 180 for Israel, 169 for Javier Milei. Browse tags at gamma-api.polymarket.com/tags.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemType": {
                        "title": "Item type",
                        "enum": [
                            "markets",
                            "events"
                        ],
                        "type": "string",
                        "description": "Markets returns one row per individual market (question + outcomes). Events returns one row per event group (a basket of related markets, like 'Who will win the 2028 election').",
                        "default": "markets"
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "active",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Active is the default. Closed returns resolved markets. All returns both.",
                        "default": "active"
                    },
                    "minVolume24h": {
                        "title": "Minimum 24h volume (USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop markets with less than this much volume in the last 24 hours. Useful when you only want liquid, actively traded markets.",
                        "default": 0
                    },
                    "minLiquidity": {
                        "title": "Minimum liquidity (USD)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop markets with less than this much resting liquidity on the CLOB. Filters thin books.",
                        "default": 0
                    },
                    "minTotalVolume": {
                        "title": "Minimum total volume (USD)",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "integer",
                        "description": "Drop markets with less than this much lifetime traded volume. Filters toy markets.",
                        "default": 0
                    },
                    "minPriceChangePct": {
                        "title": "Minimum price move (%)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only keep markets whose 1 week or 1 month price has moved by at least this many percentage points (absolute value). Set to 0 to disable. Example: 10 returns only markets that moved 10+ points. Applies to markets, not events.",
                        "default": 0
                    },
                    "minutesUntilEnd": {
                        "title": "Minimum minutes until end",
                        "minimum": 0,
                        "maximum": 525600,
                        "type": "integer",
                        "description": "Drop markets ending sooner than this many minutes from now. Set to 0 to keep everything. Useful to exclude markets too close to resolution for your strategy.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort",
                        "enum": [
                            "volume24hr",
                            "liquidity",
                            "endDate",
                            "startDate",
                            "volumeNum"
                        ],
                        "type": "string",
                        "description": "Sort markets before filtering. volume24hr ranks by last 24 hours traded. liquidity ranks by depth. endDate ranks by closest to resolution. startDate returns newest first.",
                        "default": "volume24hr"
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per tag or run",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Per tag cap on items processed. Polymarket Gamma returns up to 100 per page; the actor paginates.",
                        "default": 100
                    },
                    "maxItemsTotal": {
                        "title": "Maximum items per run",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on items pushed to the dataset per run. Controls total cost.",
                        "default": 200
                    },
                    "dedupe": {
                        "title": "Deduplicate across runs",
                        "type": "boolean",
                        "description": "Skip market IDs pushed on previous runs. Stored in the key value store under SEEN_IDS. Turn off to snapshot every run, useful when tracking price moves over time.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. The Polymarket Gamma API is public and does not IP rate limit aggressively, so proxy is rarely needed."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
