# Airbnb Scraper — Listings, Prices, Calendar & Reviews (`automation_craft/airbnb-scraper`) Actor

Scrape Airbnb by location, search URL, or room URL/ID in one actor. Nightly + total price in your chosen currency, 12-month availability calendar, reviews with host replies (newest first), host profiles. Fair pay-per-event: $0 on zero results.

- **URL**: https://apify.com/automation\_craft/airbnb-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

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 — Listings, Prices, Calendar & Reviews

Get Airbnb data three ways with one actor: search a **location**, paste a **search URL**, or give **room URLs / listing IDs**. Turn on only the data you need — details, availability calendar, reviews, host profile — and pay only for what is actually delivered.

### Quick start

1. Type a location (e.g. `Lisbon, Portugal`) — or paste an Airbnb search URL, or paste room URLs/IDs.
2. Optionally set check-in/check-out dates so prices are exact for that stay.
3. Pick your currency and run. Results land in the dataset as clean JSON.

A 3-night, 2-adult search of Lisbon with full details costs about **half a cent per listing**.

### What you get

Every listing record includes:

- **Prices that are correct**: nightly rate AND stay total with the fee breakdown, always in the currency you selected — never silently switched to the proxy country's currency. If Airbnb shows only a stay total, the nightly rate is computed for you. Verified across 13 currencies (USD, EUR, GBP, INR, JPY, BRL, MXN, AUD, THB, ZAR, AED, TRY, KRW).
- **Working links**: listing ID (as a string — 19-digit IDs break in spreadsheets and JS tools otherwise) and a canonical room URL that opens.
- Title, name, coordinates, rating + review count, badges (e.g. Guest favorite), photos.
- With **details on** (default): description, structured amenities by category, house rules, sub-ratings (cleanliness, location, value…), capacity, and the **host**: ID, name, profile URL, superhost status, rating average/count, years hosting.
- **Calendar add-on**: up to 12 months of per-day availability, check-in eligibility, and min/max nights.
- **Reviews add-on**: newest first — rating, date, text, reviewer, and the host's reply when one exists.
- **Host profile add-on**: the host's about text, verification status, and stats.

### What this actor does NOT do

Honesty up front, so there are no surprises:

- **No emails or phone numbers.** Airbnb does not show host contact details publicly; any actor claiming otherwise is guessing from third-party sources.
- **Calendar shows availability, not prices.** Per-day prices are not in Airbnb's calendar API. For stay pricing, set check-in/check-out dates.
- **One currency per run.** All prices come back in the currency you select (deterministic). There is no "each listing in its own local currency" mode.
- **Flexible-date searches** (e.g. "weekend in August") work by pasting the search URL from airbnb.com. The structured inputs cover exact dates only.
- **Homes only.** Experiences and Services are not scraped.
- A single Airbnb search returns at most ~280 listings — that is Airbnb's cap, not ours. Turn on **Full coverage** to go past it (see below).

### Why this one over the alternatives

- **One actor, whole job.** The market leader splits search, room URLs, and reviews across 3–4 separate actors — most rated under 3 stars. Here everything is one input form.
- **Beats the ~280-result cap.** `fullCoverage` recursively splits the map into sub-areas until the whole city is collected. Verified live: 397 unique Porto listings in a single run, where a plain search stops at ~280.
- **Fair pay-per-event, enforced in code and verified by tests:**
  - Location not recognized → clear status record, **$0**
  - Search returns nothing → status record, **$0**
  - A listing page fails to load → status record, **$0**
  - Charges always equal delivered data, never attempts.
- **Monitoring mode** for scheduled runs: remembers what previous runs (same input) already returned and outputs only new listings — new listings cost, repeats don't.
- **No browser under the hood.** Pure HTTP against Airbnb's own APIs: fast (a 3-listing detailed run takes ~20 s), cheap, and stable.

### Inputs at a glance

