# Airbnb Scraper: Host Full Listings (`simpleapi/airbnb-scraper`) Actor

Scrape live Airbnb listings to fuel travel content, destination guides, or SEO research. Find top listings, popular amenities, and guest trends to create high-converting content strategies.

- **URL**: https://apify.com/simpleapi/airbnb-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** E-commerce, Travel, Lead generation
- **Stats:** 5 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### Airbnb Scraper — Host Listings, Superhost Status and Host Contacts

This Airbnb scraper collects Airbnb search listings and enriches each one with its full host block — host ID, name, superhost status, response rate and time, years hosting, and identity verifications — then optionally expands every host into their complete portfolio with per-host summary analytics for portfolio size, average rating, and average price. Short-term-rental analysts, revenue management teams, and market researchers use it to map which hosts and superhosts dominate a market. Every result lands in a structured JSON dataset ready for filtering, export, or further pipeline work.

### What is Airbnb Scraper: Host Full Listings?

Airbnb Scraper: Host Full Listings is an Apify Actor that searches Airbnb by location or search URL, pulls back priced, rated listings, and attaches the host who operates each one. Turning on **Expand host portfolio** additionally fetches every other listing that host manages plus a roll-up summary row, so a single run can go from "listings in a city" to "every host active in that city and everything they own." It runs logged-out — **no Airbnb account, cookies, or API key are required.**

- Discovers listings by **location keyword** (`hostMarketQueries`) or by pasting **Airbnb search URLs** (`hostSearchUrls`)
- Attaches the identifying host fields on every row: host ID, name, profile URL, superhost flag, response rate/time, and verifications
- Expands unique hosts into their **full managed-listings portfolio** plus one `host_summary` analytics row per host
- Returns geographic coordinates, room type, property type, and unit size (bedrooms/beds/bathrooms) on every listing
- Supports region/country disambiguation, currency and locale selection, and Airbnb's own sort orders (relevance, price low-high, price high-low)
- Streams rows to the Apify **Dataset** as the run progresses, exportable to JSON, CSV, Excel, or via API

### What data can I extract with Airbnb Scraper: Host Full Listings?

Every run returns listing rows enriched with host data, and — with portfolio expansion on — portfolio-listing rows and host-summary roll-up rows in the same dataset, distinguished by the `type` and `isChild` fields. The table below lists the fields Apify surfaces in the default dataset view.

| Field | Example Value | Use Case |
| --- | --- | --- |
| `type` | `"listing"` / `"host_listing"` / `"host_summary"` | Filter or split the dataset by record kind |
| `isChild` | `false` | Separate primary search hits from portfolio/roll-up rows |
| `id` | `"53658202"` | Unique Airbnb listing ID for the search-matched stay |
| `listingId` | `"9182736450"` | Unique ID of a listing inside a host's portfolio |
| `title` | `"Dream OceanView Villa"` | Listing headline for display or text search |
| `name` | `"Ocean Breeze Studio"` | Portfolio listing's name |
| `hostName` | `"Mehdi"` | Host display name |
| `isSuperhost` | `true` | Superhost qualification flag |
| `responseRate` | `"100%"` | Host communication reliability signal |
| `responseTime` | `"Responds within an hour"` | Host communication speed signal |
| `hostSince` | `"14 years"` | Host tenure/experience signal |
| `verifications` | `["Identity","Email address","Phone number"]` | Trust/identity signals for lead qualification |
| `listingsCount` | `6` | Listings the host manages, per their public profile |
| `portfolioSize` | `4` | Host's authoritative total portfolio size |
| `portfolioListingsCollected` | `4` | How many portfolio listings were actually returned |
| `avgRating` | `4.99` | Mean rating across the host's collected portfolio |
| `avgPrice` | `1192` | Mean nightly price across the host's priced listings |
| `hostRatingAverage` | `4.97` | Host-level review rating |
| `hostRatingCount` | `268` | Host-level review volume |
| `ratingAverage` | `4.99` | Per-listing rating (portfolio rows) |
| `reviewCount` | `45` | Per-listing review volume (portfolio rows) |
| `roomType` | `"Entire home"` | Room-type classification |
| `propertyType` | `"Villa"` | Property-type classification |
| `bedrooms` | `3` | Unit size |
| `beds` | `4` | Unit size |
| `bathrooms` | `2` | Unit size |
| `hostUrl` | `"https://www.airbnb.com/users/show/4188395"` | Host's public profile / contact link |
| `listingUrl` | `"https://www.airbnb.com/rooms/9182736450"` | Portfolio listing link |
| `url` | `"https://www.airbnb.com/rooms/53658202"` | Canonical listing link |
| `scrapedAt` | `"2026-07-06T08:32:52Z"` | Extraction timestamp for freshness tracking |

