# Airbnb Scraper — Listings, Prices & Ratings by Location (`datascoutlab/airbnb-scraper`) Actor

Scrape Airbnb listings for any destination: price per night, ratings, review counts, room type, coordinates, host badges and images. Filter by dates, guests, price and bedrooms. No API key.

- **URL**: https://apify.com/datascoutlab/airbnb-scraper.md
- **Developed by:** [Anton DataScout](https://apify.com/datascoutlab) (community)
- **Categories:** Travel, Developer tools, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listings

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Airbnb Scraper — Prices, Availability Calendar & Revenue Estimates

All-in-one Airbnb scraper: type a location and get one clean row per listing with prices, ratings, amenities, host details, GPS coordinates, images — plus an opt-in **per-day availability calendar** and **AirDNA-style occupancy & revenue estimates**. Filter by dates, guests, price and bedrooms. **Pure HTTP — no browser, no CAPTCHA solver, no API key.**

Type a city — `Lisbon`, `Austin TX`, `Paris, France` — and get structured rental data ready for a spreadsheet, database, or pandas DataFrame. Prices come in the currency you choose, not whatever the server's location defaults to, so your data is comparable across markets. Turn on **Full coverage** to beat Airbnb's ~270-per-search cap and surface thousands of a dense city's listings.

| You give it | You get back |
| --- | --- |
| A location name (`Lisbon`, `Austin TX`) | Every listing in that market, one row each |
| Check-in / check-out dates | Accurate per-night prices for that exact stay |
| Filters (price, guests, bedrooms) | Only listings that match |
| A currency (`USD`, `EUR`, `GBP`) | All prices in that currency, comparable across cities |
| `calendarMonths` + `includeRevenueEstimate` | Per-day availability + occupancy % and estimated 365-day revenue |
| `fullCoverage: true` | Thousands of listings per city, past the ~270 cap |

### Two modes

- **Full mode (default)** — visits each listing to return 40+ fields: amenities, host, description, house rules, ratings, images, plus opt-in calendar and revenue.
- **Search-only mode (`skipDetailPages: true`)** — overview rows (price, rating, coordinates, name) without the per-listing fetch. Fast and cheap for whole-city market scans.

### What does the Airbnb Scraper do?

It resolves each location into an Airbnb search, reads Airbnb's own page state over pure HTTP (no headless browser), and returns each listing as one flat JSON row — id, title, room type, price, price label, rating, review count, Superhost flag, badges, latitude/longitude, thumbnail image and description. It paginates through the results up to the limit you set, and forces your chosen currency so prices never drift with the proxy's geolocation. No Airbnb account, no API key, no login.

### Who is it for?

| Audience | What they pull |
| --- | --- |
| **Short-term-rental investors** | Nightly rates, ratings and Superhost density across neighborhoods to spot high-yield markets |
| **Revenue / pricing managers** | Competitor nightly prices to benchmark and tune their own listings |
| **Real-estate analysts** | Supply and price maps for a market before buying, using exact coordinates |
| **Market researchers** | Price distribution, room-type mix and rating spread by area |
| **Data & AI teams** | Clean flat rows for dashboards, pricing models and LLM pipelines |

### Why use this scraper?

- **Pure HTTP — fast and cheap.** No headless browser and no CAPTCHA-bypass service, so runs are lightweight and cost a fraction of browser-based Airbnb scrapers.
- **Currency you control.** Pass a currency and every price comes back in it — no random local currencies from the proxy's location.
- **Exact coordinates on every listing** — map it, cluster it, compute distances.
- **Deep pagination** — pull far past the single-page default, up to your result cap.
- **Reliable extraction** — reads Airbnb's structured page state, so prices, ratings and coordinates come back consistently, not scraped fragilely from rendered HTML.

### What data can you extract from Airbnb?

Each listing is one flat row:

```json
{
    "locationQuery": "Austin TX",
    "id": "887004639380466573",
    "url": "https://www.airbnb.com/rooms/887004639380466573",
    "name": "Tarrytown Treasure - 3BR 3Bath - 2nd Floor",
    "roomType": "Entire home in Austin",
    "price": "$531",
    "priceLabel": "$531 for 2 nights",
    "rating": 4.94,
    "reviewsCount": 203,
    "isSuperhost": true,
    "badges": ["Guest favorite"],
    "latitude": 30.27915,
    "longitude": -97.79,
    "image": "https://a0.muscache.com/...",
    "description": "Bright top-floor retreat minutes from downtown…"
}
````

In **full mode** each row carries 30+ fields across identity, pricing, geo, ratings, host, amenities and (opt-in) reviews, availability calendar and revenue estimates:

| Field | Description |
| --- | --- |
| `locationQuery` | The search this listing came from |
| `id` / `url` | Airbnb room id and direct URL |
| `name` / `roomType` | Listing name and room/property type |
| `price` / `priceLabel` / `priceNumber` | Nightly price string, full label, and numeric value |
| `rating` / `reviewsCount` / `ratingLabel` / `guestSatisfaction` | Guest rating, review count, label, overall satisfaction |
| `isSuperhost` / `badges` | Superhost flag and listing badges (e.g. Guest favorite) |
| `latitude` / `longitude` | Exact GPS coordinates |
| `image` / `images` / `description` | Thumbnail, full photo list, and description |
| `amenities` / `amenityCount` | Full amenity list and count |
| `hostName` / `hostId` / `hostReviewCount` / `hostIsSuperhost` | Host profile |
| `personCapacity` / `houseRules` | Max guests and house rules |
| `reviews[]` *(opt-in)* | Per-review `rating`, `text`, `reviewerName`, `createdAt`, host `response` |
| `availabilityCalendar[]` *(opt-in)* | Per-day `available`, `bookable`, `minNights`, `maxNights`, check-in/out eligibility |
| `occupancyRate365d` / `bookedNights365d` / `estRevenue365d` / `avgMinNights` *(opt-in)* | AirDNA-style occupancy & revenue estimate |

### How to scrape Airbnb listings

1. Add one or more destinations to **Locations** — a city or region name like `Lisbon`, `Austin TX`, or `Paris, France`.
2. Set **Max results per location** to cap how many listings you collect (you're billed per listing).
3. Optionally add **check-in/check-out dates**, **guests**, **price** and **bedroom** filters, and a **currency**.
4. Run the Actor and download the dataset as JSON, CSV or Excel, or pull it via the Apify API.

### How much does it cost to scrape Airbnb?

You pay per listing returned. Because the Actor runs on **pure HTTP with no headless browser**, platform compute is a fraction of browser-based Airbnb scrapers that spin up a full browser per page. Real figures from cloud runs: a **search-only city scan costs roughly $0.15 per 1,000 listings**; a **full-detail run** (amenities, host, calendar and revenue per listing) costs around **$2 per 1,000 listings** — still well below browser-based competitors that charge $5–6 per 1,000. Use **Max results per location** to cap the volume, and therefore the cost, of any run.

### How to monitor Airbnb prices in your area

Run the scraper for your target market, then save it as a task and attach an Apify **schedule** (daily or weekly). Each run stores a fresh dataset, so comparing runs over time gives you a nightly-price time series, supply changes, and Superhost density trends — without writing any tracking code. Wire the dataset to Google Sheets or a webhook to get an auto-updating view.

### How to scrape Airbnb reviews

Turn on `includeReviews` and each listing carries a `reviews[]` array — guest rating, full text, reviewer name, date, and the host's response where present. Set `maxReviewsPerListing` (e.g. 20) to cap how many are fetched per listing. Pair reviews with the amenity and rating-breakdown fields to see not just *what* guests scored, but *why* — ideal for competitor pain-point analysis, sentiment models, and listing-copy research.

```json
{
    "reviews": [
        { "rating": 5, "text": "Great location, spotless apartment, responsive host…", "reviewerName": "Laura", "createdAt": "2026-05-12", "response": "Thank you Laura, come back soon!" }
    ]
}
```

### How to estimate Airbnb revenue and occupancy

Turn on `includeRevenueEstimate` and the Actor reads each listing's forward availability calendar to derive an AirDNA-style estimate: `occupancyRate365d`, `bookedNights365d`, `availableNights365d`, `estRevenue365d` (booked nights × nightly price) and `avgMinNights`. Set `calendarMonths` (1–12) to also get the raw per-day `availabilityCalendar` array. It's a directional estimate from public availability, not Airbnb-reported earnings — ideal for ranking markets and screening properties by yield.

```json
{
    "id": "887004639380466573",
    "price": "€142",
    "occupancyRate365d": 0.72,
    "bookedNights365d": 263,
    "availableNights365d": 102,
    "estRevenue365d": 33700,
    "avgMinNights": 2.4,
    "availabilityCalendar": [
        { "date": "2026-08-01", "available": false, "bookable": false, "minNights": 2, "maxNights": 365, "availableForCheckin": false, "availableForCheckout": false }
    ]
}
```

### How many Airbnb listings are there by city?

By default Airbnb caps a single search at roughly 270 results. Turn on `fullCoverage` and the Actor splits the search into nightly-price bands and de-duplicates, surfacing far more of a dense city's inventory — useful for market sizing and supply analysis. Raise `maxPricePerNight` above 10000 for luxury markets so high-end listings aren't missed. Combine `fullCoverage: true` with `skipDetailPages: true` for a fast, wide, cheap city-wide count.

### How to do Airbnb market research

Scrape your target neighborhood, export to CSV, and pivot: average nightly price by area, rating distribution by price tier, Superhost density as a market-maturity proxy, and room-type mix. Use the `latitude`/`longitude` fields to plot supply on a map and spot pricing gaps by location.

### How to export Airbnb data to CSV or Google Sheets

After a run finishes, open the **Dataset** tab and export as CSV, Excel, JSON, XML or HTML table. For a live spreadsheet, connect the Apify **Google Sheets integration** so each scheduled run appends fresh rows automatically.

### Airbnb API alternative

Airbnb has no public listings API. This Actor is the practical alternative: give it a location or search and get structured listing data — prices, ratings, coordinates, host signals — as JSON or CSV, callable from the Apify API or from AI agents via MCP.

### Input configuration

| Field | Type | Notes |
| --- | --- | --- |
| `locationQueries` | array | Destinations to search, e.g. `["Lisbon","Austin TX"]` |
| `maxResults` | integer | Listings per location (billed per listing), default 100 |
| `checkIn` / `checkOut` | string | `YYYY-MM-DD` for accurate per-night pricing |
| `adults` | integer | Guest count |
| `priceMin` / `priceMax` | integer | Nightly price window |
| `minBedrooms` | integer | Minimum bedrooms |
| `currency` | string | Price currency, default `USD` |
| `startUrls` | array | Specific Airbnb room URLs — full record each |
| `skipDetailPages` | boolean | Search-only fast mode |
| `fullCoverage` | boolean | Price-band splitting past the ~270 cap |
| `includeReviews` / `maxReviewsPerListing` | boolean / int | Append reviews per listing |
| `calendarMonths` / `includeRevenueEstimate` | int / boolean | Availability calendar + occupancy & revenue |

### FAQ

**Why does the result count vary between runs?** Airbnb caps and fluctuates how many listings it returns per search — this is Airbnb's behavior, not the scraper. Use more specific locations or date ranges to shape results.

**Are prices per night?** Pass `checkIn`/`checkOut` for accurate per-night pricing for that stay. Without dates, Airbnb returns an indicative price that may span a default stay length.

**Do I need an Airbnb account or API key?** No. No login, no key, no CAPTCHA solver.

### Integrations

Connect the Actor to the tools you already use through Apify integrations:

- **Airbnb → Google Sheets** — auto-append each run's listings to a spreadsheet for collaborative analysis and price tracking.
- **Airbnb → Slack / Discord** — get notified when a run finishes or when new listings appear in your market.
- **Airbnb → Make / Zapier** — trigger downstream workflows: update a CRM, send alerts, populate a database.
- **Airbnb → BigQuery / Snowflake** — pipe listing data into your warehouse via Airbyte for large-scale analytics.
- **Scheduled runs & webhooks** — run daily/weekly to build a price time series, or POST results the moment a run completes.

### Use with AI agents via MCP

This Actor is callable from AI assistants that speak the Model Context Protocol through Apify's MCP server. Prompt in plain English — "get Airbnb listings in Lisbon under €150 with reviews" — and your assistant configures and runs the scraper, returning structured rows.

### Related scrapers

Part of the **datascoutlab** data toolkit:

- [App Store Reviews Scraper](https://apify.com/datascoutlab/appstore-reviews-scraper)
- [Google Play Reviews Scraper](https://apify.com/datascoutlab/googleplay-reviews-scraper)
- [YouTube Outlier Finder](https://apify.com/datascoutlab/youtube-outlier-finder)
- [Google Trends Scraper](https://apify.com/datascoutlab/google-trends-reliable)
- [Telegram Channel Scraper](https://apify.com/datascoutlab/telegram-channels-scraper)

### Disclaimer

This Actor is not affiliated with, endorsed by, or sponsored by Airbnb, Inc. "Airbnb" and related marks are trademarks of Airbnb, Inc. It accesses only publicly available listing data — no login walls, no access controls bypassed. Comply with Airbnb's Terms of Service and applicable laws (GDPR, CCPA). Results may contain personal data; do not scrape personal data without a legitimate basis.

### SEO Keywords

airbnb scraper, airbnb data extraction, airbnb listings scraper, airbnb price scraper, airbnb reviews scraper, airbnb availability calendar, airbnb occupancy data, airbnb revenue estimate, airbnb host scraper, short-term rental data, str market analysis, vacation rental scraper, airbnb api alternative, airbnb bulk export, airbnb csv export, airbnb json export, rental market research, airbnb scraper by location, airbnb listing prices, airbnb room url scraper, apify airbnb actor

# Actor input Schema

## `locationQueries` (type: `array`):

Destinations to search, e.g. `Lisbon`, `Paris, France`, `Austin TX`. Each is searched separately. Optional if you use startUrls.

## `maxResults` (type: `integer`):

Upper limit of listings collected per location. You are billed per listing returned.

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

YYYY-MM-DD (optional) — enables real per-night pricing for these dates.

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

YYYY-MM-DD (optional).

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

Number of guests (optional).

## `priceMin` (type: `integer`):

Minimum nightly price filter (optional).

## `priceMax` (type: `integer`):

Maximum nightly price filter (optional).

## `minBedrooms` (type: `integer`):

Minimum bedrooms (optional).

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

Residential proxy country code (optional), e.g. `US`, `GB`.

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

Currency code for prices, e.g. `USD`, `EUR`, `GBP`. Default USD.

## `skipDetailPages` (type: `boolean`):

Skip per-listing detail pages — return overview rows only (price, rating, coords, name). Much faster for whole-city scans.

## `fullCoverage` (type: `boolean`):

Split the search into price bands to surface far more of a dense city's inventory (thousands of listings) instead of Airbnb's ~270-per-search limit.

## `calendarMonths` (type: `integer`):

Fetch per-day availability for 0–12 future months per listing (0 = off). Adds requests.

## `includeRevenueEstimate` (type: `boolean`):

Add AirDNA-style occupancy rate, booked/available nights and estimated 365-day revenue (uses the availability calendar).

## `maxPricePerNight` (type: `integer`):

Upper price bound for full-coverage band splitting. Raise above 10000 for luxury markets.

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

Specific Airbnb room URLs (e.g. https://www.airbnb.com/rooms/12345) — each returns a full record. Alternative/supplement to location search.

## `includeReviews` (type: `boolean`):

Append a reviews\[] array per listing (rating, text, reviewer, date, host response).

## `maxReviewsPerListing` (type: `integer`):

Cap reviews fetched per listing when reviews are on.

## Actor input object example

```json
{
  "locationQueries": [
    "Lisbon"
  ],
  "maxResults": 100,
  "currency": "USD",
  "skipDetailPages": false,
  "fullCoverage": false,
  "calendarMonths": 0,
  "includeRevenueEstimate": false,
  "maxPricePerNight": 10000,
  "includeReviews": false,
  "maxReviewsPerListing": 20
}
```

# Actor output Schema

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

Listings with price, rating, location and availability.

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

The same rows as CSV — open in Excel or pull into Google Sheets with IMPORTDATA().

# 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 = {
    "locationQueries": [
        "Lisbon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascoutlab/airbnb-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 = { "locationQueries": ["Lisbon"] }

# Run the Actor and wait for it to finish
run = client.actor("datascoutlab/airbnb-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 '{
  "locationQueries": [
    "Lisbon"
  ]
}' |
apify call datascoutlab/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper — Listings, Prices & Ratings by Location",
        "description": "Scrape Airbnb listings for any destination: price per night, ratings, review counts, room type, coordinates, host badges and images. Filter by dates, guests, price and bedrooms. No API key.",
        "version": "0.1",
        "x-build-id": "cbr0T7pkoAi7tGLHm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascoutlab~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascoutlab-airbnb-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/datascoutlab~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascoutlab-airbnb-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/datascoutlab~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascoutlab-airbnb-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": {
                    "locationQueries": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Destinations to search, e.g. `Lisbon`, `Paris, France`, `Austin TX`. Each is searched separately. Optional if you use startUrls.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results per location",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper limit of listings collected per location. You are billed per listing returned.",
                        "default": 100
                    },
                    "checkIn": {
                        "title": "Check-in",
                        "type": "string",
                        "description": "YYYY-MM-DD (optional) — enables real per-night pricing for these dates."
                    },
                    "checkOut": {
                        "title": "Check-out",
                        "type": "string",
                        "description": "YYYY-MM-DD (optional)."
                    },
                    "adults": {
                        "title": "Adults",
                        "type": "integer",
                        "description": "Number of guests (optional)."
                    },
                    "priceMin": {
                        "title": "Min price",
                        "type": "integer",
                        "description": "Minimum nightly price filter (optional)."
                    },
                    "priceMax": {
                        "title": "Max price",
                        "type": "integer",
                        "description": "Maximum nightly price filter (optional)."
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "type": "integer",
                        "description": "Minimum bedrooms (optional)."
                    },
                    "countryCode": {
                        "title": "Proxy country",
                        "type": "string",
                        "description": "Residential proxy country code (optional), e.g. `US`, `GB`."
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code for prices, e.g. `USD`, `EUR`, `GBP`. Default USD.",
                        "default": "USD"
                    },
                    "skipDetailPages": {
                        "title": "Search-only mode (fast & cheap)",
                        "type": "boolean",
                        "description": "Skip per-listing detail pages — return overview rows only (price, rating, coords, name). Much faster for whole-city scans.",
                        "default": false
                    },
                    "fullCoverage": {
                        "title": "Full coverage (beat the ~270 cap)",
                        "type": "boolean",
                        "description": "Split the search into price bands to surface far more of a dense city's inventory (thousands of listings) instead of Airbnb's ~270-per-search limit.",
                        "default": false
                    },
                    "calendarMonths": {
                        "title": "Availability calendar (months)",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Fetch per-day availability for 0–12 future months per listing (0 = off). Adds requests.",
                        "default": 0
                    },
                    "includeRevenueEstimate": {
                        "title": "Occupancy & revenue estimate",
                        "type": "boolean",
                        "description": "Add AirDNA-style occupancy rate, booked/available nights and estimated 365-day revenue (uses the availability calendar).",
                        "default": false
                    },
                    "maxPricePerNight": {
                        "title": "Price-split ceiling",
                        "type": "integer",
                        "description": "Upper price bound for full-coverage band splitting. Raise above 10000 for luxury markets.",
                        "default": 10000
                    },
                    "startUrls": {
                        "title": "Airbnb room URLs",
                        "type": "array",
                        "description": "Specific Airbnb room URLs (e.g. https://www.airbnb.com/rooms/12345) — each returns a full record. Alternative/supplement to location search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReviews": {
                        "title": "Include reviews",
                        "type": "boolean",
                        "description": "Append a reviews[] array per listing (rating, text, reviewer, date, host response).",
                        "default": false
                    },
                    "maxReviewsPerListing": {
                        "title": "Max reviews per listing",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap reviews fetched per listing when reviews are on.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
