# Bovada Sportsbook Odds Scraper (`automation-lab/bovada-sportsbook-odds-scraper`) Actor

🏀 Export live, pregame, and futures Bovada odds as normalized event, market, outcome, and price rows—no login or external API key required.

- **URL**: https://apify.com/automation-lab/bovada-sportsbook-odds-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Sports, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Bovada Sportsbook Odds Scraper

Export current Bovada sportsbook odds without a login or third-party API key.

**Bovada Sportsbook Odds Scraper** turns Bovada's nested event feeds into clean, flat rows—one priced outcome per dataset item. Select basketball, football, soccer, hockey, tennis, or a more specific Bovada league path and receive event, market, period, outcome, and price context ready for spreadsheets, databases, models, and monitoring jobs.

- 🏀 Extract live, pregame, and futures markets
- 🎯 Keep American, decimal, and fractional odds together
- 🧭 Preserve competition, event, display-group, market, and period context
- 🔗 Trace every record to its Bovada event and structured source URL
- ⚡ Use lightweight HTTP extraction with no browser overhead

### What does the Bovada Sportsbook Odds Scraper do?

The Actor calls Bovada's public sportsbook data surface and normalizes its nested response.

Instead of making you unpack events, groups, markets, outcomes, and prices yourself, it emits a consistent analytics-ready row for each priced outcome.

You can:

- collect currently open Bovada markets;
- separate live events from pregame events;
- monitor one sport or several sports on a schedule;
- target a league, category, event, or public Bovada URL;
- cap output with one global `maxItems` limit;
- export results as JSON, CSV, Excel, XML, or RSS.

### Who is this Bovada odds extractor for?

#### Odds-comparison product teams

Feed source-native Bovada prices into a line-shopping or price-comparison system.

Stable event, market, outcome, and price IDs help reconcile repeated snapshots.

#### Betting analysts and researchers

Study market availability, implied probability, pricing differences, futures, and live-market structure.

The Actor does not recommend wagers or promise profits; it provides source data for independent analysis.

#### Data engineers

Schedule repeated runs, retrieve rows through the Apify API, and load them into warehouses or dashboards.

#### Spreadsheet users

Download flat rows directly instead of writing code to flatten deeply nested sportsbook JSON.

### Why use this Actor?

- ✅ **Bovada-specific depth:** retain display groups, period flags, statuses, and source-native IDs.
- ✅ **No external API key:** the useful data route is publicly accessible at run time.
- ✅ **Flat output:** every row has one outcome and one price.
- ✅ **Three odds formats:** American, decimal, and fractional values travel together.
- ✅ **Live context:** distinguish event live state, period live state, and main markets.
- ✅ **Cost control:** select sources and stop at a predictable row limit.
- ✅ **Repeatability:** use schedules, webhooks, API clients, or MCP.

### What Bovada data can you extract?

| Group | Example fields | Why it matters |
|---|---|---|
| Sport | `sport`, `sportCode` | Group records across leagues |
| Competition | `competition`, `competitionId`, `competitionPath` | Retain source hierarchy |
| Event | `eventId`, `eventName`, `startTime`, `isLive` | Identify and time the fixture or future |
| Competitors | `homeCompetitor`, `awayCompetitor`, `competitorNames` | Join outcomes to participants |
| Display group | `displayGroupId`, `displayGroup` | Preserve Bovada's market navigation context |
| Market | `marketId`, `marketName`, `marketKey`, `marketStatus` | Distinguish similarly named lines |
| Period | `periodName`, `periodAbbreviation`, `isMainMarket` | Separate full game, halves, periods, and live context |
| Outcome | `outcomeId`, `outcomeName`, `outcomeStatus` | Identify the priced selection |
| Price | `americanOdds`, `decimalOdds`, `fractionalOdds` | Use the preferred odds format |
| Probability | `impliedProbability` | Compare normalized prices |
| Provenance | `eventUrl`, `sourceUrl`, `scrapedAt` | Audit where and when a row was collected |

### Supported sports and league selectors

Use the path text seen in a Bovada URL.