Beyond the default view, `listing` rows also carry a `rating` object (`accuracy`, `checking`, `cleanliness`, `communication`, `location`, `value`, `guestSatisfaction`, `reviewsCount`), a `price` object with a full `breakDown` (base price, service fee, cleaning fee, taxes, total), `coordinates` (`latitude`/`longitude`), `thumbnail`, `description`, `currency`, `locale`, `hostId`, and a nested `host` object that adds `about`, `highlights`, `hasIdentityBadge`, `location`, and `guestReviewCount`. `host_summary` rows additionally carry `avgPriceSampleSize`, `totalPortfolioReviews`, `guestReviewCount`, `location`, and `seedListingsMatched`. Open a row's full JSON in the Dataset tab, or export it, to see every key.

#### Pricing, ratings and portfolio analytics

The `price` object carries the full nightly cost breakdown for the stay window you set — base price, cleaning fee, service fee, taxes, and total — so downstream logic can separate advertised price from all-in cost. The `rating` object splits Airbnb's single guest-satisfaction score into six sub-ratings (accuracy, check-in, cleanliness, communication, location, value) plus review volume. With portfolio expansion on, each `host_summary` row rolls these up per host: `avgPrice` (mean nightly price across that host's priced listings, with `avgPriceSampleSize` reporting how many contributed), `avgRating`, and `totalPortfolioReviews`. A revenue analyst can, for example, compare `avgPrice` against `portfolioSize` to spot hosts running large, high-yield portfolios in a market.

#### Location and property targeting data

Every listing carries `coordinates` (latitude/longitude) for mapping and density work, alongside `roomType`, `propertyType`, and unit size (`bedrooms`, `beds`, `bathrooms`) for segmenting inventory by type. On the input side, `hostRegion` and `hostCountry` narrow an ambiguous place name to the right map area, and `includeNearbyAreas` controls whether similarly-named nearby areas are swept in or excluded.

### Why not build this yourself?

Airbnb has no public, official third-party API for search listings or host portfolios — anything built in-house has to reverse-engineer Airbnb's internal page data, which is served behind Akamai's bot defense. A plain HTTP client's TLS/JA3 fingerprint gets served an "Access to this page has been denied" page instead of listing data, and getting past that reliably means impersonating a real Chrome TLS fingerprint, handling proxy escalation (direct → datacenter → residential) on blocks, and re-parsing Airbnb's embedded JSON structures (which change without notice) for both the listing page's `MEET_YOUR_HOST` section and the separate host-profile page's `managedListings` payload. This Actor already does that work: it impersonates Chrome 131 over `curl_cffi`, escalates proxy mode automatically on a block, and reads both surfaces so a single run returns priced, rated listings joined to full host and portfolio data — no scraping infrastructure to build or maintain on your side.

Building your own scraper only makes sense if you need custom parsing logic this Actor doesn't expose. For a ready-to-run pipeline into a dataset, API, or downstream export, use this Actor directly.

### How to use data extracted from Airbnb?

#### Travel and OTA analysts

Analysts benchmarking a destination pull `hostMarketQueries` for target cities, cap results with `maxHostListings`, and export `price`, `rating`, `roomType`, and `propertyType` to compare nightly rates and guest-satisfaction sub-scores across neighborhoods. Because `price` reflects the `stayWindowStart`/`stayWindowEnd` you set, the same run doubles as a live rate check for a specific travel-date window, and `avgPrice` per host (with portfolio expansion on) turns individual listings into market-level pricing benchmarks landed straight in a dataset or BI tool.

#### Revenue management agencies

Agencies managing multiple STR clients use `expandHostPortfolio` to pull a competing host's entire managed-listings block in one run — `portfolioSize`, `avgRating`, and `avgPrice` — as a recurring competitive audit. Re-running the same `hostMarketQueries` weekly against known competitor hosts turns this into portfolio-size and pricing monitoring without manually re-checking each listing.

#### Market research and intelligence

Researchers map STR density and host concentration by combining `coordinates` with `hostRegion`/`hostCountry` filters, then cross-referencing `isSuperhost`, `listingsCount`, and `avgRating` to see how much of a market's supply sits with a small number of large-portfolio hosts versus individual single-listing hosts.

