# 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:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

> 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("💾 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 '{
  "location": "Lisbon, Portugal",
  "maxResults": 20
}' |
apify call thirdwatch/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper - Listings, Prices & Ratings",
        "description": "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.",
        "version": "1.0",
        "x-build-id": "wRjHjDFQSmmQ1UjPK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thirdwatch~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thirdwatch-airbnb-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/thirdwatch~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thirdwatch-airbnb-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/thirdwatch~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thirdwatch-airbnb-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",
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or address to search for stays (e.g. 'Lisbon, Portugal', 'Paris', 'Bali, Indonesia'). Either this or 'listingUrl' is required."
                    },
                    "listingUrl": {
                        "title": "Listing URL",
                        "type": "string",
                        "description": "A single Airbnb listing URL (e.g. 'https://www.airbnb.com/rooms/12345678') to scrape details for. Takes priority over 'location' when set.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum number of listings to return (location search only).",
                        "default": 20
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code for prices (e.g. 'USD', 'EUR', 'GBP', 'INR').",
                        "default": "USD"
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Optional check-in date in YYYY-MM-DD format. When set with checkOut, prices reflect that stay.",
                        "default": ""
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Optional check-out date in YYYY-MM-DD format.",
                        "default": ""
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 0,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Optional number of adult guests to filter availability/pricing.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings, pre-configured with a sensible default. Leave this as-is unless you have a specific need.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
