# Open Trivia DB Quiz Questions Scraper (`parseforge/opentdb-trivia-scraper`) Actor

Pull trivia questions from Open Trivia DB. Returns category, type (multiple/true-false), difficulty, question text, correct answer, incorrect answers. Filter by category (24 supported: science, history, geography, art, sports, etc.), difficulty (easy/medium/hard), or type.

- **URL**: https://apify.com/parseforge/opentdb-trivia-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Games, Education, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 result items

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧠 Open Trivia Database Question Scraper

> 🚀 **Pull trivia questions across 24 categories with correct + incorrect answers, difficulty, type, category counts. Stable IDs for dedupe.**

> 🕒 **Last updated:** 2026-05-08 · **📊 26 fields** per record · **21,000+ trivia questions** · **24 categories** · easy / medium / hard · multiple choice + true/false · stable hash IDs · category + global counts

The **Open Trivia Database Question Scraper** pulls trivia questions from the Open Trivia DB community dataset. Output includes a stable question ID (SHA-1 hash for dedupe across runs), category name + numeric ID + group + subject, difficulty, type, language, the question text + length + word count, correct answer, incorrect answers (plain + joined text), all answers shuffled with the correct answer's index, per-category total + easy + medium + hard counts, and global category counts (total / verified / pending / rejected).

The Actor uses session tokens to avoid duplicates within a run, plus a SHA-1 hash of the question for dedupe across runs. Filter by category, difficulty (easy / medium / hard), and type (multiple choice / true-false).

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Quiz app builders, ML / NLP researchers, education platforms, party-game makers, content marketers | Quiz / trivia apps, educational content generation, NLP training data, conversational agents, party games |

---

### 📋 What the Open Trivia Database Question Scraper does

Five filtering workflows in a single run:

- 🆔 **Stable question IDs.** SHA-1 hash for dedupe across runs.
- 🏷️ **24 categories.** General Knowledge, Books, Film, Music, Science, History, Sports, etc.
- 📊 **Difficulty filter.** Easy / medium / hard.
- ✅ **Type filter.** Multiple choice or true / false.
- 📈 **Category counts included.** Per-category and global totals (verified / pending / rejected).

> 💡 **Why it matters:** clean, server-side filtering and fresh data on every run.

---
### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>category</code></td><td>string</td><td><code>""</code></td><td>Category ID (9 = General Knowledge, 11 = Film, 21 = Sports, etc). Empty = any.</td></tr>
<tr><td><code>difficulty</code></td><td>string</td><td><code>""</code></td><td>easy, medium, or hard. Empty = any.</td></tr>
<tr><td><code>type</code></td><td>string</td><td><code>""</code></td><td>multiple or boolean. Empty = any.</td></tr>
</tbody>
</table>

**Example: 100 random trivia questions.**