#### AI agents and automated pipelines

Because the Actor runs as a standard Apify Actor with a JSON input and dataset output, agent frameworks can call it as a tool to pull host-enriched listing data for a location on demand, feeding a RAG index or an automated lead-scoring pipeline that flags superhosts by verification count and portfolio size without any manual dataset export step.

### 🔼 Input sample

All 14 input fields are optional — provide at least one `hostMarketQueries` entry or one `hostSearchUrls` link, or the run exits with nothing to search.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `hostMarketQueries` | No | array | Host market keywords — cities, neighborhoods, or `City--ST` style keywords | `["paris"]` |
| `hostSearchUrls` | No | array | Airbnb search URLs (or other start links) to derive the market from | `["https://www.airbnb.com/s/london/homes"]` |
| `stayWindowStart` | No | string | Stay start (check-in) — absolute date or relative (`14 days`, `2 weeks`) | `"2026-06-01"` |
| `stayWindowEnd` | No | string | Stay end (check-out) — must be after the start | `"2026-06-08"` |
| `portfolioCurrency` | No | string (enum) | Currency for listing and portfolio prices | `"USD"` |
| `portfolioLocale` | No | string (enum) | Language/region used to label listings and prices | `"en-US"` |
| `maxHostListings` | No | integer (1–5000) | Stop after this many search-matched listings collected | `10` |
| `maxSearchPages` | No | integer (1–500) | Optional cap on search result pages scrolled | `10` |
| `includeNearbyAreas` | No | boolean | Off (default) keeps only listings truly inside the named market; on also includes nearby/similarly-named areas | `false` |
| `expandHostPortfolio` | No | boolean (default `false`) | When on, emit every listing each host manages plus a `host_summary` roll-up row | `true` |
| `sortOrder` | No | string (enum, default `"relevance"`) | Airbnb search result order: `relevance`, `price_asc`, `price_desc` | `"price_asc"` |
| `hostRegion` | No | string (enum) | Region/state/province to pin an ambiguous market | `"California"` |
| `hostCountry` | No | string (enum) | Country to pin an ambiguous market | `"United States"` |
| `connectionProxy` | No | object | Apify Proxy configuration; runs direct by default | `{"useApifyProxy": true}` |

#### Example input

