# Airbnb Reviews Scraper & API: Every Review, from $0.50/1K (`alexmorain/airbnb-reviews-scraper`) Actor

Scrape every review of any Airbnb listing: rating, original-language text (never a translation), exact date, host reply, reviewer first name and home town. 3,202 of 3,202 on the largest listing we found. New-reviews-only monitoring and webhook.

- **URL**: https://apify.com/alexmorain/airbnb-reviews-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Travel, Marketing, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reviews

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 Reviews Scraper

This Actor exports every review of any Airbnb listing. Give it listing URLs or ids and it returns one row per review: the star rating, the review text exactly as the guest wrote it, the language, the exact date, the host's reply, the reviewer's first name, home town and profile photo, and the stay highlight Airbnb shows under the review. A summary row per listing comes with it.

It works as an **Airbnb reviews API**: plain HTTP requests to the data source the listing page uses when you scroll its reviews. No browser, no Airbnb login, no residential proxy. Pricing is pay per event: $1.00 per 1,000 reviews on the Apify Free plan, down to $0.50 per 1,000 on Gold, plus $0.005 when a run starts.

**What makes it different:** it has no cap on the number of reviews (3,202 of 3,202 on the largest listing we found), it returns the original text in the guest's own language and never a machine translation, and it has a **New reviews only** mode that remembers what it already delivered, so a scheduled run charges only for new reviews.

***

### What does Airbnb Reviews Scraper do?

For each listing you give it, the Actor:

1. Reads the listing id from the URL (the number after `/rooms/`), on any Airbnb domain, or uses the id you pasted.
2. Asks for the first page of reviews. The answer announces the total number of reviews, which tells the Actor how many pages to read.
3. Reads the pages 50 reviews at a time, four pages in parallel, in the order you chose.
4. Reads the listing page for its name, overall rating, city and approximate coordinates.
5. Pushes the reviews in batches of 100, and adds one summary row for the listing unless you turn it off.

Supported pages are stays: `https://www.airbnb.com/rooms/<id>` (also `/rooms/plus/<id>`), with or without query strings, on `.com`, `.fr`, `.co.uk` and the other Airbnb domains. Experiences and services are not covered.

### Why scrape Airbnb reviews?

- **Host and property manager monitoring.** Schedule it in New reviews only mode: each run returns only the reviews that appeared since the last one, and you are not charged again for the ones you already have. A webhook tells Slack, Make, Zapier or n8n when a run ends.
- **Competitor research.** Read what guests praise or complain about at the listings around yours, in every language, with the lowest-rated reviews first if you want.
- **Sentiment analysis and LLM pipelines.** The text is the original review, with a language code. You choose what to translate and with which model.
- **Market studies.** Review dates, ratings and reviewer origin (home town or years on Airbnb) per listing.
- **Datasets.** Complete review histories for a list of listings, with stable review ids.

Apify adds scheduling, an API for every run, integrations with Google Sheets, Slack, Zapier, Make and n8n, and exports to JSON, CSV and Excel.

### How to scrape Airbnb reviews

#### From the Apify console

1. Click **Try for free** and open the Actor.
2. Open a listing on Airbnb and copy its URL, for example `https://www.airbnb.com/rooms/12937`. The number after `/rooms/` is the listing id.
3. Paste it in **Listing URLs or ids**, one per line. A bare id such as `12937` works too.
4. Set **Max reviews per listing**. The default is 100, and `0` means every review.
5. Optionally choose an order, a start date, or **New reviews only**.
6. Click **Start**, then export the dataset as JSON, CSV or Excel.

### Which fields should I fill?

| I want to... | Fill | Notes |
|---|---|---|
| Try it once | **Listing URLs or ids** | The prefilled listing with 50 reviews costs about six cents on the Free plan and took 4 seconds in our test. |
| Get every review of a listing | **Max reviews per listing** = `0` | One charged result per review, so this is also your cost cap per listing. |
| Read the worst reviews first | **Order** = `Lowest rated first` | Also `Highest rated first`. The default is newest first. |
| Get reviews since a fixed date | **Only reviews published after** | `YYYY-MM-DD`. Newest first is the only order that stops reading early at the date. |
| Monitor a listing | **New reviews only** = on | Add a **Monitoring key** for several independent watches on one listing. |
| Change the labels language | **Interface language** | Changes Airbnb's labels only, never the review text. |
| Be told when a run ends | **Webhook URL** | Receives a JSON summary. |
| Get a reviews-only CSV | **Add one summary row per listing** = off | Otherwise the dataset also holds one `place` row per listing. |

