# Polymarket + Kalshi Arbitrage Finder (`maximedupre/prediction-market-arbitrage-finder`) Actor

Compare public Polymarket and Kalshi binary markets. Get ranked theoretical arbitrage opportunities with prices, opposing legs, liquidity, match confidence, and direct market links.

- **URL**: https://apify.com/maximedupre/prediction-market-arbitrage-finder.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.80 / 1,000 arbitrage opportunities

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### 🔎 Compare Polymarket and Kalshi opportunities

Built for prediction-market researchers, traders, and analysts, this Actor compares likely equivalent public binary markets on Polymarket and Kalshi. It returns ranked theoretical arbitrage opportunities with observed prices, opposing YES/NO legs, estimated economics, liquidity, volume, match evidence, warnings, and direct market links—without marketplace API keys or trading-account credentials.

Use it to:

- **[Prediction market arbitrage finder](https://apify.com/maximedupre/prediction-market-arbitrage-finder/examples/prediction-market-arbitrage-finder)** — scan current public markets for positive theoretical cross-venue opportunities.
- **[Polymarket Kalshi arbitrage](https://apify.com/maximedupre/prediction-market-arbitrage-finder/examples/polymarket-kalshi-arbitrage)** — compare likely equivalent contracts across both venues in one run.
- **[Prediction market price comparison](https://apify.com/maximedupre/prediction-market-arbitrage-finder/examples/prediction-market-price-comparison)** — review observed YES/NO prices, spread, and total opposing-leg cost.
- **[Cross-platform prediction market arbitrage](https://apify.com/maximedupre/prediction-market-arbitrage-finder/examples/cross-platform-prediction-market-arbitrage)** — rank opportunities by estimated return after applying quality thresholds.
- **[Prediction market opportunity scanner](https://apify.com/maximedupre/prediction-market-arbitrage-finder/examples/prediction-market-opportunity-scanner)** — schedule fresh scans and send qualifying opportunities into downstream workflows.

#### 📊 What data does the Actor return?

Each qualifying dataset row includes:

- `opportunityId` — identity for the matched pair and recommended direction
- `polymarket` and `kalshi` — market IDs, questions, direct URLs, observed YES/NO prices, and nullable close time, liquidity, recent volume, and resolution summary
- `legs` — exactly two opposing contracts, each with its venue, `YES` or `NO` outcome, and observed price
- `totalCost`, `profitPerPayout`, `rawReturn`, and `priceSpread` — unadjusted theoretical economics from observed prices
- `estimatedProfitPerPayout` and `estimatedReturn` — net estimates after your fee and slippage assumptions
- `match` — confidence score, supporting reasons, and review warnings
- `observedAt` — when the estimate's prices and context were observed

Rows are ranked by estimated return. The Actor evaluates both cross-venue directions and keeps only positive theoretical opportunities that pass your filters. Nullable source fields remain `null` when a venue does not expose them.

#### 🚀 How to run the Actor

1. Open the Actor in Apify Console.
2. Adjust the opportunity and market-quality filters, or keep the defaults.
3. Click **Start**.
4. Review the linked contracts and warnings in the default dataset before making any decision.

A run scans one configuration. Run separate scans when you need different filter sets.

#### 🎛️ Input

```json
{
  "minPriceSpread": 2,
  "minEstimatedReturn": 2,
  "minMatchConfidence": 80,
  "minLiquidity": 1000,
  "minRecentVolume": 500,
  "feePercent": 0.5,
  "slippagePercent": 0.5,
  "maxResults": 25
}
````

| Field | Meaning |
|---|---|
| `minPriceSpread` | Minimum opposing-leg edge in percentage points, from 0 to 100 |
| `minEstimatedReturn` | Minimum theoretical return on total opposing-leg cost, as a percentage |
| `minMatchConfidence` | Minimum market-equivalence confidence from 0 to 100 |
| `minLiquidity` | Minimum source-reported USD liquidity on each venue; `0` allows any reported amount |
| `minRecentVolume` | Minimum source-reported recent USD volume on each venue; `0` allows any reported amount |
| `feePercent` | Conservative combined fees as a percentage of opposing-leg cost; raw economics remain available |
| `slippagePercent` | Conservative combined adverse slippage as a percentage of opposing-leg cost |
| `maxResults` | Maximum ranked opportunities to return, from 1 to 5,000 |

When a liquidity or volume threshold is above zero, a market with no reported value cannot pass that filter.

#### 📦 Output

A shortened example of one conforming dataset item:

```json
{
  "opportunityId": "123456__KXPRESELECT-28-A__polymarket-yes",
  "polymarket": {
    "marketId": "123456",
    "question": "Will Candidate A win the 2028 election?",
    "url": "https://polymarket.com/event/example-market",
    "yesPrice": 0.47,
    "noPrice": 0.53,
    "closeTime": "2028-11-08T00:00:00Z",
    "liquidityUsd": 125000.5,
    "recentVolumeUsd": 48500,
    "resolutionSummary": "Resolves Yes if Candidate A is declared the winner."
  },
  "kalshi": {
    "marketId": "KXPRESELECT-28-A",
    "question": "Will Candidate A win the 2028 presidential election?",
    "url": "https://kalshi.com/markets/kxpreselect",
    "yesPrice": 0.55,
    "noPrice": 0.45,
    "closeTime": "2028-11-08T00:00:00Z",
    "liquidityUsd": 98000,
    "recentVolumeUsd": 32200,
    "resolutionSummary": "Resolves Yes if Candidate A wins the election."
  },
  "legs": [
    { "venue": "polymarket", "outcome": "YES", "price": 0.47 },
    { "venue": "kalshi", "outcome": "NO", "price": 0.45 }
  ],
  "totalCost": 0.92,
  "profitPerPayout": 0.08,
  "rawReturn": 8.695652,
  "priceSpread": 8,
  "estimatedProfitPerPayout": 0.0708,
  "estimatedReturn": 7.695652,
  "match": {
    "confidence": 91,
    "reasons": ["Questions identify the same candidate and election", "Close times align"],
    "warnings": ["Review each venue's resolution rules before acting"]
  },
  "observedAt": "2026-07-17T14:30:00Z"
}
```

Export results as JSON, CSV, Excel, XML, or RSS from the Apify dataset, or retrieve them through the dataset API.

#### 💳 Pricing

The Actor uses pay-per-event pricing. You are charged **$0.0018 for each successful visible arbitrage opportunity written to the default dataset**. A successful scan with no qualifying opportunities returns an empty dataset and has no opportunity charge. Platform usage charges may still apply according to your Apify plan.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

Use Apify's API, schedules, webhooks, dataset exports, and integrations with spreadsheets or automation tools. The Actor identifies opportunities but does not place trades, access private accounts, manage portfolios, or maintain change-only monitoring state between runs.

#### ❓ FAQ

##### Why can a high-return opportunity still be risky?

The calculations use observed source prices and do not guarantee simultaneous fills. Fees, slippage, market movement, trading restrictions, and fill timing can reduce or eliminate an apparent edge.

##### Does a high match-confidence score prove the contracts are identical?

No. Confidence, reasons, timing evidence, and warnings help screen likely matches, but they are not an authoritative determination that resolution rules are legally or economically identical. Inspect both linked contracts before acting.

##### Why did my run return no rows?

There may be no positive theoretical opportunity that meets every configured spread, return, confidence, liquidity, and volume threshold. A missing source-reported liquidity or volume value also fails a nonzero threshold. An empty successful scan is valid and has no opportunity charge.

##### Does the Actor need Polymarket or Kalshi credentials?

No. It reads public market data and does not require marketplace API keys, wallets, or trading-account credentials.

##### Does the Actor cover every prediction-market venue?

No. Its cross-venue comparison is limited to public Polymarket and Kalshi binary markets that can be paired with enough evidence for evaluation.

##### Is this financial advice or an automated trading bot?

No. The output is research data, not financial advice, executable profit, or a guarantee. The Actor never executes trades or holds funds.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~prediction-market-arbitrage-finder/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Stocktwits Scraper](https://apify.com/maximedupre/stocktwits-scraper) — collect public ticker messages, source sentiment, and trending symbols for adjacent market research.
- [Crypto Fear and Greed Index Scraper](https://apify.com/maximedupre/crypto-fear-and-greed-index-scraper) — add current or historical crypto sentiment context to research workflows.
- [FEC Campaign Finance Scraper](https://apify.com/maximedupre/fec-campaign-finance-scraper) — inspect source-backed candidate, committee, contribution, and spending data when researching political markets.
- [Polymarket Market Monitor + Whale & Arbitrage Signals](https://apify.com/memo23/polymarket-market-monitor) — monitor Polymarket activity, price changes, and market signals between scans.
- [Polymarket Sports Odds Scanner & Divergence Finder](https://apify.com/bigdavidson/polymarket-sports-odds-divergence) — compare Polymarket sports contracts with sportsbook odds for divergence research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `minPriceSpread` (type: `number`):

Return only opportunities whose opposing-leg price spread is at least this many percentage points.

## `minEstimatedReturn` (type: `number`):

Return only opportunities whose estimated return on total opposing-leg cost meets this percentage after the fee and slippage assumptions below are deducted.

## `maxResults` (type: `integer`):

Return at most this many qualifying opportunities, ranked by estimated return after the fee and slippage assumptions.

## `minMatchConfidence` (type: `integer`):

Return only cross-venue market matches with at least this confidence score. Higher values require stricter likely-equivalence matches but do not prove that resolution rules are identical.

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

Require each matched market to report at least this much available liquidity in USD. Use 0 to allow markets with any reported amount.

## `minRecentVolume` (type: `number`):

Require each matched market to report at least this much recent trading volume in USD. Use 0 to allow markets with any reported amount.

## `feePercent` (type: `number`):

Deduct this conservative percentage of total opposing-leg cost for combined venue and transaction fees when screening and ranking opportunities. Use 0 for unadjusted economics; raw observed-price economics remain in each result.

## `slippagePercent` (type: `number`):

Deduct this conservative percentage of total opposing-leg cost for combined adverse price slippage when screening and ranking opportunities. Use 0 for unadjusted economics.

## Actor input object example

```json
{
  "minPriceSpread": 1,
  "minEstimatedReturn": 1,
  "maxResults": 100,
  "minMatchConfidence": 70,
  "minLiquidity": 0,
  "minRecentVolume": 0,
  "feePercent": 0,
  "slippagePercent": 0
}
```

# Actor output Schema

## `results` (type: `string`):

Qualifying opportunities with observed venue prices, recommended opposing legs, estimated economics, market context, match evidence, warnings, and direct links.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/prediction-market-arbitrage-finder").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/prediction-market-arbitrage-finder").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 '{}' |
apify call maximedupre/prediction-market-arbitrage-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Polymarket + Kalshi Arbitrage Finder",
        "description": "Compare public Polymarket and Kalshi binary markets. Get ranked theoretical arbitrage opportunities with prices, opposing legs, liquidity, match confidence, and direct market links.",
        "version": "0.1",
        "x-build-id": "3yYetFG77cRajF4tc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~prediction-market-arbitrage-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-prediction-market-arbitrage-finder",
                "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/maximedupre~prediction-market-arbitrage-finder/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-prediction-market-arbitrage-finder",
                "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/maximedupre~prediction-market-arbitrage-finder/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-prediction-market-arbitrage-finder",
                "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": {
                    "minPriceSpread": {
                        "title": "Minimum price spread",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Return only opportunities whose opposing-leg price spread is at least this many percentage points.",
                        "default": 1
                    },
                    "minEstimatedReturn": {
                        "title": "Minimum estimated return",
                        "minimum": 0,
                        "type": "number",
                        "description": "Return only opportunities whose estimated return on total opposing-leg cost meets this percentage after the fee and slippage assumptions below are deducted.",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "Maximum opportunities",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Return at most this many qualifying opportunities, ranked by estimated return after the fee and slippage assumptions.",
                        "default": 100
                    },
                    "minMatchConfidence": {
                        "title": "Minimum match confidence",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Return only cross-venue market matches with at least this confidence score. Higher values require stricter likely-equivalence matches but do not prove that resolution rules are identical.",
                        "default": 70
                    },
                    "minLiquidity": {
                        "title": "Minimum liquidity",
                        "minimum": 0,
                        "type": "number",
                        "description": "Require each matched market to report at least this much available liquidity in USD. Use 0 to allow markets with any reported amount.",
                        "default": 0
                    },
                    "minRecentVolume": {
                        "title": "Minimum recent volume",
                        "minimum": 0,
                        "type": "number",
                        "description": "Require each matched market to report at least this much recent trading volume in USD. Use 0 to allow markets with any reported amount.",
                        "default": 0
                    },
                    "feePercent": {
                        "title": "Estimated fees",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Deduct this conservative percentage of total opposing-leg cost for combined venue and transaction fees when screening and ranking opportunities. Use 0 for unadjusted economics; raw observed-price economics remain in each result.",
                        "default": 0
                    },
                    "slippagePercent": {
                        "title": "Estimated slippage",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Deduct this conservative percentage of total opposing-leg cost for combined adverse price slippage when screening and ranking opportunities. Use 0 for unadjusted economics.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