```json
{
  "hostMarketQueries": ["malibu--ca"],
  "stayWindowStart": "2026-08-01",
  "stayWindowEnd": "2026-08-05",
  "portfolioCurrency": "USD",
  "maxHostListings": 15,
  "expandHostPortfolio": true,
  "sortOrder": "relevance",
  "hostCountry": "United States",
  "connectionProxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

**Common pitfall:** `maxHostListings` caps search-matched **listings**, not the total rows the run produces — with `expandHostPortfolio` on, a small `maxHostListings` value can still return far more rows once every matched host's whole portfolio is expanded. Set `maxHostListings` low first to check portfolio sizes before scaling up.

### 🔽 Output sample

Each run pushes typed, normalized JSON rows to the Apify Dataset as it goes — no waiting for the run to finish to see data. Rows are tagged `type` (`listing`, `host_listing`, or `host_summary`) and `isChild`, so you can filter one dataset into three logical tables. Export as JSON, CSV, Excel, or pull it via the Apify API. With `expandHostPortfolio` on, `host_summary` rows also mirror to a per-run child dataset named `<runId>-hosts`.

```json
{
  "type": "listing",
  "isChild": false,
  "id": "53658202",
  "title": "Dream OceanView Villa",
  "description": "Sunlit 3-bedroom villa steps from the beach, with a private pool and full kitchen.",
  "thumbnail": "https://a0.muscache.com/im/pictures/example-hero.jpg",
  "url": "https://www.airbnb.com/rooms/53658202",
  "currency": "USD",
  "locale": "en-US",
  "rating": {
    "accuracy": 4.96,
    "checking": 4.95,
    "cleanliness": 4.93,
    "communication": 4.98,
    "location": 4.87,
    "value": 4.91,
    "guestSatisfaction": 4.92,
    "reviewsCount": 1456
  },
  "price": {
    "label": "USD 210",
    "qualifier": "night",
    "price": "USD 210",
    "originalPrice": "",
    "discountedPrice": "USD 210",
    "breakDown": {
      "basePrice": { "description": "4 nights x USD 210", "price": "USD 840" },
      "serviceFee": "USD 75",
      "cleaningFee": "USD 60",
      "taxes": "USD 84",
      "total": { "price": "USD 1059", "description": "Total" },
      "totalBeforeTaxes": "USD 975"
    }
  },
  "coordinates": { "latitude": 34.0259, "longitude": -118.7798 },
  "hostId": "4188395",
  "hostName": "Mehdi",
  "hostUrl": "https://www.airbnb.com/users/show/4188395",
  "isSuperhost": true,
  "responseRate": "100%",
  "responseTime": "Responds within an hour",
  "hostSince": "14 years",
  "verifications": ["Identity", "Email address", "Phone number"],
  "listingsCount": 6,
  "hostRatingAverage": 4.97,
  "hostRatingCount": 268,
  "host": {
    "id": "4188395",
    "name": "Mehdi",
    "url": "https://www.airbnb.com/users/show/4188395",
    "isSuperhost": true,
    "isVerified": true,
    "responseRate": "100%",
    "responseTime": "Responds within an hour",
    "hostSince": "14 years",
    "ratingAverage": 4.97,
    "ratingCount": 268,
    "about": "Full-time host based in Malibu, sharing coastal properties since 2012.",
    "highlights": ["Speaks English and Spanish"],
    "verifications": ["Identity", "Email address", "Phone number"],
    "hasIdentityBadge": true,
    "location": "Malibu, California",
    "listingsCount": 6,
    "guestReviewCount": 32
  },
  "scrapedAt": "2026-07-06T08:32:52Z"
}
```

### How do you filter and target specific listings?

`hostMarketQueries` (a plain place name or `City--ST` keyword) is more accurate than pasting a `hostSearchUrls` link when you want the Actor's own geo-matching to lock the result set to the right map area; use search URLs when you already have a specific Airbnb search configured (dates, filters) that you want replicated exactly. For scope, `hostRegion` and `hostCountry` disambiguate a place name that exists in multiple countries (there are two Cordobas, for instance), while `includeNearbyAreas` controls whether the net widens to similarly-named or adjacent areas — leave it off for a tight, single-market pull. `stayWindowStart`/`stayWindowEnd` set the date scope that drives live pricing, since Airbnb's price for a given listing depends on the exact stay length and dates requested. This Actor has no rating- or review-count minimum filter built in — quality thresholds are applied downstream by filtering the returned `rating`/`hostRatingAverage`/`reviewCount` fields after extraction. Volume is controlled by `maxHostListings` (how many search-matched listings to collect) and `maxSearchPages` (how many result pages to walk to find them); with `expandHostPortfolio` on, actual row volume grows with each matched host's real portfolio size, which the Actor does not cap.

```json
{ "hostMarketQueries": ["Austin--TX"], "hostCountry": "United States", "maxHostListings": 25 }
```

```json
{ "hostMarketQueries": ["cordoba"], "hostRegion": "Córdoba", "hostCountry": "Argentina", "includeNearbyAreas": false }
```

```json
{ "hostMarketQueries": ["lisbon"], "expandHostPortfolio": true, "sortOrder": "price_desc", "maxHostListings": 10 }
```

### ▶️ Want to try other Airbnb scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| Airbnb Full Year Price Tracker Scraper | A full year of nightly Airbnb prices per listing for availability and pricing-calendar analysis |
| Airbnb Occupancy & Rate Analytics Scraper | Occupancy and rate analytics for Airbnb listings over a date range |
| Airbnb Phone Number Scraper with Host Listing Leads Finder | Airbnb listings, host profiles, and experiences discovered via Google SERP, classified with Airbnb ID and result type |
| Google Hotels — Location Details Scraper | Hotel location details from Google Hotels for comparable travel-inventory research |
| Zillow Agents Finder & Reviews Scraper | Real-estate agent profiles and reviews from Zillow |
| Zillow Search Scraper: Investment Analyzer | Zillow property search results with investment and rental-yield analytics |

### How to extract Airbnb data programmatically

This Actor runs as a standard Apify Actor: send a JSON input to a run endpoint with your Apify API token, and get structured JSON rows back from the run's dataset — no scraping code to maintain.

#### Python example

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("SimpleAPI/airbnb-scraper-host-full-listings").call(
    run_input={
        "hostMarketQueries": ["austin--tx"],
        "maxHostListings": 20,
        "expandHostPortfolio": True,
        "sortOrder": "price_asc",
    }
)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("type") == "listing":
        print(row["hostName"], row["isSuperhost"], row["price"]["price"])
```

