# Airbnb Scraper - Listings, Prices & Ratings (`thirdwatch/airbnb-scraper`) Actor

Scrape Airbnb stays via the internal StaysSearch JSON API. Get listing name, price per night, total price, rating, review count, room type, coordinates, host, amenities, and booking URL. Search by location or a single listing URL. No API key needed.

- **URL**: https://apify.com/thirdwatch/airbnb-scraper.md
- **Developed by:** [Thirdwatch](https://apify.com/thirdwatch) (community)
- **Categories:** Travel
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

> **Thirdwatch portfolio:** 5K users across 88 public Actors, 2M+ records delivered, and >99% run success. [Explore all Thirdwatch Actors](https://apify.com/thirdwatch).

> Scrape Airbnb stays by city or listing URL — get price per night, rating, review count, room type, coordinates, and the booking link as clean, structured rows.

Search any city, region, or address and pull a ready-to-analyze table of Airbnb stays: listing name, nightly price, total stay price, average rating, review count, property type, exact map coordinates, and the direct booking URL. Built for short-term-rental market research, pricing intelligence, competitor benchmarking, travel aggregators, and investment analysis. Export to JSON, CSV, or Excel, or pipe straight into your own pipeline.

### What you get

- **Location search (primary path):** give it a city like "Lisbon, Portugal" and a result count, and get back a clean row per listing with price, rating, review count, room type, and coordinates — the most reliable way to use this Actor.
- **Date-aware pricing:** add check-in / check-out dates and a guest count to get the price for that specific stay.
- **Single-listing lookup (secondary path):** paste one Airbnb listing URL to pull that listing's detail record, including its amenities list.
- **Choose your currency:** prices come back in USD, EUR, GBP, INR, or any standard currency code you set.
- Stays current automatically as Airbnb updates its site, so your scheduled runs keep working.

### Output fields

| Field | Description |
|-------|-------------|
| `room_id` | Airbnb listing ID |
| `name` | Listing title (e.g. "Charming Apartment with Terrace") |
| `room_type` | Property type and area (e.g. "Apartment in Lisbon") |
| `price_per_night` | Displayed nightly price with currency symbol |
| `total_price` | Total for the displayed stay, including the original price when discounted |
| `rating` | Average review rating, when the listing has reviews |
| `review_count` | Number of reviews, when the listing has reviews |
| `lat` | Latitude of the listing |
| `lng` | Longitude of the listing |
| `host` | Host name, when shown |
| `amenities` | Amenities list (populated for single-listing URL lookups) |
| `images` | Listing image URLs |
| `badges` | Badges such as Guest Favorite or Superhost, when present |
| `url` | Direct booking URL for the listing |
| `search_location` | The location you searched (location search only) |
| `person_capacity` | Maximum guests the listing sleeps (single-listing URL lookups only) |

### Example output

```json
{
  "room_id": "1709223735731352361",
  "name": "Sunlit Studio in Alfama with River View",
  "room_type": "Apartment in Lisbon",
  "price_per_night": "$92",
  "total_price": "$416 for 4 nights",
  "rating": 4.89,
  "review_count": 223,
  "lat": 38.7118,
  "lng": -9.1305,
  "host": "Mariana",
  "amenities": [],
  "images": [
    "https://a0.muscache.com/im/pictures/miso/Hosting-1709223735731352361/original/abc123.jpeg"
  ],
  "badges": ["Guest Favorite"],
  "url": "https://www.airbnb.com/rooms/1709223735731352361",
  "search_location": "Lisbon, Portugal"
}
```

### Input parameters

| Parameter | Required | Description |
|-----------|----------|-------------|
| `location` | Yes (unless `listingUrl` is set) | City, region, or address to search for stays — e.g. "Lisbon, Portugal", "Paris", "Bali, Indonesia". This is the primary, most reliable way to use the Actor. |
| `listingUrl` | No | A single Airbnb listing URL (e.g. `https://www.airbnb.com/rooms/12345678`) to pull one listing's details. When set, it takes priority over `location`. |
| `maxResults` | No | Maximum number of listings to return for a location search. Default 20, up to 300. |
| `currency` | No | Currency code for prices — e.g. USD, EUR, GBP, INR. Default USD. |
| `checkIn` | No | Optional check-in date (YYYY-MM-DD). When set with `checkOut`, prices reflect that specific stay. |
| `checkOut` | No | Optional check-out date (YYYY-MM-DD). |
| `adults` | No | Optional number of adult guests, to size availability and pricing for that party. |
| `proxyConfiguration` | No | Proxy settings, pre-configured with a sensible default. Leave as-is unless you have a specific need. |

#### Example: search a city

```json
{
  "location": "Lisbon, Portugal",
  "maxResults": 50,
  "currency": "USD"
}
```

#### Example: search with dates and guests

```json
{
  "location": "Paris, France",
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-05",
  "adults": 2,
  "currency": "EUR",
  "maxResults": 40
}
```

#### Example: look up a single listing

```json
{
  "listingUrl": "https://www.airbnb.com/rooms/1709223735731352361",
  "currency": "USD"
}
```

### Use cases

- **Short-term-rental analysts:** track supply, nightly rates, and ratings across a market over time to spot pricing and demand trends.
- **Revenue managers and hosts:** benchmark your nightly rate against comparable stays in the same city or neighborhood.
- **Real-estate investors:** size up Airbnb yield in a target city by pulling live price and rating data before you buy.
- **Travel and listing aggregators:** build comparison datasets across multiple destinations from a single, consistent schema.
- **Market researchers and data teams:** assemble repeatable, exportable rental-market datasets for dashboards, models, or reports.
- **Founders and product teams:** seed a travel or property product with real listings, prices, and geolocation data.

### Limitations

- **Location (city) search is the primary, reliable path.** A location search returns the core listing fields for each stay: name, price per night, total price, rating, review count, room type, and map coordinates. This is what we recommend for most workloads.
- **The single `listingUrl` path is secondary.** It returns a single listing's detail record, including its amenities list, but does not return live pricing in the same way a location search does, and detail coverage can vary by listing. Treat exhaustive per-listing detail (full amenities, host history) as best-effort, not guaranteed.
- Newly listed stays often show "New" instead of a rating. For those, `rating` and `review_count` come back as `null`.
- `amenities` is populated for single-listing URL lookups; a location search returns the core listing fields above (its `amenities` is empty).
- `maxResults` for a location search is capped at 300 per run. Split larger jobs across multiple searches (e.g. by neighborhood) for deeper coverage.
- Prices come back as displayed strings with the currency symbol (e.g. "$92"), so you can show them as-is; parse to a number if you need to compute on them.

### Compared to alternatives

The most popular Airbnb scraper on Apify Store is **tri\_angle / airbnb-scraper**. Here is how this Actor differs:

- **Cleaner, flatter fields.** You get a tidy row per listing — price, rating, review count, room type, latitude, longitude, and booking URL — without digging through deeply nested objects, so the output drops straight into a spreadsheet or database.
- **Reliable location-search core.** The city/region search path is designed to be the dependable backbone of your workflow and to keep working through site changes, so scheduled runs don't quietly break.
- **Predictable pay-per-result pricing.** You pay per listing returned, with volume tiers that lower the per-result price as you scale — easy to forecast for recurring jobs.
- **Honest about scope.** We're explicit that location search is the primary path and single-listing detail is best-effort, so you know exactly what to expect before you run.

### FAQ

**Do I need an Airbnb account or API key?**
No. Just provide a location or a listing URL and run it.

**What's the best way to get the most listings?**
Use a location search with `maxResults` set to your target (up to 300). For larger coverage, run several searches scoped to different neighborhoods or nearby cities.

**Can I get prices for specific dates?**
Yes. Set `checkIn` and `checkOut` (and optionally `adults`), and prices reflect that stay.

**Why are `rating` and `review_count` sometimes empty?**
Brand-new listings show "New" instead of a rating until they collect reviews. For those, both fields are `null`.

**Can I get a listing's amenities?**
Yes — use the single `listingUrl` lookup. Amenities are not returned on the bulk location search.

**Which currencies are supported?**
Any standard currency code (USD, EUR, GBP, INR, and more). Set it with the `currency` parameter.

**Can I schedule recurring runs?**
Yes. Schedule it from the Apify Console to track a market's prices and ratings over time.

### Related scrapers

- [Booking.com Scraper](https://thirdwatch.dev) — hotel and stay listings with prices and ratings
- [TripAdvisor Scraper](https://thirdwatch.dev) — reviews and ratings for hotels and attractions
- [Yelp Scraper](https://thirdwatch.dev) — local business listings and reviews

Built by [Thirdwatch](https://thirdwatch.dev) — reliable, well-documented data scrapers.

Last verified: 2026-06

# Actor input Schema

## `location` (type: `string`):

City, region, or address to search for stays (e.g. 'Lisbon, Portugal', 'Paris', 'Bali, Indonesia'). Either this or 'listingUrl' is required.

## `listingUrl` (type: `string`):

A single Airbnb listing URL (e.g. 'https://www.airbnb.com/rooms/12345678') to scrape details for. Takes priority over 'location' when set.

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

Maximum number of listings to return (location search only).

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

Currency code for prices (e.g. 'USD', 'EUR', 'GBP', 'INR').

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

Optional check-in date in YYYY-MM-DD format. When set with checkOut, prices reflect that stay.

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

Optional check-out date in YYYY-MM-DD format.

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

Optional number of adult guests to filter availability/pricing.

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

Proxy settings, pre-configured with a sensible default. Leave this as-is unless you have a specific need.

## Actor input object example

```json
{
  "location": "Lisbon, Portugal",
  "listingUrl": "",
  "maxResults": 20,
  "currency": "USD",
  "checkIn": "",
  "checkOut": "",
  "adults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "location": "Lisbon, Portugal",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("thirdwatch/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 = {
    "location": "Lisbon, Portugal",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("thirdwatch/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 '{
  "location": "Lisbon, Portugal",
  "maxResults": 20
}' |
apify call thirdwatch/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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