```json
{
    "maxItems": 100
}
````

**Example: hard science questions.**

```json
{
    "maxItems": 50,
    "category": "17",
    "difficulty": "hard"
}
```

***

### 📊 Output

Each record contains **26 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `questionId` | string | `"a1b2c3d4e5f6g7h8"` |
| 🏷️ `category` | string | `"Geography"` |
| 🆔 `categoryId` | number | `22` |
| 🏷️ `categorySubject` | string | `"Geography"` |
| 📊 `difficulty` | string | `"hard"` |
| 📊 `type` | string | `"multiple"` |
| 🌐 `language` | string | `"en"` |
| ❓ `question` | string | `"What North American tourist attraction is served by..."` |
| 📏 `questionLength` | number | `88` |
| 🔢 `wordCount` | number | `15` |
| ✅ `correctAnswer` | string | `"Niagara Falls"` |
| ❌ `incorrectAnswers` | array | `["Whistler","Disney World","Yosemite"]` |
| 🔀 `allAnswers` | array | `["Niagara Falls","Yosemite","Disney World","Whistler"]` |
| 🔢 `answerCount` | number | `4` |
| ✅ `correctAnswerIndex` | number | `0` |
| 📊 `categoryTotalQuestions` | number | `383` |
| 📊 `categoryEasyCount` | number | `121` |
| 📊 `categoryMediumCount` | number | `179` |
| 📊 `categoryHardCount` | number | `83` |
| 📊 `categoryGlobalTotal` | number | `815` |
| 📊 `categoryGlobalVerified` | number | `383` |
| 📊 `categoryGlobalPending` | number | `269` |
| 📊 `categoryGlobalRejected` | number | `163` |

#### 📦 Sample records

<details>
<summary><strong>🧠 Geography (hard)</strong></summary>

```json
{"questionId":"a1b2c3...","category":"Geography","categoryId":22,"difficulty":"hard","question":"What North American tourist attraction is served by the Maid of the Mist tour?","correctAnswer":"Niagara Falls"}
```

</details>

<details>
<summary><strong>🧠 Sports (medium)</strong></summary>

```json
{"category":"Sports","categoryId":21,"difficulty":"medium","question":"In which year did the first FIFA World Cup take place?","correctAnswer":"1930"}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🆔 | **Stable IDs.** SHA-1 hash of question lets you dedupe across runs (the API has no native ID). |
| 🔀 | **Shuffled answers + index.** Quiz-app ready: all answers in random order plus the index of the correct answer. |
| 📊 | **Category counts.** Per-category and global counts let you weight your sampling. |
| 🌐 | **24 categories.** From General Knowledge through Sports, Science, History, Books, Film, Music. |
| 🆓 | **Free + open.** Open Trivia DB is community-maintained. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **24 categories** | Live per run | Filters | ⚡ 2 min |
| Open Trivia DB direct | Free | Same | Live | DIY | 🐢 Code |
| Trivia API (paid) | $$ | Larger | Live | Yes | 🐢 Account |
| Manual scraping | Free | Mixed | Live | DIY | 🐢 Days |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Find the Open Trivia Database Question Scraper on the Apify Store.
3. 🎯 **Set input.** Pick filters and `maxItems`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📱 Quiz + Trivia Apps

- Question banks for trivia apps
- Daily quiz generators
- Party-game card decks
- Pub-trivia content

</td>
<td width="50%" valign="top">

#### 🤖 ML + NLP

- Train QA models
- Multiple-choice fine-tuning
- Distractor-generation research
- Difficulty-prediction studies

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎓 Education

- Classroom quiz tools
- After-school trivia clubs
- Reading-comprehension warm-ups
- Learning-app gamification

</td>
<td width="50%" valign="top">

#### 🎲 Games + Entertainment

- Board-game card content
- Streaming-show fact moments
- Holiday party games
- Mobile game side-quests

</td>
</tr>
</table>

***

### 🔌 Automating Open Trivia Database Question Scraper

Control the scraper programmatically:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- QA datasets
- Distractor research
- Difficulty calibration
- Reproducible trivia corpora

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal trivia collections
- Pub-quiz hosting
- Side projects with question data
- Quiz-app prototypes

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Educational trivia outreach
- Free quiz collections
- Public-library trivia nights
- Community game events

</td>
<td width="50%">

#### 🧪 Experimentation

- Train answer-generators
- Prototype tutoring agents
- Build difficulty-classifiers
- Test gamification logic

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Open%20Trivia%20Database%20Question%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Open%20Trivia%20Database%20Question%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Open%20Trivia%20Database%20Question%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Open%20Trivia%20Database%20Question%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Set optional filters (category, difficulty, type) and a max item count. The Actor pages OpenTDB with a session token to avoid duplicates and emits one record per question.

#### 📊 How many fields per record?

26, including the question text, correct + incorrect answers, all answers shuffled, category + global counts, stable ID.

#### 🆔 What's questionId?

SHA-1 hash of category + type + difficulty + question + correct answer. Stable across runs for dedupe.

#### 🌐 Are non-English questions supported?

No. OpenTDB is English-only.

#### 📊 What does correctAnswerIndex mean?

