# Airbnb & Booking Price Index (`inovaflow/airbnb-booking-price-index`) Actor

Get the true market-wide median and average nightly price for any city and dates — across the entire Airbnb and Booking.com market, not a small sample. No API keys or logins, just a free Apify account.

- **URL**: https://apify.com/inovaflow/airbnb-booking-price-index.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** Travel, Automation
- **Stats:** 3 total users, 2 monthly users, 94.7% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / actor start

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

**Compare the real, market-wide median and average nightly price across many cities and date ranges at once — measured over every Airbnb and Booking.com listing, not a handful.**

If you've ever priced a place to rent — or tried to pick the cheapest week for a trip — you've hit the same wall: *what does a night here actually cost, and how do my dates or cities compare?* Airbnb shows you one screen of listings, Booking.com another, and comparing "Lisbon next week vs the week after," or "Lisbon vs Porto," means running the same search over and over.

There's a faster way. Behind every price slider sits a little bar chart — the **price histogram** — that already counts how many listings fall in each price band, across the whole search. We built this to read that chart and turn it into a clean median and average over **every** listing — one read instead of hundreds of scrapes. Give it several cities and date ranges and it fills a comparison grid: **one row per city, one column per date**, so you can see at a glance which week and which city win.

You get a ready **comparison table (CSV)** for Excel/Sheets, the same grid as a dataset (for the API), and a **detail record** with the average, listing counts, and full price breakdown behind every number. No API keys, no Airbnb/Booking login — just a free Apify account.

> 🧪 **Early access — runs at cost.** No markup: you pay only Apify's raw platform usage (often a few cents, free within starter credits). Try it, and if it's useful, tell us what to add next — more sites, currencies, output, schedules. **Your feedback shapes the roadmap** → open an issue on the **Issues** tab. 🙏

### Who it's for

- **Hosts & rental owners** — *"is my nightly rate above or below the real market, and how does it shift week to week?"*
- **Travelers picking dates** — *"which week of July is cheapest in Lisbon — and is Porto cheaper?"*
- **Hotels & revenue managers** comparing price distributions across upcoming weekends in one run.
- **Analysts & data scientists** pulling true median, average, and the full distribution for many cities × dates into a spreadsheet.
- **App builders & AI agents** needing a cheap *"what does a night cost here, on these dates?"* lookup.

### Input

Everything but the first two has a sensible default.

