# Airbnb Scraper API - Prices, Reviews & Calendar (`datapipe/airbnb-scraper`) Actor

Scrape whole cities or single listings. Extract prices with the full fee breakdown, all six rating categories, host details, amenities, photos, day-by-day availability and guest reviews — 99 fields per listing. Export to JSON, CSV or Excel, run via API, or schedule it. Failed listings are free.

- **URL**: https://apify.com/datapipe/airbnb-scraper.md
- **Developed by:** [Ayoub El Haddad](https://apify.com/datapipe) (community)
- **Categories:** Travel, Real estate
- **Stats:** 1 total users, 1 monthly users, 66.7% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 API extracts public Airbnb listing data without an Airbnb API key, which
does not exist for developers. It returns 99 fields per property — nightly and total price
as numbers, all six rating categories, host details, amenities, day-by-day availability and
guest reviews — from any city, region or room URL, as JSON, CSV or Excel.

*Last updated: 2 September 2026.*

### 99 fields per listing at half the price of the most-used Airbnb scraper

Airbnb has no public API, so most Airbnb scrapers hand you the search card: a title, a
price label and a rating. This one opens every property page and returns the price broken
down line by line as a number you can sort on, all six rating categories, the host, every amenity, day by
day availability, and every guest review if you ask for them.

$2.00 per 1,000 listings against $4.00 for the most-used Airbnb scraper — four times the
fields at half the price, with the availability calendar in the same run, and every guest
review for $0.0003 where the marketplace's review scrapers start at $0.005. Search mode
returns card-level records at $0.50 per 1,000 search results. Walking the search pages to
find a property is free, because finding one is not a product.

Listings that fail are free too. If a property has been pulled, or Airbnb refuses the
request, you get a record with the id, the url and what went wrong, and you are not billed
for it.

Reviews are priced separately at $0.0003 each, and off unless you ask. A busy property
carries several hundred, so folding them into the listing price would charge everyone for
something plenty of callers do not want. Turn on `includeReviews` and you get every review
a listing has, at a third of the cheapest per-review price on the marketplace.

| | This scraper | The most-used Airbnb scraper |
| --- | --- | --- |
| Fields per listing | 99 | 25 |
| Counting nested values | 164 | 58 |
| Listings per 1,000, free plan | $2.00 | $4.00 |
| Listings per 1,000, Diamond plan | $0.30 | $0.50 |
| Guest reviews | $0.0003 each, opt-in, same run | $0.005 each, separate scraper |
| Host and cohost profiles | Included | $6.00 per 1,000 as "enriched" |
| Search pages | Free | Charged |
| Failed listings | Free | Charged |
| Output contract | All 99 declared and described in `dataset_schema.json` | 8 columns in the dataset schema; the rest shown once as an example |

Every figure in that table was read on 1 September 2026, from the Apify API rather than from
a store page — the live `pricingInfos` entry on `tri_angle/airbnb-scraper` and
`tri_angle/airbnb-reviews-scraper` for the prices, and the "Output example" published in
that Actor's own README for the field counts. A store page can lag the price list it bills
on, so the API is what these numbers come from.

#### Measured, not claimed

Every number on this page comes from a run, on the date given, not from a spec sheet.

| What | Measured | When |
| --- | --- | --- |
| Fields per listing | 99, against 25 in the most-used scraper's published output example | 1 Sep 2026 |
| Currencies | 28, each run against Airbnb and returning that currency | 2 Sep 2026 |
| Languages | 18, each run and returned translated | 2 Sep 2026 |
| Default run | 20 listings, all 99 fields, 22 seconds | 2 Sep 2026 |
| Listings priced | 9 of 10 in Paris, Chamonix and Aspen alike | 2 Sep 2026 |
| Billing | 8 listings and 80 reviews delivered, 8 and 80 charged | 1 Sep 2026 |

Pass the dates you care about, because Airbnb quotes a different price for every stay.

### Airbnb data export: 99 fields, in tabs you can read

A record this wide is unreadable as one table, so the dataset arrives grouped. Seven tabs
above your results, each answering one question:

| Tab | What it answers |
| --- | --- |
| **Listings** | The whole picture: photo, name, city, type, capacity, all three prices with the stay they were quoted for, rating, review count, Guest Favourite, Superhost, occupancy and the booking terms |
| **Availability** | The day-by-day calendar, minimum and maximum nights, days free, days blocked, occupancy rate and the next free date |
| **Ratings & reviews** | All six category scores behind the star, the rating distribution, and the reviews themselves |
| **Host** | Host and co-hosts, Superhost status, licence, whether the address is verified |
| **Location** | Coordinates and whether they are exact rather than Airbnb's privacy circle, address, neighbourhood, map link |
| **Amenities & rules** | The full amenity list by category, direct flags for the ones people filter on, house rules, cancellation terms, safety features |
| **Description & photos** | The listing's own copy, highlights, sleeping arrangements, badges and every image |

Switch tabs at the top of the dataset, or export any of them to JSON, CSV or Excel. **All
fields** shows the raw record if you would rather have everything at once.

### Is there an Airbnb API?

Not a public one. Airbnb's API is closed to approved partners — channel managers and
property-management software — and there is no key you can sign up for as a developer.
Searching for an Airbnb API key, or for free Airbnb API access, turns up partner
application forms rather than documentation you can use.

This is the practical substitute: give it a location and it walks Airbnb's search results,
opens each property page, and returns one record per listing with 99 fields, through a REST
API you already have credentials for. No Airbnb login, no partner application, no rate-limit
negotiation. Export to JSON, CSV, Excel or HTML, or pull it straight from the API.

You can run it two ways. Full detail opens every property page and returns everything below.
Search mode reads only the results pages, returns 18 card-level fields per listing, and costs
a third as much. Sweep a whole market in search mode, then go deep on the properties that
matter.

### What Airbnb data can you extract?

Every full detail record contains:

| Group | Fields |
| --- | --- |
| Identity | id, url, name, title, subtitle, description, description language, SEO title, thumbnail, images |
| Location | latitude, longitude, coordinates, neighbourhood, location descriptions, and whether the coordinates are the exact spot rather than Airbnb's privacy circle |
| Capacity | person capacity, bedrooms, beds, bathrooms, room type, property type, home tier |
| Price | nightly rate and stay total as numbers, currency, original and discounted price, nights, and the breakdown line by line. Airbnb quotes all-in prices and no longer itemises cleaning or service fees, so neither does this |
| Ratings | guest satisfaction overall, plus accuracy, check-in, cleanliness, communication, location and value |
| Host | name, id, photo, superhost and verified status, years hosting, response rate and time, rating average and count, listings count, highlights, about (co-hosts are a separate top-level field) |
| Amenities | the complete list, plus direct flags for wifi, air conditioning, heating, kitchen, parking, washer, dedicated workspace and pets |
| Reviews | reviewer, date, rating, review text, highlights and the host response, up to a limit you set |
| Availability | day by day calendar, minimum and maximum nights, availability days total and available, occupancy rate, blocked days |
| Rules and policies | house rules, cancellation policy, check-in and check-out times, self check-in, smoking, parties, commercial photography, licence number |
| Metadata | instant book, highlights, scrapedAt timestamp |

Search mode returns id, url, title, subtitle, name, thumbnail, coordinates, room type,
person capacity, price label, rating, review count, badges and the scrapedAt timestamp.

### Airbnb prices as numbers, not screenshots of numbers

A price label tells you what a listing asks. "$2,119 for 5 nights" is a string; 2119 and
423.63 are numbers you can sort, filter and average. This returns the nightly rate and the
stay total as numbers, the pre-discount price where a stay is discounted, and whether the
listing can actually be booked for those dates at all — seven of eight listings sampled in
one city could not be.

Ratings work the same way. An overall 4.9 hides whether guests marked a place down on
cleanliness or on value, and six category scores tell you which.

Then there is the calendar. Nightly rates alone tell you what a market advertises. Rates
with occupancy tell you what it books.

### Airbnb API pricing: what a run costs

| | Price |
| --- | --- |
| Full detail, 99 fields, with the calendar | $2.00 per 1,000 listings |
| Search results, card-level fields | $0.50 per 1,000 |
| Search pages walked | Free |
| Guest reviews, when you ask for them | $0.0003 each |

Volume discounts follow your Apify plan, down to $0.30 per 1,000 listings.

Scraping 240 listings from one city with full detail costs about $0.48. The same city in
search mode costs about $0.12.

Reviews are the one line that depends on the properties rather than on how many you asked
for. Those 240 listings carry roughly 200 reviews each, so pulling all of them adds about
$14.40. Cap it with `maxReviewsPerListing: 20` and it is about $1.44. If you are budgeting
a run, this is the number to look at twice.

#### Why pay per event

You are charged for listings the scraper returns, not for the work it did to find them.
Paginating a city of 240 listings takes about 14 search pages and costs nothing.

Failures are free as well. A removed property, or one Airbnb refuses to serve, still comes
back as a record carrying the id, the url and what happened, and that record is not billed.
You pay for listings you can use.

### How to scrape Airbnb listings without an API key

1. Add the locations you want under `locationQueries`, or paste listing URLs into
   `startUrls`.
2. Set `checkIn` and `checkOut` for the stay you care about. Airbnb quotes a different
   rate for every stay, so leaving them empty prices a single night a month out instead —
   every record reports the `checkIn` and `checkOut` it was priced for.
3. Choose `mode`. Use `full` for complete property data, `search` for a cheaper sweep.
4. Set `maxListings` to cap the run. Turn on `includeReviews` if you want reviews, and
   `maxReviewsPerListing` to bound how many of them you pay for.
5. Start the run. Results appear in the dataset while the run is still going, so you can
   begin reading before it finishes.

### Input

#### Search one city or many

Each location becomes its own search and all of them merge into a single dataset. Covering
ten cities takes one run rather than ten.

```json
{
  "locationQueries": ["Porto, Portugal", "Lisbon, Portugal", "Braga, Portugal"],
  "mode": "full",
  "maxListings": 500
}
```

#### Set dates, guests and prices

Airbnb prices depend on the stay, so pass the nights you care about. Guest counts
change both the price and which listings appear.

```json
{
  "locationQueries": ["Barcelona, Spain"],
  "checkIn": "2026-09-10",
  "checkOut": "2026-09-15",
  "adults": 2,
  "children": 1,
  "priceMin": 80,
  "priceMax": 300
}
```

#### Scrape Airbnb from another country

Airbnb ranks results and shows prices and availability differently depending on where you
browse from. A Paris search seen from France is not the same result set as the one you get
from a US connection — different ordering, different totals, sometimes different listings.

`proxyCountry` picks the country to browse from. 23 markets are supported:

```json
{
  "locationQueries": ["Paris, France"],
  "proxyCountry": "FR"
}
```

| | |
| --- | --- |
| **Europe** | United Kingdom, France, Germany, Spain, Italy, Portugal, Netherlands, Poland, Sweden, Denmark, Austria, Ireland, Greece, Turkey |
| **Americas** | United States, Canada, Brazil, Mexico |
| **Asia-Pacific** | Japan, South Korea, India, Singapore, Australia |

Leave it empty and the market follows the language you chose, so `locale: "de-DE"` browses
Germany. Set both when you want them to differ — an English-speaking buyer researching the
German market, for example.

The scraper follows Airbnb's own country sites, so a German market run reads `airbnb.de` and
returns what a visitor there actually sees. China and Russia are not offered: Airbnb
withdrew from both, and a search from either returns nothing.

#### Scrape specific listings

Skip search entirely when you already know the properties. `startUrls` accepts room URLs
and bare listing ids in the same list.

```json
{
  "startUrls": [
    "https://www.airbnb.com/rooms/691479",
    "https://www.airbnb.com/rooms/1478285053144011262",
    "1733326288002241501"
  ],
  "mode": "full"
}
```

#### Filter what comes back

```json
{
  "locationQueries": ["Lisbon, Portugal"],
  "roomTypes": ["Entire home/apt"],
  "propertyTypes": ["Apartment", "Loft"],
  "minBedrooms": 2,
  "minBathrooms": 1,
  "minRating": 4.8
}
```

#### Scrape Airbnb reviews and the availability calendar

The calendar comes with every full listing. Reviews are opt-in and billed per review, so
ask for them when you want them — both arrive nested inside the listing record, so a
property and its history stay together.

```json
{
  "locationQueries": ["Madrid, Spain"],
  "includeReviews": true,
  "maxReviewsPerListing": 20,
  "calendarMonths": 3
}
```

`maxReviewsPerListing` defaults to 50, which keeps one very popular property from
dominating the bill. Set it to 0 to take every review a listing has.

#### All input options

| Option | Type | What it does |
| --- | --- | --- |
| `locationQueries` | array | Locations to search. Each becomes its own search, merged into one dataset. |
| `startUrls` | array | Room URLs or bare listing ids to fetch directly, skipping search. |
| `mode` | string | `full` opens every property page. `search` reads results pages only. |
| `checkIn`, `checkOut` | string | Stay dates, so prices reflect a real booking. |
| `adults`, `children`, `infants`, `pets` | integer | Guest counts. These change price and availability. |
| `priceMin`, `priceMax` | integer | Nightly price bounds. |
| `minBeds`, `minBedrooms`, `minBathrooms` | integer | Size filters. |
| `roomTypes` | array | Entire home/apt, private room, shared room, hotel room. |
| `propertyTypes` | array | Keep only listings matching these property types. |
| `minRating` | number | Drop listings rated below this. |
| `maxPages` | integer | Search pages to walk per location. Usually leave empty; `maxListings` already bounds the run. |
| `maxListings` | integer | How many listings to return. Defaults to 20; 0 takes every listing found. |
| `includeReviews` | boolean | Fetch guest reviews. Off by default; billed per review. |
| `maxReviewsPerListing` | integer | Reviews per property, at most. Defaults to 50; 0 fetches every one. |
| `calendarMonths` | integer | Months of availability to pull, from today. 0 skips the calendar. |
| `calendarStartMonth`, `calendarStartYear` | integer | Start the calendar somewhere other than today. Defaults to the current month and year. |
| `currency` | string | Prices converted to this. 28 options, each checked against Airbnb. |
| `locale` | string | Language for review dates, house rules and cancellation terms. 18 options. |

### Output

#### Table view

| id | name | personCapacity | price.label | rating.guestSatisfaction | reviewCount |
| --- | --- | --- | --- | --- | --- |
| 691479 | Loft in Porto | 5 | $1,457 for 5 nights, originally $1,633 | 4.96 | 412 |
| 1478285053144011262 | Apartment in Porto | 4 | $487 for 5 nights | 4.99 | 128 |
| 1599392401671897626 | Apartment in Porto | 6 | $828 for 5 nights | 4.97 | 76 |

#### JSON

```json
{
  "id": "691479",
  "url": "https://www.airbnb.com/rooms/691479",
  "name": "Apartreboleira. Terrace with a view",
  "roomType": "Entire home/apt",
  "propertyType": "Entire loft",
  "personCapacity": 6,
  "bedrooms": "3",
  "beds": "5",
  "bathrooms": "2",
  "latitude": 41.13951,
  "longitude": -8.61515,
  "isSuperHost": true,
  "price": {
    "amount": null,
    "breakdown": [],
    "currency": "USD",
    "discountedPrice": null,
    "label": null,
    "originalPrice": null,
    "qualifier": null
  },
  "rating": {
    "accuracy": 4.97,
    "checkin": 4.98,
    "cleanliness": 4.99,
    "communication": 4.99,
    "guestSatisfaction": 4.96,
    "location": 4.99,
    "value": 4.92
  },
  "host": {
    "about": "Native from Switzerland, leaving in Porto for more then thirty years. Working as an architect (among other act...",
    "details": [
      "Superhost"
    ],
    "highlights": [
      {
        "icon": "SYSTEM_EVENTS",
        "text": "Born in the 60s"
      }
    ],
    "id": "RGVtYW5kVXNlcjozNTM0ODY0",
    "isSuperHost": true,
    "isVerified": true,
    "listingsCount": null,
    "name": "Anne"
  },
  "amenities": [
    {
      "available": true,
      "icon": "SYSTEM_VIEW_OCEAN",
      "name": "River view"
    }
  ],
  "amenityWifi": true,
  "amenityKitchen": true,
  "images": [
    {
      "caption": "Terrace",
      "orientation": "LANDSCAPE",
      "url": "https://a0.muscache.com/im/pictures/9221831/8034b59a_original.jpg"
    }
  ],
  "reviews": [
    {
      "collectionTag": null,
      "createdAt": "2026-08-10T13:42:09Z",
      "date": "2 weeks ago",
      "highlightType": "LENGTH_OF_STAY",
      "id": "1749297646833504458",
      "language": "en",
      "photos": [],
      "rating": 5
    }
  ],
  "availability": [
    {
      "available": false,
      "availableForCheckin": false,
      "availableForCheckout": false,
      "bookable": false,
      "date": "2026-09-01",
      "maxNights": 30,
      "minNights": 2,
      "price": null
    }
  ],
  "availabilityDaysTotal": 30,
  "availabilityDaysAvailable": 5,
  "occupancyRate": 0.8333333333333334,
  "minNights": 2,
  "checkInTime": "Check-in: 3:00 PM - 11:00 PM",
  "houseRules": [
    {
      "icon": "SYSTEM_CLOCK",
      "rule": "Check-in: 3:00 PM - 11:00 PM"
    }
  ],
  "scrapedAt": "2026-08-28T00:49:37.684113927Z",
  "error": null
}
```

### What people use Airbnb data for

Property managers and hosts track what comparable listings nearby charge for the same
nights, and how their occupancy compares. The availability calendar and the price breakdown
together show what a market books at, rather than what it advertises.

Real estate investors screen neighbourhoods before buying by pulling every listing in an
area with occupancy rates and nightly rates attached.

Travel and booking sites build inventory feeds, comparing Airbnb prices against their own.

Researchers and journalists study short term rental density in cities considering
regulation, using coordinates, licence numbers and host portfolios.

Anyone doing due diligence on a host can pull their full portfolio through `startUrls` and
check ratings, response rates and review history across properties.

### How the Airbnb scraper handles blocks and failures

A listing that cannot be fetched becomes a record instead of disappearing. It carries the
id and url you asked for, plus an `error` array explaining what happened:

```json
{
  "id": "999999999999999",
  "url": "https://www.airbnb.com/rooms/999999999999999",
  "error": [
    {
      "scope": "listing",
      "type": "user.airbnb_detail_state_missing",
      "message": "Airbnb PDP state was not present in the detail page HTML"
    }
  ]
}
```

The run carries on and finishes normally. One removed property does not cost you the other
499, and error records are not charged.

Problems that affect the whole run, such as a location Airbnb does not recognise, appear in
the run summary rather than being attached to a listing.

### Frequently asked questions

**Do I need an Airbnb API key?**
No. There is no public Airbnb API to get a key for — it is restricted to approved partner
integrations. This reads the same public pages a browser does, so there is nothing to apply
for and no quota to negotiate.

**Do I need an Airbnb account?**
No. The scraper reads public listing pages and needs no login or cookies.

**Can I call it from Python or n8n?**
Yes. It is an ordinary Apify Actor, so anything that can make an HTTP request can start a
run and read the dataset — the Python and JavaScript clients, n8n, Make, Zapier, or plain
`curl`. The API tab on this page has the exact call with your token filled in.

**Why are prices different from what I see on Airbnb?**
Airbnb quotes by stay, so the same listing has no single price. Without `checkIn` and
`checkOut` this prices one night about a month out and tells you which night on every
record. Pass your own dates and guest counts and the numbers match what a guest is shown.

**Can I get every listing in a city?**
Airbnb caps how deep its own search goes, so no scraper can return literally every property
from one query. Splitting a city into neighbourhoods or price bands and passing them as
separate `locationQueries` reaches more of the inventory.

**How many reviews can I get?**
As many as a listing has, up to `maxReviewsPerListing` — 50 by default, or 0 for every one.
Reviews add time, so cap it when you are sweeping a whole market.

**What does search mode leave out?**
Everything that only exists on the property page: the availability calendar, reviews, the
full amenity list, host details, house rules and the price breakdown. Search mode gives you
the card: id, url, title, price label, rating, capacity, coordinates and thumbnail.

**Is the output shape stable?**
Fields are consistent across records. A field Airbnb does not publish for a given listing
comes back null rather than being dropped, so a column that exists for one listing exists
for all of them.

**Can I run this on a schedule?**
Yes. Schedule it like any other Actor and results append to the dataset each run. The
`scrapedAt` field on every record tells you which run it came from.

### Notes

This is an unofficial scraper. It is not affiliated with, authorised by, sponsored by or
endorsed by Airbnb, and "Airbnb" is used only to say which public website it reads.

Prices, availability and ratings change constantly. A record is a snapshot at `scrapedAt`,
not a standing fact.

Review counts and calendar depth are the two settings that drive run length. A market sweep
with reviews off and `calendarMonths` at 1 finishes far quicker than the same sweep with
every review and a year of availability.

### Start scraping

Paste a city into `locationQueries`, set `checkIn` and `checkOut`, and run it. A 240 listing
city costs about $0.97 with full detail, or $0.13 if you only need the search cards.

# Actor input Schema

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

Cities, regions or neighbourhoods, e.g. \["Porto, Portugal", "Lisbon, Portugal"]. Each one is searched and the results land in the same dataset.

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

Scrape these listings directly and skip the search. Airbnb room URLs or bare listing ids. Use this instead of a location, not as well as.

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

Stop after this many. 20 by default, which is a complete run of every field on a real market in about twenty seconds. Raise it for a full sweep, or set 0 to take every listing the search finds — a big city is thousands of them, so that is a deliberate choice rather than something to inherit.

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

Full opens every listing's own page for the complete record. Search only reads the result cards — much cheaper and faster, but most fields come back empty.

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

Prices come back converted to this. Every option here was checked against Airbnb and returns that currency; the list is what it accepts, not every ISO code.

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

YYYY-MM-DD. Defaults to about a month from the run.

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

YYYY-MM-DD, after check-in. Defaults to the night after check-in.

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

Guest count sent to Airbnb's search, which affects both availability and price.

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

Children in the party. Counts toward occupancy and can change the price.

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

Infants in the party. Most listings do not count them toward occupancy.

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

Pets in the party. Some listings price these separately, others refuse them.

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

In the currency chosen above.

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

In the currency chosen above.

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

Keep only listings with at least this many beds.

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

Keep only listings with at least this many bedrooms.

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

Keep only listings with at least this many bathrooms.

## `minRating` (type: `number`):

Drop listings rated below this, out of 5. A brand-new listing has no rating yet and is dropped too.

## `propertyTypes` (type: `array`):

Empty keeps all. These four are the whole set Airbnb's own filter panel offers.

## `roomTypes` (type: `array`):

Empty keeps all.

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

Off by default because reviews bill per review. Turn it on and you get every review a listing has, up to the cap below.

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

Only used when "Include guest reviews" is on. 50 by default; the busiest listing measured carried 537, so this is what stops one popular property dominating a run. Set 0 for every review, however many that is.

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

How far forward the day-by-day calendar goes, counted from today. Three months covers the booking window most analysis uses; raise it to 12 for a full year, or set 0 to skip the calendar and make the run faster.

## `calendarStartMonth` (type: `integer`):

1-12. Defaults to the month the run happens in, which is almost always what you want.

## `calendarStartYear` (type: `integer`):

Defaults to the year the run happens in. Set it together with the month above to look at a window that does not start today.

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

Usually leave empty — "How many listings" already bounds the run, and search pages are free. About 18 listings per page.

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

The language Airbnb writes review dates, house rules and cancellation terms in. It does not change which listings come back.

## `proxyCountry` (type: `string`):

Which country to search Airbnb from. Airbnb ranks listings, converts prices and shows availability differently depending on where the visitor is, so a Paris search seen from France is not the same result set you get from the United States — different ordering, different totals, sometimes different listings.

Pick the country your buyers browse from. The scraper reads that country's own Airbnb site (airbnb.de for Germany, airbnb.co.uk for the UK) and returns what a visitor there actually sees.

Leave it empty and it follows the language above, so choosing German browses Germany. Set both when they should differ — an English-speaking analyst researching the German market, for example.

China and Russia are not listed: Airbnb withdrew from both in 2022 and a search from either returns nothing.

## Actor input object example

```json
{
  "locationQueries": [
    "Paris, France"
  ],
  "maxListings": 20,
  "mode": "full",
  "currency": "USD",
  "includeReviews": false,
  "maxReviewsPerListing": 50,
  "calendarMonths": 3,
  "locale": "en-US",
  "proxyCountry": ""
}
```

# Actor output Schema

## `records` (type: `string`):

The scraped records, one row each.

## `summary` (type: `string`):

Run-level fields: source, the run instant, and any run-level errors.

# 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, France"
    ],
    "maxListings": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datapipe/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, France"],
    "maxListings": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datapipe/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 '{
  "locationQueries": [
    "Paris, France"
  ],
  "maxListings": 20
}' |
apify call datapipe/airbnb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datapipe/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 <APIFY_API_TOKEN>` 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/6nRRg66EUZxYPllQR/builds/XpqAQNcW6SSKaTY3b/openapi.json