#### Export to spreadsheets or CRM

Every dataset supports one-click export to CSV, Excel, or JSON from the Apify Dataset tab, or via the API's dataset items endpoint. Map `hostName`, `hostUrl`, `isSuperhost`, `responseRate`, `verifications`, and `listingsCount` straight into CRM columns for host/lead tracking, and `price`, `rating`, `roomType` into a pricing or inventory sheet.

### Is it legal to scrape Airbnb listings?

Yes — this Actor extracts data that Airbnb publishes openly on public listing and host-profile pages, without logging in or bypassing any access control. Airbnb search results and listing pages are public business/product data (pricing, availability, property attributes) published to be discovered by prospective guests, which is generally governed by Airbnb's Terms of Service and database-rights considerations rather than by data-protection law. The host block does include a host's self-published name and profile — personal identifiers a host chooses to display publicly to run their business — so if you store host names or profile data in bulk, treat that subset under GDPR/CCPA-style lawful-basis principles. Consult legal counsel for commercial applications involving bulk storage of personal data.

### ❓ FAQ

#### What happens if a host removes a listing or it goes off-market?

The Actor returns listings and host profiles exactly as published at request time; a listing that's been removed or taken off-market simply won't appear in a fresh search, and re-running with `expandHostPortfolio` on will reflect the host's current, updated portfolio rather than a stale one.

#### Can I get host portfolio data along with the main listing search?

Yes. Every listing row already includes the host block (superhost, response rate/time, verifications, listings count) with no extra step. Turn on `expandHostPortfolio` to additionally emit one `host_listing` row per listing the host manages plus one `host_summary` roll-up row per unique host; this fetches one extra page per unique host, so the more distinct hosts your search returns, the more rows and requests the run produces.

#### How accurate is the host and pricing data?

The Actor returns data exactly as it appears on the public listing and host-profile pages at the time of the request. Accuracy depends on whether the host keeps their profile and listing details current — for time-sensitive pricing, re-run the Actor close to your target dates and treat `price` as a point-in-time snapshot rather than a permanent record.

#### How many listings can I get per run?

`maxHostListings` accepts 1–5,000 and defaults to 10; that caps the number of search-matched listings collected, not the total dataset rows. With `expandHostPortfolio` on, each matched host's full real portfolio is added on top, uncapped by `maxHostListings`, so total row count scales with how many listings the matched hosts actually manage.

#### How does the portfolio expansion filter work?

Set `expandHostPortfolio` to `true` and every unique host behind your matched listings gets expanded into their complete `managedListings` portfolio plus a `host_summary` row (portfolio size, average rating, average price, superhost flag). Leave it `false` (the default) to keep the run to listing rows only, each still carrying the host block.

#### Does this Actor work with Claude, ChatGPT, and AI agent frameworks?

Yes, as a standard HTTP-callable Apify Actor — any agent framework that can call the Apify API can trigger a run with a JSON input and read the resulting dataset, making it usable as a tool inside a custom agent pipeline.

#### How does this compare to other Airbnb scrapers?

Compared with scrapers that return only priced listings, this Actor's distinguishing feature is host-level enrichment: it attaches the full host block to every listing and can expand each host into their entire managed portfolio with roll-up analytics, rather than requiring a second, separate lookup per host.

#### Can I use this without an Airbnb account or API key?

Yes. The Actor runs fully logged-out against Airbnb's public pages — no Airbnb account, cookies, or API key are needed. You only need an Apify account to run the Actor itself.

#### Do I need to configure a proxy to run this?

No — it connects directly by default and only needs `connectionProxy` set if your workspace requires routing through Apify Proxy or you hit persistent blocks in a tough network environment.

#### What region and language options are supported?

`portfolioCurrency` and `portfolioLocale` control how prices and text are displayed, each backed by a fixed list of enum values in the input schema, while `hostRegion` and `hostCountry` (also enum-backed) narrow ambiguous place names to the right country or region.

### Conclusion

Airbnb Scraper: Host Full Listings turns a plain city search into host-centric market intelligence — every listing arrives with its host's identity, trust signals, and communication metrics, and any host can be expanded into their full portfolio with roll-up analytics in the same run. It's built for travel analysts, revenue management teams, and market researchers who need structured, filterable host and listing data without maintaining their own Airbnb scraping infrastructure. Open the Actor on Apify and start a run with a market keyword to see it in your Dataset tab.

