# Sports Odds Arbitrage Finder (`trovevault/sports-odds-arbitrage-finder`) Actor

Find pre-match sports arbitrage opportunities, guaranteed-profit stake splits, and freshness signals from Sportsmonks odds data.

- **URL**: https://apify.com/trovevault/sports-odds-arbitrage-finder.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Automation, News, Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sports Odds Arbitrage Finder

Find pre-match football arbitrage and live in-play arbitrage candidates from your Sportsmonks odds feed. The Actor compares bookmaker prices for upcoming and current football markets, returns guaranteed pre-match arbitrage rows when the best odds imply less than 100% probability, and marks live rows as candidates because in-play odds can suspend or move before execution.

The output is built for fast triage: event, league, market, arbitrage percentage, implied probability total, stake split, bookmaker selections, and odds freshness signals when timestamps are available.

### Why use this Actor

Sports odds APIs can return a lot of raw prices, but the work is deciding which events are actionable. This Actor turns odds into ranked arbitrage opportunities:

- Scan upcoming pre-match opportunities and current in-play fixtures with almost no setup.
- Compare the main full-time result markets across bookmakers.
- Get exact pre-match arbitrage rows, live in-play candidates, and near-miss watchlist rows in the same dataset.
- Get calculated stakes per outcome, not just a list of prices.
- Keep a clean dataset for scheduled monitoring or downstream alerts.

### What it produces

Each dataset row represents one event and market. `sourceMode` is always `prematch` or `live`. Pre-match exact rows use `opportunityStatus: "arbitrage_found"`. Live exact rows use `opportunityStatus: "live_arbitrage_candidate"` because execution risk is materially higher. Near-miss rows use `near_miss_watchlist` or `live_near_miss_watchlist` and show negative profit values so they are not confused with profitable arbitrage.

Important fields include:

- `eventName`, `leagueName`, `startTime`
- `sourceMode`
- `market`
- `arbitragePercent`
- `impliedProbabilityTotal`
- `guaranteedProfit`
- `totalStake`
- `bestOutcomeSummary`
- `outcomes`
- `freshnessStatus`
- `lastOddsUpdate`
- `executionRisk`, `oddsAgeSeconds` on live rows when available

### Use cases

Betting analysts can monitor upcoming fixtures and quickly find opportunities worth checking in their own bookmaker accounts.

Trading and odds teams can use the output to benchmark market discrepancies across bookmakers covered by their Sportsmonks plan.

Automation builders can schedule the Actor and send high-margin rows into Slack, a database, or another Apify workflow.

Affiliate and content teams can use the dataset as a source for internal research, provided their Sportsmonks plan and downstream use allow it.

### How it works

1. The Actor reads your encrypted `sportsmonksApiToken`.
2. It scans pre-match, live, or both depending on `mode`.
3. For pre-match, it scans today through tomorrow by default, or your optional date range.
4. For live, it checks current in-play fixtures and retrieves in-play odds.
5. It fetches odds per fixture in parallel for lower latency.
6. It normalizes odds, markets, selections, bookmakers, and update timestamps.
7. For each event and market, it selects the best decimal odds per outcome.
8. It returns exact rows first, then the closest near-miss rows.

The Actor currently targets football odds through Sportsmonks API v3, covering pre-match odds and standard in-play odds. It uses the main full-time result market family by default. Available bookmakers, odds, in-play fixtures, and freshness timestamps depend on your Sportsmonks subscription.

### Input

