# Airbnb Listings Scraper: Prices, Hosts, Amenities, Ratings (`datagleaner/airbnb-scraper`) Actor

Airbnb scraper for listings by city search or room URL: title, property type, location and coordinates, beds, baths, rating, review count, host, amenities, photos and the price for your dates. One cheap Actor, plain HTTP, no browser, no login.

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

## Pricing

$0.80 / 1,000 airbnb listings

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

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

## What's an Apify Actor?

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 Scraper - Listings, Prices, Hosts & Amenities by City or Room URL

Scrape Airbnb listings for any city or neighbourhood, or look up specific rooms by URL: title, property type, coordinates, beds and baths, rating, review count, Superhost status, full amenity list, photos and the total price for your dates, as one clean JSON record per listing.

One Actor does both jobs that usually need two: **search by place** and **room details by URL or ID**. It reads the public Airbnb web pages over plain HTTP, with no browser, no login and no Airbnb account, and costs **$0.80 per 1,000 listings**.

### What does Airbnb Scraper do?

It returns the same data a visitor sees on Airbnb's search results and room pages, through the Apify dataset and API as JSON, CSV or Excel. Typical uses:

- **Short-term rental market research:** map supply, ratings, room types and price levels in any city.
- **Competitor and pricing analysis for hosts and property managers:** pull the comparable listings around yours, with prices for the exact dates you care about.
- **Investment and location scouting:** compare neighbourhoods by listing count, rating, Guest favorite share and nightly price.
- **Lead and partner lists:** hosts, Superhost status and hosting experience per listing.
- **Travel apps and AI agents:** feed live Airbnb listings into an itinerary tool or an LLM agent.

### Input

| Field | Meaning |
|---|---|
| `locations` | Places as you would type them on Airbnb: `Lisbon, Portugal`, `Austin, TX`, `Bali`. Each returns up to `maxItems` listings (270 at most per place: Airbnb shows 15 result pages of 18). |
| `roomUrls` | Room mode. Airbnb room URLs (`https://www.airbnb.com/rooms/20669368`, any airbnb domain) or bare room IDs. Rooms that no longer exist are skipped and not charged. |
| `checkIn`, `checkOut` | `YYYY-MM-DD`, both or neither. With dates, search results carry the `price` for your stay. Without dates, a location search prices a default stay: 2 nights starting 14 days from the run date (worked out at run time). The run's status message says so, and every item echoes the dates used in `checkIn` and `checkOut`. |
| `adults` | 1 to 16, default 2. The guests the price is for, with your dates or the default stay. |
| `currency` | ISO code, default `USD`. |
| `maxItems` | Listings per location, default 20, max 270. |
| `includeDetails` | Default on. One extra request per search result adds amenities, host, all photos, country, guest capacity, description and rating breakdown. Off gives a faster, lighter list from the search cards only. |
| `requestDelaySecs` | Pacing between requests, default 0.7. |
| `proxyConfiguration` | Optional, off by default. |

With no input at all, the Actor runs a built-in example of 5 listings in Paris. If you already call another Airbnb Actor, these input names are also accepted: `locationQueries`, `startUrls`, `checkin`, `checkout`, `maxListings`.

```json
{
  "locations": ["Lisbon, Portugal"],
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-13",
  "adults": 2,
  "currency": "USD",
  "maxItems": 50
}
```

Room mode:

```json
{
  "roomUrls": ["https://www.airbnb.com/rooms/20669368", "766765"]
}
```

### Output

