# Airbnb Scraper — Vacation Rental Prices, Ratings & Locations (`haketa/airbnb-scraper`) Actor
Scrape Airbnb vacation rental listings by city — name, nightly price, rating, reviews, coordinates and cover photo — for pricing research, host competitor tracking and market or investment analysis. Export clean JSON/CSV in minutes, no login required. Search Istanbul, London, New York and more.
- **URL**: https://apify.com/haketa/airbnb-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Travel, Real estate
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.75 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## 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.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## Airbnb Scraper — Vacation Rental Prices, Ratings & Locations
**Scrape Airbnb vacation rental listings by city as clean, structured data — listing names, nightly prices, currencies, ratings, review counts, coordinates and cover photos for pricing research, host competitor tracking and short-term rental market analysis.**
Export to **JSON, CSV, Excel, or API** — no login, no coding.
> Built for **vacation rental hosts, property managers, revenue & pricing teams, short-term rental investors, travel analysts and data teams** who need comparable Airbnb listings across cities — fast, structured, and repeatable.
***
### 📑 Contents
- [At a glance](#-at-a-glance)
- [Why scrape Airbnb?](#-why-scrape-airbnb)
- [What this Airbnb scraper does](#-what-this-airbnb-scraper-does)
- [Use cases](#-use-cases)
- [Input](#-input)
- [Output](#-output)
- [Pagination & scale](#-pagination--scale)
- [How to use](#️-how-to-use)
- [Tips](#-tips)
- [Integrations](#-integrations)
- [FAQ](#-faq)
- [Related scrapers](#-related-scrapers)
- [Changelog](#-changelog)
***
### ⚡ At a glance
| | |
|---|---|
| **What you collect** | Airbnb listings: name, nightly price, currency, rating, reviews, coordinates, photo, badges |
| **Search by** | City — 20 popular cities built in, plus any city or area you type |
| **Filters** | Guests, minimum bedrooms, nightly price range, exact check-in / check-out dates |
| **Key fields** | `pricePerNight`, `currency`, `rating`, `reviewsCount`, `latitude` / `longitude`, `badges` |
| **Empty run** | Still returns ~100 listings across popular cities |
| **Last verified run** | **500 unique listings across 20 cities in ~5.5 min**, 0% duplicates |
| **Output formats** | JSON, CSV, Excel, HTML and XML via the Apify export |
| **Code required** | None — pick cities and press **Start** |
***
### 🔎 Why scrape Airbnb?
[Airbnb](https://www.airbnb.com) is the largest short-term rental marketplace in the world, and its search results are a live map of the vacation rental economy: what a night costs in **Istanbul** versus **London** or **New York**, how a Superhost apartment near the centre is priced against a studio across town, which listings guests actually rate highly, and where inventory clusters on a map. That data moves constantly with demand, season and local events.
Collecting it by hand is painful. Airbnb shows prices in the viewer's currency, mixes per-night and multi-night totals, repeats listings across search pages, and hides the raw numbers behind an infinite-scroll grid. Copying prices and ratings city by city into a spreadsheet is slow, error-prone, and stale before you finish. An **Airbnb scraper** turns those search pages into one clean record per listing so you can filter, sort, map and compare in seconds.
**Common reasons people scrape Airbnb:**
- **Pricing research** — benchmark your nightly rate against comparable listings in the same city and segment.
- **Host competitor tracking** — monitor rival listings' prices, ratings and review growth over time.
- **Short-term rental investment** — size up cities and neighbourhoods before buying or listing a property.
- **Market & travel analysis** — compare destination supply, price bands and quality signals across cities.
- **Revenue management** — feed a dynamic pricing model with repeatable, timestamped price snapshots.
- **Geospatial mapping** — plot where inventory concentrates and where a new listing would face little competition.
- **Academic & data projects** — build citable rental datasets, price indices and room-type distributions.
***
### 🏡 What this Airbnb scraper does
This **Airbnb scraper** searches Airbnb by city and returns structured vacation rental data — no Airbnb login, no browser automation to babysit, no code. Pick one city or several, optionally narrow by guests, bedrooms, price band or exact dates, and the actor collects one clean, de-duplicated record per listing.
**Features:**
- ✅ **Twenty popular cities built in** — Istanbul, London, New York, Paris, Dubai, Barcelona, Rome, Tokyo, Amsterdam, Bali, Los Angeles, Miami, Berlin, Vienna, Prague, Lisbon, Bangkok, Sydney, Toronto, Cape Town — ready to pick and compare in a single run.
- ✅ **Any city or area you can name** — type destinations outside the list (Antalya, Cappadocia, Marrakech…) and they are searched alongside the picked ones.
- ✅ **Automatic pagination** — steps through Airbnb search pages (18 listings per page) with `items_offset`, de-duplicating by `listingId`, and splits your result cap fairly across cities.
- ✅ **Real nightly prices** — `pricePerNight` is derived correctly even when Airbnb shows a multi-night total, with `originalPrice` kept whenever a discount applies.
- ✅ **Currency detection that follows the locale** — reads the symbol or ISO code from the price (USD, EUR, GBP, JPY, TRY, SEK, and any three-letter code Airbnb returns) so price and currency always stay in sync.
- ✅ **Honest ratings** — `rating` and `reviewsCount` are parsed together; brand-new listings report `reviewsCount: 0` instead of a fabricated score.
- ✅ **Captured fields** grouped: **identity** (`listingId`, `name`, `title`, `subtitle`, `roomType`), **price** (`pricePerNight`, `currency`, `originalPrice`), **quality** (`rating`, `reviewsCount`, `badges`), **location & media** (`latitude`, `longitude`, `imageUrl`, `url`) and `locationQuery` + `scrapedAt`.
- ✅ **Targeting filters** — guests, minimum bedrooms, nightly price band and exact check-in / check-out dates.
- ✅ **Fast & reliable** — HTTP-based with automatic proxy rotation and patient retries; the last verification run collected **500 listings in about 5.5 minutes**.
- ✅ **Export anywhere** — JSON, CSV, Excel, or straight through the Apify API and integrations.
***
### 🎯 Use cases
- **Vacation rental hosts & property managers** — benchmark your `pricePerNight` and `rating` against comparable listings in your city and guest/bedroom segment.
- **Dynamic pricing & revenue teams** — build repeatable, timestamped price snapshots instead of manual spot-checks, and diff them week over week to detect seasonal surges.
- **Short-term rental & real estate investors** — compare price bands, rating distributions, review counts and supply depth across cities before acquiring real estate or onboarding new units.
- **Travel tech & OTA aggregators** — feed real-time vacation rental inventory, geo-coordinates and room categories into comparison engines and mobile travel apps.
- **Market researchers & tourism boards** — study destination supply, room-type mix (villas, apartments, studios) and quality signals across 20+ global cities in a single consolidated export.
- **Data analysts & quantitative researchers** — assemble vacation rental datasets, price indices and occupancy proxy metrics from clean JSON/CSV feeds.
- **GIS & spatial intelligence teams** — plot `latitude` / `longitude` to visualise where inventory clusters, identify undersupplied tourist districts, and map luxury hotspots.
- **B2B travel intelligence & consulting** — conduct automated short-term rental market benchmarking for hospitality advisory reports and investment memos.
- **Academic research & urban planning** — analyze short-term rental density, housing stock impacts, and urban tourism patterns with reproducible public dataset extracts.
***
### 📥 Input
Every field is optional — press **Start** with the defaults for an instant sample, then narrow down. Configure it in the visual Apify form or pass JSON via the API.
| Field | Type | Description |
|---|---|---|
| `locations` | array (select) | Pick one or more of 20 built-in popular cities (e.g. `Istanbul`, `London`, `New York`). |
| `customLocations` | array (string list) | Any extra city or area not in the list, one per line (e.g. `Antalya`, `Cappadocia`). Combined with `locations`. |
| `guests` | string (select) | Only homes hosting at least this many guests (`""`, `1`…`16`). |
| `bedrooms` | string (select) | Only homes with at least this many bedrooms (`""`, `1`…`5`). |
| `priceMin` | integer | Skip listings cheaper than this per night, in the search currency. |
| `priceMax` | integer | Skip listings more expensive than this per night, in the search currency. |
| `checkIn` | string | Check-in date `YYYY-MM-DD` (e.g. `2026-12-10`). Use with `checkOut` for an exact stay. |
| `checkOut` | string | Check-out date `YYYY-MM-DD` (e.g. `2026-12-13`). |
| `maxItems` | integer | Maximum listings to collect across all cities. Leave empty for ~100. |
| `proxyConfiguration` | object | Connection settings. The default Apify proxy works for most runs; switch to residential if a city returns very few listings. |
#### Example input — multi-city comparison
```json
{
"locations": ["Istanbul", "London", "New York", "Paris", "Dubai"],
"maxItems": 500,
"proxyConfiguration": { "useApifyProxy": true }
}
```
#### Example input — family-sized homes in a price band
```json
{
"locations": ["London"],
"guests": "6",
"bedrooms": "3",
"priceMax": 400,
"maxItems": 150
}
```
#### Example input — exact holiday stay
```json
{
"locations": ["Paris"],
"checkIn": "2026-12-24",
"checkOut": "2026-12-27",
"maxItems": 100
}
```
#### Example input — custom city outside the built-in list
```json
{
"locations": [],
"customLocations": ["Cappadocia"],
"maxItems": 150
}
```
An empty input `{}` still returns about 100 listings across the default city mix — the fastest way to see the output shape.
***
### 📤 Output
Each run produces one clean record per Airbnb listing. Field names stay identical across cities and filters, so exports are easy to combine and compare. Empty values are left out of a record.
#### Example output record
```json
{
"listingId": "1501604567440178197",
"name": "Charming Spacious & Rooftop Access in Galata",
"title": "Apartment in Istanbul",
"subtitle": "1905 Galata gem with Golden Horn views, a rooftop terrace, and 3.10 m ceilings",
"roomType": "Apartment",
"rating": 5,
"reviewsCount": 68,
"pricePerNight": 98.2,
"currency": "USD",
"originalPrice": 121,
"latitude": 41.02606,
"longitude": 28.97429,
"imageUrl": "https://a0.muscache.com/im/pictures/hosting/Hosting-1501604567440178197/original/75e2aa34-d076-4073-a8de-992036fd3317.png",
"badges": ["Guest favorite"],
"locationQuery": "Istanbul",
"url": "https://www.airbnb.com/rooms/1501604567440178197",
"scrapedAt": "2026-11-02T02:02:45.941Z"
}
```
#### Field reference
| Field | Description |
|---|---|
| `listingId` | Airbnb listing identifier (natural key, used for de-duplication). |
| `name` | Listing name set by the host. |
| `title` | Title line as shown in search, e.g. `Apartment in Istanbul`. |
| `subtitle` | Subtitle / descriptive line from the search card. |
| `roomType` | Room type parsed from the title, e.g. `Apartment`, `Condo`, `Room`, `Villa`, `Loft`. |
| `pricePerNight` | Price per night, derived from multi-night totals when needed. |
| `currency` | ISO currency code of the price, e.g. `USD`, `EUR`, `SEK`, `JPY`, `TRY` (follows the search locale). |
| `originalPrice` | Pre-discount price per night — present only on discounted listings. |
| `rating` | Guest rating (0–5) — present on rated listings. |
| `reviewsCount` | Number of reviews; `0` for brand-new listings with no score yet. |
| `badges` | Badges such as `Guest favorite`, `Superhost`, `Featured hotel`, `Luxe` — present when available. |
| `latitude` | Listing latitude. |
| `longitude` | Listing longitude. |
| `imageUrl` | Cover photo URL. |
| `locationQuery` | The city as searched (lets you group multi-city runs). |
| `url` | Direct link to the Airbnb listing page. |
| `scrapedAt` | ISO timestamp of when this record was collected. |
#### Field coverage & reliability
| Emoji | Field group | Coverage | Description & Notes |
|---|---|---|---|
| 🆔 | `listingId`, `name`, `title`, `url` | 🟢 High (100%) | Core listing identifiers, canonical host titles and listing links |
| 💰 | `pricePerNight`, `currency` | 🟢 High (~99%) | Normalized per-night rate and detected ISO currency code |
| 📍 | `latitude`, `longitude`, `locationQuery` | 🟢 High (100%) | Coordinates for GIS mapping and searched city attribution |
| 🏷️ | `roomType`, `subtitle` | 🟢 High (100%) | Accommodation category (Apartment, Villa, Loft) and card subtitle |
| ⭐ | `rating`, `reviewsCount` | 🟢 High (~91%) | Guest rating score (0-5) and review counts (0 for new listings) |
| 🏆 | `badges` | 🟡 Conditional (~88%) | Special status tags (`Guest favorite`, `Superhost`, `Luxe`) |
| 🏷️ | `originalPrice` | 🟡 Conditional (~31%) | Pre-discount baseline rate when promotional pricing is active |
| 🖼️ | `imageUrl` | 🟢 High (100%) | Primary high-resolution preview photograph link |
| ⏱️ | `scrapedAt` | 🟢 High (100%) | Precise extraction timestamp on every single record |
Prices ranged from about **$17 to $23,000 per night** (luxury and large whole-home listings) with **zero duplicates**, zero malformed URLs, and no `[object Object]` or out-of-range values in the verification run.
***
### 🔁 Pagination & scale
The actor paginates Airbnb search **automatically**. For each city it steps through the result pages using the `items_offset` parameter (**18 listings per page**), parses the embedded search state, and de-duplicates by `listingId` as it goes — so repeated listings across pages never inflate your dataset.
Airbnb deliberately repeats listings across search pages, so **one city search yields tens of unique listings per pass**. Breadth comes from running multiple cities: the actor divides your `maxItems` cap evenly across the cities in the run and collects up to that many unique listings each. In the latest verification run, **20 built-in cities returned 500 unique de-duplicated listings (25 per city) in ~5.5 minutes with a 0% duplicate rate**. Combining the 20 built-in cities, your own `customLocations`, and filter variations (guests, bedrooms, price band, dates) scales a single run into the hundreds-to-thousands, and scheduled repeated runs build datasets in the tens of thousands. Control the size with `maxItems`.
***
### ⚙️ How to use
1. Open the actor in the **Apify Console** and go to the **Input** tab.
2. Pick one or more **Cities to search** (Istanbul is pre-selected), and/or add **Other cities** one per line.
3. (Optional) Set **Guests**, **Minimum bedrooms**, a **nightly price band**, or exact **check-in / check-out dates**.
4. Set **Max results** (`maxItems`) to the size you want — 100 for a quick look, 500+ for a multi-city dataset.
5. Press **Start** and watch the live log and status counter.
6. When the run finishes, open the **Dataset** tab, then **Export** to **JSON, CSV or Excel**.
7. Prefer automation? Call the actor from the **Apify API**, run it on a **schedule**, or wire it into **Make, Zapier, n8n, Google Sheets** or a webhook.
***
### 💡 Tips
- **Start with one city** to confirm the output shape, then add comparison cities in the same run.
- **Match filters to your comp set** — guests, bedrooms and a price band give a tight, comparable sample that beats raw volume.
- **Use dates when season matters** — flexible-date pricing and holiday-week pricing are different products; collect the one you actually charge against.
- **Read `reviewsCount` with `rating`** — a 5.0 from 3 reviews and a 4.8 from 300 reviews are very different signals.
- **Keep runs comparable** — the same cities and filters on a schedule give a clean time series; changing inputs mid-series breaks it.
- **If a city returns very few listings**, check spelling, widen the price band, or switch **Proxy configuration** to residential — some searches show fuller results that way.
***
### 🔌 Integrations
Results live in a standard Apify dataset, so they flow into the tools you already use:
- **Spreadsheets** — export CSV/Excel, or connect Google Sheets to refresh a pricing workbook on a schedule.
- **Maps & BI** — plot `latitude` / `longitude` in Looker Studio, Tableau, Power BI or any GIS tool.
- **Databases & warehouses** — pull the dataset through the Apify API into Postgres, BigQuery or Snowflake.
- **Automation platforms** — trigger **Make, Zapier or n8n** when a scheduled run finishes (e.g. "new listing under €100").
- **Chat alerts** — post a Slack or email digest of price movers after each run.
- **Custom code** — call the actor from the Apify API / SDKs and read structured JSON back into your pricing pipeline.
***
### ❓ FAQ
#### Is scraping Airbnb legal?
This actor collects **publicly available** Airbnb search results — the same information any visitor sees without logging in. It is an independent tool, not affiliated with Airbnb. Use the collected data responsibly and in line with Airbnb's terms and applicable laws, especially around personal data and republishing.
#### Do I need an Airbnb account or login?
No. The **Airbnb scraper** works entirely on public search pages — no login, no account, no cookies to supply.
#### How many listings can I collect, and how fast?
Set **Max results** (`maxItems`) to the size you need. The latest verification run collected **500 unique listings across 20 cities in about 5.5 minutes**. One city yields tens of unique listings per pass (Airbnb repeats listings across pages); combining the 20 built-in cities plus your own and filter variations scales into the hundreds-to-thousands per run.
#### Do I need proxies?
The **default Apify proxy** is pre-configured and works for most runs. If a specific city returns very few or no listings, switch **Proxy configuration** to residential — some city searches show fuller results that way.
#### What export formats are supported?
**JSON, CSV, Excel (XLSX), HTML and XML** via the Apify Console, or pull the dataset straight through the **Airbnb API** endpoint on Apify.
#### Is there an API?
Yes. Every actor on Apify has a full REST API — start runs, pass input, and fetch the dataset programmatically. This makes the scraper easy to embed in a scheduled pricing pipeline.
#### How is the nightly price calculated?
Airbnb often shows a multi-night total. The actor reads the number of nights, divides to get `pricePerNight`, and keeps the pre-discount `originalPrice` when a discount applies — so the per-night figure in `currency` is always comparable.
#### What currency are prices in?
Airbnb returns prices in the viewer's locale currency, which depends on the proxy IP (often `USD`, but you may also see `EUR`, `GBP`, `SEK`, `JPY`, `TRY`, etc.). The `currency` field is read directly from each price string, so it always matches the number — the scraper detects symbols and three-letter ISO codes alike.
#### Why do some listings have no rating?
They are new. Airbnb shows no score until guests review a listing, so the record carries `reviewsCount: 0` and omits `rating` rather than inventing one.
#### Can I filter by city, guests, bedrooms, price or dates?
Yes — all of them. Pick built-in cities or type your own, and narrow by guests, minimum bedrooms, a nightly price band, and exact check-in / check-out dates.
#### How fresh is the data?
Every run is a live snapshot. Prices, ratings and availability change constantly, so schedule the actor (weekly works well) and compare exports by `listingId` and `scrapedAt` to build a time series.
#### How do I extract 1,000+ listings across multiple destinations?
Set `maxItems` to 1,000 or higher. For comprehensive coverage, select multiple cities in `locations` or add custom regions via `customLocations`. The actor automatically divides the target quota across all specified locations and deep-paginates until the requested volume is collected or available results are exhausted.
#### Can I run this actor on an automated schedule?
Yes. In your Apify Console, navigate to the **Schedules** tab and set up a recurring cron job (e.g., daily at midnight or weekly on Mondays). The actor will extract fresh rates, availability, and review counts and deposit them into your default dataset or stream them via webhooks into your data warehouse or BI dashboard.
#### A run returned very few listings — what should I try?
Check the city spelling, widen or clear the price band, and re-run. If it persists, switch **Proxy configuration** to residential.
***
### 🔗 Related scrapers
Building a travel, accommodation or events dataset? Pair this **Airbnb scraper** with other travel and event actors from the same author:
- **[Expedia Scraper](https://apify.com/haketa/expedia-scraper)** — collect hotel prices, ratings and availability from Expedia to benchmark Airbnb rentals against hotel supply in the same city.
- **[HRS Scraper](https://apify.com/haketa/hrs-scraper)** — scrape hotel rates and details from HRS for business-travel and city accommodation pricing research.
- **[Eventbrite Scraper](https://apify.com/haketa/eventbrite-scraper)** — pull events, dates and venues from Eventbrite to understand the demand spikes that move nightly rental prices.
- **[Meetup Scraper](https://apify.com/haketa/meetup-scraper)** — collect Meetup events and groups by city for local-demand and destination research.
- **[Luma Event Scraper](https://apify.com/haketa/luma-event-scraper)** — gather Luma (lu.ma) events and schedules to track the conferences and gatherings that fill a city's rentals.
- **[Yachtall Scraper](https://apify.com/haketa/yachtall-scraper)** — scrape yacht and boat listings from Yachtall for adjacent travel-market and luxury-rental research.
***
### 📋 Changelog
#### v1.2 (2026-11)
- **1,000+ deep pagination unlocked**: Removed static 40-page city loop limitation; pagination dynamically scales with requested `maxItems` to crawl deep into multi-page search results.
- **Global default destinations pool**: Expanded default sample query pool from 5 to 20 world-class travel hubs (Istanbul, London, New York, Paris, Dubai, Tokyo, Rome, etc.), ensuring large multi-hundred or 1,000+ item extractions succeed seamlessly on default runs.
- **Dynamic cross-city allocation**: Fixed allocation logic so if an initial city exhausts early, subsequent cities automatically consume the remaining quota until `maxItems` is satisfied.
- **Currency normalization**: Added robust ISO-4217 extraction and multi-currency parsing for European, US, and regional proxy locale responses.
#### v1.1 (2026-10)
- **Advanced filtering**: Added granular filtering by guests, minimum bedrooms, price ranges (min/max), and custom check-in / check-out stay dates.
- **Deduplication engine**: Integrated in-memory listing ID deduplication preventing repeated cards across multi-page crawls.
#### v1.0 (2026-09)
- Initial release featuring vacation rental discovery across global metropolitan destinations with nightly price extraction, coordinates, ratings, and instant exports.
***
**Ready to turn Airbnb search into a dataset?** Pick your cities, set `maxItems`, and press **Start** — clean vacation rental data in JSON, CSV or Excel within minutes.
# Changelog
This Actor's version history is a separate document: https://apify.com/haketa/airbnb-scraper/changelog.md
# Actor input Schema
## `locations` (type: `array`):
Pick one or more popular cities to collect vacation rentals from. Great for comparing prices and ratings across destinations in a single run.
## `customLocations` (type: `array`):
Search any city or area that is not in the list above — just type its name, for example 'Antalya', 'Cappadocia' or 'Marrakech'. One entry per line; combined with the cities above.
## `guests` (type: `string`):
Only show homes that can host at least this many guests. Handy when you research family-sized or group rentals instead of studios.
## `bedrooms` (type: `string`):
Only show homes with at least this many bedrooms. Useful for separating whole-home inventory from private rooms and studios.
## `priceMin` (type: `integer`):
Skip listings cheaper than this amount per night, in the currency shown on Airbnb for your search. Helps you focus on a specific price segment.
## `priceMax` (type: `integer`):
Skip listings more expensive than this amount per night, in the currency shown on Airbnb for your search. Helps you stay inside a budget or competitor band.
## `checkIn` (type: `string`):
Check-in date in YYYY-MM-DD format, for example 2026-12-10. Add both dates to see prices for an exact stay instead of flexible upcoming dates.
## `checkOut` (type: `string`):
Check-out date in YYYY-MM-DD format, for example 2026-12-13. Used together with the check-in date above.
## `maxItems` (type: `integer`):
Maximum number of listings to collect across all cities in this run. Leave empty or set to 0 for a balanced sample of about 100 listings.
## `proxyConfiguration` (type: `object`):
Connection settings for loading search results. The default works for most runs; if a run returns very few or no listings, switching this to residential in Apify Proxy can help show complete results for that city.
## Actor input object example
```json
{
"locations": [
"Istanbul"
],
"customLocations": [],
"guests": "",
"bedrooms": "",
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `dataset` (type: `string`):
Link to the dataset with all collected Airbnb listings (name, nightly price, rating, reviews, coordinates, photo and listing URL).
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"locations": [
"Istanbul"
],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
};
// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"locations": ["Istanbul"],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": { "useApifyProxy": True },
}
# Run the Actor and wait for it to finish
run = client.actor("haketa/airbnb-scraper").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"locations": [
"Istanbul"
],
"customLocations": [],
"maxItems": 100,
"proxyConfiguration": {
"useApifyProxy": true
}
}' |
apify call haketa/airbnb-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/airbnb-scraper"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/7jqgtTAdHCj1nJKlR/builds/4BoecS4SAO9UXxREp/openapi.json