### Input examples

**One listing, the 50 newest reviews:**

```json
{
    "startUrls": ["https://www.airbnb.com/rooms/53997462"],
    "maxReviewsPerListing": 50
}
```

**Every review of a large listing:**

```json
{
    "startUrls": ["https://www.airbnb.com/rooms/35636293"],
    "maxReviewsPerListing": 0,
    "sortBy": "newest"
}
```

**The lowest rated reviews of two listings, by URL and by id, since January 2026:**

```json
{
    "startUrls": ["https://www.airbnb.fr/rooms/12937", "35636293"],
    "maxReviewsPerListing": 0,
    "sortBy": "lowest-rated",
    "reviewsNewerThan": "2026-01-01"
}
```

**Daily monitoring, with a webhook and French labels:**

```json
{
    "startUrls": ["https://www.airbnb.com/rooms/53997462"],
    "maxReviewsPerListing": 0,
    "newOnly": true,
    "locale": "fr",
    "webhookUrl": "https://hooks.example.com/airbnb"
}
```

### Details that need a word

- **50 reviews per page, whatever you ask.** Airbnb serves 50 reviews per page at most. If a request asks for 100, Airbnb answers 50 without an error. A scraper that then moves its offset by 100 skips every second page. This Actor reads 50 at a time and checks what it read against the announced total.
- **The text is always the original.** Airbnb's site can show a machine translation. This Actor never asks for it: `text` is the review in the guest's language, and `language` is that language. The interface language only changes Airbnb's labels (`stayHighlight`, `reviewerTenure`, the reply date).
- **Line breaks are kept.** Airbnb sends reviews with HTML line breaks and entities. The Actor turns them into plain text with real line breaks.
- **`rating` can be `null`.** Some reviews are text with no stars: 8 of 502 on the New York listing in our recon (1.6%), none on the Rome listing. They are reviews, so they are returned and charged like the others.
- **Most helpful order is not offered.** Airbnb's site fails on it (the answer has no data), so the Actor offers newest, highest rated and lowest rated only.
- **One listing twice is read once**, and a listing Airbnb does not know is reported and skipped. The run is marked failed only when every listing failed.
- **IP and proxy.** The Actor starts from the Apify IP. If Airbnb answers 401, 403, 429 or a server error, it switches to the datacenter proxy and takes a new IP for each later refusal. Airbnb also changes the identifier of its review query from time to time. The Actor re-reads it from Airbnb's site when the old one is refused.

### What data can it extract? Every output field

Each review is one dataset row with `"type": "review"`.

| Field | Type | Description |
|---|---|---|
| `type` | string | `review` for a review, `place` for the summary row |
| `source` | string | Always `airbnb` |
| `reviewId` | string | Airbnb review id, stable across runs |
| `rating` | number | Stars, 1 to 5. `null` on reviews that carry text only |
| `ratingScale` | integer | Always `5` |
| `text` | string | The review, original language, line breaks kept |
| `language` | string | Language code the guest wrote in (`en`, `es`, `fr`...) |
| `publishedAt` | string | Exact review date and time, ISO 8601 UTC |
| `stayHighlight` | string | Stay length or trip type Airbnb shows under the review, in the chosen interface language |
| `roomType` | string | Unit title, only for listings that rent several rooms. `null` on single-unit listings |
| `photos` | array | Photo URLs attached to the review. Empty in everything we sampled (see Limits) |
| `reviewerName` | string | First name, as Airbnb shows it |
| `reviewerId` | string | Airbnb user id of the reviewer |
| `reviewerProfileUrl` | string | Reviewer's Airbnb profile |
| `reviewerPhotoUrl` | string | Reviewer's profile photo |
| `reviewerLocation` | string | Home town, when Airbnb shows one |
| `reviewerTenure` | string | How long the reviewer has been on Airbnb (for example `8 years on Airbnb`), shown instead of a home town when the guest has none |
| `ownerResponse` | string | The host's reply |
| `ownerResponseDate` | string | Date of the reply as Airbnb shows it, relative (for example `1 week ago`) |
| `ownerResponderRole` | string | `Host` when the host replied |
| `placeId` | string | Airbnb listing id |
| `placeName` | string | Listing title |
| `placeType` | string | Always `vacation_rental` on Airbnb |
| `placeUrl` | string | `https://www.airbnb.com/rooms/<id>` |
| `scrapedAt` | string | When the row was collected, ISO 8601 UTC |

