# Airbnb Scraper (Pay-Per-Event) (`prodiger/airbnb-listing-scraper`) Actor

Scrape Airbnb listings worldwide for prices, ratings, amenities, host info, photos, coordinates, house rules, and per-day calendar availability. Pay-per-event pricing — only pay for the listings you actually scrape.

- **URL**: https://apify.com/prodiger/airbnb-listing-scraper.md
- **Developed by:** [Arnas](https://apify.com/prodiger) (community)
- **Categories:** E-commerce, Real estate, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

### What does Airbnb Scraper do?

**Airbnb Scraper** extracts every available Airbnb listing for any location worldwide — complete with prices, descriptions, ratings, amenities, host info, GPS coordinates, house rules, photos, and (optionally) per-day calendar availability. Enter a city name, click **Start**, and get structured rental data in JSON, CSV, or Excel. No login, no API key, no browser.

Unlike most other Airbnb scrapers, this one uses **price-range binary splitting** to bypass Airbnb's pagination cap. Most scrapers are limited to ~300 results per query — this one finds every listing in your target area, no matter how big. London returns 12,000+ listings, Tokyo 14,000+, Cape Town 7,400+.

The scraper runs as a serverless Apify Actor, so you also get scheduled runs, integrations (Google Sheets, Make, Zapier, Slack, S3, BigQuery, …), residential proxy rotation, monitoring, and an API to drive it programmatically.

### Why use Airbnb Scraper?

- **100% listing coverage** — price-range splitting bypasses Airbnb's pagination cap.
- **100% price coverage** — every listing has nightly price; with detail pages you also get cleaning fee, service fee, and total price.
- **No browser, low cost** — HTTP-only scraper running on a lightweight Crawlee crawler.
- **Two modes** — fast search-only for market sizing, full mode for rich per-listing data.
- **30+ currencies and 14 locales** — get prices in EUR, GBP, JPY, or whatever currency Airbnb supports.
- **Budget guard** — set a Max Charge Per Run and the actor halts the moment the limit is reached.
- **Auto-extending ceiling** — if your target market has luxury listings above `maxPricePerNight`, the actor automatically extends the ceiling so they aren't silently truncated.
- **Drop-in compatible** with the popular `automation-lab/airbnb-listing` actor at **identical pricing**: $0.005/run + $5/1,000 listings.

### How to use Airbnb Scraper

1. Open the actor in Apify Console and click **Try for free**.
2. Type your target location in **Location queries** (e.g. `London`, `Tokyo, Japan`, `Miami Beach, FL`). Multiple locations are scraped in a single run.
3. Optionally set check-in/check-out dates, guest counts, price range, or filters.
4. Toggle **Search-only mode** for a faster, cheaper market overview.
5. Click **Start** and download the results in JSON, CSV, Excel, XML, or HTML.

### Input

Minimum input:

```json
{
    "locationQueries": ["London"]
}
````

Targeted search with dates and filters:

```json
{
    "locationQueries": ["Barcelona, Spain"],
    "checkIn": "2026-06-15",
    "checkOut": "2026-06-22",
    "adults": 2,
    "currency": "EUR",
    "locale": "en-US",
    "minBedrooms": 2,
    "priceMin": 50,
    "priceMax": 250
}
```

Fast market overview (no detail pages):

```json
{
    "locationQueries": ["Tokyo, Japan"],
    "skipDetailPages": true,
    "maxListings": 500
}
```

With per-day calendar availability for the next 6 months:

```json
{
    "locationQueries": ["Setúbal, Portugal"],
    "calendarMonths": 6
}
```

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `locationQueries` | string\[] | — | Locations to search. At least one is required (or use `startUrls`). |
| `startUrls` | string\[] / object\[] | — | Pre-filtered Airbnb search URLs (paste from your browser). |
| `checkIn` / `checkOut` | string (YYYY-MM-DD) | — | Date range filter. |
| `adults`, `children`, `infants`, `pets` | integer | `1, 0, 0, 0` | Guest counts. |
| `priceMin`, `priceMax` | integer | — | Hard price range filter. |
| `minBeds`, `minBedrooms`, `minBathrooms` | integer | — | Property size filters. |
| `locale` | enum | `en-US` | Listing language. 14 options. |
| `currency` | enum | `USD` | Price currency. 20 options. |
| `skipDetailPages` | boolean | `false` | Search-only mode (faster, fewer fields per listing — same per-listing price). |
| `calendarMonths` | integer 0–12 | `0` | Per-listing calendar months to fetch. |
| `maxListings` | integer | `0` | Stop after N listings (0 = unlimited). |
| `maxPricePerNight` | integer | `10000` | Splitting ceiling (auto-extends for luxury markets). |
| `maxRequestsPerCrawl` | integer | `0` | Cap total HTTP requests (0 = unlimited). |
| `proxyConfiguration` | object | RESIDENTIAL | Apify proxy. Datacenter IPs are blocked by Airbnb. |

### Output

One row per unique listing. Full mode example:

```json
{
    "id": "788405891732745420",
    "title": "Recanto da Lima",
    "url": "https://www.airbnb.com/rooms/788405891732745420",
    "androidLink": "airbnb://rooms/788405891732745420",
    "iosLink": "airbnb://rooms/788405891732745420",
    "thumbnail": "https://a0.muscache.com/im/pictures/...",
    "coordinates": { "latitude": 38.546, "longitude": -8.84326 },
    "roomType": "Private room in home",
    "propertyType": "Private room in home",
    "personCapacity": 3,
    "neighborhood": "Praias do Sado",
    "locationSubtitle": "Quiet riverside neighborhood",
    "isSuperHost": true,
    "rating": {
        "guestSatisfaction": 4.98,
        "reviewsCount": 129,
        "cleanliness": 5,
        "accuracy": 5,
        "checking": 5,
        "communication": 5,
        "location": 4.8,
        "value": 4.9
    },
    "price": {
        "label": "$45 per night",
        "qualifier": "per night",
        "price": "$45",
        "breakDown": {
            "nightlyPrice": "$45",
            "totalPrice": "$315 total",
            "cleaningFee": "$30",
            "serviceFee": "$50"
        }
    },
    "host": {
        "name": "Cláudia",
        "isSuperHost": true,
        "profileImage": "https://...",
        "highlights": ["Superhost", "128 reviews"],
        "about": ["Lives in Setúbal, Portugal"]
    },
    "amenities": [
        { "title": "Bathroom", "values": [{ "title": "Bathtub", "available": true }] }
    ],
    "images": [{ "caption": "Living room", "imageUrl": "https://..." }],
    "houseRules": {
        "general": [{ "title": "Checking in and out", "values": [{ "title": "Check-in after 3:00 PM" }] }]
    },
    "calendar": [
        { "date": "2026-06-01", "available": true, "minNights": 2, "maxNights": 90, "price": "$45" }
    ],
    "timestamp": "2026-05-22T16:00:00.000Z"
}
```

`calendar` is only present when `calendarMonths > 0`. Search-only mode (`skipDetailPages: true`) returns the same row with detail-only fields (`description`, `amenities`, `host`, `images`, `houseRules`, …) set to `null` or `[]`, but **still includes the full `price.breakDown` parsed from search cards** — most other search-only scrapers omit the breakdown.

You can download the dataset in JSON, CSV, HTML, XML, or Excel from the Output tab in Apify Console.

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

Pay-per-event pricing. You pay only for what you scrape — no monthly subscription. All platform costs (compute, residential proxy, storage) are included in the per-listing price.

| Apify plan | Per run | Per listing | 1,000 listings |
| --- | ---: | ---: | ---: |
| Free | $0.005 | $0.005 | $5.00 |
| Starter | $0.005 | $0.005 | $5.00 |
| Scale / Business | $0.005 | $0.005 | $5.00 |

Real-world cost examples (search-only):

| Location | Listings | Cost (Free) |
| --- | ---: | ---: |
| Setúbal, Portugal | ~950 | $4.76 |
| London, UK | ~12,000 | $60.00 |
| Tokyo, Japan | ~14,000 | $70.00 |

Set a **Max Charge Per Run** in Apify Console to protect your budget — the actor halts the moment the limit is reached.

### Tips

- **Start small.** Set `maxListings: 10` for a quick preview before scraping an entire city.
- **Use search-only mode** for market sizing — same per-listing price, ~5× faster, includes the fee breakdown.
- **Run multiple cities in one run** — `locationQueries: ["Paris", "Rome", "Berlin"]` pays the start fee once and dedupes overlapping listings by `id`.
- **Bump `maxPricePerNight`** above 10000 if you're scraping luxury markets and want a higher starting ceiling. The actor will auto-extend it on cap-hit, but starting higher saves an extra round-trip.
- **Use `startUrls`** to pre-apply Airbnb filters that aren't input fields — set up your filtered search on airbnb.com, copy the URL, paste it in.
- **Schedule recurring runs** to track pricing trends over time.

### FAQ and disclaimers

**What's the difference between full mode and search-only mode?**
Full mode visits each listing detail page and returns ~40 fields (description, amenities, host, photos, rules, etc.). Search-only is ~5× faster and returns roughly 15 fields — but unlike most search-only scrapers, this one still returns the price `breakDown` from search cards.

**Why every listing has a price.** Airbnb always includes pricing in search results, so 100% of returned listings have a price regardless of mode.

**What happens on a luxury market with listings above `maxPricePerNight`?** The actor detects the cap-hit on the top window and automatically extends `maxPricePerNight` (doubles, up to $100,000). A warning is logged so you can see it happened.

**Is it legal to scrape Airbnb?** This scraper only accesses publicly available listing data. It does not bypass any login walls or CAPTCHAs. Web scraping of publicly available data is generally legal in most jurisdictions, but listings can contain personal data (host names, photos) which is protected by GDPR and similar laws. Don't scrape personal data unless you have a legitimate reason. Review Airbnb's Terms of Service and consult a lawyer when in doubt.

**Found a bug or have a feature request?** Open an issue on the **Issues** tab — we monitor it and respond within ~1 business day.

### Related actors

- `automation-lab/airbnb-listing` — the reference actor we cloned. Same surface, same price.
- Pair with `automation-lab/airbnb-reviews` to scrape per-listing reviews.

# Actor input Schema

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

Enter one or more locations to search (e.g. 'London', 'Paris, France', 'Miami Beach, FL'). At least one of locationQueries or startUrls is required.

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

Pre-built Airbnb search URLs (alternative to locationQueries). Copy a filtered search URL from your browser to apply property type, amenity, or other filters not available as input fields.

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

Check-in date in YYYY-MM-DD format. Leave empty to scrape without date filters.

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

Check-out date in YYYY-MM-DD format. Must be after the check-in date.

## `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.

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

Only include listings at or above this nightly price.

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

Only include listings at or below this nightly price.

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

Minimum number of beds.

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

Minimum number of bedrooms.

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

Minimum number of bathrooms.

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

Language/locale for listing descriptions and labels.

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

Currency for prices.

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

Skip detail pages — much faster and cheaper per run, but returns fewer fields (no description, amenities, host info, or full photo gallery). Same per-listing price.

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

Number of months of future calendar/availability data to fetch per listing (0–12). Each day includes availability, check-in/check-out eligibility, min/max nights, and price. 0 disables calendar fetching (default).

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

Stop after collecting this many listings. Set to 0 for unlimited. Use a small number (e.g. 10) for testing.

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

Upper bound for the price-range splitting algorithm. The scraper splits price ranges to bypass Airbnb's pagination cap. The actor will automatically extend this ceiling if the top window cap-hits (luxury markets). Increase the starting value only if you want a higher initial ceiling.

## `maxRequestsPerCrawl` (type: `integer`):

Limit total HTTP requests per run. 0 = unlimited. Only set this if you need to cap resource usage.

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

Apify proxy. Residential proxies are strongly recommended — Airbnb blocks datacenter IPs aggressively. Leave the default to use RESIDENTIAL.

## Actor input object example

```json
{
  "locationQueries": [
    "Setúbal, Portugal"
  ],
  "adults": 1,
  "locale": "en-US",
  "currency": "USD",
  "skipDetailPages": false,
  "calendarMonths": 0,
  "maxListings": 0,
  "maxPricePerNight": 10000,
  "maxRequestsPerCrawl": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped Airbnb listings. One record per unique listing id across the run.

# 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": [
        "Setúbal, Portugal"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper (Pay-Per-Event)",
        "description": "Scrape Airbnb listings worldwide for prices, ratings, amenities, host info, photos, coordinates, house rules, and per-day calendar availability. Pay-per-event pricing — only pay for the listings you actually scrape.",
        "version": "0.1",
        "x-build-id": "SIGngHnGLWhH9dbG0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodiger~airbnb-listing-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodiger-airbnb-listing-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/prodiger~airbnb-listing-scraper/runs": {
            "post": {
                "operationId": "runs-sync-prodiger-airbnb-listing-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/prodiger~airbnb-listing-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-prodiger-airbnb-listing-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": "Location queries",
                        "type": "array",
                        "description": "Enter one or more locations to search (e.g. 'London', 'Paris, France', 'Miami Beach, FL'). At least one of locationQueries or startUrls is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Pre-built Airbnb search URLs (alternative to locationQueries). Copy a filtered search URL from your browser to apply property type, amenity, or other filters not available as input fields.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Leave empty to scrape without date filters."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Must be after the check-in date."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 1
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of children."
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of infants."
                    },
                    "pets": {
                        "title": "Pets",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of pets."
                    },
                    "priceMin": {
                        "title": "Minimum price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or above this nightly price."
                    },
                    "priceMax": {
                        "title": "Maximum price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings at or below this nightly price."
                    },
                    "minBeds": {
                        "title": "Minimum beds",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of beds."
                    },
                    "minBedrooms": {
                        "title": "Minimum bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms."
                    },
                    "minBathrooms": {
                        "title": "Minimum bathrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bathrooms."
                    },
                    "locale": {
                        "title": "Language",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "de-DE",
                            "fr-FR",
                            "es-ES",
                            "it-IT",
                            "pt-BR",
                            "ja-JP",
                            "ko-KR",
                            "zh-CN",
                            "zh-TW",
                            "nl-NL",
                            "pl-PL",
                            "ru-RU"
                        ],
                        "type": "string",
                        "description": "Language/locale for listing descriptions and labels.",
                        "default": "en-US"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "CNY",
                            "KRW",
                            "BRL",
                            "INR",
                            "MXN",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "CZK",
                            "HUF",
                            "RUB",
                            "TRY"
                        ],
                        "type": "string",
                        "description": "Currency for prices.",
                        "default": "USD"
                    },
                    "skipDetailPages": {
                        "title": "Search-only mode",
                        "type": "boolean",
                        "description": "Skip detail pages — much faster and cheaper per run, but returns fewer fields (no description, amenities, host info, or full photo gallery). Same per-listing price.",
                        "default": false
                    },
                    "calendarMonths": {
                        "title": "Calendar months",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Number of months of future calendar/availability data to fetch per listing (0–12). Each day includes availability, check-in/check-out eligibility, min/max nights, and price. 0 disables calendar fetching (default).",
                        "default": 0
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many listings. Set to 0 for unlimited. Use a small number (e.g. 10) for testing.",
                        "default": 0
                    },
                    "maxPricePerNight": {
                        "title": "Max price per night (splitting ceiling)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound for the price-range splitting algorithm. The scraper splits price ranges to bypass Airbnb's pagination cap. The actor will automatically extend this ceiling if the top window cap-hits (luxury markets). Increase the starting value only if you want a higher initial ceiling.",
                        "default": 10000
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max HTTP requests",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit total HTTP requests per run. 0 = unlimited. Only set this if you need to cap resource usage.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential proxies are strongly recommended — Airbnb blocks datacenter IPs aggressively. Leave the default to use RESIDENTIAL.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