Common broad selectors include:

- `basketball`
- `football`
- `soccer`
- `baseball`
- `hockey`
- `tennis`
- `golf`
- `boxing`
- `mma`
- `esports`

More specific selectors such as `basketball/nba` are also supported when that path exists on Bovada.

Availability changes with seasons and Bovada's current catalog.

### How to scrape Bovada sportsbook odds

1. Open the Actor input page.
2. Enter one or more sport or league selectors.
3. Optionally paste specific Bovada URLs.
4. Choose all, live, or pregame events.
5. Leave **Open markets only** enabled for actionable prices.
6. Set a maximum number of priced outcomes.
7. Click **Start**.
8. Review the **Bovada odds** dataset view.
9. Export or integrate the resulting dataset.

For a cheap first run, use `basketball` with `maxItems: 20`.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `sports` | string array | `["basketball"]` | Bovada sport or league paths |
| `startUrls` | request list | empty | Bovada sport, league, event, or structured API URLs |
| `eventFilter` | string | `all` | `all`, `live`, or `pregame` |
| `openMarketsOnly` | boolean | `true` | Exclude markets not marked open by Bovada |
| `maxItems` | integer | `100` | Global priced-outcome limit, maximum 50,000 |

When both `sports` and `startUrls` are present, the Actor combines and deduplicates their selectors.

Only `bovada.lv` and `bovada.com` URLs are accepted.

### Input examples

#### Small basketball scrape

```json
{
  "sports": ["basketball"],
  "eventFilter": "all",
  "openMarketsOnly": true,
  "maxItems": 20
}
````

#### Multi-sport pregame feed

```json
{
  "sports": ["football", "soccer", "hockey"],
  "eventFilter": "pregame",
  "openMarketsOnly": true,
  "maxItems": 500
}
```

#### Bovada URL input

```json
{
  "startUrls": [
    { "url": "https://www.bovada.lv/basketball" }
  ],
  "eventFilter": "live",
  "maxItems": 100
}
```

### Output example

```json
{
  "sport": "Basketball",
  "sportCode": "BASK",
  "competition": "NBA Championship Winner",
  "competitionPath": "Basketball > NBA Futures > NBA Championship > NBA Championship Winner",
  "eventId": "26018499",
  "eventName": "Championship 2026-27",
  "startTime": "2027-06-26T04:00:00.000Z",
  "isLive": false,
  "displayGroup": "Futures",
  "marketId": "498749399",
  "marketName": "Champion 2026-27",
  "periodName": "Game",
  "isMainMarket": true,
  "outcomeName": "Oklahoma City Thunder",
  "americanOdds": "+260",
  "decimalOdds": 3.6,
  "fractionalOdds": "13/5",
  "impliedProbability": 0.277778,
  "eventUrl": "https://www.bovada.lv/basketball/...",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Empty strings can appear where Bovada does not provide a concept—for example, futures often have no home or away competitor.

### How much does it cost to scrape Bovada odds?

This Actor uses pay-per-event pricing.

A run has a small one-time start charge and a per-row charge for each priced outcome saved.

Current pricing starts at **$0.005 per run** plus a plan-based rate for each saved row:

| Plan | Price per priced outcome |
|---|---:|
| Free | $0.000034274 |
| Bronze | $0.000029803 |
| Silver | $0.000023247 |
| Gold | $0.000017882 |
| Platinum | $0.000011921 |
| Diamond | $0.000010000 |

Your total is predictable:

`$0.005 run start + priced outcome rows × your plan rate`

For example, 1,000 rows cost about **$0.0343** on Free or **$0.0298** on Bronze, plus the start charge.

Use `maxItems` to control the maximum dataset charge. The Apify free plan can cover small tests within the account's included platform credits.

### Tips for reliable odds collection

- 💡 Schedule frequent small snapshots rather than one unbounded run.
- 💡 Keep stable IDs when comparing prices across snapshots.
- 💡 Use `openMarketsOnly: true` for currently offered markets.
- 💡 Use `pregame` when live volatility is not part of the workflow.
- 💡 Use a sport/league path instead of a broad sport when you need a narrow feed.
- 💡 Treat `scrapedAt` as collection time and `startTime` as event time.
- 💡 Deduplicate downstream on `eventId + marketId + outcomeId + priceId`.

### Monitoring and scheduling workflows

Sportsbook prices change over time, so repeated runs are often more valuable than a one-time export.

A practical monitoring workflow is:

1. create an Apify Schedule;
2. run every 5–30 minutes for selected sports;
3. save each dataset or forward rows through a webhook;
4. compare stable IDs and price values;
5. alert only when a relevant price changes.

Bovada may add, suspend, reopen, or remove markets between runs.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to append current rows for manual line review.

#### Webhooks

Trigger a data pipeline when a run succeeds, then fetch the default dataset.

#### Databases and warehouses

Load rows into PostgreSQL, BigQuery, Snowflake, or ClickHouse and index stable IDs plus `scrapedAt`.

#### Zapier and Make

Start a run on a timer and route selected prices to chat, email, or a dashboard.

#### Python and notebooks

Pull JSON rows into pandas for probability, movement, and market-coverage analysis.

### Run through the Apify API with Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bovada-sportsbook-odds-scraper').call({
  sports: ['basketball'],
  eventFilter: 'pregame',
  openMarketsOnly: true,
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Run through the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bovada-sportsbook-odds-scraper').call(run_input={
    'sports': ['soccer'],
    'eventFilter': 'all',
    'openMarketsOnly': True,
    'maxItems': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bovada-sportsbook-odds-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "sports": ["hockey"],
    "eventFilter": "pregame",
    "openMarketsOnly": true,
    "maxItems": 100
  }'
