# Airbnb Reviews Scraper (`cirkit/airbnb-reviews-scraper`) Actor

Fast multi-listing Airbnb reviews scraper. Scrape every review from any listing URL with full pagination, filtering, and sort control.

- **URL**: https://apify.com/cirkit/airbnb-reviews-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Airbnb Reviews Scraper

Scrape every guest review from any Airbnb listing in seconds. Multi-listing input, full pagination, cheap.

This Airbnb Reviews Scraper is built around the gap most existing actors leave open: the popular ones charge several dollars per thousand reviews, and the cheap ones only handle a single listing URL at a time. This actor handles both: multiple Airbnb listing URLs in a single run, full pagination through every review, and a price per review that is meaningfully cheaper than the leading alternatives.

### Why this actor

Most short-term rental teams, market researchers, and review-analytics tools end up paying far more for Airbnb review data than they need to. The market roughly splits in two: a flagship Airbnb Reviews Scraper that handles bulk URLs but charges around $5 per 1,000 reviews, and a long tail of cheaper single-URL scrapers that force you to run them one listing at a time. Neither is a great fit if you want to scrape reviews across, say, 200 properties in one job and not lose a quarter to per-review fees.

This scraper is designed for that real-world job. It accepts an arbitrary list of Airbnb listing URLs, paginates through every review on each one, and emits a flat row per review so that the dataset drops straight into a spreadsheet, BigQuery, or a dashboard.

### What it does

- Accepts one or more Airbnb listing URLs (e.g. `https://www.airbnb.com/rooms/12937`)
- Paginates through every review for each listing (50 reviews per request, full coverage)
- Lets you sort by Most recent, Best quality, Highest rated, or Lowest rated
- Lets you cap the total number of reviews returned across all listings via `maxResults`
- Lets you filter reviews by `dateFrom` and `dateTo` (most efficient with `MOST_RECENT` sort, where pagination short-circuits once older reviews are encountered)
- Returns every field you would expect: review text, rating, language, created-at timestamp, host response, reviewer profile, host profile, photos, review highlight tags

### Output schema

Every dataset item is a single review:

| Field | Type | Notes |
|---|---|---|
| `startUrl` | string | Original input URL the review was found under |
| `roomId` | string | Numeric Airbnb room id parsed from the URL |
| `id` | string | Airbnb review id |
| `language` | string | ISO language code |
| `text` | string | Review text in the original language |
| `localizedText` | string | Review text in the locale you requested |
| `localizedReview` | object or null | `{ text, disclaimer }` when Airbnb auto-translates |
| `localizedDate` | string | Human-readable date e.g. `2 weeks ago` |
| `localizedReviewerLocation` | string | e.g. `Tomah, Wisconsin` |
| `createdAt` | string | ISO 8601 timestamp |
| `reviewer` | object | `{ id, firstName, hostName, pictureUrl, profilePath, profilePicture }` |
| `reviewee` | object | Host details, same shape as reviewer |
| `reviewHighlight` | string or null | e.g. `Stayed a few nights` |
| `highlightType` | string or null | e.g. `LENGTH_OF_STAY` |
| `rating` | number | 1 through 5. Pre-2014 reviews predate Airbnb's rating system and return `null` here |
| `response` | string or null | Host response text |
| `ratingAccessibilityLabel` | string | e.g. `Rating, 5 stars` |
| `photoUrls` | array | URLs of any photos attached to the review |

The schema is a superset of the most popular Airbnb Reviews Scraper actor, so existing pipelines that consume that actor's output should drop in without changes.

### Input

