# Airbnb Scraper — Listings Search & Detail (`nomad-agent/airbnb-scraper`) Actor

Scrape Airbnb listings into clean structured JSON. Search any location with dates, guests, price and room-type filters — automatic price-range splitting gets past Airbnb's ~270-result cap. Or pass listing URLs for full detail: price, rating, coordinates, host, amenities count, description.

- **URL**: https://apify.com/nomad-agent/airbnb-scraper.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 listing 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

## Airbnb Scraper — Listings Search & Detail

Scrape Airbnb listings into clean, structured JSON — search any location with dates, guests, price, room-type and bedroom/bed filters, or resolve listing URLs to full detail records (optionally including an availability calendar). Built for reliability: automatic price-range splitting gets past Airbnb's ~270-result cap, blocks are classified and logged (never crash a run), and every record comes back in one flat, predictable shape.

### What Airbnb data does this scraper extract?

One flat JSON record per listing:

| Field | Meaning |
|---|---|
| `id` | Airbnb listing id |
| `url` | Direct `airbnb.com/rooms/...` link |
| `title` | Listing name |
| `propertyType` | e.g. "Entire rental unit", "Apartment in Lisbon" |
| `price` / `currency` / `pricePer` | Numeric price, ISO currency, qualifier (`total` / `night`) |
| `rating` / `reviewsCount` | Guest rating and review count |
| `roomType` | Entire home/apt, Private room, Shared room, Hotel room |
| `beds` / `bedrooms` / `baths` | Where Airbnb exposes them |
| `lat` / `lng` | Listing coordinates |
| `hostName` | Host first name (detail mode) |
| `imagesCount` | Number of photos |
| `amenitiesCount` | Number of amenities (detail mode) |
| `personCapacity` / `isSuperhost` / `description` | Detail mode extras |
| `calendar` | `[{month, year, availableDays}, ...]` — only populated when `calendarMonths` > 0 (detail mode); otherwise `null` |
| `mode` | `search` or `detail` |

### Input

| Name | Type | Default | Description |
|---|---|---|---|
| `mode` | string (`search` \| `detail`) | `"search"` | Search a location, or resolve specific listing URLs/ids to full detail records. |
| `location` | string | — | Where to search, as typed on airbnb.com (e.g. `"Lisbon, Portugal"`). Required in search mode. |
| `listingUrls` | array of strings | — | Listing URLs or bare numeric ids. Required in detail mode. |
| `checkIn` / `checkOut` | string (`YYYY-MM-DD`) | — | Optional dates. With both set, prices become stay totals. |
| `priceMin` / `priceMax` | integer | `0` | Nightly price filter bounds. `0` = no bound. |
| `adults` / `children` | integer | `0` | Guest counts. |
| `roomType` | string (enum) | `"any"` | `any`, `entire_home`, `private_room`, `shared_room`, `hotel_room`. |
| `minBedrooms` | integer | `0` | Only listings with at least this many bedrooms. `0` = no filter. |
| `minBeds` | integer | `0` | Only listings with at least this many beds. `0` = no filter. |
| `minBathrooms` | integer | `0` | Only listings with at least this many bathrooms. `0` = no filter. |
| `calendarMonths` | integer | `0` | Detail mode only. Fetch this many months (0–6) of availability into the `calendar` output field. `0` = skip. Best-effort (see Known limitations). |
| `maxItems` | integer | `100` | Hard cap on listings returned. |
| `currency` | string | `"USD"` | ISO currency code for returned prices. |
| `concurrency` *(Advanced)* | integer | `2` | Parallel listing fetches in detail mode (max `4`). Keep low — Airbnb rate-limits aggressively. |
| `maxPriceSplits` *(Advanced)* | integer | `8` | How many times a search may auto-split its price range past the ~270-result cap. Lower it to cap cost on dense markets. |
| `proxyConfiguration` | object | Apify Residential | Proxy group. Residential is strongly recommended — see Pricing below for its separate billing. |

### How to scrape Airbnb listings with this Actor

**Search mode** — set `location` (e.g. `"Lisbon, Portugal"`), optionally `checkIn`/`checkOut`, `priceMin`/`priceMax` (per night), `adults`, `roomType`, `minBedrooms`/`minBeds`/`minBathrooms` and `maxItems`. With dates set, prices are stay totals for those dates. When a query hits Airbnb's ~270-result ceiling, the Actor automatically splits the price range into sub-ranges (up to `maxPriceSplits` times) and searches each — so large markets still come back complete up to your `maxItems`.

