# OddsPortal.com Scraper | 1$/1k Cheap (`trev0n/oddsportal-com-scraper`) Actor

Scrape match listings and bookmaker odds from OddsPortal.com across every sport and league. Get average and maximum 1X2 / Home-Away odds, or full per-bookmaker markets (Asian Handicap, Over/Under) with opening odds — in any odds format.

- **URL**: https://apify.com/trev0n/oddsportal-com-scraper.md
- **Developed by:** [Paweł](https://apify.com/trev0n) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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

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

## 🎯 OddsPortal.com Scraper

🎯 **Pull match listings and bookmaker odds from OddsPortal.com — for any sport, any league, in any odds format.**

This scraper turns any OddsPortal league or match page into clean, structured data: teams, dates, results, and odds. Get quick average and maximum win/draw/loss odds for a whole league in one go, or dig into full per-bookmaker markets — 1X2, Asian Handicap, Over/Under — complete with opening odds.

### 🚀 What Does It Do?

This scraper automatically reads a league, tournament, or match page on OddsPortal and collects **structured, ready-to-use odds data** — no manual browsing, no copy-pasting. Just paste a URL and hit Start.

💡 **Two modes of operation:**

1. **⚡ Main Odds Mode** — Fast and cheap. One pass over a league returns every match with its average and maximum 1X2 (or Home/Away) odds across all bookmakers.
2. **📊 Full Odds Mode** — Deep dive. Each match is enriched with full per-bookmaker markets (1X2, Over/Under, Asian Handicap, and more), including each bookmaker's opening odds.

### 👥 Who Is This For?

| 🏢 Use Case                      | 💬 How It Helps                                                             |
| -------------------------------- | --------------------------------------------------------------------------- |
| 📈 **Odds analysts & traders**   | Track price movements and compare bookmaker margins across whole leagues    |
| 🤖 **Betting model builders**    | Feed clean historical and live odds into prediction models and backtests    |
| 🔎 **Arbitrage & value hunters** | Spot the highest available odds and divergence between bookmakers instantly |
| 📰 **Sports media & tipsters**   | Surface market favourites and odds shifts for content and previews          |
| 🧮 **Data teams & researchers**  | Build odds datasets across sports without maintaining fragile scrapers      |

### ✨ Features

- 🌍 **Every Sport & League** — Football, tennis, basketball, hockey and more — anything OddsPortal covers
- ⚡ **Whole-League in One Pass** — Average and maximum win/draw/loss odds for every match at once
- 📊 **Full Per-Bookmaker Markets** — Drill into 1X2, Over/Under, Asian Handicap and other markets bookmaker by bookmaker
- 🕗 **Opening vs Current Odds** — See how each price moved from open to now
- 💱 **Six Odds Formats** — Decimal, Fractional, Money Line (American), Hong Kong, Malay, Indonesian
- 🏁 **Upcoming & Finished** — Scrape scheduled fixtures, finished results, or both
- 🎛️ **Smart Filters** — Pick markets, market scope (full time / 1st half / 2nd half), and a max-matches cap
- 🔗 **Direct URLs** — Drop in league pages, results pages, or individual match links
- ⚡ **Fast & Scalable** — Reads odds straight from the source feeds; hundreds of matches per run
- 🧹 **Deduplication** — Each match appears once, even across overlapping pages
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                      | What It Does                                                                                 |
| --------------------------- | -------------------------------------------------------------------------------------------- |
| 🔗 **League / Match URLs**  | The OddsPortal league, tournament, results, or match pages to scrape                         |
| 📊 **Full Odds**            | Switch on full per-bookmaker markets with opening odds (off = fast main odds only)           |
| 💱 **Odds Format**          | Decimal, Fractional, Money Line, Hong Kong, Malay or Indonesian                              |
| 🏷️ **Markets**              | Which markets to collect in full mode (Over/Under, Asian Handicap, Double Chance, …, or All) |
| ⏱️ **Market Scope**         | Full Time, 1st Half, 2nd Half, or All                                                        |
| 🕗 **Include Opening Odds** | Add each bookmaker's opening price alongside the current one                                 |
| 🏁 **Include Finished**     | Keep finished matches, or limit to upcoming fixtures only                                    |
| 🔢 **Max Matches**          | Control how many matches to extract per run                                                  |

### 📦 What You Get (Output Fields)

Every match includes:

#### Match Info

| Field      | Example                                                                                 |
| ---------- | --------------------------------------------------------------------------------------- |
| matchUrl   | `https://www.oddsportal.com/football/england/premier-league/arsenal-coventry-2q2NhX43/` |
| matchId    | `10852491`                                                                              |
| sport      | `football`                                                                              |
| country    | `England`                                                                               |
| league     | `Premier League`                                                                        |
| home       | `Arsenal`                                                                               |
| away       | `Coventry`                                                                              |
| date       | `2026-08-21T19:00:00.000Z`                                                              |
| matchTime  | `19:00`                                                                                 |
| status     | `Scheduled`                                                                             |
| isFinished | `false`                                                                                 |

#### Result (finished matches)

| Field         | Example    |
| ------------- | ---------- |
| score         | `2:1`      |
| homeResult    | `2`        |
| awayResult    | `1`        |
| partialResult | `1:0, 1:1` |

#### Main Odds

| Field          | Example   |
| -------------- | --------- |
| homeWinOdds    | `1.16`    |
| drawOdds       | `7.08`    |
| awayWinOdds    | `15.6`    |
| homeWinOddsMax | `1.18`    |
| drawOddsMax    | `8.5`     |
| awayWinOddsMax | `18`      |
| bookmakerCount | `5`       |
| oddsFormat     | `Decimal` |

#### Full Markets (full odds mode)

| Field       | Example                                                      |
| ----------- | ------------------------------------------------------------ |
| markets     | `[ { market, scope, handicap, outcomes, bookmakers[] }, … ]` |
| marketCount | `27`                                                         |

### 📊 Example Output

```json
{
    "matchUrl": "https://www.oddsportal.com/football/h2h/arsenal-hA1Zm19f/coventry-GOvB22xg/",
    "matchId": 10852491,
    "eventHash": "2q2NhX43",
    "sport": "football",
    "country": "England",
    "league": "Premier League",
    "home": "Arsenal",
    "away": "Coventry",
    "date": "2026-08-21T19:00:00.000Z",
    "matchTime": "19:00",
    "status": "Scheduled",
    "isFinished": false,
    "homeResult": null,
    "awayResult": null,
    "partialResult": null,
    "homeWinOdds": 1.16,
    "drawOdds": 7.08,
    "awayWinOdds": 15.6,
    "homeWinOddsMax": 1.18,
    "drawOddsMax": 8.5,
    "awayWinOddsMax": 18,
    "bookmakerCount": 5,
    "markets": [
        {
            "market": "Over/Under",
            "scope": "Full Time",
            "handicap": "3.50",
            "unit": "Goals",
            "outcomes": ["over", "under"],
            "bookmakers": [
                {
                    "bookmaker": "bet365",
                    "bookmakerId": 16,
                    "over": 2.33,
                    "overOpening": 2.24,
                    "under": 1.51,
                    "underOpening": 1.55
                },
                {
                    "bookmaker": "Pinnacle",
                    "bookmakerId": 18,
                    "over": 2.4,
                    "overOpening": 2.3,
                    "under": 1.54,
                    "underOpening": 1.58
                }
            ]
        }
    ],
    "marketCount": 27,
    "oddsFormat": "Decimal",
    "scrapedAt": "2026-06-22T10:00:00.000Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **3 ready-made table views** to quickly browse your results:

| View                | What It Shows                                               |
| ------------------- | ----------------------------------------------------------- |
| 📊 **Overview**     | Teams, league, date, and the average win/draw/loss odds     |
| 🎯 **Odds**         | Average and maximum odds side by side, with bookmaker count |
| 📋 **Full Details** | Every single field, including full per-bookmaker markets    |

### ❓ FAQ

**🤔 Which sports and leagues are supported?**
All of them. If OddsPortal has a page for it — football, tennis, basketball, hockey, baseball, esports — you can scrape it. Just paste the league or match URL.

**🤔 What's the difference between Main Odds and Full Odds mode?**
Main Odds mode is fast and returns the average and maximum win/draw/loss odds for every match in a league. Full Odds mode additionally opens each match and pulls every bookmaker's prices for markets like Over/Under and Asian Handicap, plus opening odds.

**🤔 Can I get odds in American (Money Line) or fractional format?**
Yes — choose from Decimal, Fractional, Money Line, Hong Kong, Malay or Indonesian. All odds in the output are converted to your chosen format.

**🤔 Can I scrape a single match instead of a whole league?**
Absolutely. Paste an individual match (h2h) URL and you'll get that match only — with full odds if you enable Full Odds mode.

**🤔 Can I get odds for finished matches?**
Yes. The most reliable way is to paste the finished match's direct URL — you'll get its closing and opening odds for every market. League **results** pages are supported too; for best coverage of historical seasons, pick a proxy region where OddsPortal serves the bookmakers you need.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh odds, run before kickoff or on a schedule. You can schedule automatic runs on Apify with just a few clicks — great for tracking how prices move.

**🤔 Does it work with proxies?**
Yes — residential proxies are recommended for the best results. The scraper works with Apify's built-in proxy service.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (specific bookmakers only, specific markets like Correct Score or HT/FT, minimum bookmaker count)
- 📊 Extra data fields or custom output formats (one row per bookmaker, odds movement history)
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping that tracks odds movement over time
- 🌐 Scraping from other odds-comparison platforms alongside OddsPortal

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects **only publicly available information** from OddsPortal.com. It does not access private data, bypass authentication, or place any bets. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

## `leagueUrls` (type: `array`):

OddsPortal league or tournament URLs to scrape — e.g. https://www.oddsportal.com/football/england/premier-league/ . You can also paste a results page (.../results/) or a single match (h2h) URL. Works for any sport.

## `fullOdds` (type: `boolean`):

When ON, each match is enriched with full per-bookmaker markets (1X2, Over/Under, Asian Handicap, …) including opening odds. When OFF (default), you get the average and maximum win/draw/loss odds only — much faster and cheaper.

## `oddsFormat` (type: `string`):

Format used for all odds in the output. The site delivers decimal odds; everything else is converted for you.

## `markets` (type: `array`):

Which betting markets to collect when Full odds is ON. Main win/draw/loss is always included. Choose "All" to grab every market a match offers.

## `marketScope` (type: `string`):

Which part of the match the markets refer to.

## `includeOpeningOdds` (type: `boolean`):

In full odds mode, include each bookmaker's opening odds alongside the current ones.

## `includeFinished` (type: `boolean`):

Include matches that have already finished (results). Turn OFF to keep only upcoming/scheduled matches.

## `maxMatches` (type: `integer`):

Stop after this many matches across all URLs. Set 0 for no limit.

## `detailConcurrency` (type: `integer`):

How many matches to enrich in parallel in full odds mode. Lower this if you hit rate limits.

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

Proxy settings. Residential proxies are recommended for reliable access to OddsPortal.

## Actor input object example

```json
{
  "leagueUrls": [
    {
      "url": "https://www.oddsportal.com/football/england/premier-league/"
    }
  ],
  "fullOdds": false,
  "oddsFormat": "Decimal",
  "markets": [
    "Over/Under",
    "Asian Handicap"
  ],
  "marketScope": "Full Time",
  "includeOpeningOdds": true,
  "includeFinished": true,
  "maxMatches": 0,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "leagueUrls": [
        {
            "url": "https://www.oddsportal.com/football/england/premier-league/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/oddsportal-com-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "leagueUrls": [{ "url": "https://www.oddsportal.com/football/england/premier-league/" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("trev0n/oddsportal-com-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "leagueUrls": [
    {
      "url": "https://www.oddsportal.com/football/england/premier-league/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call trev0n/oddsportal-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OddsPortal.com Scraper | 1$/1k Cheap",
        "description": "Scrape match listings and bookmaker odds from OddsPortal.com across every sport and league. Get average and maximum 1X2 / Home-Away odds, or full per-bookmaker markets (Asian Handicap, Over/Under) with opening odds — in any odds format.",
        "version": "1.0",
        "x-build-id": "mgQrRBZUFzRy5YBib"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~oddsportal-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-oddsportal-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/trev0n~oddsportal-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-oddsportal-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/trev0n~oddsportal-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-oddsportal-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "leagueUrls"
                ],
                "properties": {
                    "leagueUrls": {
                        "title": "League / match URLs",
                        "type": "array",
                        "description": "OddsPortal league or tournament URLs to scrape — e.g. https://www.oddsportal.com/football/england/premier-league/ . You can also paste a results page (.../results/) or a single match (h2h) URL. Works for any sport.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "fullOdds": {
                        "title": "Full odds (per bookmaker)",
                        "type": "boolean",
                        "description": "When ON, each match is enriched with full per-bookmaker markets (1X2, Over/Under, Asian Handicap, …) including opening odds. When OFF (default), you get the average and maximum win/draw/loss odds only — much faster and cheaper.",
                        "default": false
                    },
                    "oddsFormat": {
                        "title": "Odds format",
                        "enum": [
                            "Decimal",
                            "Fractional",
                            "Money Line",
                            "Hong Kong",
                            "Malay",
                            "Indonesian"
                        ],
                        "type": "string",
                        "description": "Format used for all odds in the output. The site delivers decimal odds; everything else is converted for you.",
                        "default": "Decimal"
                    },
                    "markets": {
                        "title": "Markets (full odds mode)",
                        "type": "array",
                        "description": "Which betting markets to collect when Full odds is ON. Main win/draw/loss is always included. Choose \"All\" to grab every market a match offers.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Over/Under",
                                "Asian Handicap",
                                "Double Chance",
                                "Draw No Bet",
                                "Both Teams to Score",
                                "European Handicap",
                                "Correct Score",
                                "Odd or Even",
                                "All"
                            ]
                        },
                        "default": [
                            "Over/Under",
                            "Asian Handicap"
                        ]
                    },
                    "marketScope": {
                        "title": "Market scope (full odds mode)",
                        "enum": [
                            "Full Time",
                            "1st Half",
                            "2nd Half",
                            "All"
                        ],
                        "type": "string",
                        "description": "Which part of the match the markets refer to.",
                        "default": "Full Time"
                    },
                    "includeOpeningOdds": {
                        "title": "Include opening odds",
                        "type": "boolean",
                        "description": "In full odds mode, include each bookmaker's opening odds alongside the current ones.",
                        "default": true
                    },
                    "includeFinished": {
                        "title": "Include finished matches",
                        "type": "boolean",
                        "description": "Include matches that have already finished (results). Turn OFF to keep only upcoming/scheduled matches.",
                        "default": true
                    },
                    "maxMatches": {
                        "title": "Max matches",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many matches across all URLs. Set 0 for no limit.",
                        "default": 0
                    },
                    "detailConcurrency": {
                        "title": "Detail concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many matches to enrich in parallel in full odds mode. Lower this if you hit rate limits.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for reliable access to OddsPortal.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