# Actor input Schema

## `hostMarketQueries` (type: `array`):

Examples: `london`, `paris`, or for the US `Austin--TX` so the right area is clear. Add one entry per line. 🌆

## `hostSearchUrls` (type: `array`):

Optional: full Airbnb search URLs or other start links — we’ll figure out the place from them. 🔗

## `stayWindowStart` (type: `string`):

When the stay starts — calendar date **or** relative (e.g. `14 days`, `2 weeks`). Future dates work best for live prices. 📆

## `stayWindowEnd` (type: `string`):

When the stay ends — must be **after** the stay start. Same calendar or relative style as above. 🌅

## `portfolioCurrency` (type: `string`):

Host listing prices and per-host average prices are shown in this money format. 💶

## `portfolioLocale` (type: `string`):

How Airbnb labels host listings and prices for you (language/region). 🗣️

## `maxHostListings` (type: `integer`):

Stop after this many listings that **match your search** (each carries its host block). 📊

## `maxSearchPages` (type: `integer`):

Advanced: limit how many result pages to scroll. Leave empty and we’ll pick a sensible cap for you. 📑

## `includeNearbyAreas` (type: `boolean`):

Leave **off** ✅ (default) to keep only hosts whose listings really belong to the market you named — best when a city name exists in many countries. Turn **on** to also include hosts from nearby or similarly-named areas. 🧭

## `expandHostPortfolio` (type: `boolean`):

When **on** ✅ each unique host is expanded into **all of their listings** (rows tagged `type=host_listing`) plus one **`host_summary`** roll-up row (portfolio size, average rating, average price, superhost flag). Summaries also mirror to a per-run `<runId>-hosts` child dataset. When **off**, you still get the host block on every listing. Example: 5 listings by 3 hosts → 5 listing rows + all 3 hosts' portfolios + 3 host\_summary rows. 📊

## `sortOrder` (type: `string`):

Order Airbnb returns search results in. Example: `price_asc` to see the cheapest of a host's area first. Default is `relevance`. 🔀

## `hostRegion` (type: `string`):

Optional dropdown of regions worldwide — pick the closest match, or none. US tip: you can also use `City--ST` in the market keyword field. 🇺🇸

## `hostCountry` (type: `string`):

Optional: which country the host market should be in (helps when two cities share a name). Leave empty if you’re sure. 🏳️

## `connectionProxy` (type: `object`):

Configure Apify Proxy if needed; otherwise we connect directly. ☁️

## Actor input object example

```json
{
  "hostMarketQueries": [
    "paris"
  ],
  "hostSearchUrls": [
    "https://www.airbnb.com/s/london/homes"
  ],
  "stayWindowStart": "2026-06-01",
  "stayWindowEnd": "2026-06-08",
  "portfolioCurrency": "USD",
  "portfolioLocale": "en-US",
  "maxHostListings": 10,
  "expandHostPortfolio": false,
  "sortOrder": "relevance",
  "connectionProxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "hostMarketQueries": [
        "paris"
    ],
    "hostSearchUrls": [
        "https://www.airbnb.com/s/london/homes"
    ],
    "stayWindowStart": "2026-06-01",
    "stayWindowEnd": "2026-06-08",
    "portfolioCurrency": "USD",
    "portfolioLocale": "en-US",
    "maxHostListings": 10,
    "hostRegion": "",
    "hostCountry": "",
    "connectionProxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "hostMarketQueries": ["paris"],
    "hostSearchUrls": ["https://www.airbnb.com/s/london/homes"],
    "stayWindowStart": "2026-06-01",
    "stayWindowEnd": "2026-06-08",
    "portfolioCurrency": "USD",
    "portfolioLocale": "en-US",
    "maxHostListings": 10,
    "hostRegion": "",
    "hostCountry": "",
    "connectionProxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/airbnb-scraper").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 '{
  "hostMarketQueries": [
    "paris"
  ],
  "hostSearchUrls": [
    "https://www.airbnb.com/s/london/homes"
  ],
  "stayWindowStart": "2026-06-01",
  "stayWindowEnd": "2026-06-08",
  "portfolioCurrency": "USD",
  "portfolioLocale": "en-US",
  "maxHostListings": 10,
  "hostRegion": "",
  "hostCountry": "",
  "connectionProxy": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/BYjai4waOTxfg0Yv5/builds/4zNYt0NeBCfKi4vjs/openapi.json