# Airbnb Scraper (`scraperforge/airbnb-scraper`) Actor

🏠 Airbnb Scraper (airbnb-scraper) extracts structured listing data—prices, availability, reviews, ratings, amenities, location & host details—at scale. 🔎 Export via API to CSV/JSON. 📊 Ideal for market research, pricing strategy, rental analytics & competitor tracking. 🚀

- **URL**: https://apify.com/scraperforge/airbnb-scraper.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

Airbnb Scraper is a fast, scalable Airbnb web scraper that discovers listings for your chosen places and dates — with prices, ratings, coordinates, titles, descriptions, and thumbnails saved to your Apify dataset as the run progresses. It solves the challenge of collecting structured Airbnb data at scale for market research and pricing analysis by combining concurrent extraction with geo-accurate filtering. Built for marketers, developers, data analysts, and researchers, this Airbnb data scraper lets you scrape Airbnb listings reliably and export results programmatically for downstream analytics and workflows.

### What data / output can you get?

| Data field | Description | Example value |
| --- | --- | --- |
| id | Airbnb listing identifier parsed from the detail URL | 12345678 |
| url | Direct listing URL with locale, currency, check-in/out applied | https://www.airbnb.com/rooms/12345678?locale=en-US&currency=USD&check_in=2026-06-01&check_out=2026-06-08 |
| title | Listing headline extracted from the page | Charming studio near the Louvre |
| description | Long-form listing description (best-effort extraction) | A bright, newly renovated studio in the heart of Paris… |
| thumbnail | Primary image URL (from JSON-LD or hero image) | https://a0.muscache.com/im/pictures/…/hero.jpg |
| rating.guestSatisfaction | Overall rating score (if present) | 4.86 |
| rating.reviewsCount | Total visible review count (if present) | 128 |
| rating.accuracy | Category rating (if present) | 4.9 |
| price.label | Readable price label as shown on Airbnb | $1,234 total before taxes |
| price.breakDown.total.price | Total price string (best-effort from search/detail) | $1,234 |
| price.breakDown.serviceFee | Service fee (if detected) | $85 |
| price.breakDown.cleaningFee | Cleaning fee (if detected) | $60 |
| coordinates.latitude | Latitude of the listing (if available) | 48.8566 |
| coordinates.longitude | Longitude of the listing (if available) | 2.3522 |
| currency | Currency context used for the run | USD |
| locale | Locale (language/region) used for the run | en-US |

Notes:
- Results stream live to the Apify Dataset. You can export via API to CSV or JSON.
- Some nested fields may be missing when not available on a given page; the actor fills safe defaults and placeholders where possible.

### Key features

- 🧭 Geo-accurate filtering with strict area matching
  - Validates each listing against your intended location using OpenStreetMap Nominatim (bounds, reverse geocoding). With strictGeo enabled, only stays that match your target area are saved — ideal for precise Airbnb market data scraping.

- ⚡ Concurrent detail scraping
  - Asynchronously fetches multiple listing pages with aiohttp and a semaphore-controlled pool for speed and stability, making it a reliable Airbnb scraper tool for batch runs.

- 🔐 Smart proxy fallback
  - Automatic escalation when blocked: direct → datacenter → residential (sticky). Clear log messages guide you through connection changes to keep your Airbnb data extraction running.

- 🧮 Rich price breakdown merging
  - Combines search-page “structuredDisplayPrice” with detail-page data and heuristic fee detection to populate totals, service fees, cleaning fees, and taxes where available — perfect for Airbnb price scraper use cases.

- 🧵 Live dataset streaming
  - Each accepted listing is pushed to the dataset immediately, reducing risk and enabling real-time pipelines for Airbnb scraping API workflows.

- 🔎 Cursor pagination with de-duplication
  - Walks search pages using cursors and avoids duplicates, so you can scrape Airbnb listings efficiently across many pages.

- 🌐 Locale & currency control
  - Set locale and currency per run to align labels and formats with your analysis needs.