| Field | What it does |
|---|---|
| `locationQueries` | Free-text places, geocode-checked (`["Lisbon, Portugal"]`) |
| `searchUrls` | Any `airbnb.com/s/...` URL — every URL filter is honored as-is |
| `roomUrlsOrIds` | `https://www.airbnb.com/rooms/12345` or bare `12345` |
| `checkIn` / `checkOut` | Exact dates → stay-accurate nightly + total pricing |
| `currency` / `locale` | Output currency (ISO code) and language |
| `adults`…`pets`, `priceMin/Max`, `placeType`, `minBedrooms/Beds/Bathrooms`, `amenityIds` | Search filters. Price is per night — the conversion to Airbnb's stay-total filter is handled for you |
| `scrapeDetails` | ON = full records; OFF = fast cheap search cards |
| `includeCalendar` + `calendarMonths` | Availability calendar (1–12 months) |
| `includeReviews` + `maxReviewsPerListing` | Reviews, newest first |
| `includeHostDetails` | Extended host profile |
| `maxListings` | Stop after N listings (0 = no limit) |
| `fullCoverage` | Collect past the ~280 cap via map splitting |
| `monitoringMode` | Output only listings not seen in previous runs |

### Example output

```jsonc
{
  "type": "listing",
  "id": "1547194623602171394",
  "url": "https://www.airbnb.com/rooms/1547194623602171394",
  "title": "Apartment in Lisbon",
  "price": { "nightly": 136.33, "total": 409.0, "nights": 3, "currency": "EUR",
             "breakdown": [{ "description": "3 nights x €126.4", "amount": 379.09 }] },
  "rating": { "value": 4.91, "reviewCount": 32 },
  "subRatings": { "cleanliness": 4.88, "location": 4.97, "value": 4.91 },
  "coordinates": { "latitude": 38.71989, "longitude": -9.12956 },
  "host": { "id": "8361172", "name": "Camila And Cynthia", "isSuperhost": true,
            "ratingAverage": 4.86, "yearsHosting": 10,
            "profileUrl": "https://www.airbnb.com/users/show/8361172" },
  "amenities": [{ "title": "Kitchen and dining", "values": ["..."] }],
  "calendar": [{ "month": 8, "year": 2026,
                 "days": [{ "date": "2026-08-01", "available": true, "minNights": 2 }] }],
  "reviews": [{ "rating": 5, "date": "2026-07-08T15:41:10Z", "text": "...",
                "reviewer": { "name": "Ana" }, "hostReply": null }],
  "sourceQuery": "Alfama, Lisbon"
}
````

When something can't be delivered you get a status record instead of a silent nothing — and no charge:

```json
{ "type": "status", "status": "location_not_found", "sourceQuery": "Xyzzyland",
  "message": "Airbnb does not recognize this location. No charge was made for it." }
```

### Pricing (pay per event)

| Event | Price |
|---|---|
| Actor start | $0.005 |
| Search result card | $0.001 |
| Listing details | $0.004 |
| Availability calendar (per listing) | $0.002 |
| Review | $0.0005 |
| Host profile add-on | $0.002 |

Worked examples:

- 100 search cards (fast mode): **$0.105**
- 100 fully detailed listings: **$0.505**
- 100 detailed listings + calendar + 20 reviews each: **$1.81**

Reviews are ~10× cheaper than the category leader ($0.0005 vs $0.005).

### Tested

Every feature path is verified by a 36-scenario live acceptance suite before each release: 6 continents, 13 currencies, 8 languages, big-city pagination, full-coverage map splitting, tiny villages, the Galápagos, unicode and ambiguous queries, pasted URLs, bare IDs, every add-on, and every $0-fairness path. The release you're running passed 36/36.

### FAQ

**Is scraping Airbnb legal?** This actor collects only publicly visible data — no login, nothing behind authentication. Make sure your use complies with your local regulations and Airbnb's terms.

**A field changed / something broke?** Airbnb ships changes regularly. Open an issue in the Issues tab — fast fixes and honest answers are the point of this actor.

***

Built on the MIT-licensed [pyairbnb](https://github.com/johnbalvin/pyairbnb) by John Balvin — vendored and hardened (geo-domain fallback, retry/backoff, cap-beating map recursion, deterministic currency).

# Actor input Schema

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

Free-text places to search, e.g. `Lisbon, Portugal` or `Brooklyn, NY`. Each location is geocode-checked first — unrecognized locations produce a clear status record and are never charged.

## `searchUrls` (type: `array`):

Search result URLs pasted straight from airbnb.com — every filter in the URL (dates, price, flexible dates, amenities…) is honored as-is. This is also the way to run flexible-date searches.

## `roomUrlsOrIds` (type: `array`):

Direct listing URLs (`https://www.airbnb.com/rooms/12345`) or bare numeric IDs (`12345`). Scraped as full detail pages, no search step needed.

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