```json
{
  "id": "5262010",
  "url": "https://www.airbnb.com/rooms/5262010",
  "title": "Wow, Glass-Walled Design Bungalow near University of Texas",
  "roomType": "Entire home/apt",
  "propertyType": "Entire home",
  "location": {"city": "Austin", "country": "United States", "lat": 30.30799, "lng": -97.7015},
  "personCapacity": 4,
  "bedrooms": 2,
  "beds": 2,
  "bathrooms": 2,
  "starRating": 4.95,
  "reviewsCount": 634,
  "ratingCategories": {"cleanliness": 4.9, "accuracy": 5, "checkin": 5, "communication": 5, "location": 4.9, "value": 4.8},
  "isGuestFavorite": true,
  "badges": ["Guest favorite"],
  "host": {"name": "Michael", "isSuperhost": true, "id": "12628034", "reviewsCount": 1392, "yearsHosting": 11},
  "description": "...",
  "amenities": ["Wifi", "Kitchen", "Air conditioning", "Free parking on premises", "..."],
  "photos": ["https://a0.muscache.com/im/pictures/..."],
  "price": {"total": 564, "perNight": 188, "originalTotal": null, "nights": 3, "currency": "USD", "display": "$564", "note": null},
  "position": 1,
  "searchLocation": "Austin, TX",
  "inputUrl": null,
  "source": "search",
  "checkIn": "2026-12-10",
  "checkOut": "2026-12-13",
  "adults": 2,
  "scrapedAt": "2026-10-11T12:00:00+00:00"
}
```

`position` is the listing's 1-based rank in the search results for that place (null for room URLs). The dataset has a **Listings** view with the main columns.

#### Which fields are filled

- **Always:** `id`, `url`, `title`, `propertyType`, `location.lat`/`lng`, `photos`, `source`, `scrapedAt`. `starRating` and `reviewsCount` are filled for every listing that has reviews (new listings have none yet).
- **Full details on (default) and in room mode:** `roomType`, `personCapacity`, `amenities`, `host`, `description`, `ratingCategories`, `location.country`.
- **`price`:** only for search results (for your `checkIn`/`checkOut`, or the default 2-night stay from 14 days out for 2 adults when you give none), and only when Airbnb shows a price for that listing (listings that are booked out on your dates have none). Room URLs never carry a price, because Airbnb's room page does not include one without a logged-in booking request. Hotels and multi-unit listings show the price of the cheapest unit and say so in `price.note`.
- **`bedrooms`, `beds`, `bathrooms`:** blank for multi-unit listings (hotels and apartment blocks that show "N apartments available") and for listings whose host did not state them. A studio is `bedrooms: 0`.

### Pricing

Pay per result: **$0.80 per 1,000 listings** ($0.0008 per listing). You pay only for listings pushed to the dataset. Room URLs that no longer exist return nothing and cost nothing. The run stops at your maximum charge.

Worked example: 5 cities at 100 listings each is 500 listings, which costs $0.40. Re-running the same set every day for 30 days costs $12.00. A 10-listing test run costs $0.008.

### Use it from the API

Run it synchronously and get the listings back as JSON. Replace `<YOUR_APIFY_TOKEN>` with your token.

```bash
curl -X POST "https://api.apify.com/v2/acts/datagleaner~airbnb-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["Lisbon, Portugal"], "checkIn": "2026-12-10", "checkOut": "2026-12-13", "maxItems": 20}'
```

It also works from n8n, Make or Zapier through the Apify integrations, since the output is a flat JSON record per listing.

### Use with Python

`pip install apify-client`, set the `APIFY_TOKEN` environment variable, and run. This input returns at most 10 listings, about $0.008.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("datagleaner/airbnb-scraper").call(run_input={
    "locations": ["Lisbon, Portugal"],
    "checkIn": "2026-12-10",
    "checkOut": "2026-12-13",
    "maxItems": 10,
})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    price = (listing.get("price") or {}).get("total")
    print(listing["title"], listing.get("starRating"), price)
```

### Use with JavaScript / Node.js

`npm install apify-client`, set `APIFY_TOKEN`, and run it as an ES module (`.mjs`).

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/airbnb-scraper').call({
    locations: ['Lisbon, Portugal'],
    checkIn: '2026-12-10',
    checkOut: '2026-12-13',
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const l of items) console.log(l.title, l.starRating, l.price?.total);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/airbnb-scraper`

Minimal input:

```
{"locations": ["Lisbon, Portugal"], "checkIn": "2026-12-10", "checkOut": "2026-12-13", "maxItems": 10}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/airbnb-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/airbnb-scraper`. In Claude Code:

  ```
  claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/airbnb-scraper"
  ```

  Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Find 10 Airbnb listings in Lisbon for 2 adults from December 10 to 13 and list the cheapest three with their ratings." An agent without the Actor preloaded can find it with Apify's `search-actors` tool by searching "airbnb".
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/airbnb-scraper")
result = tool.invoke({"run_input": json.loads('{"locations": ["Lisbon, Portugal"], "checkIn": "2026-12-10", "checkOut": "2026-12-13", "maxItems": 10}')})
```

### Limits

- **No guest reviews.** Review text is not part of the public room page; Airbnb loads it through a separate authenticated API, which this Actor does not use. You get `starRating`, `reviewsCount`, the category ratings and `isGuestFavorite` instead.
- Airbnb shows at most about 270 listings per search (15 pages of 18). For more coverage, search sub-areas (`Alfama, Lisbon`, `Belem, Lisbon`). A few cards repeat between pages and are removed, so a place can return slightly fewer than 270.
- Listings on Airbnb's map for a broad place can be sparse for small towns; the Actor returns what Airbnb returns.
- Prices are totals as Airbnb displays them for the market and currency you set; whether taxes and fees are included follows Airbnb's display. Airbnb's search ranking and prices change by the minute.
- Airbnb shows approximate coordinates for most listings, not the exact address.
- At very high volume Airbnb may start refusing requests. The Actor backs off, refreshes its connection and finishes what it has. Enable `proxyConfiguration` if that happens.

### FAQ

**Is there an Airbnb API?** Airbnb offers no public API for listings or prices. This Actor works as one: you call the Apify API with places and dates, it reads the Airbnb pages and returns JSON.

**How do I get the price of a listing?** Search a location, ideally with `checkIn` and `checkOut` set (without them a 2-night stay 14 days out is priced). Each search result then carries `price.total` and `price.perNight` for exactly those dates. A room URL on its own returns the listing record without a price.

**Can I get the reviews?** Not in this version (see Limits). Ratings, review counts and category ratings are included.

**How do I track a market over time?** Schedule the Actor daily for the same places and dates and compare `price` and `reviewsCount` between runs. Each record carries `scrapedAt`.

**Do I need a proxy?** No, it works without one in testing. A proxy option is there if you scrape at very high volume.

### Responsible use

This Actor reads publicly visible Airbnb pages without logging in. Use the data in line with Airbnb's terms. Listing records are business data; host first names appear as Airbnb shows them publicly. If you combine them with anything else about individuals, the data-protection obligations are yours.

# Actor input Schema

## `locations` (type: `array`):

Places to search, as you would type them on Airbnb: `Lisbon, Portugal`, `Austin, TX`, `Bali`. Each place returns up to `maxItems` listings, up to 270 per place (Airbnb shows 15 result pages of 18).

## `roomUrls` (type: `array`):

Room mode: Airbnb room URLs (`https://www.airbnb.com/rooms/20669368`) or bare room IDs. Each returns the full listing record. Any airbnb domain works. Rooms that no longer exist are skipped and not charged.

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

YYYY-MM-DD. Set both dates to get a `price` for your stay on search results. Leave both empty and a location search prices a 2-night stay starting 14 days from the run date for 2 adults (the dates used are echoed on every item as `checkIn` and `checkOut`).

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

YYYY-MM-DD, after check-in. Empty with no check-in: the default 2-night stay applies.

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

Number of adult guests the price is for. Used for the price, with your dates or with the default stay.

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

ISO 4217 code for prices, e.g. `USD`, `EUR`, `GBP`, `JPY`.

## `maxItems` (type: `integer`):

Stops after this many listings for each place in `locations`. Room URLs are not limited by it.

## `includeDetails` (type: `boolean`):

One extra request per search result adds amenities, host, all photos, country, guest capacity, description and rating breakdown. Turn off for a faster, lighter list from the search cards only (the price, rating, beds and coordinates stay).

## `requestDelaySecs` (type: `number`):

Polite pacing. Lower is faster and raises the chance of being blocked.

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

Optional. Off by default: Airbnb answered Apify datacenter IPs in testing. Enable a proxy if runs start getting blocked at high volume.

## Actor input object example

```json
{
  "locations": [
    "Lisbon, Portugal"
  ],
  "adults": 2,
  "currency": "USD",
  "maxItems": 20,
  "includeDetails": true,
  "requestDelaySecs": 0.7
}
```

# Actor output Schema

## `listings` (type: `string`):

No description

## `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 = {
    "locations": [
        "Lisbon, Portugal"
    ]
};

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

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

```

## MCP server setup

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