Airbnb MCP Server — Claude, Cursor & AI Agents

⭐ Useful? Leave a review — 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):

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

Example structured output:

{
  "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:

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

Output:

{
  "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.

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

{
  "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:

{
  "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:

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:

{
  "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:

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:

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:

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:

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 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 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.

Troubleshooting

Claude Desktop doesn't show the Airbnb tools

• Verify your claude_desktop_config.json has valid JSON (no trailing commas).
• Restart Claude Desktop completely (not just the window).
• Check the MCP logs at ~/Library/Logs/Claude/mcp*.log for the connection error.
• Make sure your Apify token in the URL has not been revoked — try it with the curl example above.

Cursor doesn't pick up the tools

• Cursor reads .cursor/mcp.json from the project root, not from the home directory.
• Restart Cursor after adding the file. The MCP tools appear in the chat composer under the wrench icon.
• If you're on Cursor < 0.45, you may need to update — MCP support is 0.45+.

"Method not allowed" on GET /mcp That's expected. MCP over Streamable HTTP uses POST for all operations. If you see this in a browser, you hit the right endpoint, but browsers don't speak MCP directly.

Tool call returns "Error searching Airbnb"

• Airbnb may be serving a consent banner for your IP region. Use Apify Proxy (the actor already does this by default).
• Double-check the location string — Airbnb is lenient, but ambiguous inputs like "Springfield" without a state return zero listings.

Listings seem stale / cached Every search_airbnb call is live — we don't cache. If prices look stuck, it's more likely Airbnb itself is serving the same set to the same proxy session. Try running again a few minutes later; Apify Proxy will rotate.

Rate limits Apify accounts have generous concurrency limits, but very high-frequency agents (100+ tool calls / minute) should implement their own throttling. MCP clients handle this automatically in most cases.

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 — 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 — raw JSON/CSV search-result scraper
• Airbnb Market Analytics — ADR, RevPAR, Occupancy — aggregated market stats for STR investors

---

🙏 Enjoying this MCP server? Star a review so other builders can find it. Feature requests welcome via the issues tab.