```

Retrieve items from the `defaultDatasetId` returned with the finished run.

### Use Bovada odds through MCP

Connect this Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/bovada-sportsbook-odds-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bovada-sportsbook-odds-scraper"
    }
  }
}
```

Example prompts:

- “Export 50 open pregame Bovada basketball outcome prices.”
- “Get live Bovada hockey odds and group them by event and market.”
- “Collect Bovada soccer markets with all three odds formats.”

### Data quality and freshness

Rows reflect Bovada's public response at the time shown in `scrapedAt`.

The Actor keeps source values rather than inventing unavailable fields.

A market marked open can change immediately after collection.

`impliedProbability` is computed as `1 / decimalOdds` and is not adjusted for bookmaker margin.

Stable IDs are source-controlled and can change if Bovada recreates an event or market.

### Limitations

- The Actor covers Bovada only; it does not compare other sportsbooks.
- It does not calculate arbitrage, no-vig fair odds, or betting recommendations.
- Available sports and leagues depend on Bovada's current catalog.
- Geography, regulation, maintenance, or upstream rate limits may affect access.
- Futures do not always have home/away competitors.
- Some event URLs can become unavailable after a market closes.
- A live-only filter can legitimately produce no rows when no selected event is live.

### Responsible and legal use

Sports betting and access to sportsbook services are regulated differently by location.

Use this Actor only where you are legally permitted to access and process the source data.

Review Bovada's terms and applicable laws before collecting data.

Do not use the output to facilitate underage gambling, evade geographic restrictions, or make misleading claims.

This Actor provides data extraction, not financial, legal, or betting advice.

### Troubleshooting

#### Why did a live-only run return no rows?

No selected Bovada event may have been live at collection time.

Try `eventFilter: "all"` to verify current source availability.

#### Why was my URL rejected?

Only public `bovada.lv` and `bovada.com` paths are accepted.

Use a sport, league, event, or structured sportsbook URL—not a login, account, cashier, or unrelated URL.

#### Why are home and away empty?

Futures and ranked events often price competitors without a home/away fixture structure.

Use `competitorNames` and `outcomeName` for those markets.

#### Why did fewer than `maxItems` appear?

`maxItems` is a ceiling, not a guaranteed count.

Filters, seasonality, suspended markets, and the current Bovada catalog determine actual volume.

### FAQ

