# Airbnb MCP Server — Claude, Cursor & AI Agents (`makework36/airbnb-mcp-server`) Actor

Plug-and-play Airbnb MCP server for Claude Desktop, Cursor and any MCP-compatible AI agent. Search listings, compare prices across cities, pull ratings, photos and coordinates — no login, no API key.

- **URL**: https://apify.com/makework36/airbnb-mcp-server.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** AI, Integrations, Travel
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 105 total users, 34 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 tool-calls

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/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 MCP Server — Real-time Airbnb Search for Claude, Cursor & AI Agents

> ⭐ **Useful?** [Leave a review](https://apify.com/makework36/airbnb-mcp-server/reviews) — it takes 10 seconds and helps other builders find this server.

Give your AI agent the power to search **Airbnb** in real time. This is a Model Context Protocol (MCP) server that plugs directly into **Claude Desktop**, **Cursor**, **OpenAI Agents SDK**, **Continue**, **Cline**, or any other MCP-compatible client. Ask Claude "find me an Airbnb in Lisbon under $120 with at least 4.8 stars" and it can actually pull the live listings, prices, photos, reviews count, coordinates and Superhost badges — then summarize, compare, book-planning, whatever your workflow needs.

No Airbnb account, no cookies, no API key. The server is hosted on Apify in Standby mode, so it wakes on the first request and stays warm while your agent is working.

### Why an Airbnb MCP Server?

MCP (Model Context Protocol) is Anthropic's open standard for connecting LLMs to tools and data. A normal Airbnb scraper gives you JSON. An **Airbnb MCP** gives Claude or Cursor a tool it can call in the middle of a conversation, reason over, and chain with other tools (calendars, Notion, Google Sheets, Slack). That shifts the agent from "I can't browse Airbnb" to a travel research assistant that works inside your editor or chat.

Use cases our users are building:

- **Claude Desktop trip planner** — Claude compares Airbnb prices in Cancun, Tulum, Playa del Carmen for the same dates and drops the winner into a Notion page.
- **Cursor dev-mode MCP** — a developer pipes Airbnb listing data straight into a Next.js rental-intelligence dashboard they're prototyping.
- **OpenAI Agents SDK** — an autonomous travel agent that watches prices weekly and emails the user when a neighborhood drops below a threshold.
- **STR (short-term rental) analysts** — Claude builds a quick ADR / occupancy sketch by hitting the compare tool across 10 submarkets.
- **Real-estate investors** — a vacation rental investor asks Claude "what's the average nightly rate for 2-bedroom entire homes in Cascais this weekend" and gets an answer backed by real Airbnb data.

### Features

- Two MCP tools out of the box: `search_airbnb` and `compare_airbnb_prices`
- Works with **Claude Desktop**, **Cursor**, **Continue**, **Cline**, **OpenAI Agents SDK**, **LangChain MCP adapter**, and any Streamable HTTP MCP client
- Runs in Apify **Standby mode** — one persistent URL, always on, no cold-start pain
- Pay-per-tool-call pricing — you only pay for the calls the agent actually makes
- No Airbnb login, no reCAPTCHA solving, no browser, no scraping SDK to learn
- Returns structured JSON *and* a human-readable summary (dual content blocks), so small models can read it straight
- Works globally — any city, neighborhood, address or landmark Airbnb supports
- Superhost + Guest favorite badges, photos, coordinates, rating, reviews count, room info

### Tools exposed by this MCP server

#### 1. `search_airbnb`

Search Airbnb listings in a single location.

**Input schema:**

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `location` | string | yes | City, area, neighborhood or landmark (e.g. "Cancun", "New York", "Barcelona") |
| `checkin` | string | no | Check-in date `YYYY-MM-DD` |
| `checkout` | string | no | Check-out date `YYYY-MM-DD` |
| `adults` | number | no | Number of guests (default `2`) |
| `currency` | string | no | Currency code `USD`, `EUR`, `MXN`, `GBP` (default `USD`) |
| `maxListings` | number | no | Max listings to return (default `20`) |

**Example call (what Claude would send):**

```json
{
  "name": "search_airbnb",
  "arguments": {
    "location": "Lisbon, Portugal",
    "checkin": "2026-06-15",
    "checkout": "2026-06-20",
    "adults": 2,
    "currency": "EUR",
    "maxListings": 15
  }
}
```

**Example structured output:**

```json
{
  "listings": [
    {
      "id": "14926879",
      "name": "Charming loft in Alfama with river view",
      "url": "https://www.airbnb.com/rooms/14926879",
      "price": "€610",
      "priceAmount": 610,
      "priceCurrency": "EUR",
      "pricePerNight": "5 nights x €122",
      "rating": 4.89,
      "reviewsCount": 312,
      "isSuperhost": true,
      "roomInfo": "1 bedroom · 1 bed · 1 bath",
      "latitude": 38.7108,
      "longitude": -9.1286,
      "mapUrl": "https://www.google.com/maps?q=38.7108,-9.1286",
      "photos": ["https://a0.muscache.com/im/pictures/..."],
      "thumbnail": "https://a0.muscache.com/im/pictures/..."
    }
  ],
  "total": 15,
  "location": "Lisbon, Portugal"
}
```

#### 2. `compare_airbnb_prices`

Compare average / min / max Airbnb nightly rates across multiple destinations for the same dates. Perfect for "where should I go" prompts.

**Input schema:**

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `locations` | string\[] | yes | List of cities to compare |
| `checkin` | string | yes | `YYYY-MM-DD` |
| `checkout` | string | yes | `YYYY-MM-DD` |
| `adults` | number | no | Guests (default `2`) |
| `currency` | string | no | Currency (default `USD`) |

**Example:**

```json
{
  "name": "compare_airbnb_prices",
  "arguments": {
    "locations": ["Cancun", "Playa del Carmen", "Tulum"],
    "checkin": "2026-07-10",
    "checkout": "2026-07-14",
    "currency": "USD"
  }
}
```

**Output:**

```json
{
  "comparison": [
    { "location": "Playa del Carmen", "avgPrice": 184, "minPrice": 78, "maxPrice": 612, "totalListings": 20, "currency": "USD" },
    { "location": "Cancun", "avgPrice": 221, "minPrice": 95, "maxPrice": 710, "totalListings": 20, "currency": "USD" },
    { "location": "Tulum", "avgPrice": 298, "minPrice": 120, "maxPrice": 980, "totalListings": 20, "currency": "USD" }
  ],
  "checkin": "2026-07-10",
  "checkout": "2026-07-14"
}
```

### Setup — Claude Desktop

Claude Desktop supports MCP natively. The Apify MCP Standby URL for this actor is:

```
https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN
```

Grab your Apify token from [console.apify.com/settings/integrations](https://console.apify.com/settings/integrations).

Then open `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS (or `%APPDATA%\Claude\claude_desktop_config.json` on Windows) and add:

```json
{
  "mcpServers": {
    "airbnb": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-streamable-http",
        "https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN"
      ]
    }
  }
}
```

Restart Claude Desktop. You should see the hammer 🔨 icon with `search_airbnb` and `compare_airbnb_prices` tools available. Ask Claude:

> *"Find me 5 Airbnbs in Porto under €130 per night with at least 4.85 stars, for July 1 to July 5, 2 adults. Rank them by review count."*

### Setup — Cursor

Cursor added MCP support in 0.45+. Create `.cursor/mcp.json` in your project root:

```json
{
  "mcpServers": {
    "airbnb": {
      "url": "https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN"
    }
  }
}
```

Cursor will pick up the tools automatically in the chat panel. You can now say:

> *"Use the airbnb MCP to pull 20 listings in Mexico City, entire homes only, and generate a TypeScript interface that matches the shape."*

### Setup — OpenAI Agents SDK

OpenAI's Agents SDK (python) supports MCP via `HostedMCPTool`:

```python
from agents import Agent, Runner, HostedMCPTool