`title`, `reviewUrl` and `originalLanguage` are always `null` on Airbnb: a review has no title and no permalink, and the text is always the original. They stay in the rows to keep the column names of the Tripadvisor, Booking.com and Agoda Actors. `isMachineTranslated` is `false`. Airbnb does not publish sub-ratings per review (cleanliness, communication and so on); those exist only as averages for the listing, so they are not in the rows.

#### The summary row

One row per listing, with `"type": "place"`:

| Field | Description |
|---|---|
| `placeId`, `placeName`, `placeType`, `placeUrl` | The listing |
| `city` | City from the listing page |
| `latitude`, `longitude` | Approximate coordinates, as Airbnb shows them on the map |
| `rating`, `ratingScale` | Overall rating of the listing, out of 5 |
| `reviewsCount` | Number of reviews Airbnb announces |
| `reviewsDelivered` | Reviews this run delivered |
| `input` | The URL or id you gave |
| `scrapedAt` | Collection time |

`address` and `countryCode` are `null`: the listing page does not show the street address. If the listing page cannot be read but the reviews can, the name, rating and city are left empty and the log says so.

### Example output

A review row (read from listing 12937, New York):

```json
{
    "type": "review",
    "source": "airbnb",
    "placeId": "12937",
    "placeType": "vacation_rental",
    "placeUrl": "https://www.airbnb.com/rooms/12937",
    "reviewId": "1797136208892103094",
    "rating": 5,
    "ratingScale": 5,
    "title": null,
    "text": "Orestes was a kind and responsive host -- his home was warm and inviting, super clean, and amazingly refined. We enjoyed his garden, and the area was perfectly situated to access Manhattan and other parts of NY. Great neighborhood bodegas and restaurants are quite nearby. Very much recommend!",
    "language": "en",
    "publishedAt": "2026-10-15T13:48:50Z",
    "stayHighlight": "Stayed a few nights",
    "roomType": null,
    "photos": [],
    "reviewerId": "474082169",
    "reviewerName": "Anastasia",
    "reviewerLocation": "Ventura, California",
    "reviewerTenure": null,
    "ownerResponse": "It was a  pleasure to host you. \nHope to see you both again!",
    "ownerResponseDate": "1 week ago",
    "ownerResponderRole": "Host"
}
```

A summary row (name, rating, city and coordinates are also filled, here left out):

```json
{
    "type": "place",
    "source": "airbnb",
    "placeId": "12937",
    "placeType": "vacation_rental",
    "reviewsCount": 502,
    "reviewsDelivered": 502,
    "input": "https://www.airbnb.com/rooms/12937"
}
```

### How many Airbnb reviews can it get? Measurements

Airbnb's review feed has no page limit we could find. We checked the count Airbnb announces against what we read, and against the number of unique review ids.

| Listing | Announced | Returned | Unique ids |
|---|---|---|---|
| New York private bedroom (12937) | 502 | 502 | 502 |
| Rome, Viminale Hill double room (35636293) | 3,202 | 3,202 | 3,202 |

These came from our recon of 31 October 2026. The Rome listing is the largest of eight cities we scanned, so we have no measurement above 3,202. In the recon it was read twice, newest first and then lowest rated first, and both reads returned the same 3,202 ids. On the Apify platform (31 October 2026) the Rome listing was read in full in 24 seconds: 3,202 of 3,202 unique ids.