#### Does this Bovada scraper need an account?

No. The implemented structured sportsbook route is anonymous and keyless.

#### Does it use a browser or residential proxy?

No. It uses lightweight direct HTTP requests, bounded retries, and conservative sequential processing.

#### Can I scrape a specific league?

Yes. Use a Bovada path selector such as `basketball/nba` when available, or paste the corresponding Bovada URL.

#### Can I extract closed markets?

Set `openMarketsOnly` to `false`. Closed/suspended records are returned only when Bovada includes priced outcomes for them.

#### Can I get historical odds?

The Actor captures current source responses. Create scheduled snapshots and store them to build your own history.

#### Are odds guaranteed to remain available?

No. Sportsbook prices can change or disappear at any moment.

### Related sports data Actors

- [Action Network Sports Odds Line Movement Scraper](https://apify.com/automation-lab/action-network-sports-odds-line-movement-scraper) — compare sports lines and market movement from a different source.

Choose this Actor when you need deep Bovada-native market and outcome context.

Choose the Action Network Actor when you need that source's book comparison and line-movement data.

### Support

If a valid Bovada sport or URL stops producing expected data, open an Actor issue with:

- the exact input;
- the run ID;
- the expected sport or event;
- whether the source was live or pregame;
- a short description of the missing market.

That evidence makes source changes faster to reproduce and fix.

# Actor input Schema

## `sports` (type: `array`):

Enter Bovada path selectors such as basketball, football, soccer, tennis, or basketball/nba.

## `startUrls` (type: `array`):

Optionally add bovada.lv or bovada.com sport, league, event, or sportsbook JSON URLs.

## `eventFilter` (type: `string`):

Include all events, only live events, or only pregame events.

## `openMarketsOnly` (type: `boolean`):

Save only markets Bovada currently marks as open.

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

Stop after this many normalized outcome-price rows across all selected sources.

## Actor input object example

```json
{
  "sports": [
    "basketball"
  ],
  "startUrls": [],
  "eventFilter": "all",
  "openMarketsOnly": true,
  "maxItems": 20
}
```

# 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 = {
    "sports": [
        "basketball"
    ],
    "startUrls": [],
    "eventFilter": "all",
    "openMarketsOnly": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bovada-sportsbook-odds-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 = {
    "sports": ["basketball"],
    "startUrls": [],
    "eventFilter": "all",
    "openMarketsOnly": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bovada-sportsbook-odds-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 '{
  "sports": [
    "basketball"
  ],
  "startUrls": [],
  "eventFilter": "all",
  "openMarketsOnly": true,
  "maxItems": 20
}' |
apify call automation-lab/bovada-sportsbook-odds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bovada Sportsbook Odds Scraper",
        "description": "🏀 Export live, pregame, and futures Bovada odds as normalized event, market, outcome, and price rows—no login or external API key required.",
        "version": "0.1",
        "x-build-id": "FlYmFef1HsKvcCNip"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bovada-sportsbook-odds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bovada-sportsbook-odds-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/automation-lab~bovada-sportsbook-odds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bovada-sportsbook-odds-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/automation-lab~bovada-sportsbook-odds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bovada-sportsbook-odds-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sports": {
                        "title": "Sport or league selectors",
                        "type": "array",
                        "description": "Enter Bovada path selectors such as basketball, football, soccer, tennis, or basketball/nba.",
                        "default": [
                            "basketball"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Bovada URLs",
                        "type": "array",
                        "description": "Optionally add bovada.lv or bovada.com sport, league, event, or sportsbook JSON URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "eventFilter": {
                        "title": "Event timing",
                        "enum": [
                            "all",
                            "live",
                            "pregame"
                        ],
                        "type": "string",
                        "description": "Include all events, only live events, or only pregame events.",
                        "default": "all"
                    },
                    "openMarketsOnly": {
                        "title": "Open markets only",
                        "type": "boolean",
                        "description": "Save only markets Bovada currently marks as open.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum priced outcomes",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Stop after this many normalized outcome-price rows across all selected sources.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```