# Expedia Hotels Scraper — Prices, Ratings & Reviews (`haketa/expedia-scraper`) Actor

Scrape hotels from Expedia by destination and dates: name, nightly price, guest rating, reviews count, location, deals and link. Optionally attach real guest reviews per hotel (text, score, date, reviewer, manager replies). Export JSON/CSV for rate shopping, price intelligence and review analysis.

- **URL**: https://apify.com/haketa/expedia-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Travel
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Expedia Hotels Scraper — Prices, Ratings & Reviews

Extract **hotel listings and prices from Expedia** as clean, structured JSON. Give it a destination and dates and get the **full results list** — hotel name, nightly price, guest rating, review count, location, deal badges and link — for every property, across as many cities as you like.

Built for **travel price intelligence, hotel revenue managers, OTAs, market researchers and data teams** who need fresh Expedia hotel data at scale, without writing or maintaining a scraper.

---

### Why this scraper

- 🏨 **The whole results list** — not just the first few sponsored hotels. It renders the page and loads every property Expedia shows for your search.
- 💷 **Live nightly prices** for your exact dates and occupancy — the core of any rate-shopping or price-intelligence workflow.
- ⭐ **Ratings + real guest reviews** — the numeric score, rating label, review count, **and (optionally) the actual review text** per hotel: score, date, reviewer, sentiment themes and manager responses.
- 🌍 **Many cities at once** — pass a list of destinations and scrape them all in one run.
- 🧹 **Clean, typed, de-duplicated** output, ready for spreadsheets, dashboards and databases.
- 🛟 **Reliable** — runs a real browser over residential proxy to handle Expedia's anti-bot and lazy loading.

---

### What you can do with it

#### 💷 Rate shopping & price intelligence
Track nightly prices for your hotels and your competitors across dates and cities. Spot underpricing and overpricing, monitor how rates move with demand, and feed live data into your revenue-management models.

#### 🏨 Hotel benchmarking
Compare your property against the local set on price, guest rating and review volume — and watch how that comparison changes over time.

#### 📊 Travel market research
Analyse supply and pricing across destinations: average nightly rates, rating distribution and deal activity by city and season.

#### 🧳 OTA & metasearch monitoring
Monitor how hotels are presented and priced on Expedia, track deal badges and sponsored placements, and keep your own listings competitive.

#### 🔁 Dashboards & data feeds
Feed Expedia hotel data into your own tool, BI dashboard or data warehouse with a stable schema, and schedule daily runs to keep it fresh.

---

### Features

- 🔎 **Search by destination + dates**, adults, rooms and sort order.
- 🔗 **Start-URL mode** — paste Expedia Hotel-Search URLs with your own filters.
- 📜 **Full list loading** — scrolls and loads the complete results set.
- ⭐ **Rich fields** — name, price, guest rating, rating label, review count, location, deal, sponsored flag, image and link.
- 💬 **Optional guest reviews** — turn on `Scrape guest reviews` to attach real review text per hotel: score, date, reviewer name, "Liked" sentiment themes, verified flag and hotel manager responses.
- 🌍 **Multi-destination** in one run, de-duplicated per search.
- ⚙️ **Configurable** — cap hotels per search, set concurrency, choose your proxy.
- 🌐 **Proxy-ready** — US residential proxy recommended.
- 📤 **Export anywhere** — JSON, CSV, Excel, HTML or API, with one-click integrations.

---

### Input

| Field | Type | Description |
|-------|------|-------------|
| `destinations` | array | Cities/places to search, e.g. `New York`, `Paris`, `London`. |
| `checkIn` | string | Check-in date (`YYYY-MM-DD`). |
| `checkOut` | string | Check-out date (`YYYY-MM-DD`). |
| `adults` | integer | Number of adults. |
| `rooms` | integer | Number of rooms. |
| `sortBy` | select | Recommended, price, guest rating or distance. |
| `startUrls` | array | Expedia Hotel-Search URLs with your own filters. |
| `maxItemsPerSearch` | integer | Cap hotels per destination. |
| `scrapeReviews` | boolean | Also fetch real guest review text per hotel. |
| `maxReviewsPerHotel` | integer | How many recent reviews to fetch per hotel. |
| `proxyConfiguration` | object | Proxy settings. **US residential** strongly recommended. |
| `maxConcurrency` | integer | Parallel browser pages. |

#### Example input