airbnb = HostedMCPTool(
    tool_config={
        "type": "mcp",
        "server_label": "airbnb",
        "server_url": "https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN",
        "require_approval": "never",
    }
)

agent = Agent(
    name="travel_agent",
    instructions="You plan trips. Use the Airbnb MCP tools to research real prices.",
    tools=[airbnb],
)

result = Runner.run_sync(agent, "Compare Airbnb average prices in Cancun, Tulum, and Playa del Carmen for July 10-14, 2026.")
print(result.final_output)
```

### Setup — Continue (open-source VS Code + JetBrains extension)

Continue supports MCP via its config file. Edit `~/.continue/config.json`:

```json
{
  "mcpServers": [
    {
      "name": "airbnb",
      "transport": "streamable-http",
      "url": "https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN"
    }
  ]
}
```

Reload Continue. Tools appear in the `/tools` menu.

### Setup — Cline (autonomous agent in VS Code)

Cline reads MCP servers from its settings panel. Open Cline → Settings → MCP Servers → Add Remote Server:

- **Name**: `airbnb`
- **URL**: `https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN`
- **Transport**: `streamable-http`

Cline will use the Airbnb tools automatically when its planning loop decides it needs real booking data.

### Setup — raw MCP over HTTP (curl / LangChain / custom agents)

The MCP endpoint speaks Streamable HTTP JSON-RPC 2.0. You can call it directly:

```bash
curl -X POST 'https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list",
    "params": {}
  }'