What the reviews look like in those two listings, from the recon:

| | New York (502 reviews) | Rome (3,202 reviews) |
|---|---|---|
| Ratings | 5 stars: 458, 4 stars: 34, 3 stars: 2, no stars: 8 | 5 stars: 2,708, 4: 405, 3: 76, 2: 9, 1: 4 |
| Languages | en 410, fr 34, de 29, es 15, nl 10, it 2 | en 2,287, es 249, fr 177, it 154, de 80, pt 65, ko 34, nl 29 and others |
| Reviews with a host reply | 122 | not counted |

Airbnb gives no language filter, so a listing's reviews come in every language, and `language` lets you split them.

### Monitor new Airbnb reviews: New reviews only mode

Turn on **New reviews only** and schedule the Actor.

- The Actor keeps a registry per listing in a named key-value store of your account, `airbnb-reviews-registry`, with the ids of the reviews already delivered.
- Set **Max reviews per listing** to `0` on the first run. A run stopped by the review limit, a spend limit, a timeout or unreadable pages is not recorded as a complete read, and the next run reads the full history again. Reviews already delivered are never returned or charged twice.
- After a complete read, later runs read only the reviews newer than that read minus 30 days, which covers reviews that appear after newer ones.
- Skipped reviews are not charged. The status message says how many were skipped.
- With **Only reviews published after** set, the run is not recorded as a complete read.
- A **Monitoring key** names the watch yourself. Without it there is one watch per listing.

We tested it on listing 53997462: a first run delivered 77 reviews, and the second run delivered 0.

#### Webhook at the end of the run

Fill **Webhook URL** and the Actor sends one JSON POST when it has finished reading (example values):

```json
{
    "actor": "airbnb-reviews-scraper",
    "runId": "abc123",
    "datasetId": "def456",
    "mode": "new-only",
    "status": "succeeded",
    "places": 1,
    "reviews": 2,
    "skippedAlreadySeen": 77,
    "targets": 1,
    "failedTargets": 0,
    "chargeLimitReached": false
}
```

`status` is `succeeded`, `partial` (some listings failed) or `failed` (every listing failed). The URL is stored as a secret and is never written to the log. The call has a 15 second timeout, a 307 or 308 redirect is followed once, and a failure never changes the run's result. The webhook is not sent when the input is invalid.

### Export Airbnb reviews to CSV, Excel or JSON

Open the run, go to **Storage** or the **Output** tab, and choose JSON, CSV, Excel, HTML or XML. From the API:

```
https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<YOUR_API_TOKEN>
```

For a reviews-only file, turn off **Add one summary row per listing**, or filter on the `type` column after the export. The review text keeps its line breaks, which most spreadsheet tools handle inside quoted cells.