```json
{
  "destinations": ["New York", "Miami"],
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-03",
  "adults": 2,
  "rooms": 1,
  "sortBy": "RECOMMENDED",
  "maxItemsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

***

### Output

Each hotel is one dataset record:

```json
{
  "hotelId": "h3229",
  "name": "Kixby",
  "url": "https://www.expedia.com/New-York-Hotels-Kixby.h3229.Hotel-Information",
  "priceNightly": 130,
  "priceCurrency": "USD",
  "allPrices": [130, 227, 728],
  "rating": 9.4,
  "ratingLabel": "Exceptional",
  "reviewCount": 1922,
  "location": "New York",
  "dealBadge": "Summer Savings",
  "isSponsored": false,
  "image": "https://...",
  "searchDestination": "New York",
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-03",
  "rank": 1,
  "scrapedAt": "2026-06-20T14:00:00.000Z",
  "reviewsScraped": 2,
  "reviews": [
    {
      "reviewId": "6a2ebd506f963f0b4244d2a1",
      "score": 9,
      "scoreText": "9/10 Wonderful",
      "superlative": "Wonderful",
      "title": "Great stay in midtown",
      "text": "This hotel is in a great location and my room was very nice...",
      "date": "Jun 14, 2026",
      "verified": true,
      "author": "Victor",
      "themes": ["Liked: Cleanliness, staff & service, amenities"],
      "managerResponse": null
    }
  ]
}
```

> Set `scrapeReviews: true` to attach the `reviews` array (and `reviewsScraped` count) to every hotel. Leave it off for the fastest, cheapest price-only runs.

#### Field reference

| Field | Description |
|-------|-------------|
| `hotelId` | Expedia hotel ID (stable — safe for deduplication). |
| `name` | Hotel name. |
| `url` | Hotel page URL. |
| `priceNightly` | Lead nightly price for your dates. |
| `priceCurrency` | Price currency. |
| `allPrices` | All price figures shown on the card (nightly, total, strikethrough). |
| `rating` | Guest rating out of 10. |
| `ratingLabel` | Rating word (Exceptional, Excellent, Very Good…). |
| `reviewCount` | Number of guest reviews. |
| `location` | Location / neighborhood. |
| `dealBadge` | Deal / promotion badge, if any. |
| `isSponsored` | Whether the listing is a sponsored (Ad) placement. |
| `image` | Hotel image URL. |
| `searchDestination` / `checkIn` / `checkOut` | The search that produced the record. |
| `rank` | Position in the results. |
| `scrapedAt` | ISO scrape timestamp. |

> **Tip:** prices reflect the **exact `checkIn`/`checkOut` and occupancy** you set — change them to rate-shop across stay lengths and party sizes.

***

### How to use

1. Set `destinations`, `checkIn`, `checkOut` and occupancy (or paste `startUrls`).
2. Keep the **US residential proxy** suggested in the input.
3. Click **Start** and watch hotels stream into the dataset.
4. Export as **JSON, CSV, Excel, HTML or via API**, or connect to Google Sheets, Make, Zapier, Slack and more.

#### Run on a schedule

Use the platform **Scheduler** to run the same searches daily and build a price history per hotel and city — the foundation of any rate-shopping or revenue-management workflow.

#### Run it via API

Start runs and fetch results programmatically through the standard platform API and client libraries, and wire Expedia data straight into your own systems.

***

### Tips for best results

- **Use US residential proxies** — Expedia blocks datacenter IPs; residential is the most reliable.
- **Use valid future dates** in `YYYY-MM-DD` — prices are date-specific.
- **One destination per search** keeps results focused; pass several in `destinations` to cover multiple cities.
- **Cap with `maxItemsPerSearch`** to control volume and cost.
- **Deduplicate on `hotelId`** when merging runs over time.
- **Schedule it** to build a historical price dataset.

***

### Frequently asked questions

**Which Expedia site does it scrape?**
The main Expedia hotel search (expedia.com).

**Do I get prices for my exact dates?**
Yes — nightly prices reflect the `checkIn`, `checkOut`, `adults` and `rooms` you set.

**Do I get the full list or just a few hotels?**
The full results list — the Actor loads all properties Expedia shows for your search, not only the sponsored ones at the top.

**Do I get guest ratings and reviews?**
Yes — every hotel carries the numeric rating, rating label and review count. Turn on **Scrape guest reviews** to also get the **actual review text** per hotel: score, date, reviewer name, "Liked" sentiment themes, a verified flag and hotel manager responses.

**Will scraping reviews slow down my run?**
It adds a little time per hotel (one lightweight request per page of reviews), so leave it **off** for fast price-only runs and **on** when you need review content. Use `maxReviewsPerHotel` to control how many you pull.

**Can I use my own filters (price, stars, amenities)?**
Yes — apply filters on Expedia in your browser, copy the URL, and paste it into `startUrls`.

**How many cities can I scrape?**
As many as you like — pass them all in `destinations` and they're scraped in one run.

**How fresh is the data?**
It is scraped live at run time. Schedule the Actor to keep prices up to date.

**Is a proxy required?**
A US residential proxy is strongly recommended (and pre-filled) for reliable results.

**Do I need to write code?**
No. Set the inputs, click Start and export. Developers can also drive everything via the API.

***

### Troubleshooting

- **No hotels found?** Check the destination spelling and that dates are valid future `YYYY-MM-DD` dates, and make sure a US residential proxy is enabled.
- **Fewer hotels than expected?** Raise `maxItemsPerSearch`, or broaden your destination/dates.
- **Run is slow or blocked?** Lower `maxConcurrency`, keep residential proxy on, and avoid extremely broad searches.

***

### Changelog

#### 0.1 — Initial release (June 2026)

- Search Expedia hotels by **destination and dates** (adults, rooms, sort), or via **Start URLs**.
- Loads the **full results list** in a real browser and parses every property.
- Fields: name, **nightly price** (+ all prices), **guest rating** and label, **review count**, location, deal badge, sponsored flag, image and link.
- **Optional guest reviews** — attach real review text per hotel (score, date, reviewer, sentiment themes, verified flag, manager responses) via `scrapeReviews`.
- Multi-destination per run, **de-duplication by hotel ID**, and graceful handling of anti-bot and lazy loading.

# Actor input Schema

## `destinations` (type: `array`):

Cities or places to search hotels in, e.g. 'New York', 'Paris', 'London'.

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

Check-in date in YYYY-MM-DD format.

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

Check-out date in YYYY-MM-DD format.

## `adults` (type: `integer`):

Number of adults.

## `rooms` (type: `integer`):

Number of rooms.

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

Result ordering.

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

Paste Expedia Hotel-Search URLs with your own filters instead of the fields above.

## `maxItemsPerSearch` (type: `integer`):

Cap hotels per destination. 0 = all on the results page.

## `scrapeReviews` (type: `boolean`):

Also fetch real guest review text (with score, date, author, themes and manager responses) for each hotel. Adds time per hotel.

## `maxReviewsPerHotel` (type: `integer`):

How many recent guest reviews to fetch per hotel when 'Scrape guest reviews' is on.

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

Expedia blocks datacenter IPs — US residential proxy is strongly recommended.

## `maxConcurrency` (type: `integer`):

Parallel browser pages. Keep at 1 for the most reliable results and lowest cost; raise to scrape faster.

## Actor input object example

```json
{
  "destinations": [
    "New York"
  ],
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-03",
  "adults": 2,
  "rooms": 1,
  "sortBy": "RECOMMENDED",
  "startUrls": [],
  "maxItemsPerSearch": 0,
  "scrapeReviews": false,
  "maxReviewsPerHotel": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 1
}
```

# Actor output Schema

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

Expedia hotel ID

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

Hotel name

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

Hotel page URL

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

Nightly price

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

Price currency

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

All prices shown on the card

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

Guest rating (out of 10)

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

Rating word (e.g. Excellent)

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

Number of reviews

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

Location / neighborhood

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

Deal / promo badge

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

Sponsored (Ad) listing

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

Hotel image URL

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

Destination searched

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

Check-in date

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

Check-out date

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

ISO timestamp

# 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 = {
    "destinations": [
        "New York"
    ],
    "checkIn": "2026-08-01",
    "checkOut": "2026-08-03",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/expedia-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 = {
    "destinations": ["New York"],
    "checkIn": "2026-08-01",
    "checkOut": "2026-08-03",
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/expedia-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 '{
  "destinations": [
    "New York"
  ],
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-03",
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call haketa/expedia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Expedia Hotels Scraper — Prices, Ratings & Reviews",
        "description": "Scrape hotels from Expedia by destination and dates: name, nightly price, guest rating, reviews count, location, deals and link. Optionally attach real guest reviews per hotel (text, score, date, reviewer, manager replies). Export JSON/CSV for rate shopping, price intelligence and review analysis.",
        "version": "0.1",
        "x-build-id": "sYBiImHucrgPjjE6Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~expedia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-expedia-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/haketa~expedia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-expedia-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/haketa~expedia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-expedia-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": {
                    "destinations": {
                        "title": "Destinations",
                        "type": "array",
                        "description": "Cities or places to search hotels in, e.g. 'New York', 'Paris', 'London'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 14,
                        "type": "integer",
                        "description": "Number of adults.",
                        "default": 2
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of rooms.",
                        "default": 1
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "RECOMMENDED",
                            "PRICE_LOW_TO_HIGH",
                            "PRICE_HIGH_TO_LOW",
                            "REVIEW",
                            "DISTANCE"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "RECOMMENDED"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Expedia Hotel-Search URLs with your own filters instead of the fields above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItemsPerSearch": {
                        "title": "Max hotels per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap hotels per destination. 0 = all on the results page.",
                        "default": 0
                    },
                    "scrapeReviews": {
                        "title": "Scrape guest reviews",
                        "type": "boolean",
                        "description": "Also fetch real guest review text (with score, date, author, themes and manager responses) for each hotel. Adds time per hotel.",
                        "default": false
                    },
                    "maxReviewsPerHotel": {
                        "title": "Max reviews per hotel",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many recent guest reviews to fetch per hotel when 'Scrape guest reviews' is on.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Expedia blocks datacenter IPs — US residential proxy is strongly recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel browser pages. Keep at 1 for the most reliable results and lowest cost; raise to scrape faster.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