```json
{
  "sportsmonksApiToken": "YOUR_SPORTSMONKS_API_TOKEN",
  "mode": "both",
  "includeNearMissWatchlist": true
}
````

#### Input fields

| Field | Description |
| --- | --- |
| `sportsmonksApiToken` | Required. Encrypted Sportsmonks API token with access to odds data. |
| `mode` | Optional. `both` scans pre-match and live in-play odds. Use `prematch` or `live` to restrict the scan. |
| `dateFrom` / `dateTo` | Optional UTC event dates in `YYYY-MM-DD` format. Leave empty to scan today through tomorrow. |
| `includeNearMissWatchlist` | Optional. Keep `true` to include close markets to monitor. Set `false` to return only direct arbitrage/candidate rows. |

The Actor uses sensible internal defaults: football, `mode: "both"`, main full-time result markets, all upcoming fixtures in the selected date window, current live fixtures, EUR stake labels, and a `500` total stake for stake-split calculations.

### Output example

```json
{
  "opportunityStatus": "arbitrage_found",
  "sourceMode": "prematch",
  "profitSignal": "solid_margin",
  "sport": "football",
  "leagueName": "Premier League",
  "eventId": "123456",
  "eventName": "Team A vs Team B",
  "startTime": "2026-07-04T18:00:00.000Z",
  "market": "1X2",
  "arbitragePercent": 3.42,
  "impliedProbabilityTotal": 96.69,
  "guaranteedProfit": 17.1,
  "currency": "EUR",
  "totalStake": 500,
  "outcomeCount": 3,
  "bestOutcomeSummary": "Team A: Bookmaker 1 @ 2.2 stake 219.77 | Draw: Bookmaker 2 @ 3.6 stake 134.31 | Team B: Bookmaker 3 @ 3.3 stake 145.92",
  "outcomes": [
    {
      "selection": "Team A",
      "bookmaker": "Bookmaker 1",
      "odds": 2.2,
      "stake": 219.77,
      "payout": 483.49,
      "updatedAt": "2026-07-02T09:15:00.000Z"
    },
    {
      "selection": "Draw",
      "bookmaker": "Bookmaker 2",
      "odds": 3.6,
      "stake": 134.31,
      "payout": 483.52,
      "updatedAt": "2026-07-02T09:14:00.000Z"
    },
    {
      "selection": "Team B",
      "bookmaker": "Bookmaker 3",
      "odds": 3.3,
      "stake": 145.92,
      "payout": 481.54,
      "updatedAt": "2026-07-02T09:13:00.000Z"
    }
  ],
  "freshnessStatus": "fresh",
  "lastOddsUpdate": "2026-07-02T09:15:00.000Z",
  "oldestOddsUpdate": "2026-07-02T09:13:00.000Z",
  "runId": null
}
```

Near-miss rows use the same shape but are clearly marked:

```json
{
  "opportunityStatus": "near_miss_watchlist",
  "sourceMode": "prematch",
  "profitSignal": "near_miss",
  "eventName": "Team A vs Team B",
  "market": "Fulltime Result",
  "arbitragePercent": -0.27,
  "impliedProbabilityTotal": 100.27,
  "guaranteedProfit": -1.35,
  "bestOutcomeSummary": "Away: Coral @ 11 stake 45.3 | Draw: Ladbrokes @ 5.5 stake 90.6 | Home: Dafabet @ 1.37 stake 363.1"
}
```

Near-miss rows are a radar signal only. They mean the best available prices are close to arbitrage, not that the stake split is guaranteed profitable.

Live rows use `sourceMode: "live"` and candidate statuses:

```json
{
  "opportunityStatus": "live_arbitrage_candidate",
  "sourceMode": "live",
  "profitSignal": "thin_margin",
  "executionRisk": "high",
  "oddsAgeSeconds": 8,
  "eventName": "Team A vs Team B",
  "market": "Fulltime Result",
  "arbitragePercent": 0.41,
  "impliedProbabilityTotal": 99.59,
  "guaranteedProfit": 2.05,
  "bestOutcomeSummary": "Away: Bookmaker 1 @ 4.8 stake 103.76 | Draw: Bookmaker 2 @ 3.9 stake 127.7 | Home: Bookmaker 3 @ 1.86 stake 268.54"
}
```

Live candidate rows are not guaranteed execution opportunities. They mean the current in-play odds snapshot calculates as profitable before fees, limits, suspension, account rules, and odds movement.

### API usage

```bash
curl "https://api.apify.com/v2/acts/TROVEVAULT_ACTOR_ID/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -d '{
    "sportsmonksApiToken": "YOUR_SPORTSMONKS_API_TOKEN",
    "mode": "both",
    "includeNearMissWatchlist": true
  }'