### Using the Airbnb reviews API from your code

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/airbnb-reviews-scraper").call(run_input={
    "startUrls": ["https://www.airbnb.com/rooms/35636293"],
    "maxReviewsPerListing": 0,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["type"] == "review":
        print(row["publishedAt"], row["rating"], row["language"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('alexmorain/airbnb-reviews-scraper').call({
    startUrls: ['https://www.airbnb.com/rooms/35636293'],
    maxReviewsPerListing: 0,
    sortBy: 'lowest-rated',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.type === 'review').length);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~airbnb-reviews-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://www.airbnb.com/rooms/12937"], "maxReviewsPerListing": 50}'
```

This call waits for the run and returns the items. For large listings, start the run with `POST /v2/acts/alexmorain~airbnb-reviews-scraper/runs` and read the dataset when it ends.

### What people use it for

#### Host and property manager monitoring

List your listings, turn on New reviews only, schedule a daily run and send the webhook to a chat channel. A run with a few new reviews costs about one cent on the Free plan.

#### Reading the complaints around your listing

Run the Actor on the listings near yours with the order set to lowest rated first. The text, the language and the stay highlight tell you what guests dislike.

#### Multilingual review analysis

`language` and the untranslated `text` let you route each review to the right model or translator, instead of feeding a translation of a translation to your pipeline.

#### Review datasets

Complete histories with stable ids, exact dates and reviewer origin, for a list of listings you choose.

### Airbnb Reviews Scraper pricing

You pay per event. There is no monthly rental.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Review (per 1,000) | $1.00 | $0.90 | $0.80 | $0.50 |
| Summary row (per 1,000) | $2.00 | $1.80 | $1.60 | $1.00 |
| Actor start (per run, per GB of memory, minimum one) | $0.005 | $0.005 | $0.005 | $0.005 |

The Actor runs with 512 MB, so the start fee is $0.005 per run. The tier that applies is the one of your Apify plan.

| Job | Free plan | Gold plan |
|---|---|---|
| 50 reviews, one listing | $0.057 | $0.031 |
| All 502 reviews of the New York listing | $0.509 | $0.257 |
| All 3,202 reviews of the Rome listing | $3.21 | $1.61 |
| Daily monitoring run with 3 new reviews | $0.010 | $0.0075 |

Each worked example is the reviews plus one summary row ($0.002 Free, $0.001 Gold) plus the start fee. The $5 of monthly credit in the Apify Free plan covers about 5,000 reviews.

**Cost control.** **Max reviews per listing** caps each listing. You can also set a maximum cost for the run in the Apify run options. We tested it on this Actor: with a limit of $0.05, the run stopped after 50 reviews, 50 reviews were charged and the log said that the limit was reached. Reviews already delivered in New reviews only mode are not charged again.

### Limits and what this Actor does not do

- **Stays only.** Experiences and services are not read.
- **No sub-ratings per review.** Airbnb publishes cleanliness, communication and similar scores only as listing averages.
- **No street address or country code.** The listing page does not show them. The coordinates are approximate.
- **The host reply date is relative** (`1 week ago`). The review date, `publishedAt`, is exact.
- **Photos.** `photos` is read from the field Airbnb's own page reads, but it was empty on about 15,000 reviews we sampled (about 130 listings). We do not promise review photos.
- **No language or rating filter.** Filter the dataset on `language` or `rating` after the run, and use **Max reviews per listing** or a start date to keep the cost down.
- **No most helpful order.** Airbnb's site fails on it.
- **Above 3,202 reviews is not measured.** It is the largest listing among the eight cities we scanned.
- **A listing with no reviews** has not come up in our tests. The Actor is written to return a summary row with 0 reviews for it, but we have not seen it run on a real one.
- **Reviewer data is limited to what Airbnb shows**: first name, home town or tenure, profile link and photo.

### FAQ

#### Is there an Airbnb reviews API?

This Actor does not use an official Airbnb API. It reads the review data that the public listing page loads and returns it as JSON through the Apify API. You call it with an Apify token.

#### How do I scrape Airbnb reviews?

Paste the listing URL or id in the Actor, set the maximum number of reviews, press Start, and download the dataset as CSV, Excel or JSON.

#### How do I export Airbnb reviews to CSV?

Run the Actor, open the dataset and choose CSV. Turn off the summary row if you want only reviews in the file.

#### How many reviews can I scrape from one Airbnb listing?

All of them. We read 3,202 of 3,202 on the largest listing we found. Set **Max reviews per listing** to `0`.

#### Why does the review count differ from the number on the Airbnb page?

It should not. Airbnb announces a review count for the listing, and the summary row shows it next to the number of reviews the run delivered. The two matched on both listings we measured. If you see a gap, the log says how many pages were unreadable, and in monitoring mode that run is not recorded as a complete read.

#### Is the review text translated?

No. `text` is always the original, with its `language` code. The interface language option only changes Airbnb's labels.

#### Why is `rating` sometimes null?

Some reviews, mostly old ones, were left as text with no stars. They are still reviews, so they are returned and charged like the others.

#### Why is the reply date relative?

Airbnb shows the host's reply date as `1 week ago` and does not expose a timestamp for it. The review date, `publishedAt`, is exact.

#### Can I get only the 1 star Airbnb reviews?

Not directly. Set **Order** to `Lowest rated first` and cap **Max reviews per listing**, or filter the dataset on `rating` after the run.

#### Can I scrape the reviews of several listings in one run?

Yes. Paste all of them in **Listing URLs or ids**. They are read one after the other, and a listing Airbnb does not know is skipped without stopping the run.

#### What if Airbnb blocks the Actor?

Requests start from the Apify IP and move to the datacenter proxy as soon as Airbnb refuses one. If both are refused, the run ends with a message instead of returning a partial dataset as if it were complete.

#### How do I monitor new Airbnb reviews?

Turn on New reviews only, schedule the Actor daily or weekly and add a webhook. See the monitoring section.

#### Is it legal to scrape Airbnb reviews?

The Actor reads pages that anyone can open without logging in. The output contains data that guests made public: a first name, a home town, a profile link and photo, the review text. Personal data is protected by the GDPR in the European Union and by similar laws elsewhere. Use the data for a legitimate purpose, check Airbnb's terms and take legal advice for your own use. This is not legal advice.

### Integrations, exports and support

Connect the dataset to Google Sheets, Slack, Zapier, Make or n8n with Apify's integrations, or use the Apify API and client libraries. Runs can be scheduled from the console.

Something not working, or a field you need? Open an issue in the **Issues** tab. The same developer publishes [Tripadvisor Reviews Scraper](https://apify.com/alexmorain/tripadvisor-reviews-scraper), [Booking.com Reviews Scraper](https://apify.com/alexmorain/booking-reviews-scraper) and [Agoda Reviews Scraper](https://apify.com/alexmorain/agoda-reviews-scraper), with the same column names.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Airbnb Reviews Scraper page](https://alexis.morain.fr/en/scrapers/airbnb-reviews-scraper/) of my site. The [Reviews family page](https://alexis.morain.fr/en/scrapers/families/reviews/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Airbnb listing pages, one per line, such as <code>https://www.airbnb.com/rooms/12937</code>. Any Airbnb domain works (.com, .fr, .co.uk…) and query strings are fine. A numeric listing id such as <code>12937</code> works too.

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

<b>0 = every review</b>, however many the listing has. Each review is one charged result, so this is also your cost cap per listing.

## `sortBy` (type: `string`):

Newest first is the default and the only order that stops early on a date filter. Airbnb's "most helpful" order is not offered: the site fails on it.

## `reviewsNewerThan` (type: `string`):

Fixed start date (YYYY-MM-DD). Leave empty for the full history.

## `newOnly` (type: `boolean`):

Remembers, per listing, which reviews it already delivered and returns only the new ones on the next run. Already delivered reviews are not charged again. Schedule it daily or weekly.

## `registryKey` (type: `string`):

Name your monitoring memory to run several independent watches on the same listing (one per client, say). Empty = one memory per listing.

## `webhookUrl` (type: `string`):

Receives a JSON summary when the run ends (reviews, listings, status, dataset id). Works with Slack, Make, Zapier, n8n.

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

Language of Airbnb's own labels (stay highlight, reviewer tenure, reply date). The review text is <b>always the original</b>, in the language the guest wrote it.

## `includeListingSummary` (type: `boolean`):

One extra row per listing with its name, rating, announced review count and how many reviews this run delivered (charged as a listing).

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

Requests start from the Apify IP and move to the datacenter proxy only if Airbnb refuses. No residential proxy needed.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.airbnb.com/rooms/53997462"
  ],
  "maxReviewsPerListing": 50,
  "sortBy": "newest",
  "newOnly": false,
  "locale": "en",
  "includeListingSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One row per review

## `places` (type: `string`):

One summary row per page URL

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

Every row with all fields

# 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 = {
    "startUrls": [
        "https://www.airbnb.com/rooms/53997462"
    ],
    "maxReviewsPerListing": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/airbnb-reviews-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 = {
    "startUrls": ["https://www.airbnb.com/rooms/53997462"],
    "maxReviewsPerListing": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/airbnb-reviews-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 '{
  "startUrls": [
    "https://www.airbnb.com/rooms/53997462"
  ],
  "maxReviewsPerListing": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/airbnb-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/airbnb-reviews-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/cntojzAR4C66aUIt0/builds/JQg4cr2DuUkif6cxL/openapi.json
