# RTINGS Scraper (`crawlerbros/rtings-scraper`) Actor

Scrape RTINGS.com lab-tested electronics reviews with TVs, headphones, monitors, soundbars, vacuums, laptops, projectors, and more. Get overall scores, per-usage scores, featured spec test results, pros/cons, verdicts, images, and size variants.

- **URL**: https://apify.com/crawlerbros/rtings-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## RTINGS Scraper

Scrape **RTINGS.com** — the lab-tested electronics review site that buys its own units, tests them under identical conditions, and publishes detailed score breakdowns for TVs, headphones, monitors, soundbars, keyboards, mice, vacuums, laptops, mattresses, printers, projectors, and more.

The actor returns clean JSON records with the **overall score**, **per-usage scores** (e.g. *Mixed Usage*, *Gaming*, *Home Theater*), **featured spec test results** (resolution, refresh rate, panel type, etc.), editor **pros / cons / mixed-notes summaries**, the **verdict** text, **product imagery**, and **size/colour variants** — all extracted from the page's embedded structured JSON, so the output schema is stable and field-complete.

### What this scraper does

For each product review on RTINGS, the actor pulls:

- **Identity** — product name, brand, RTINGS product ID, review ID, model slug, category
- **Overall score** — RTINGS' headline 0-10 rating
- **Per-usage suitability** — `Mixed Usage`, `Home Theater`, `Bright Room`, `Sports`, `Gaming` (TVs); `Neutral Sound`, `Commute/Travel`, `Sports/Fitness`, `Office`, `Wireless Gaming` (headphones); `Mixed Usage`, `Office`, `Gaming`, `Media Creation`, `HDR Gaming` (monitors) — each with the suitable flag and editorial description
- **Featured test results** — the top 5-8 technical specs RTINGS highlights per product (e.g. *Resolution: 4k @ 10/10*, *Native Refresh Rate: 144Hz @ 9.5/10*, *Sub-Type: WOLED*)
- **Summaries** — pros, cons, and mixed-priority bullet points written by the editorial team
- **Verdict text** — the multi-paragraph introduction explaining what the product is good for
- **Recommended / not recommended for** — derived from the per-usage suitable flag
- **Imagery** — main product image URL (rehosted on i.rtings.com CDN)
- **Variants** — size variants (e.g. 55", 65", 77", 83", 97" for TVs), SKU IDs
- **Provenance** — review publish date, methodology version (test bench), authors, community comment count, scrape timestamp

### Modes

| Mode | What it does | Typical input |
|---|---|---|
| `search` | Match a free-text query against product slugs in RTINGS' sitemap, then fetch each | `searchQuery=lg c4`, `category=tv` |
| `byCategory` | Pull the curated picks from `/{category}` then enrich with sitemap-listed reviews | `category=headphones`, `maxItems=20` |
| `byUrls` | Fetch specific review URLs you paste in | `reviewUrls=[ "https://www.rtings.com/tv/reviews/lg/g4-oled" ]` |
| `byBrand` | Pull every reviewed model for a brand in a category | `category=tv`, `brands=["lg","sony"]` |

### Filters

- `category` — 25-option dropdown (TV, Headphones, Monitor, Soundbar, Keyboard, Mouse, Vacuum, Laptop, Mattress, Printer, Projector, Blender, Lawn Mower, Snowblower, Graphics Card, Speaker, Router, SSD, Webcam, Phone, Tablet, Air Purifier, Robot Vacuum, Gaming Headset, Earbuds)
- `minScore` / `maxScore` — drop products outside this 0-10 range
- `suitableUsages` — keep products marked suitable for any of these usages (case-insensitive substring)
- `containsKeyword` — substring search across name, brand, verdict, tagline
- `yearMin` / `yearMax` — drop reviews published outside this year range
- `sortBy` — score-desc / score-asc / newest / oldest / alphabetical
- `includeVerdict` — turn the multi-paragraph verdict on/off to keep records compact
- `includeSummaries` — turn pros / cons / mixed notes on/off

### Example input

```json
{
  "mode": "byCategory",
  "category": "tv",
  "sortBy": "score-desc",
  "maxItems": 15
}
````

```json
{
  "mode": "search",
  "category": "headphones",
  "searchQuery": "sony wh-1000xm5",
  "maxItems": 5
}
```

```json
{
  "mode": "byUrls",
  "reviewUrls": [
    "https://www.rtings.com/tv/reviews/lg/g4-oled",
    "https://www.rtings.com/monitor/reviews/lg/27gp850-b-27gp83b-b"
  ]
}
```

```json
{
  "mode": "byBrand",
  "category": "tv",
  "brands": ["lg", "samsung"],
  "minScore": 8,
  "sortBy": "score-desc",
  "maxItems": 20
}
```

### Example output (excerpt)

```json
{
  "productId": "84591",
  "reviewId": "192473",
  "name": "LG G4 OLED",
  "brand": "LG",
  "category": "tv",
  "brandSlug": "lg",
  "modelSlug": "g4-oled",
  "overallScore": 8.6,
  "reviewedVariation": "65\"",
  "publishedAt": "2024-04-15 09:30:00 -0400",
  "publishedYear": 2024,
  "reviewUrl": "https://www.rtings.com/tv/reviews/lg/g4-oled",
  "productUrl": "https://www.rtings.com/tv/reviews/lg/g4-oled",
  "mainImageUrl": "https://i.rtings.com/assets/products/.../lg-g4-oled/design-medium.jpg",
  "skuIds": ["10492", "10493", "10494", "10495", "10496"],
  "variantCount": 5,
  "authors": ["Jacob Falato Rodrigues", "Ben Trudeau"],
  "testBenchName": "2.2",
  "testBenchId": "227",
  "verdict": "The LG G4 OLED is one of the best TVs we've tested...",
  "recommendedFor": ["Mixed Usage", "Home Theater", "Gaming"],
  "usageRatings": [
    {"usage": "Mixed Usage", "suitable": true, "description": "Excellent for mixed usage..."},
    {"usage": "Gaming", "suitable": true, "description": "The G4 is exceptional for gaming..."}
  ],
  "featuredTests": [
    {"name": "Resolution", "value": "4k", "score": 10.0},
    {"name": "Native Refresh Rate", "value": "144Hz", "score": 9.5},
    {"name": "Panel Type", "value": "OLED", "score": 10.0}
  ],
  "testScoresFlat": {
    "Resolution": "4k",
    "Native Refresh Rate": "144Hz",
    "Panel Type": "OLED"
  },
  "pros": [
    "Near-infinite contrast ratio for perfect blacks with no blooming.",
    "Native 144Hz support with HDMI 2.1 on all four ports."
  ],
  "cons": [
    "Reflections can be intense in very bright rooms."
  ],
  "commentCount": 1247,
  "recordType": "review",
  "scrapedAt": "2026-05-21T10:30:00+00:00"
}
```

### FAQ

#### How fresh is the data?

RTINGS keeps `published_at` and `first_published_at` on every review and re-tests products periodically. The actor reports both fields and the methodology version (`testBenchName`, e.g. `2.2`).

#### Do I need cookies or an API key?

No. Everything the actor extracts is publicly visible on rtings.com — the scraper simply parses the structured Vue component data already embedded in each page.

#### Why are some `score` values missing from `usageRatings`?

RTINGS hides the per-usage numeric scores behind their Insider membership paywall on some pages. The `suitable` boolean and the editorial `description` are still extracted (they're public), and the headline `overallScore` is always populated.

#### What's the difference between `byCategory` and `byBrand`?

`byCategory` starts from the category landing page (e.g. `/tv`) and pulls the editor-curated "best of" picks plus all reviews listed in the sitemap. `byBrand` enumerates every model RTINGS has reviewed for a specific brand × category (e.g. all LG TVs).

#### Why doesn't search work like Google?

RTINGS' live search UI is JavaScript-rendered with no public API. To keep the actor cookie-free and fast, the scraper instead loads the full sitemap (~5,600 review URLs) and matches your query tokens against brand + model slugs. So `lg c4` matches `/tv/reviews/lg/c4-oled` reliably.

#### Which categories are supported?

The 25-option category dropdown covers everything RTINGS reviews regularly — TVs, headphones, monitors, soundbars, keyboards, mice, vacuums, laptops, mattresses, printers, projectors, blenders, lawn mowers, snowblowers, graphics cards, speakers, routers, SSDs, webcams, phones, tablets, air purifiers, robot vacuums, gaming headsets, and earbuds. New categories RTINGS adds in the future can be reached via `byUrls`.

#### How does pagination work?

Each request fetches one review page. Set `maxItems` to control the hard cap. The actor automatically de-duplicates and sorts before emitting.

#### Are all output fields always present?

No — the scraper omits empty fields so your records stay lean. Always-present fields: `name`, `brand`, `reviewUrl`, `category`, `productId`, `recordType`, `scrapedAt`. Other fields depend on what RTINGS publishes for each product.

### Data Source

This actor scrapes publicly accessible review pages on **www.rtings.com**. RTINGS publishes hands-on lab test results purchased independently — no manufacturer-sent units, no sponsored placements. The scraper reads the same structured Vue component data the website itself uses to render each page.

# Actor input Schema

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

What to scrape.

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

Product category on RTINGS. Used by modes byCategory, byBrand, and as a search-filter for mode=search.

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

Free-text query — matched against product brand / model slug in the review URL. E.g. `lg c4`, `sony wh-1000xm5`, `dyson v15`. Use the `category` input to scope the search.

## `reviewUrls` (type: `array`):

Direct RTINGS review URLs (e.g. https://www.rtings.com/tv/reviews/lg/g4-oled). One review per URL.

## `brands` (type: `array`):

Brand slugs (e.g. `lg`, `samsung`, `sony`, `hisense`, `dyson`, `bose`). One emission per brand × category model.

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

Result ordering (mode=byCategory / mode=byBrand / mode=search). Score-desc is the default RTINGS browsing order.

## `minScore` (type: `integer`):

Drop products with overall score below this value (0-10). Field-absent products pass through.

## `maxScore` (type: `integer`):

Drop products with overall score above this value (0-10).

## `suitableUsages` (type: `array`):

Keep only products marked `suitable=true` for at least one of these usages. Usage labels vary by category: TV uses `Mixed Usage`, `Home Theater`, `Sports`, `Gaming`, `Bright Room`; headphones use `Neutral Sound`, `Commute/Travel`, `Sports/Fitness`, `Office`, `Wireless Gaming`; monitors use `Mixed Usage`, `Office`, `Gaming`, `Media Creation`, `HDR Gaming`. Free-text — case insensitive.

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

Case-insensitive substring filter — match against product name, brand, or verdict text. Field-absent products pass through.

## `yearMin` (type: `integer`):

Drop reviews published before this year.

## `yearMax` (type: `integer`):

Drop reviews published after this year.

## `includeVerdict` (type: `boolean`):

Include the multi-paragraph verdict / introduction text. Off by default to keep records compact.

## `includeSummaries` (type: `boolean`):

Include the editor-curated pros, cons, and mixed-priority summary bullets per product.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "tv",
  "searchQuery": "lg oled",
  "reviewUrls": [],
  "brands": [],
  "sortBy": "score-desc",
  "suitableUsages": [],
  "includeVerdict": true,
  "includeSummaries": true,
  "maxItems": 25
}
```

# Actor output Schema

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

Dataset containing all scraped RTINGS reviews.

# 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 = {
    "mode": "byCategory",
    "category": "tv",
    "searchQuery": "lg oled",
    "reviewUrls": [],
    "brands": [],
    "sortBy": "score-desc",
    "suitableUsages": [],
    "includeVerdict": true,
    "includeSummaries": true,
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/rtings-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 = {
    "mode": "byCategory",
    "category": "tv",
    "searchQuery": "lg oled",
    "reviewUrls": [],
    "brands": [],
    "sortBy": "score-desc",
    "suitableUsages": [],
    "includeVerdict": True,
    "includeSummaries": True,
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/rtings-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 '{
  "mode": "byCategory",
  "category": "tv",
  "searchQuery": "lg oled",
  "reviewUrls": [],
  "brands": [],
  "sortBy": "score-desc",
  "suitableUsages": [],
  "includeVerdict": true,
  "includeSummaries": true,
  "maxItems": 25
}' |
apify call crawlerbros/rtings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RTINGS Scraper",
        "description": "Scrape RTINGS.com lab-tested electronics reviews with TVs, headphones, monitors, soundbars, vacuums, laptops, projectors, and more. Get overall scores, per-usage scores, featured spec test results, pros/cons, verdicts, images, and size variants.",
        "version": "1.0",
        "x-build-id": "QL1nYdPv2KFG780XV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~rtings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-rtings-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/crawlerbros~rtings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-rtings-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/crawlerbros~rtings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-rtings-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byUrls",
                            "byBrand"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "tv",
                            "headphones",
                            "monitor",
                            "soundbar",
                            "keyboard",
                            "mouse",
                            "vacuum",
                            "laptop",
                            "mattress",
                            "printer",
                            "projector",
                            "blender",
                            "lawn-mower",
                            "snowblower",
                            "graphics-card",
                            "speaker",
                            "router",
                            "ssd",
                            "webcam",
                            "phone",
                            "tablet",
                            "air-purifier",
                            "robot-vacuum",
                            "headset",
                            "earbuds"
                        ],
                        "type": "string",
                        "description": "Product category on RTINGS. Used by modes byCategory, byBrand, and as a search-filter for mode=search.",
                        "default": "tv"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query — matched against product brand / model slug in the review URL. E.g. `lg c4`, `sony wh-1000xm5`, `dyson v15`. Use the `category` input to scope the search.",
                        "default": "lg oled"
                    },
                    "reviewUrls": {
                        "title": "Review URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Direct RTINGS review URLs (e.g. https://www.rtings.com/tv/reviews/lg/g4-oled). One review per URL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "brands": {
                        "title": "Brands (mode=byBrand)",
                        "type": "array",
                        "description": "Brand slugs (e.g. `lg`, `samsung`, `sony`, `hisense`, `dyson`, `bose`). One emission per brand × category model.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "score-desc",
                            "score-asc",
                            "newest",
                            "oldest",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Result ordering (mode=byCategory / mode=byBrand / mode=search). Score-desc is the default RTINGS browsing order.",
                        "default": "score-desc"
                    },
                    "minScore": {
                        "title": "Minimum overall score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop products with overall score below this value (0-10). Field-absent products pass through."
                    },
                    "maxScore": {
                        "title": "Maximum overall score",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Drop products with overall score above this value (0-10)."
                    },
                    "suitableUsages": {
                        "title": "Suitable for usages",
                        "type": "array",
                        "description": "Keep only products marked `suitable=true` for at least one of these usages. Usage labels vary by category: TV uses `Mixed Usage`, `Home Theater`, `Sports`, `Gaming`, `Bright Room`; headphones use `Neutral Sound`, `Commute/Travel`, `Sports/Fitness`, `Office`, `Wireless Gaming`; monitors use `Mixed Usage`, `Office`, `Gaming`, `Media Creation`, `HDR Gaming`. Free-text — case insensitive.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "containsKeyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Case-insensitive substring filter — match against product name, brand, or verdict text. Field-absent products pass through."
                    },
                    "yearMin": {
                        "title": "Published year (min)",
                        "minimum": 2010,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop reviews published before this year."
                    },
                    "yearMax": {
                        "title": "Published year (max)",
                        "minimum": 2010,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Drop reviews published after this year."
                    },
                    "includeVerdict": {
                        "title": "Include long verdict text",
                        "type": "boolean",
                        "description": "Include the multi-paragraph verdict / introduction text. Off by default to keep records compact.",
                        "default": true
                    },
                    "includeSummaries": {
                        "title": "Include pros / cons / mixed summaries",
                        "type": "boolean",
                        "description": "Include the editor-curated pros, cons, and mixed-priority summary bullets per product.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