- 🧰 Developer-friendly outputs
  - Clean JSON objects with consistent shape (id, url, title, description, rating, price breakdown, coordinates, thumbnail, currency, locale) ready for downstream tools and pipelines.

### How to use Airbnb Scraper - step by step

1) Sign in to your Apify account and open the Airbnb Scraper actor.

2) Add where to search:
   - locationQueries: one place keyword per line (e.g., paris, austin--tx, berlin).
   - Or startItems: paste full Airbnb search URLs (e.g., https://www.airbnb.com/s/london/homes).

3) Set trip dates:
   - checkin and checkout accept absolute dates (YYYY-MM-DD) or relative values like 14 days, 2 weeks.

4) Configure display context:
   - currency (e.g., USD, EUR) and locale (e.g., en-US, fr-FR) to control labels and formats.

5) Control scope and precision:
   - maxItems: how many stays to collect (1–5000).
   - maxPages (optional): page-walking cap; leave empty to auto-tune.
   - strictGeo: keep results strictly in your search area.
   - Optional disambiguation: state and/or country to lock to the right map.

6) Connection settings (optional):
   - proxyConfiguration: enable Apify Proxy if your workspace requires it. The actor will escalate automatically on blocks.

7) Start the run:
   - Listings matching your criteria are pushed to the Dataset as they are collected. Logs show paging, proxy transitions, and save progress.

8) Export your data:
   - Open the Dataset tab and export to CSV or JSON, or pull results via the Apify API into BI tools, pricing engines, or custom pipelines.

Pro tip: Chain runs or integrate with your stack via the Apify API to build automated short-term rental data scraper workflows for dashboards and pricing models.

### Use cases

| Use case | Description |
| --- | --- |
| Market research for cities/regions | Analyze supply, pricing patterns, and rating signals by collecting structured Airbnb listing data across target geographies. |
| Pricing strategy & competitiveness | Track total prices, fees, and discounts to benchmark markets and tune revenue strategies with an Airbnb price scraper pipeline. |
| Mapping & spatial analysis | Export coordinates to visualize density, hot zones, and proximity to landmarks for urban planning or investment analysis. |
| Competitor monitoring | Monitor titles, descriptions, ratings, and pricing changes for specific areas using an automated Airbnb listing scraper. |
| Data enrichment pipelines (API) | Use the Apify API to programmatically scrape Airbnb listings and stream structured data into data warehouses or CRMs. |
| Academic & policy research | Collect publicly available Airbnb market data for longitudinal studies and city-level policy insights. |

### Why choose Airbnb Scraper?

Built for precision, automation, and production-grade reliability, this Airbnb web scraper outperforms lightweight browser extensions and ad‑hoc scripts.

- 🎯 Accurate area matching: Strict location filtering using map bounds and reverse geocoding to keep results true to your target.
- ⚡ Scalable concurrency: Async fetching and de-duplication to scrape Airbnb listings at speed.
- 🌐 Locale & currency control: Get labels and totals aligned with your audience and region.
- 🧩 Developer-first outputs: Clean JSON with consistent price and rating structures for easy parsing.
- 🔐 Resilient networking: Automatic proxy fallback (direct → datacenter → residential) to reduce disruptions.
- 🛡️ No login required: Works without cookies or authentication on publicly available listing pages.
- 🔗 API-ready: Export via API to CSV/JSON and plug into analytics, ETL, and automation platforms.

In short: a reliable Airbnb market data scraper that combines geo-precision with structured outputs for serious analysis.

### Is it legal / ethical to use Airbnb Scraper?

Yes — when done responsibly. This actor collects data from publicly available Airbnb listing pages and does not access private or authenticated content.

Guidelines for compliant use:
- Only extract publicly visible information.
- Respect platform terms and applicable data protection laws (e.g., GDPR/CCPA).
- Avoid scraping personal data or using results for spam.
- Validate your specific use case with your legal team if you operate in regulated contexts.

### Input parameters & output format