Index (0-based) of the correct answer inside the shuffled allAnswers array. Useful for quiz UIs.

#### 🔢 Why are there only 24 categories?

OpenTDB defines 24 active categories. The category list is loaded once at the start of each run.

#### ⏱️ Why is this slower than other Actors?

OpenTDB rate-limits to 1 request per 5 seconds. 100 items takes ~18 seconds.

#### 🆓 Do I need an API key?

No. OpenTDB is free and open.

#### 🔁 Can I schedule runs?

Yes. Schedule daily for a fresh question rotation.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs (10 records).

***

### 🔌 Integrate with any app

Open Trivia Database Question Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

***

### 🔗 Recommended Actors

- [**🃏 Yu-Gi-Oh! Card Database**](https://apify.com/parseforge/yugioh-card-database-scraper) - Yu-Gi-Oh! cards with stats, archetypes, sets, prices
- [**🧠 Open Trivia DB Questions**](https://apify.com/parseforge/opentdb-trivia-scraper) - Trivia questions across 24 categories with answers
- [**🌍 Wikivoyage Travel Articles**](https://apify.com/parseforge/wikivoyage-articles-scraper) - Wikivoyage city and country articles with image, geo
- [**📚 Wikipedia Article Summary**](https://apify.com/parseforge/wikipedia-rest-summaries-scraper) - Pull Wikipedia summaries with thumbnail, extract, geo and Wikidata link
- [**🌍 REST Countries Reference Data**](https://apify.com/parseforge/rest-countries-scraper) - Every country with flag, capital, currency, languages

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Open Trivia DB project, its maintainers, or any individual question contributor. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: max 1,000,000 (50 per API call, auto-paginated)

## `category` (type: `string`):

Open Trivia DB category. Empty = any.

## `difficulty` (type: `string`):

Easy, medium, or hard. Empty = any.

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

Multiple choice or true/false. Empty = any.

## Actor input object example

```json
{
  "maxItems": 10,
  "category": "",
  "difficulty": "",
  "type": ""
}
```

# 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 = {
    "maxItems": 10,
    "category": "",
    "difficulty": "",
    "type": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/opentdb-trivia-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 = {
    "maxItems": 10,
    "category": "",
    "difficulty": "",
    "type": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/opentdb-trivia-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 '{
  "maxItems": 10,
  "category": "",
  "difficulty": "",
  "type": ""
}' |
apify call parseforge/opentdb-trivia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Trivia DB Quiz Questions Scraper",
        "description": "Pull trivia questions from Open Trivia DB. Returns category, type (multiple/true-false), difficulty, question text, correct answer, incorrect answers. Filter by category (24 supported: science, history, geography, art, sports, etc.), difficulty (easy/medium/hard), or type.",
        "version": "1.0",
        "x-build-id": "co8H7fr56TzDTpKe2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~opentdb-trivia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-opentdb-trivia-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/parseforge~opentdb-trivia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-opentdb-trivia-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/parseforge~opentdb-trivia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-opentdb-trivia-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: max 1,000,000 (50 per API call, auto-paginated)"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "9",
                            "10",
                            "11",
                            "12",
                            "13",
                            "14",
                            "15",
                            "16",
                            "17",
                            "18",
                            "19",
                            "20",
                            "21",
                            "22",
                            "23",
                            "24",
                            "25",
                            "26",
                            "27",
                            "28",
                            "29",
                            "30",
                            "31",
                            "32"
                        ],
                        "type": "string",
                        "description": "Open Trivia DB category. Empty = any.",
                        "default": ""
                    },
                    "difficulty": {
                        "title": "Difficulty",
                        "enum": [
                            "",
                            "easy",
                            "medium",
                            "hard"
                        ],
                        "type": "string",
                        "description": "Easy, medium, or hard. Empty = any.",
                        "default": ""
                    },
                    "type": {
                        "title": "Question type",
                        "enum": [
                            "",
                            "multiple",
                            "boolean"
                        ],
                        "type": "string",
                        "description": "Multiple choice or true/false. Empty = any.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