**Detail mode** — set `mode` to `detail` and pass `listingUrls` (full URLs or bare numeric ids). Each listing resolves to a full record including coordinates, per-category ratings source, host, photo and amenity counts, a plain-text description, and — if you set `calendarMonths` — a month-by-month availability summary.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-agent/airbnb-scraper").call(run_input={
    "mode": "search",
    "location": "Lisbon, Portugal",
    "checkIn": "2026-09-23",
    "checkOut": "2026-09-28",
    "priceMax": 150,
    "maxItems": 200,
    "proxyConfiguration": {"useApifyProxy": True,
                           "apifyProxyGroups": ["RESIDENTIAL"]},
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["price"], item["currency"], "|", item["title"], item["url"])
````

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-agent~airbnb-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "detail", "listingUrls": ["https://www.airbnb.com/rooms/796929"]}'
```

### Output example

Real `push_data` shape (detail mode, live-fetched 2026-07 — `description` truncated for brevity):

```json
{
  "id": "796929",
  "url": "https://www.airbnb.com/rooms/796929",
  "title": "Rental unit in Lisbon",
  "propertyType": "Entire rental unit",
  "price": 465.0,
  "currency": "EUR",
  "pricePer": "total",
  "rating": 4.92,
  "reviewsCount": 463,
  "roomType": "Entire home/apt",
  "beds": 2.0,
  "bedrooms": 1.0,
  "baths": 1.0,
  "lat": 38.71991,
  "lng": -9.13289,
  "hostName": "Bruno",
  "imagesCount": 44,
  "amenitiesCount": 63,
  "personCapacity": 4,
  "isSuperhost": true,
  "description": "A very cool flat in a great location! ...",
  "calendar": null,
  "mode": "detail"
}
```

With `calendarMonths` set (e.g. `2`), `calendar` is populated instead of `null`:

```json
"calendar": [
  {"month": 7, "year": 2026, "availableDays": 2},
  {"month": 8, "year": 2026, "availableDays": 8}
]
```

### Pricing

Pay per event: **$0.05 per Actor start** and **$0.004 per listing returned**.
100 listings ≈ $0.45. No subscription — pay only for what you fetch.

**Residential proxy is billed separately.** The default `proxyConfiguration` prefill (`{"useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"]}`) turns Apify's Residential Proxy **on by default**, and that traffic is billed separately from the actor's own pay-per-event pricing above — per GB, on top of your Apify plan. As of 2026, Apify lists Residential Proxy at roughly **$7–8/GB depending on plan tier** (Free/Starter ≈ $8/GB, Scale ≈ $7.5/GB, Business ≈ $7/GB) — **check [Apify's current proxy pricing](https://apify.com/pricing) for the up-to-date rate**, since this changes independently of this Actor. If cost-sensitive, you can switch `proxyConfiguration` to a datacenter group or disable it, at the risk of more frequent blocks (see Anti-blocking notes).

### Integrations

Dataset results export straight to JSON, CSV, Excel/XLSX, or a plain HTML table from the Apify Console. Pull them into Make, Zapier or n8n via Apify's native integrations, call `run-sync-get-dataset-items` from any HTTP client (see the `curl` example above), or use the [Apify MCP server](https://apify.com/apify/actors-mcp-server) to let an LLM agent drive this Actor and read results directly.

### Why this Actor?

Airbnb scrapers are notorious for flaky runs and messy nested output. This one is built around three choices: (1) it reads the same structured payloads Airbnb's own site renders from, not brittle HTML selectors; (2) every record is one flat object with stable field names — no digging through `sections[12].section.cardData`; (3) blocks and rate limits are detected and reported with the partial results you already paid for, instead of a crashed run.

### Anti-blocking notes

Airbnb aggressively blocks datacenter and shared IPs. **Residential proxies are strongly recommended** — set `proxyConfiguration` to Apify residential (the default prefill). The Actor uses a fixed browser User-Agent, randomized 1–2.5 s delays between requests, and low concurrency (default 2, max 4). A 403/429/challenge response stops the run gracefully and keeps everything collected so far.

### Use cases

- Market and pricing research for short-term rentals (STR analytics)
- Competitive sets for property managers and revenue managers
- Feeding availability/pricing data into investment models
- Monitoring specific listings (price, rating, review count over time)

### FAQ

**Is it legal to scrape Airbnb?**
The Actor only reads publicly visible listing data — the same data any logged-out visitor sees. Review Airbnb's terms and your local regulations for your use case; you are responsible for how you use the data.

**Why do I get fewer results than Airbnb claims exist?**
Airbnb itself only serves ~15 pages (~270 listings) per query. The Actor splits price ranges to go past that; extremely dense markets may still need narrower filters (dates, room type).

**Why are prices totals, not per night?**
With `checkIn`/`checkOut` set (or when Airbnb picks default dates), listing cards show stay totals — `pricePer` tells you which one you got. Divide by nights for a nightly rate.

**The run says "blocked" — what now?**
Switch to residential proxies, lower concurrency to 1, and retry. Partial results are kept.

**Can I filter by property type (house, apartment, guesthouse, ...) instead of room type?**
Not currently. `roomType` (entire home / private room / shared room / hotel room) is a confirmed, documented-by-reverse-engineering raw filter on Airbnb's search page. A separate "property type" facet (house vs. apartment vs. guesthouse) does not have a similarly discoverable raw query param on the public search page — Airbnb only exposes that facet through its interactive UI, not a stable URL param we could verify. `propertyType` is still returned per-listing in the output (e.g. `"Entire rental unit"`) — it just isn't a request-side filter.

**How reliable is `calendarMonths`?**
It replays an internal, unauthenticated Airbnb GraphQL persisted query (`PdpAvailabilityCalendar`) using a known-good operation hash — live-verified working as of 2026-07. Unlike the amenities count (whose operation hash is rediscovered from a JS bundle on every run), this hash is not currently re-discoverable at runtime from any bundle we could find referenced by the listing page, so it's a static snapshot. If Airbnb ever rotates it, calendar fetches fail closed (best-effort — the rest of the record is unaffected) and `calendar` comes back `null` for that run until the Actor is updated.

**Something broken or missing?**
Open an issue on the Actor's **Issues** tab — it is monitored and fixes ship fast.

### Related Actors

- [Greenhouse Jobs Scraper — Company Job Boards](https://apify.com/nomad-agent/greenhouse-jobs-scraper)
- [Lever Jobs Scraper — Company Job Postings API](https://apify.com/nomad-agent/lever-jobs-scraper)
- [LinkedIn Jobs Scraper — No Login, No Cookies](https://apify.com/nomad-agent/linkedin-scraper)

### Attribution

See `NOTICE`. Price-range-splitting pagination strategy inspired by [digital-engineering/airbnb-scraper](https://github.com/digital-engineering/airbnb-scraper) (GPL-3.0) — **algorithm inspiration only, no code copied, translated or derived**. All code in this Actor was written from scratch against Airbnb's current site (2026) and is MIT-licensed.

# Actor input Schema

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

search = scrape listings for a location; detail = resolve listing URLs/ids to full records.

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

Where to search, as you would type it on airbnb.com (e.g. <code>Lisbon, Portugal</code>, <code>Brooklyn, NY</code>). Required in search mode.

## `listingUrls` (type: `array`):

Listings to fetch in detail mode — full https://www.airbnb.com/rooms/... URLs or bare numeric ids.

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

Optional check-in date (YYYY-MM-DD). With checkOut set, prices become stay totals for those dates.

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

Optional check-out date (YYYY-MM-DD).

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

Lower bound for the nightly price filter. 0 = no bound.

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

Upper bound for the nightly price filter. 0 = no bound.

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

Number of adult guests. 0 = Airbnb default.

## `children` (type: `integer`):

Number of child guests.

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

Filter by room type.

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

Only show listings with at least this many bedrooms. 0 = no filter.

## `minBeds` (type: `integer`):

Only show listings with at least this many beds. 0 = no filter.

## `minBathrooms` (type: `integer`):

Only show listings with at least this many bathrooms. 0 = no filter.

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

Detail mode only. Fetch this many months of day-level availability per listing (starting from checkIn's month, or the current month) and summarize it into the <code>calendar</code> output field. 0 = skip (default). Best-effort against an internal, unauthenticated Airbnb endpoint — may silently return nothing if Airbnb changes it.

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

Hard cap on listings returned. Search mode auto-splits price ranges to reach it past Airbnb's ~270-result cap.

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

ISO currency code for returned prices (USD, EUR, GBP, ...).

## `concurrency` (type: `integer`):

Parallel listing fetches in detail mode. Keep low — Airbnb rate-limits aggressively.

## `maxPriceSplits` (type: `integer`):

How many times a search is allowed to auto-split its price range to get past Airbnb's ~270-result cap (search mode). Higher = more complete results for huge markets, at the cost of more requests. Lower it to cap cost for dense locations.

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

Airbnb frequently blocks datacenter IPs — residential proxies are strongly recommended.

## Actor input object example

```json
{
  "mode": "search",
  "location": "Lisbon, Portugal",
  "priceMin": 0,
  "priceMax": 0,
  "adults": 0,
  "children": 0,
  "roomType": "any",
  "minBedrooms": 0,
  "minBeds": 0,
  "minBathrooms": 0,
  "calendarMonths": 0,
  "maxItems": 20,
  "currency": "USD",
  "concurrency": 1,
  "maxPriceSplits": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "location": "Lisbon, Portugal",
    "maxItems": 20,
    "concurrency": 1,
    "maxPriceSplits": 2,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/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 = {
    "location": "Lisbon, Portugal",
    "maxItems": 20,
    "concurrency": 1,
    "maxPriceSplits": 2,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("nomad-agent/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 '{
  "location": "Lisbon, Portugal",
  "maxItems": 20,
  "concurrency": 1,
  "maxPriceSplits": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call nomad-agent/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper — Listings Search & Detail",
        "description": "Scrape Airbnb listings into clean structured JSON. Search any location with dates, guests, price and room-type filters — automatic price-range splitting gets past Airbnb's ~270-result cap. Or pass listing URLs for full detail: price, rating, coordinates, host, amenities count, description.",
        "version": "0.2",
        "x-build-id": "Gz4EjawI2DG8gcsFE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nomad-agent~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nomad-agent-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/nomad-agent~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nomad-agent-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/nomad-agent~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nomad-agent-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "search = scrape listings for a location; detail = resolve listing URLs/ids to full records.",
                        "default": "search"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search, as you would type it on airbnb.com (e.g. <code>Lisbon, Portugal</code>, <code>Brooklyn, NY</code>). Required in search mode."
                    },
                    "listingUrls": {
                        "title": "Listing URLs or ids",
                        "type": "array",
                        "description": "Listings to fetch in detail mode — full https://www.airbnb.com/rooms/... URLs or bare numeric ids.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Optional check-in date (YYYY-MM-DD). With checkOut set, prices become stay totals for those dates."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Optional check-out date (YYYY-MM-DD)."
                    },
                    "priceMin": {
                        "title": "Min price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound for the nightly price filter. 0 = no bound.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Max price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound for the nightly price filter. 0 = no bound.",
                        "default": 0
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of adult guests. 0 = Airbnb default.",
                        "default": 0
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of child guests.",
                        "default": 0
                    },
                    "roomType": {
                        "title": "Room type",
                        "enum": [
                            "any",
                            "entire_home",
                            "private_room",
                            "shared_room",
                            "hotel_room"
                        ],
                        "type": "string",
                        "description": "Filter by room type.",
                        "default": "any"
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only show listings with at least this many bedrooms. 0 = no filter.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Min beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only show listings with at least this many beds. 0 = no filter.",
                        "default": 0
                    },
                    "minBathrooms": {
                        "title": "Min bathrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only show listings with at least this many bathrooms. 0 = no filter.",
                        "default": 0
                    },
                    "calendarMonths": {
                        "title": "Availability calendar (months)",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Detail mode only. Fetch this many months of day-level availability per listing (starting from checkIn's month, or the current month) and summarize it into the <code>calendar</code> output field. 0 = skip (default). Best-effort against an internal, unauthenticated Airbnb endpoint — may silently return nothing if Airbnb changes it.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on listings returned. Search mode auto-splits price ranges to reach it past Airbnb's ~270-result cap.",
                        "default": 100
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO currency code for returned prices (USD, EUR, GBP, ...).",
                        "default": "USD"
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Parallel listing fetches in detail mode. Keep low — Airbnb rate-limits aggressively.",
                        "default": 2
                    },
                    "maxPriceSplits": {
                        "title": "Max price-range splits",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times a search is allowed to auto-split its price range to get past Airbnb's ~270-result cap (search mode). Higher = more complete results for huge markets, at the cost of more requests. Lower it to cap cost for dense locations.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Airbnb frequently blocks datacenter IPs — residential proxies are strongly recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