YYYY-MM-DD. With check-out set, prices become stay-accurate (nightly + total incl. fees).

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

YYYY-MM-DD.

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

Number of adult guests.

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

Number of children.

## `infants` (type: `integer`):

Number of infants.

## `pets` (type: `integer`):

Number of pets travelling.

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

Per night, in the selected currency. (Airbnb's API filters on the stay total when dates are set — the conversion is handled for you.)

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

Per night, in the selected currency. 0 = no cap. (Stay-total conversion handled automatically when dates are set.)

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

Filter by type of place.

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

Minimum bedrooms.

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

Minimum beds.

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

Minimum bathrooms.

## `amenityIds` (type: `array`):

Airbnb numeric amenity IDs, e.g. 4 = WiFi, 7 = Pool, 12 = Kitchen, 5 = A/C, 9 = Free parking, 33 = Washer, 30 = Heating.

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

ISO currency code for ALL prices in the output — deterministic, never dependent on proxy country. Examples: USD, EUR, GBP, INR, JPY, BRL, MXN, AUD, THB, ZAR, AED, TRY.

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

Language for titles, descriptions and reviews, e.g. en, es, fr, de, ja, pt.

## `scrapeDetails` (type: `boolean`):

ON: every listing's detail page is scraped (amenities, description, host, sub-ratings, all images). OFF: fast mode — search cards only (id, url, title, prices, rating, coordinates), much cheaper.

## `includeCalendar` (type: `boolean`):

Per-day availability, check-in eligibility and min/max nights. Note: availability only — Airbnb's calendar API does not include per-day prices.

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

How many months of availability (1–12).

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

Reviews sorted newest-first, including host replies.

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

Cap on reviews scraped per listing.

## `includeHostDetails` (type: `boolean`):

Host about-section, verifications and stats (adds one request per listing).

## `maxListings` (type: `integer`):

Stop after this many listings across all queries. 0 = no limit. The default is a small taster — raise it for real runs.

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

Airbnb caps any single search at ~280 results. ON: the map is recursively split into sub-areas until every listing is collected. Big cities can return thousands of results — combine with Max listings to control cost.

## `monitoringMode` (type: `boolean`):

Remembers listings seen in previous runs (per identical input) and outputs only NEW ones. Ideal for scheduled runs.

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

Residential proxies are strongly recommended — Airbnb rate-limits single IPs.

## Actor input object example

```json
{
  "locationQueries": [
    "Lisbon, Portugal"
  ],
  "adults": 0,
  "children": 0,
  "infants": 0,
  "pets": 0,
  "priceMin": 0,
  "priceMax": 0,
  "placeType": "",
  "minBedrooms": 0,
  "minBeds": 0,
  "minBathrooms": 0,
  "currency": "USD",
  "locale": "en",
  "scrapeDetails": true,
  "includeCalendar": false,
  "calendarMonths": 12,
  "includeReviews": false,
  "maxReviewsPerListing": 50,
  "includeHostDetails": false,
  "maxListings": 5,
  "fullCoverage": false,
  "monitoringMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `listings` (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 = {
    "locationQueries": [
        "Lisbon, Portugal"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/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, Portugal"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper — Listings, Prices, Calendar & Reviews",
        "description": "Scrape Airbnb by location, search URL, or room URL/ID in one actor. Nightly + total price in your chosen currency, 12-month availability calendar, reviews with host replies (newest first), host profiles. Fair pay-per-event: $0 on zero results.",
        "version": "0.1",
        "x-build-id": "5iphElhw5RNlMbdhb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation_craft~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation_craft-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/automation_craft~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation_craft-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/automation_craft~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation_craft-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": "Free-text places to search, e.g. `Lisbon, Portugal` or `Brooklyn, NY`. Each location is geocode-checked first — unrecognized locations produce a clear status record and are never charged.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Airbnb search URLs",
                        "type": "array",
                        "description": "Search result URLs pasted straight from airbnb.com — every filter in the URL (dates, price, flexible dates, amenities…) is honored as-is. This is also the way to run flexible-date searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "roomUrlsOrIds": {
                        "title": "Room URLs or listing IDs",
                        "type": "array",
                        "description": "Direct listing URLs (`https://www.airbnb.com/rooms/12345`) or bare numeric IDs (`12345`). Scraped as full detail pages, no search step needed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "YYYY-MM-DD. With check-out set, prices become stay-accurate (nightly + total incl. fees)."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
                        "type": "string",
                        "description": "YYYY-MM-DD."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 0,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 0
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Number of children.",
                        "default": 0
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of infants.",
                        "default": 0
                    },
                    "pets": {
                        "title": "Pets",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of pets travelling.",
                        "default": 0
                    },
                    "priceMin": {
                        "title": "Min price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per night, in the selected currency. (Airbnb's API filters on the stay total when dates are set — the conversion is handled for you.)",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Max price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per night, in the selected currency. 0 = no cap. (Stay-total conversion handled automatically when dates are set.)",
                        "default": 0
                    },
                    "placeType": {
                        "title": "Type of place",
                        "enum": [
                            "",
                            "Entire home/apt",
                            "Private room"
                        ],
                        "type": "string",
                        "description": "Filter by type of place.",
                        "default": ""
                    },
                    "minBedrooms": {
                        "title": "Min bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum bedrooms.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Min beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum beds.",
                        "default": 0
                    },
                    "minBathrooms": {
                        "title": "Min bathrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum bathrooms.",
                        "default": 0
                    },
                    "amenityIds": {
                        "title": "Amenity IDs",
                        "type": "array",
                        "description": "Airbnb numeric amenity IDs, e.g. 4 = WiFi, 7 = Pool, 12 = Kitchen, 5 = A/C, 9 = Free parking, 33 = Washer, 30 = Heating."
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO currency code for ALL prices in the output — deterministic, never dependent on proxy country. Examples: USD, EUR, GBP, INR, JPY, BRL, MXN, AUD, THB, ZAR, AED, TRY.",
                        "default": "USD"
                    },
                    "locale": {
                        "title": "Results language",
                        "type": "string",
                        "description": "Language for titles, descriptions and reviews, e.g. en, es, fr, de, ja, pt.",
                        "default": "en"
                    },
                    "scrapeDetails": {
                        "title": "Scrape full listing details",
                        "type": "boolean",
                        "description": "ON: every listing's detail page is scraped (amenities, description, host, sub-ratings, all images). OFF: fast mode — search cards only (id, url, title, prices, rating, coordinates), much cheaper.",
                        "default": true
                    },
                    "includeCalendar": {
                        "title": "Availability calendar",
                        "type": "boolean",
                        "description": "Per-day availability, check-in eligibility and min/max nights. Note: availability only — Airbnb's calendar API does not include per-day prices.",
                        "default": false
                    },
                    "calendarMonths": {
                        "title": "Calendar months",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many months of availability (1–12).",
                        "default": 12
                    },
                    "includeReviews": {
                        "title": "Reviews",
                        "type": "boolean",
                        "description": "Reviews sorted newest-first, including host replies.",
                        "default": false
                    },
                    "maxReviewsPerListing": {
                        "title": "Max reviews per listing",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on reviews scraped per listing.",
                        "default": 50
                    },
                    "includeHostDetails": {
                        "title": "Extended host profile",
                        "type": "boolean",
                        "description": "Host about-section, verifications and stats (adds one request per listing).",
                        "default": false
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many listings across all queries. 0 = no limit. The default is a small taster — raise it for real runs.",
                        "default": 5
                    },
                    "fullCoverage": {
                        "title": "Full coverage (beat the ~280 result cap)",
                        "type": "boolean",
                        "description": "Airbnb caps any single search at ~280 results. ON: the map is recursively split into sub-areas until every listing is collected. Big cities can return thousands of results — combine with Max listings to control cost.",
                        "default": false
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only new listings)",
                        "type": "boolean",
                        "description": "Remembers listings seen in previous runs (per identical input) and outputs only NEW ones. Ideal for scheduled runs.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended — Airbnb rate-limits single IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
