airbnb-mcp

# Airbnb MCP Server

<!-- mcp-name: com.hasdata/airbnb -->

A hosted Model Context Protocol (MCP) server that gives Claude, Cursor, Windsurf and any other MCP client two read-only Airbnb tools. Search stays by location and dates, and read a single listing in full, all as structured JSON, with no Airbnb developer account and no partner approval.

It reads public listing pages that a signed-out visitor can see.

```
https://mcp.hasdata.com/api/mcp?apis=airbnb
```

[![Glama score](https://glama.ai/mcp/servers/HasData/airbnb-mcp/badges/score.svg)](https://glama.ai/mcp/servers/HasData/airbnb-mcp)
[![tool contract](https://github.com/HasData/airbnb-mcp/actions/workflows/contract.yml/badge.svg)](https://github.com/HasData/airbnb-mcp/actions/workflows/contract.yml)
[![MCP](https://img.shields.io/badge/MCP-remote%20%7C%20streamable%20HTTP-6366f1?style=flat-square)](https://modelcontextprotocol.io)
[![Tools](https://img.shields.io/badge/tools-2-10b981?style=flat-square)](#tools)
[![License](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE)

## Contents

- [What you need](#what-you-need)
- [Quick start](#quick-start)
- [Example prompts](#example-prompts)
- [Tools](#tools)
- [Errors and failure paths](#errors-and-failure-paths)
- [Pricing, free tier and limits](#pricing-free-tier-and-limits)
- [Tool selection](#tool-selection)
- [How it compares](#how-it-compares)
- [FAQ](#faq)
- [HasData links](#hasdata-links)
- [Development](#development)
- [Contributing](#contributing)
- [License](#license)

## What you need

An MCP client and a HasData API key from the [dashboard](https://app.hasdata.com/sign-up?utm_source=github&utm_medium=syndication&utm_campaign=airbnb-mcp), free to create with no card, and the trial covers about 200 calls at the 5-credit rate. This is a remote server, so the simplest path is a URL and an `x-api-key` header, with no container to run and no Airbnb developer account anywhere in the flow. A client that only speaks stdio reaches it through a thin launcher, published as `@hasdata/airbnb-mcp` on npm and `hasdata-airbnb-mcp` on PyPI, shown below.

## Quick start

The server URL is the same for every client. We run it hands-on in Claude Code and Claude Desktop. The other blocks follow each client's own documented format for a remote server.

| Field | Value |
| :--- | :--- |
| URL | `https://mcp.hasdata.com/api/mcp?apis=airbnb` |
| Transport | HTTP, streamable |
| Auth header | `x-api-key: HASDATA_API_KEY` |

Clients with OAuth support can add the same URL as a connector and sign in without putting a key in a config file.

<details>
<summary><b>Claude Code</b></summary>

```bash
claude mcp add --transport http airbnb "https://mcp.hasdata.com/api/mcp?apis=airbnb" \
  --header "x-api-key: HASDATA_API_KEY"
```

</details>

<details>
<summary><b>Claude Desktop</b></summary>

Settings, then Connectors, then Add custom connector, then paste `https://mcp.hasdata.com/api/mcp?apis=airbnb` and sign in.

For the config-file route, Claude Desktop loads only local (stdio) servers, so it reaches a remote server through a stdio launcher. The `@hasdata/airbnb-mcp` package is that launcher, and it reads the key from the environment. Add this to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "airbnb": {
      "command": "npx",
      "args": ["-y", "@hasdata/airbnb-mcp"],
      "env": { "HASDATA_API_KEY": "YOUR_KEY" }
    }
  }
}
```

For Python instead of Node, swap the launcher for the PyPI package, which `uvx` runs without a manual install:

```json
{
  "mcpServers": {
    "airbnb": {
      "command": "uvx",
      "args": ["hasdata-airbnb-mcp"],
      "env": { "HASDATA_API_KEY": "YOUR_KEY" }
    }
  }
}
```

</details>

<details>
<summary><b>Cursor</b></summary>

`~/.cursor/mcp.json` for every project, or `.cursor/mcp.json` for one:

```json
{
  "mcpServers": {
    "airbnb": {
      "url": "https://mcp.hasdata.com/api/mcp?apis=airbnb",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}
```

</details>

<details>
<summary><b>Windsurf</b></summary>

`~/.codeium/windsurf/mcp_config.json`. Windsurf calls the field `serverUrl`, not `url`:

```json
{
  "mcpServers": {
    "airbnb": {
      "serverUrl": "https://mcp.hasdata.com/api/mcp?apis=airbnb",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}
```

</details>

<details>
<summary><b>VS Code</b></summary>

`.vscode/mcp.json` in the workspace:

```json
{
  "servers": {
    "airbnb": {
      "type": "http",
      "url": "https://mcp.hasdata.com/api/mcp?apis=airbnb",
      "headers": { "x-api-key": "HASDATA_API_KEY" }
    }
  }
}
```

</details>

## Example prompts

Prompts, not code. Paste one in and the agent picks the tool itself. Each is annotated with the calls it takes, because every successful call costs 5 credits.

> Search Austin stays for two adults from September 15 to 18 and give me the ten highest-rated under $200 a night.

*One call, 5 credits. Rating and nightly price come back on the search result.*

> Take the top result and pull its full amenities, the guest and bedroom count, and the host details.

*One call, 5 credits. Those live on the property page, which the details tool reads by URL.*

> Compare the nightly price of a three-night stay for two guests in Austin against Nashville.

*Two calls, 10 credits, one search per city.*

> For this listing URL, tell me how many beds and baths it has and whether the host is a Superhost.

*One call, 5 credits.*

A search result is deliberately light, enough to rank and shortlist. The amenities, beds, host and full description come from the property call, so a prompt that shortlists then inspects three homes is one search plus three property calls.

## Tools

Two tools, read-only. Samples below are trimmed from real calls, and the numbers move as Airbnb updates. Read them as shapes. Each tool name links to its endpoint reference, which carries the full field list.

The samples are the payload, not the whole response. A `tools/call` result carries one text block, and that text is itself JSON holding `url`, `status`, `text` and `json`, with the scraped data under `json`. From a raw JSON-RPC response the path is `result.content[0].text`, parsed, then `.json`. A chat client unwraps that for you and code talking to the endpoint directly does not.

### Get Airbnb listings

[`hasdata_airbnb_listing_getAirbnbListings`](https://docs.hasdata.com/apis/airbnb/listing?utm_source=github&utm_medium=syndication&utm_campaign=airbnb-mcp)

A page of search results by location and dates.

| Parameter | Type | Required | Notes |
| :--- | :--- | :--- | :--- |
| `location` | string | yes | The place to search, such as `Austin, Texas` |
| `checkIn` | string | yes | Check-in date, `YYYY-MM-DD` |
| `checkOut` | string | | Check-out date, `YYYY-MM-DD` |
| `adults` / `children` / `infants` / `pets` | number | | Guest composition, each a count |
| `nextPageToken` | string | | The `pagination.nextPageToken` from the previous response |

Returns a `properties` array and `pagination`, whose `nextPageToken` and `pageTokens` walk the result set. Each property carries `id`, `url`, `title`, `latitude`, `longitude`, a short `description` tagline, a `photos` array, `rating`, `reviews`, a `badges` array such as `Guest favorite` or `Superhost`, and a `price` object. `price` holds `originalPrice`, an optional `discountedPrice` when the stay is discounted, a `qualifier` like `for 3 nights`, and a `breakdown`.

> A search result is intentionally light. Beds, baths, amenities, the host and the full description are not here, they come from the property tool below. Do not expect a bedroom count on a search result.

```json
{
  "id": "17545365",
  "url": "https://www.airbnb.com/rooms/17545365",
  "title": "Home in East Austin",
  "latitude": 30.25741,
  "longitude": -97.73366,
  "description": "Downtown Casa - neighborhood feel, close to it all",
  "rating": 4.87,
  "reviews": 601,
  "badges": ["Guest favorite"],
  "price": {
    "originalPrice": "$607",
    "discountedPrice": "$447",
    "qualifier": "for 3 nights",
    "breakdown": [{ "description": "3 nights x $149.00", "price": "$447.00" }]
  }
}
```

### Get Airbnb property details

[`hasdata_airbnb_property_getAirbnbPropertyDetails`](https://docs.hasdata.com/apis/airbnb/property?utm_source=github&utm_medium=syndication&utm_campaign=airbnb-mcp)

One listing in full, by its URL.

| Parameter | Type | Required | Notes |
| :--- | :--- | :--- | :--- |
| `url` | string | yes | An Airbnb listing URL, the `url` field from a search result |

Returns `title`, an `overview` array like `["4 guests", "2 bedrooms", "2 beds", "2 baths"]`, the full `description`, `rating`, `reviews`, `address`, `latitude`, `longitude`, a `photos` array, `guestCapacity`, a `host` object, an `amenities` array, and `safetyAndPropertyInfo`. The `host` object carries `name`, `isSuperhost`, `isVerified`, the host's own `reviews`, `rating` and `yearsHosting`. Each amenity carries a `title`, a `type`, an optional `description` and an `available` flag, so a filter reads `available`, it does not assume every listed amenity is present.

```json
{
  "id": "17545365",
  "title": "Downtown Casa - neighborhood feel, close to it all",
  "overview": ["4 guests", "2 bedrooms", "2 beds", "2 baths"],
  "rating": 4.87,
  "reviews": 601,
  "address": "Austin, Texas, United States",
  "guestCapacity": 4,
  "host": { "name": "Deanna", "isSuperhost": true, "isVerified": true, "reviews": 1273, "rating": 4.86, "yearsHosting": 11 },
  "amenities": [
    { "title": "Wifi", "type": "SYSTEM_WI_FI", "available": true },
    { "title": "Free washer – In unit", "type": "SYSTEM_WASHER", "available": true }
  ]
}
```

## Errors and failure paths

Your client almost never sees an HTTP error code from a tool call. The MCP layer answers 200 and puts the failure inside the result, with `isError` set to `true` and the reason as text. The agent reads a message where you might expect a status line.

**A wrong key surf