Example JSON input
```json
{
  "locationQueries": ["paris"],
  "startItems": ["https://www.airbnb.com/s/london/homes"],
  "checkin": "2026-06-01",
  "checkout": "2026-06-08",
  "currency": "USD",
  "locale": "en-US",
  "maxItems": 20,
  "maxPages": 50,
  "strictGeo": true,
  "state": "",
  "country": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameter reference

- locationQueries (array of string): Place keywords to search (e.g., london, austin--tx). Default: none (prefill: \["paris"]). Required: no.
- startItems (array of string): Optional Airbnb search URLs or other start links. Default: none (prefill: \["https://www.airbnb.com/s/london/homes"]). Required: no.
- checkin (string): Check-in date (YYYY-MM-DD) or relative like 14 days, 2 weeks. Default: 2026-06-01. Required: no.
- checkout (string): Check-out date (must be after check-in). Default: 2026-06-08. Required: no.
- currency (string): Currency code for price labels. Default: USD. Required: no.
- locale (string): Language/region for labels. Default: en-US. Required: no.
- maxItems (integer): Maximum stays to collect (1–5000). Default: 20. Required: no.
- maxPages (integer): Optional cap on result pages (1–500). Default: none. Required: no.
- strictGeo (boolean): Keep results strictly in your search area. Default: true. Required: no.
- state (string): Optional region/state/province disambiguation. Default: "". Required: no.
- country (string): Optional country disambiguation. Default: "". Required: no.
- proxyConfiguration (object): Apify Proxy settings. Default prefill: {"useApifyProxy": false}. Required: no.

Tip: While all fields are optional in the schema, provide at least one of locationQueries or startItems to get results.

Example JSON output

```json
{
  "thumbnail": "https://a0.muscache.com/im/pictures/abc123/hero.jpg",
  "id": "12345678",
  "title": "Charming studio near the Louvre",
  "description": "A bright, newly renovated studio in the heart of Paris, close to museums and cafes...",
  "rating": {
    "accuracy": 4.9,
    "checking": 4.8,
    "cleanliness": 4.9,
    "communication": 5.0,
    "location": 4.9,
    "value": 4.7,
    "guestSatisfaction": 4.86,
    "reviewsCount": 128
  },
  "price": {
    "label": "$1,234 total before taxes",
    "qualifier": "total",
    "price": "$1,234",
    "originalPrice": "",
    "discountedPrice": "$1,234",
    "breakDown": {
      "basePrice": {
        "description": "7 nights × $150.00",
        "price": "$1,050.00"
      },
      "basePriceBreakdown": [
        { "description": "7 nights × $150.00", "price": "$1,050.00" }
      ],
      "serviceFee": "$85",
      "taxes": "$99",
      "total": {
        "price": "$1,234",
        "description": "Total before taxes"
      },
      "totalBeforeTaxes": "$1,234",
      "cleaningFee": "$60",
      "specialOffer": false,
      "earlyBirdDiscount": false
    }
  },
  "coordinates": {
    "latitude": 48.8566,
    "longitude": 2.3522
  },
  "url": "https://www.airbnb.com/rooms/12345678?locale=en-US&currency=USD&check_in=2026-06-01&check_out=2026-06-08",
  "currency": "USD",
  "locale": "en-US"
}
```

Notes:

- Some values may be empty or null if not present on the page (e.g., certain rating categories, fees, or coordinates).
- The actor ensures stable output structure by creating nested keys for rating, price.breakDown, and coordinates.

### FAQ

#### Do I need to log in to use this Airbnb scraper tool?

No. The actor works without login or cookies and targets publicly available Airbnb listing pages. It does not access private or authenticated content.

#### How many listings can I scrape in one run?

You can set maxItems from 1 to 5000. The actor paginates through results using cursors and avoids duplicates to help you scale.

#### What data does it collect from each listing?

It extracts the listing id, url, title, description, thumbnail, rating breakdown (overall and categories when present), a detailed price breakdown (base, fees, total), geographic coordinates, and the run’s currency/locale context.

#### Can I set my own currency and language for labels?

Yes. Use the currency and locale inputs to control how prices and labels are displayed (e.g., USD + en-US, EUR + fr-FR).

#### How does the strict area match work?

When strictGeo is on, the actor resolves your target place via OpenStreetMap Nominatim, checks map bounds, and uses reverse geocoding to validate each listing’s coordinates against your expected area.

#### How do I avoid network blocks?

Enable proxyConfiguration if your workspace supports Apify Proxy. The actor escalates automatically from direct to datacenter, then to residential on repeated blocks, retrying with jitter and logging transitions.

#### Can I export data to my BI tools or pipelines?

Yes. Results are saved to the Apify Dataset in real time. Export via API to CSV or JSON and integrate with your data warehouse, dashboards, or automation flows.

#### Does it scrape availability calendars or full review texts?

No. This actor focuses on listing metadata, rating summaries (including counts), price breakdowns, and coordinates. It does not collect availability calendars or full review content.

### Closing CTA / Final thoughts

Airbnb Scraper is built for structured, reliable Airbnb data extraction at scale. With geo-accurate filtering, rich price breakdowns, and concurrent scraping, it helps marketers, developers, analysts, and researchers turn public listing pages into actionable datasets. Export via API to CSV/JSON, plug into your analytics or pricing workflows, and automate repeatable runs with confidence. Start extracting smarter Airbnb market insights today.

# Actor input Schema

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

Examples: `london`, `paris`, or for the US `Austin--TX` so the right area is clear. Add one entry per line. 🌆

## `startItems` (type: `array`):

Optional: full Airbnb search URLs or other start links — we’ll figure out the place from them. 🔗

## `checkin` (type: `string`):

When your stay starts — calendar date **or** relative (e.g. `14 days`, `2 weeks`). Future trip dates work best for live prices. 📆

## `checkout` (type: `string`):

When your stay ends — must be **after** check-in. Same calendar or relative style as above. 🌅

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

Prices will be shown in this money format. 💶

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

How Airbnb labels listings and prices for you (language/region). 🗣️

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

Stop after this many stays that **match your search** (and your area rules below). 📊

## `maxPages` (type: `integer`):

Advanced: limit how many result pages to scroll. Leave empty and we’ll pick a sensible cap for you. 📑

## `strictGeo` (type: `boolean`):

When **on** ✅ we only keep stays that really belong to the area you meant (great when a city name exists in many countries). When **off**, more results may appear from nearby or similar names. 🌍

## `state` (type: `string`):

Optional dropdown of regions worldwide — pick the closest match, or none. US tip: you can also use `City--ST` in the location field. 🇺🇸

## `country` (type: `string`):

Optional: which country the place should be in (helps when two cities share a name). Leave empty if you’re sure. 🏳️

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

Configure Apify Proxy if needed; otherwise we connect directly. ☁️

## Actor input object example

```json
{
  "locationQueries": [
    "paris"
  ],
  "startItems": [
    "https://www.airbnb.com/s/london/homes"
  ],
  "checkin": "2026-06-01",
  "checkout": "2026-06-08",
  "currency": "USD",
  "locale": "en-US",
  "maxItems": 20,
  "strictGeo": true,
  "state": "",
  "country": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "paris"
    ],
    "startItems": [
        "https://www.airbnb.com/s/london/homes"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/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": ["paris"],
    "startItems": ["https://www.airbnb.com/s/london/homes"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/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": [
    "paris"
  ],
  "startItems": [
    "https://www.airbnb.com/s/london/homes"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper",
        "description": "🏠 Airbnb Scraper (airbnb-scraper) extracts structured listing data—prices, availability, reviews, ratings, amenities, location & host details—at scale. 🔎 Export via API to CSV/JSON. 📊 Ideal for market research, pricing strategy, rental analytics & competitor tracking. 🚀",
        "version": "0.1",
        "x-build-id": "DdXuBzzxAEGQfepAy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-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/scraperforge~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-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/scraperforge~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-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": "📍 Location keywords",
                        "type": "array",
                        "description": "Examples: `london`, `paris`, or for the US `Austin--TX` so the right area is clear. Add one entry per line. 🌆",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startItems": {
                        "title": "🔗 Or paste search links / URLs",
                        "type": "array",
                        "description": "Optional: full Airbnb search URLs or other start links — we’ll figure out the place from them. 🔗",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkin": {
                        "title": "🛎️ Check-in",
                        "type": "string",
                        "description": "When your stay starts — calendar date **or** relative (e.g. `14 days`, `2 weeks`). Future trip dates work best for live prices. 📆",
                        "default": "2026-06-01"
                    },
                    "checkout": {
                        "title": "🚪 Check-out",
                        "type": "string",
                        "description": "When your stay ends — must be **after** check-in. Same calendar or relative style as above. 🌅",
                        "default": "2026-06-08"
                    },
                    "currency": {
                        "title": "💵 Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "JPY",
                            "AUD",
                            "CAD",
                            "CHF",
                            "CNY",
                            "INR",
                            "BRL",
                            "MXN",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "NZD",
                            "SGD",
                            "HKD",
                            "KRW",
                            "TRY",
                            "ZAR",
                            "AED",
                            "THB",
                            "MYR",
                            "PHP",
                            "IDR",
                            "CZK",
                            "HUF",
                            "ILS",
                            "SAR",
                            "CLP",
                            "ARS",
                            "COP",
                            "PEN",
                            "RON",
                            "BGN",
                            "HRK",
                            "ISK",
                            "TWD",
                            "VND"
                        ],
                        "type": "string",
                        "description": "Prices will be shown in this money format. 💶",
                        "default": "USD"
                    },
                    "locale": {
                        "title": "🌐 Language & region (locale)",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "en-AU",
                            "en-CA",
                            "en-IN",
                            "en-IE",
                            "fr-FR",
                            "fr-CA",
                            "de-DE",
                            "es-ES",
                            "es-MX",
                            "es-AR",
                            "it-IT",
                            "pt-BR",
                            "pt-PT",
                            "ja-JP",
                            "ko-KR",
                            "zh-CN",
                            "zh-TW",
                            "nl-NL",
                            "nl-BE",
                            "sv-SE",
                            "da-DK",
                            "nb-NO",
                            "fi-FI",
                            "pl-PL",
                            "ru-RU",
                            "tr-TR",
                            "el-GR",
                            "cs-CZ",
                            "hu-HU",
                            "ro-RO",
                            "uk-UA",
                            "id-ID",
                            "th-TH",
                            "vi-VN",
                            "ms-MY",
                            "hi-IN",
                            "he-IL",
                            "ar-SA",
                            "ca-ES",
                            "hr-HR",
                            "sk-SK",
                            "sl-SI",
                            "bg-BG",
                            "lt-LT",
                            "lv-LV",
                            "et-EE"
                        ],
                        "type": "string",
                        "description": "How Airbnb labels listings and prices for you (language/region). 🗣️",
                        "default": "en-US"
                    },
                    "maxItems": {
                        "title": "🔢 Max stays",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many stays that **match your search** (and your area rules below). 📊",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "📄 Max search pages (optional)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Advanced: limit how many result pages to scroll. Leave empty and we’ll pick a sensible cap for you. 📑"
                    },
                    "strictGeo": {
                        "title": "📌 Strictly stay in my search area",
                        "type": "boolean",
                        "description": "When **on** ✅ we only keep stays that really belong to the area you meant (great when a city name exists in many countries). When **off**, more results may appear from nearby or similar names. 🌍",
                        "default": true
                    },
                    "state": {
                        "title": "📍 Region / state / province",
                        "enum": [
                            "",
                            "Addis Ababa",
                            "Alberta",
                            "Andalusia",
                            "Antioquia",
                            "Auckland",
                            "Australian Capital Territory",
                            "Baden-Württemberg",
                            "Bali",
                            "Bangkok",
                            "Bavaria",
                            "Beijing",
                            "Berlin",
                            "Bogotá D.C.",
                            "Brussels-Capital Region",
                            "British Columbia",
                            "Buenos Aires Province",
                            "Busan",
                            "California",
                            "Cairo Governorate",
                            "Casablanca-Settat",
                            "Catalonia",
                            "Córdoba",
                            "Delhi",
                            "Dubai",
                            "Dublin",
                            "Eastern Cape",
                            "England",
                            "Flanders",
                            "Florida",
                            "Gauteng",
                            "Guangdong",
                            "Hanoi",
                            "Hokkaido",
                            "Ho Chi Minh City",
                            "Hong Kong",
                            "Istanbul",
                            "Jakarta",
                            "Jalisco",
                            "Kanagawa Prefecture",
                            "Karnataka",
                            "KwaZulu-Natal",
                            "Lagos State",
                            "Lazio",
                            "Lesser Poland",
                            "Lima Province",
                            "Lombardy",
                            "Madrid",
                            "Maharashtra",
                            "Manitoba",
                            "Metropolitan Manila",
                            "Mexico City",
                            "Minas Gerais",
                            "Moscow Oblast",
                            "New Brunswick",
                            "New South Wales",
                            "New York",
                            "North Holland",
                            "North Rhine-Westphalia",
                            "Northern Ireland",
                            "Nova Scotia",
                            "Ohio",
                            "Ontario",
                            "Oregon",
                            "Osaka Prefecture",
                            "Pennsylvania",
                            "Provence-Alpes-Côte d'Azur",
                            "Quebec",
                            "Queensland",
                            "Rio de Janeiro",
                            "Riyadh Province",
                            "Saint Petersburg",
                            "Santiago Metropolitan",
                            "Saskatchewan",
                            "São Paulo",
                            "Scotland",
                            "Seoul",
                            "Shanghai",
                            "Sichuan",
                            "Singapore",
                            "South Australia",
                            "South Holland",
                            "Stockholm County",
                            "Taipei",
                            "Tamil Nadu",
                            "Tasmania",
                            "Tel Aviv District",
                            "Texas",
                            "Tokyo",
                            "Victoria",
                            "Viken",
                            "Wales",
                            "Wallonia",
                            "Wellington",
                            "Western Australia",
                            "Western Cape",
                            "Zurich",
                            "Île-de-France"
                        ],
                        "type": "string",
                        "description": "Optional dropdown of regions worldwide — pick the closest match, or none. US tip: you can also use `City--ST` in the location field. 🇺🇸",
                        "default": ""
                    },
                    "country": {
                        "title": "🌎 Country",
                        "enum": [
                            "",
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "France",
                            "Germany",
                            "Italy",
                            "Spain",
                            "Japan",
                            "India",
                            "Brazil",
                            "Mexico",
                            "Ireland",
                            "Netherlands",
                            "Portugal",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Poland",
                            "Czech Republic",
                            "Hungary",
                            "Greece",
                            "Turkey",
                            "South Korea",
                            "China",
                            "Taiwan",
                            "Hong Kong",
                            "Singapore",
                            "New Zealand",
                            "South Africa",
                            "United Arab Emirates",
                            "Saudi Arabia",
                            "Israel",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Thailand",
                            "Malaysia",
                            "Indonesia",
                            "Philippines",
                            "Vietnam",
                            "Egypt",
                            "Nigeria",
                            "Russia",
                            "Ukraine",
                            "Romania",
                            "Finland",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Bulgaria",
                            "Serbia",
                            "Iceland",
                            "Luxembourg",
                            "Estonia",
                            "Latvia",
                            "Lithuania",
                            "Pakistan",
                            "Bangladesh",
                            "Peru",
                            "Ecuador",
                            "Uruguay",
                            "Costa Rica",
                            "Panama",
                            "Morocco",
                            "Kenya",
                            "Qatar",
                            "Kuwait",
                            "Bahrain",
                            "Oman",
                            "Cyprus",
                            "Malta",
                            "Montenegro",
                            "Albania",
                            "North Macedonia"
                        ],
                        "type": "string",
                        "description": "Optional: which country the place should be in (helps when two cities share a name). Leave empty if you’re sure. 🏳️",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🔌 Proxy",
                        "type": "object",
                        "description": "Configure Apify Proxy if needed; otherwise we connect directly. ☁️"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