```

After the run finishes, fetch the default dataset items:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### Limitations

- The Actor does not place bets.
- Profit is calculated before bookmaker fees, limits, void rules, delays, account restrictions, currency conversion, and odds movement.
- Output depends on the sports, bookmakers, markets, and update timestamps available in your Sportsmonks plan.
- This version is designed for football odds. Multi-sport support needs additional Sportsmonks endpoint adapters.
- Live rows are in-play arbitrage candidates, not guaranteed executed arbitrage. The Actor filters stopped and suspended in-play odds, but prices can still move before a user acts.
- Near-miss watchlist rows are not guaranteed-profit arbitrage. They are ranked cases that are close enough to monitor or manually re-check. Set `includeNearMissWatchlist` to `false` to hide them.
- If Sportsmonks returns odds without update timestamps, the Actor can still calculate opportunities but marks freshness as `unknown_age`.
- If your Sportsmonks plan does not include odds, the run summary will show the API or data-access failure.

### FAQ

#### Do I need a Sportsmonks account?

Yes. This Actor uses your own Sportsmonks API token. The token is marked as a secret input in Apify.

#### Does this use MCP connectors?

Not in v1. Apify MCP connectors are a good option when a third-party service exposes an MCP server, but this Actor uses direct Sportsmonks API-token authentication because that is the documented access path.

#### Why did I get zero rows?

Common reasons:

- No exact arbitrage, live candidate, or near-miss case was found in the scanned fixtures.
- Your API plan did not return odds for the requested events.

#### Is this legal to use?

This Actor is a data analysis tool. You are responsible for complying with Sportsmonks terms, bookmaker terms, local betting laws, and any rules around publishing or acting on odds data.

### Changelog

- `0.1` - Pre-match and live football arbitrage scanner with Sportsmonks token input, fast fixture-level odds fetching, sourceMode labels, exact pre-match rows, live candidate rows, near-miss watchlist rows, stake split calculation, freshness handling, and Apify dataset output.

# Actor input Schema

## `sportsmonksApiToken` (type: `string`):

Sportsmonks API token with access to pre-match football odds.

## `dateFrom` (type: `string`):

Optional earliest event date to scan, in YYYY-MM-DD format. Defaults to today.

## `dateTo` (type: `string`):

Optional latest event date to scan, in YYYY-MM-DD format. Defaults to tomorrow.

## `includeNearMissWatchlist` (type: `boolean`):

When enabled, the Actor also returns near-miss watchlist rows. These are close markets to monitor, not guaranteed-profit arbitrage.

## `mode` (type: `string`):

Use both for the widest scan, prematch for upcoming fixtures only, or live for current in-play odds only.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID. When provided, result rows are appended there in addition to the default run dataset.

## `runId` (type: `string`):

Optional external run or workflow ID copied to result rows and RUN\_SUMMARY for pipeline tracking.

## Actor input object example

```json
{
  "includeNearMissWatchlist": true,
  "mode": "both"
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/sports-odds-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("trovevault/sports-odds-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 trovevault/sports-odds-arbitrage-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sports Odds Arbitrage Finder",
        "description": "Find pre-match sports arbitrage opportunities, guaranteed-profit stake splits, and freshness signals from Sportsmonks odds data.",
        "version": "0.1",
        "x-build-id": "FLrm7dhJZWe08psDv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~sports-odds-arbitrage-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-sports-odds-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/trovevault~sports-odds-arbitrage-finder/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-sports-odds-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/trovevault~sports-odds-arbitrage-finder/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-sports-odds-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",
                "required": [
                    "sportsmonksApiToken"
                ],
                "properties": {
                    "sportsmonksApiToken": {
                        "title": "Sportsmonks API Token",
                        "type": "string",
                        "description": "Sportsmonks API token with access to pre-match football odds."
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Optional earliest event date to scan, in YYYY-MM-DD format. Defaults to today."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Optional latest event date to scan, in YYYY-MM-DD format. Defaults to tomorrow."
                    },
                    "includeNearMissWatchlist": {
                        "title": "Include Near-Miss Watchlist",
                        "type": "boolean",
                        "description": "When enabled, the Actor also returns near-miss watchlist rows. These are close markets to monitor, not guaranteed-profit arbitrage.",
                        "default": true
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "both",
                            "prematch",
                            "live"
                        ],
                        "type": "string",
                        "description": "Use both for the widest scan, prematch for upcoming fixtures only, or live for current in-play odds only.",
                        "default": "both"
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID. When provided, result rows are appended there in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional external run or workflow ID copied to result rows and RUN_SUMMARY for pipeline tracking."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