```

Calling a tool:

```bash
curl -X POST 'https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "search_airbnb",
      "arguments": { "location": "Barcelona", "adults": 2, "maxListings": 10 }
    }
  }'
```

For LangChain, use the `langchain-mcp-adapters` package and point it at the same URL.

### LangChain / LlamaIndex integration

**LangChain (Python) with `langchain-mcp-adapters`:**

```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_anthropic import ChatAnthropic

client = MultiServerMCPClient({
    "airbnb": {
        "url": "https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN",
        "transport": "streamable_http",
    }
})

tools = await client.get_tools()
agent = create_react_agent(ChatAnthropic(model="claude-sonnet-4-6"), tools)
result = await agent.ainvoke({"messages": "Find 5 Airbnbs in Mexico City under $80/night with rating >= 4.8"})
```

**LlamaIndex:**

```python
from llama_index.tools.mcp import McpToolSpec
from llama_index.agent.openai import OpenAIAgent

mcp_spec = McpToolSpec(
    server_url="https://airbnb-mcp-server.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN",
)
agent = OpenAIAgent.from_tools(mcp_spec.to_tool_list(), verbose=True)
response = agent.chat("Compare Airbnb prices in Lisbon vs Porto for July 10-14")
```

### Prompt recipes — things to ask Claude with this MCP

These are real prompts our users run daily. Copy, paste, tweak.

**Trip planning**

> "Find the 5 best-rated Airbnbs in Porto for a 2-adult trip July 1-5, 2026. Budget €100-€180/night. Entire homes only. Return a ranked markdown table with name, nightly price, rating, review count, neighborhood, and booking URL."

**Portfolio monitoring for STR hosts**

> "Pull the top 30 Airbnb listings in South Beach Miami for next weekend (Apr 25-27, 2026, 4 adults). Compute average nightly rate, median rate, % Superhost, and flag any listings below $100/night that have over 100 reviews — those are probably my comp threats."

**Investment scouting**

> "Compare Airbnb average prices across Austin, Nashville, Phoenix, Denver and Charleston for a 4-night trip in September 2026. Give me a table sorted by ADR, and tell me which city has the highest review velocity per listing — that's my target for a new STR investment."

**Travel writer research**

> "Find 10 Airbnbs in Oaxaca City that are Superhost AND have 'colonial' or 'historic' in the name. Return the full list with photos, so I can pick 3 for a travel article."

**Price drop alerting (combined with scheduling)**

> "Run the search_airbnb tool for 'Tulum' nightly at 8 AM and alert me in Slack whenever the average price for entire-home 2BR drops more than 15% below the 30-day rolling median."

### 💵 Pricing

This actor uses the **pay-per-event** model on Apify. You pay exactly for the tool calls your agent makes — nothing for the server being warm:

| Event | Price |
|-------|-------|
| `tool-call` | **$0.02** per call (either `search_airbnb` or `compare_airbnb_prices`) |

The $5 Apify free trial gives you ~250 tool calls to try it out with Claude or Cursor before committing.

### ❓ FAQ

**What is an MCP server?**
Model Context Protocol is an open standard from Anthropic that lets LLMs like Claude call external tools during a conversation. An MCP server *exposes* tools. This actor is an MCP server that exposes two Airbnb tools.

**Does this work with ChatGPT / GPT-5?**
Via the OpenAI Agents SDK (as shown above) or any agent framework that speaks MCP. Native ChatGPT.com doesn't consume MCP directly today.

**Do I need to deploy anything?**
No. The server runs on Apify in Standby mode — it's already live. You only need your Apify API token in the URL.

**How fresh is the data?**
Every tool call hits Airbnb live, so you get real-time prices and availability at the moment the agent asks.

**Why not just run a scraper?**
You can — see our [Airbnb Scraper](https://apify.com/makework36/fast-airbnb-price-scraper) actor for raw JSON/CSV output. The MCP server wraps that capability in a format AI agents can reason with directly.

**Does it support reviews, calendar, availability?**
V1 focuses on search: listings, prices, photos, ratings, coordinates. Reviews and calendar tools are on the roadmap — if you need them now, [open an issue](https://apify.com/makework36/airbnb-mcp-server/issues) and we'll prioritize.

**What about rate limiting?**
Apify Proxy rotates IPs under the hood. For heavy use we recommend adding `currency` and spacing calls with your agent's throttle settings.

**Does this work with Anthropic's Claude API (no Desktop)?**
Yes. Pass the MCP server URL into any Claude API client that speaks MCP — the official TypeScript and Python SDKs both support it in `messages.create` via the `mcp_servers` parameter. Your agent running on the API will have the Airbnb tools available on every turn without you needing to wire up function calling manually.

**Can I self-host this MCP server?**
The source is a standard Node.js Express + MCP SDK implementation — you can copy it to your own infrastructure. That said, running it on Apify Standby gets you automatic proxy rotation, scaling, and billing built in, which is usually cheaper than a dedicated VPS once you factor in residential proxies.

**Does it support streaming responses?**
Yes. The server uses Streamable HTTP, which supports SSE for incremental tool results. Most clients don't need streaming for this scraper (results come back in 2-4 seconds), but it's there if your framework expects it.

### MCP protocol deep-dive

If you're building your own MCP client, here's what this server speaks:

- **Transport**: Streamable HTTP (MCP spec 2025-03-26+).
- **Endpoint**: `POST /mcp` with JSON-RPC 2.0 body.
- **Auth**: Apify API token via `?token=...` query param.
- **Methods supported**: `initialize`, `tools/list`, `tools/call`, `ping`.
- **Content types**: The server returns both `content` (text summary) and `structuredContent` (raw JSON). Clients that support structured content get parseable data; clients that only read text get a human-readable summary.
- **Session**: Stateless — each request spins up a fresh MCP session. No need to store a `Mcp-Session-Id` header.

This makes it drop-in compatible with any MCP SDK that supports Streamable HTTP: TypeScript SDK, Python SDK, Go SDK and community clients.

### Roadmap

- **Reviews tool** — `get_airbnb_reviews(listing_id)` — pull guest reviews for a specific listing.
- **Availability calendar tool** — `get_airbnb_availability(listing_id)` — next 12 months of available nights and blocked dates.
- **Host profile tool** — `get_airbnb_host(host_id)` — profile, Superhost since, response rate, languages.
- **Natural-language location parsing** — accept "beachfront near Tulum, walkable to cenotes" and translate into Airbnb search parameters.
- **OAuth flow** — alternative to token-in-URL for security-conscious setups.

If you need any of these sooner, [open an issue](https://apify.com/makework36/airbnb-mcp-server/issues) — we prioritize by thumbs-up count.

### 📝 Changelog

- **v1.0** (2026-04-21) — SEO-enriched README, categories AI / INTEGRATIONS / TRAVEL, confirmed compatibility with Claude Desktop 0.9+, Cursor 0.47+, OpenAI Agents SDK 0.0.11+
- **v0.1** (2026-04-15) — Initial release with `search_airbnb` and `compare_airbnb_prices` tools

### 🔗 Related actors

- [Airbnb Scraper — Listings, Prices, Photos & Hosts API](https://apify.com/makework36/fast-airbnb-price-scraper) — raw JSON/CSV search-result scraper
- [Airbnb Market Analytics — ADR, RevPAR, Occupancy](https://apify.com/makework36/airbnb-market-data) — aggregated market stats for STR investors

***

> 🙏 **Enjoying this MCP server?** [Star a review](https://apify.com/makework36/airbnb-mcp-server/reviews) so other builders can find it. Feature requests welcome via the issues tab.

# Actor input Schema

## `showSetupInstructions` (type: `boolean`):

When enabled, the test run outputs MCP connection details (the Standby URL you paste in your AI client) and the full list of available tools — search_airbnb and get_listing_details — along with their descriptions, input params, and pricing. Leave this enabled if you are exploring the Actor for the first time. This setting has no effect when the Actor is invoked via its Standby MCP endpoint from Claude, Cursor, or any other AI agent.

## Actor input object example

```json
{
  "showSetupInstructions": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

All scraped items in the default dataset (JSON).

## `csv` (type: `string`):

Default dataset formatted as CSV for spreadsheets (Google Sheets, Excel).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/airbnb-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("makework36/airbnb-mcp-server").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 '{}' |
apify call makework36/airbnb-mcp-server --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,makework36/airbnb-mcp-server"
        }
    }
}
```

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/tmuNyzfxRHQgNSM4J/builds/7kMgJt7q1FXWhhSta/openapi.json