- **Locations** — one or more, each `City, Country` (e.g. `Lisbon, Portugal`). A bare city is rejected so it can't hit the wrong Lisbon.
- **Date ranges** — one or more stays (check-in + check-out, from a calendar). Not in the past, ≤ 90 nights each; each becomes a column.
- **Adults** — 1–16 (default 1).
- **Currency** — EUR, USD, GBP, CHF, or PLN (default EUR; no conversion).
- **Booking sites** — Airbnb, Booking.com, or both. **Default: Airbnb only** (fast, near-free); add Booking.com for the fuller picture (it runs a browser, so it's slower/costlier).

Every location is priced for every date range (a run is capped at **200 city × date-range combinations** — split bigger jobs).

### How to set it up

1. **Create a free Apify account** and open this Actor — no Airbnb/Booking login, no API keys.
2. Click **Try for free / Start**.
3. Add your **locations** and **date ranges**, tweak guests / currency / sites if you like, and **Start**.
4. Open the **Output** tab and download **`comparison.csv`** — one row per city & site, one column per date (median nightly price). Or use the dataset (JSON/API) or the detail record.

*(Optional)* Use the **Schedule** tab to re-run the same grid over time.

**That's it.** Airbnb grids come back fast; Booking.com adds ~a minute of browser time per city × date.

### Output

- **`comparison.csv`** — the table ready for Excel/Sheets: **Booking site, Location, Currency, then one column per date range** (`3 Jul → 6 Jul`) holding the **market-wide median** nightly price. A blank cell means that combination was blocked or had no listings.
- **The same grid as a dataset** (API/JSON), with clean column names. *(The dataset's own table sorts the date columns alphabetically — use `comparison.csv` for the intended order.)*
- **A detail record** (`detail`, JSON) — per city × date × site: the **median and average**, the **total number of listings** (the whole market, not a sample), the full **price-band breakdown**, the **actual ISO dates**, and a short reason for any blank.

### Costs

**No per-result fee, no markup** — you pay only Apify **platform usage** (compute + a little proxy bandwidth), roughly **a few cents per (city × date range)** when Booking.com is on; the default Airbnb-only grid is near-free.

Almost all of it is the **Booking.com** step — each read launches a real headless browser (~1.5 GB, ~a minute) to clear its anti-bot challenge. **Airbnb** is one light request, seconds-fast.

> **Tip:** Booking.com is opt-in — leave it off for near-free Airbnb grids; give the run more memory for large Booking grids to finish faster.

### Use it from your AI assistant (MCP)

Call it as a tool from any MCP client (Claude, Cursor, …) via **Apify's MCP server** — just ask *"compare the median nightly price in Lisbon and Porto for the first two weeks of July."* The only credential is your **Apify API token** (Console → **Settings → Integrations → API tokens**).

```bash
claude mcp add --transport http apify-price-index \
  "https://mcp.apify.com?tools=inovaflow/airbnb-booking-price-index" \
  --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"
````

Any MCP client works the same way (OAuth too). This Actor also **powers our Travel Planner Actor**, which prices accommodation alongside flights, trains, and buses in one trip-planning call.

### Notes

This Actor reads **publicly visible search data** from Airbnb and Booking.com — it logs into nothing and creates nothing on either site. Every figure is computed over the **whole** result set (`total_listings`), not a sample. One caveat: Airbnb prices its histogram for the whole stay, so per-night figures are the stay total ÷ nights and run slightly high on short stays (the raw whole-stay numbers are in the detail record); Booking.com is already per-night. Respect each site's Terms of Service.

Found a bug, want another site or currency, or need tailored output? Open an issue on the **Issues** tab — custom tweaks on request.

# Actor input Schema

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

Required. Locations to price, one per row as "City, Country". Must include a country to avoid ambiguous matches.

## `dateRanges` (type: `array`):

Required. Check-in/check-out date ranges to sample (YYYY-MM-DD). Each range becomes its own output column.

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

Number of adult guests the prices are quoted for (1–16). Default 1.

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

Currency prices are requested and reported in. No conversion is applied. Default EUR.

## `sources` (type: `array`):

Booking sites to query. Airbnb is fast and lightweight; Booking.com uses a headless browser (slower, costlier). Default Airbnb only.

## Actor input object example

```json
{
  "locations": [
    "Lisbon, Portugal"
  ],
  "adults": 1,
  "currency": "EUR",
  "sources": [
    "airbnb"
  ]
}
```

# Actor output Schema

## `comparisonTable` (type: `string`):

The ready-to-use table: clean, correctly-ordered columns with friendly date headers. Download this one for Excel or Google Sheets.

## `comparison` (type: `string`):

The same prices as raw Apify dataset rows, for the API and integrations. Apify auto-orders these columns — for a polished table, use the cleaned-up CSV above.

## `detail` (type: `string`):

Everything behind the numbers — median, average, total listing counts, the full price-band breakdown, and the actual ISO dates, per city × date × booking site.

# 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"
    ],
    "sources": [
        "airbnb"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/airbnb-booking-price-index").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"],
    "sources": ["airbnb"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb & Booking Price Index",
        "description": "Get the true market-wide median and average nightly price for any city and dates — across the entire Airbnb and Booking.com market, not a small sample. No API keys or logins, just a free Apify account.",
        "version": "0.3",
        "x-build-id": "VZ2ObU0Q8i76MCSSG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/inovaflow~airbnb-booking-price-index/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-inovaflow-airbnb-booking-price-index",
                "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/inovaflow~airbnb-booking-price-index/runs": {
            "post": {
                "operationId": "runs-sync-inovaflow-airbnb-booking-price-index",
                "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/inovaflow~airbnb-booking-price-index/run-sync": {
            "post": {
                "operationId": "run-sync-inovaflow-airbnb-booking-price-index",
                "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": [
                    "locations",
                    "dateRanges"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations (City, Country)",
                        "minItems": 1,
                        "maxItems": 50,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Required. Locations to price, one per row as \"City, Country\". Must include a country to avoid ambiguous matches.",
                        "items": {
                            "type": "string",
                            "minLength": 3,
                            "pattern": "^[^,]+,\\s*[^,]+"
                        }
                    },
                    "dateRanges": {
                        "title": "Date ranges (check-in → check-out)",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Required. Check-in/check-out date ranges to sample (YYYY-MM-DD). Each range becomes its own output column.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "checkIn": {
                                    "title": "Check-in",
                                    "type": "string",
                                    "description": "First night (YYYY-MM-DD).",
                                    "editor": "datepicker",
                                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                                },
                                "checkOut": {
                                    "title": "Check-out",
                                    "type": "string",
                                    "description": "Morning you leave (YYYY-MM-DD).",
                                    "editor": "datepicker",
                                    "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
                                }
                            },
                            "required": [
                                "checkIn",
                                "checkOut"
                            ]
                        }
                    },
                    "adults": {
                        "title": "Number of adult guests",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests the prices are quoted for (1–16). Default 1.",
                        "default": 1
                    },
                    "currency": {
                        "title": "Currency for the prices",
                        "enum": [
                            "EUR",
                            "USD",
                            "GBP",
                            "CHF",
                            "PLN"
                        ],
                        "type": "string",
                        "description": "Currency prices are requested and reported in. No conversion is applied. Default EUR.",
                        "default": "EUR"
                    },
                    "sources": {
                        "title": "Booking sites to check",
                        "type": "array",
                        "description": "Booking sites to query. Airbnb is fast and lightweight; Booking.com uses a headless browser (slower, costlier). Default Airbnb only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "airbnb",
                                "booking"
                            ],
                            "enumTitles": [
                                "Airbnb (fast & cheap)",
                                "Booking.com (browser — slower & costlier)"
                            ]
                        },
                        "default": [
                            "airbnb"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```