```json
{
    "startUrls": [
        { "url": "https://www.airbnb.com/rooms/12937" },
        { "url": "https://www.airbnb.com/rooms/40569814" }
    ],
    "locale": "en-US",
    "currency": "USD",
    "sortingPreference": "MOST_RECENT",
    "maxResults": 500,
    "dateFrom": "2024-01-01"
}
````

| Input field | Default | Purpose |
|---|---|---|
| `startUrls` | required | Array of `{ url }` objects pointing at Airbnb listings. Numeric IDs and URLs with query params both parse correctly. |
| `locale` | `en-US` | BCP-47 locale that Airbnb uses to translate localized text and date strings. |
| `currency` | `USD` | Currency code, mostly cosmetic for reviews. |
| `sortingPreference` | `MOST_RECENT` | One of `MOST_RECENT`, `BEST_QUALITY`, `RATING_DESC`, `RATING_ASC`. |
| `maxResults` | unlimited | Hard cap across all listings combined. |
| `dateFrom` / `dateTo` | none | ISO 8601 date filters applied client-side. |
| `proxyConfiguration` | Apify Proxy | The reviews come from a public-key-protected JSON API, so any Apify proxy group works fine. Datacenter is the cheapest if your plan includes it. |

### How it works

The actor talks directly to Airbnb's internal GraphQL endpoint that powers the reviews modal in the listing page. That endpoint returns reviews 50 at a time as structured JSON. Because the data is already JSON on the wire, the actor does not run a headless browser, does not parse HTML, and does not need residential proxies. It runs on `HttpCrawler` with 256 MB of memory, which keeps the per-run compute cost negligible and makes the per-review price possible.

Practically, scraping a listing with 478 reviews takes ten paginated requests and finishes in a few seconds end to end. Scraping a portfolio of 50 listings runs in parallel and is dominated by network round trips, not CPU.

### Pricing

This actor uses a pay-per-event pricing model with two events: a tiny actor-start fee and a per-review fee. The per-review fee is the dominant cost for any non-trivial run. The pricing is deliberately set below the dominant competitor while still leaving healthy margin, because the underlying compute cost is low.

Volume tiers (BRONZE, SILVER, GOLD, PLATINUM, DIAMOND) reduce the per-review fee further as monthly usage grows. Final per-tier numbers are configured in the Apify Console.

### Use cases

- Sentiment analysis and topic mining across a portfolio of properties
- Competitor reputation tracking
- Listing optimization, where reviews surface guest pain points by category
- Market research on review velocity and rating trends in a city or neighborhood
- Powering analytics dashboards that need fresh review data refreshed daily

### Limitations

- The actor scrapes published guest reviews. It does not access private host-only data.
- A handful of pre-2014 reviews predate Airbnb's rating system and return with `rating: null` while still containing review text, language, and reviewer details. This is true negative coverage, not a parsing miss.
- Airbnb does not expose a server-side date filter for reviews. `dateFrom` and `dateTo` are applied client-side. With `MOST_RECENT` sort the actor short-circuits pagination once older reviews appear, so date-bounded queries remain fast.
- Listings that have been delisted or never existed return `NOT_FOUND` from Airbnb and are skipped with a log warning. Other listings in the same run continue normally.

### Tips

- Combine `MOST_RECENT` sort with `dateFrom` for incremental scraping (only fetch reviews newer than your last run).
- For city-wide analysis, pair this actor with an Airbnb listing-discovery actor: collect URLs first, then feed them to this scraper in batches.
- The `localizedText` field already contains Airbnb's translation of foreign-language reviews into your requested locale, so you usually don't need a separate translation step.

### Output formats

Datasets are downloadable as JSON, CSV, or XLSX from the Apify Console, or via the Apify API.

# Actor input Schema

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

One or more Airbnb listing URLs (e.g. https://www.airbnb.com/rooms/12937). Reviews from each listing are scraped independently and combined in the dataset.

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

Locale used by Airbnb to localize date strings, reviewer locations, and (when needed) translations. Use BCP-47 form e.g. en-US, es-ES, fr-FR.

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

Currency code used by Airbnb's responses. Mostly cosmetic for review data.

## `maxResults` (type: `integer`):

Hard cap on the total number of reviews returned across all listings combined. Leave empty for no limit.

## `sortingPreference` (type: `string`):

Order in which reviews are returned from Airbnb. Use MOST\_RECENT for date filtering.

## `dateFrom` (type: `string`):

Only return reviews on or after this date (ISO 8601, e.g. 2024-01-01). Most efficient when combined with MOST\_RECENT sort because pagination short-circuits once older reviews are seen.

## `dateTo` (type: `string`):

Only return reviews on or before this date (ISO 8601, e.g. 2024-12-31).

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

Apify proxy is enabled by default with the DATACENTER group, which is plenty fast for this actor.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.airbnb.com/rooms/12937"
    }
  ],
  "locale": "en-US",
  "currency": "USD",
  "sortingPreference": "MOST_RECENT",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All reviews from the latest run.

## `consoleRun` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.airbnb.com/rooms/12937"
        }
    ],
    "locale": "en-US",
    "currency": "USD",
    "sortingPreference": "MOST_RECENT",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/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": [{ "url": "https://www.airbnb.com/rooms/12937" }],
    "locale": "en-US",
    "currency": "USD",
    "sortingPreference": "MOST_RECENT",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/airbnb-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.airbnb.com/rooms/12937"
    }
  ],
  "locale": "en-US",
  "currency": "USD",
  "sortingPreference": "MOST_RECENT",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cirkit/airbnb-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Reviews Scraper",
        "description": "Fast multi-listing Airbnb reviews scraper. Scrape every review from any listing URL with full pagination, filtering, and sort control.",
        "version": "0.1",
        "x-build-id": "GVZG48TITWeGSkWbD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~airbnb-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-airbnb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/cirkit~airbnb-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-airbnb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/cirkit~airbnb-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-airbnb-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Airbnb listing URLs",
                        "type": "array",
                        "description": "One or more Airbnb listing URLs (e.g. https://www.airbnb.com/rooms/12937). Reviews from each listing are scraped independently and combined in the dataset.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Locale used by Airbnb to localize date strings, reviewer locations, and (when needed) translations. Use BCP-47 form e.g. en-US, es-ES, fr-FR.",
                        "default": "en-US"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code used by Airbnb's responses. Mostly cosmetic for review data.",
                        "default": "USD"
                    },
                    "maxResults": {
                        "title": "Max reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of reviews returned across all listings combined. Leave empty for no limit."
                    },
                    "sortingPreference": {
                        "title": "Sort reviews by",
                        "enum": [
                            "MOST_RECENT",
                            "BEST_QUALITY",
                            "RATING_DESC",
                            "RATING_ASC"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are returned from Airbnb. Use MOST_RECENT for date filtering.",
                        "default": "MOST_RECENT"
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Only return reviews on or after this date (ISO 8601, e.g. 2024-01-01). Most efficient when combined with MOST_RECENT sort because pagination short-circuits once older reviews are seen."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Only return reviews on or before this date (ISO 8601, e.g. 2024-12-31)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy is enabled by default with the DATACENTER group, which is plenty fast for this actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```