# Airbnb Real-Time Data — Listings & Host Portfolios (`b2b_leads/airbnb-real-time-data`) Actor

Fresh Airbnb data for any market: listings with nightly prices, ratings, reviews, photos, plus host portfolios with listing counts and superhost status. Streams to your dataset, webhook-ready — built for market research and lead generation. Free plan gets a sample; paid plans unlock everything.

- **URL**: https://apify.com/b2b\_leads/airbnb-real-time-data.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Real-Time Data

**Turn any market into an Airbnb dataset.** Discover listings across cities, build host and portfolio views of professional operators, and enrich your own listing links — all as **clean, flat JSON streamed to your Apify dataset while the run is still going.**

The Actor is built for short-term-rental (STR) investors, hosts, property managers, lead-gen agencies, travel-tech teams, and AI workflows that need **reliable Airbnb market data** without hand-collecting it yourself.

***

### Why this Actor

| | Airbnb Real-Time Data | Hand-collecting market data |
|---|----------------------|-----------------------------|
| **Speed** | Many listings per market, in one run | Hours of manual work per market |
| **Memory** | **512 MB** default — light on long runs | N/A |
| **Multi-market** | Dozens of markets in a single run | One city at a time |
| **Sections** | Listings, Hosts, Listing URLs — mix and match | Manual, error-prone |
| **Output** | Structured, LLM-ready JSON | Copy-paste into spreadsheets |
| **Delivery** | Dataset + optional real-time webhook | Manual export |
| **Webhooks** | Native (JSON or Slack) | None |
| **Scale** | Large runs — 1,000+ rows per run | Not practical |

***

### What to collect (sections)

The input is organised into **independent sections**. Switch on the ones you want — each has its own options and its own result limit, so nothing is shared or guessed for you. Turn on one, two, or all three in the same run.

#### 1. 🏠 Listings for markets — on by default

Give the Actor one or more markets (`"Austin, TX"`, `"Lisbon, Portugal"`, `"Bali, Indonesia"`, …) and it returns listing rows with price, rating, review count, room/property type, bed/bath counts, coordinates, photos, and Guest Favorite status.

This section has its own controls:

- **Markets** — one per row; add several to cover multiple markets in one run
- **Max listings per market** — how deep to go in each market (default `100`)
- **Max listings in total** — the overall ceiling for listing rows across all markets
- **Include host details on listing rows** — attach the host's name, profile link, and Superhost status to every listing (adds a little extra time per business)

Results stream to your dataset as they are ready, so a long multi-market run stays light on memory. Coverage goes well beyond the handful of results most tools stop at — one market can return **100+ unique listings**.

#### 2. 🧑‍💼 Host & portfolio view — off by default

Turn this on to also export one row per host. You get:

- how many listings that host has across the markets you selected
- the host's price band (min/max nightly rate)
- average rating across their listings
- Superhost status and a sample listing for reference

Its own controls:

- **Markets to build portfolios from** — leave empty to reuse the markets from the Listings section (markets shared between sections are collected once)
- **Minimum listings per host** — filter down to professional operators and multi-property managers
- **Max hosts** — how many host rows to keep, biggest portfolios first

#### 3. 🔗 Enrich listing URLs — off by default

Already have listing links (from a CRM, a spreadsheet, or a previous run)? Turn this on, paste them in, and get a full row for each one — host attribution, guest capacity, location, rating, review count, and a description excerpt.

Its own controls:

- **Listing URLs** — one listing link per row
- **Max listings from URLs** — how many of the supplied links to process

The price fields are only populated for market rows, since nightly rates depend on the stay window you choose.

***

### What you get

#### Listing rows (`type: "listing"`)

| Field | Description |
|-------|-------------|
| `listingId` | Stable listing identifier |
| `title` | Listing name |
| `url` | Direct listing link |
| `city` | Market this row was collected for |
| `location` | Full location string (street-level area) |
| `latitude`, `longitude` | Coordinates |
| `roomType` | e.g. `Entire home/apt`, `Private room` |
| `propertyType` | e.g. Home, Apartment, Condo, Guesthouse, Loft, Camper/RV |
| `beds`, `bedrooms`, `baths` | Layout |
| `personCapacity` | Max guests |
| `price` | Headline price for the selected stay window |
| `pricePerNight` | Per-night rate |
| `priceDisplay` | Original price text, as shown to guests |
| `currency` | Currency code (pinned to USD for consistent comparisons) |
| `rating` | Average guest rating (0–5) |
| `reviewCount` | Number of reviews |
| `isGuestFavorite` | Whether the listing carries a Guest Favorite badge |
| `images[]` | Photo URLs |
| `description` | Listing description excerpt (enriched links) |
| `hostId`, `hostName`, `hostUrl` | Host attribution |
| `isSuperhost` | Superhost status |
| `searchLocation` | Market used for this row |
| `checkIn`, `checkOut` | Stay window used for this row |
| `scrapedAt` | Collection timestamp |

#### Host rows (`type: "host"`)

| Field | Description |
|-------|-------------|
| `hostId` | Stable host identifier |
| `hostName` | Host display name |
| `hostUrl` | Host profile link |
| `isSuperhost` | Superhost status |
| `listingCount` | Listings this host has in the collected markets |
| `listings[]` | Listing IDs belonging to this host |
| `markets[]` | Markets where this host operates |
| `minPrice`, `maxPrice` | The host's nightly price band |
| `avgRating` | Average rating across their listings |
| `sampleListingTitle`, `sampleListingUrl` | A representative listing |
| `scrapedAt` | Collection timestamp |

***

### Use cases

**Investment & market research**

- Estimate nightly rates and occupancy signals across a target city before buying a property
- Compare price bands between neighbourhoods, or between two competing markets
- Size a market: how many listings exist, how highly rated they are, and how concentrated ownership is

**Host & operator intelligence**

- Identify professional hosts and multi-property managers in a market (Minimum listings per host ≥ 2)
- Measure portfolio concentration — who actually controls supply
- Track competitor pricing and rating changes over time by re-running on a schedule
- Find high-performing hosts to learn from: filter for Superhosts with 50+ reviews and a 4.8+ rating

**Lead generation & outreach**

- Build a prospect list of hosts for cleaning services, interior design, photography, insurance, or PMS software
- Target hosts with weak ratings (opportunity) or large portfolios (high value)
- Enrich a CRM: switch on the **Enrich listing URLs** section against your existing listing list to backfill host names, capacity, and ratings

**Revenue management & pricing**

- Pull a competitive set for a specific market and stay window
- Filter by price band and rating to isolate true comparables
- Feed nightly rates into a pricing model or dashboard

**Travel & content**

- Build regional shortlist datasets for editorial guides and travel content
- Power "best stays in X" pages with real, sortable data
- Feed an AI agent that drafts personalised stay recommendations

**Data pipelines**

- Deliver rows straight into a warehouse, Google Sheet, Airtable, or CRM via webhook
- Chain with other Actors (enrichment, scoring, outreach drafting) in an Apify workflow
- Schedule runs weekly/monthly to build a longitudinal market dataset

***

### Who it is for

| You are… | You use this Actor to… |
|----------|------------------------|
| **STR investor / analyst** | Size markets, compare price bands, validate a purchase thesis |
| **Property manager** | Track competitor portfolios and professional operator density |
| **Real-estate agent** | Show clients a data-backed view of the local STR market |
| **Growth / lead-gen agency** | Build host prospect lists and enrich CRMs |
| **Travel-tech / startup** | Power a directory, pricing product, or recommendation engine |
| **Data engineer / analyst** | Feed structured STR data into a warehouse or model |
| **AI builder** | Generate LLM-ready market data for agents, RAG, and reports |
| **Journalist / researcher** | Quantify short-term-rental supply and pricing in a city |

***

### Output reference

Every run streams rows to the **default dataset** and writes a **run summary** to the key-value store.

| Dataset view | What it shows |
|--------------|---------------|
| `overview` | All rows, listings and hosts mixed, with the columns that matter at a glance |
| `listings` | One row per listing — price, rating, layout, host attribution, link |
| `hosts` | One row per host — portfolio size, price band, average rating |

Export as **JSON, CSV, Excel, RSS**, or pull it via the Apify API.

**Run summary** (`OUTPUT` in the key-value store) includes:

```json
{
  "sections": ["listings", "hosts"],
  "markets": ["Austin, TX"],
  "hostMarkets": ["Austin, TX"],
  "stayWindow": { "checkIn": "2026-11-06", "checkOut": "2026-11-08" },
  "listingsExported": 118,
  "hostsExported": 24,
  "duplicatesRemoved": 0,
  "hostDetailsAttached": 0,
  "marketsWithoutResults": [],
  "spendingLimitReached": false,
  "freeTierLimitReached": false,
  "errors": [],
  "paywall": {
    "detected": false,
    "isPaying": false,
    "pricingTier": null,
    "blocked": false,
    "limited": false,
    "mode": "limit",
    "freeTierMaxItems": null
  }
}
```

The `paywall` object tells you exactly how the run was treated, so there are never surprises about why results were capped.

***

### Input reference

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **🏠 Listings for markets** | | | |
| `collectListings` | boolean | `true` | Switch this section on/off |
| `locations` | string\[] | `["Austin, TX"]` | One market per row. Add several to cover multiple markets in one run |
| `maxListingsPerMarket` | integer | `100` | How many listings to take from each market |
| `maxListings` | integer | `500` | Total listing rows to keep across all markets (best-rated first) |
| `includeHostDetails` | boolean | `false` | Attach host attribution to listing rows. Adds a little extra time per business |
| **🧑‍💼 Host & portfolio view** | | | |
| `collectHosts` | boolean | `false` | Switch this section on/off |
| `hostLocations` | string\[] | — | Markets to build portfolios from. Empty = reuse the Listings markets |
| `maxHosts` | integer | `100` | How many host rows to keep, biggest portfolios first |
| **🔗 Enrich listing URLs** | | | |
| `enrichListings` | boolean | `false` | Switch this section on/off |
| `listingUrls` | string\[] | — | One listing link per row |
| `maxListingsFromUrls` | integer | `200` | How many supplied links to process |
| **📅 Stay window & guests** | | | |
| `checkIn` | string | auto | `YYYY-MM-DD`. Leave empty for a sensible upcoming window |
| `checkOut` | string | auto | `YYYY-MM-DD`. Must be after `checkIn` |
| `adults` | integer | `2` | Guests for the stay window. Affects which stays qualify and the displayed price |
| `roomTypes` | select\[] | all | `entire_home`, `private_room`, `shared_room` |
| **⚙️ Output & limits** | | | |
| `maxItems` | integer | `1000` | Overall ceiling across every section. Runs stop as soon as this many rows exist |
| `maxRetries` | integer | `3` | Retry attempts when a market is temporarily busy |
| **🔔 Webhook** | | | |
| `webhookUrl` | string | — | Optional webhook URL for real-time delivery (dataset is always written too) |
| `webhookFormat` | select | `json` | `json` (full row) or `slack` (Slack message) |
| **🌐 Connection** | | | |
| `proxyConfiguration` | object | residential US | Apify residential proxy is on by default |

A full JSON schema lives in `.actor/input_schema.json` and on the **Input** tab.

***

> **A note on filtering:** earlier versions could drop rows that missed a price or rating bar. That option was retired — **every collected row now exports**. Run length depends only on the amounts you ask for, and any narrowing you want is best done after the run (the rows arrive sorted best-rated first). If an old task still sends `minPrice` / `maxPrice` / `minRating`, the run simply notes that they are ignored.

### Quick start examples

**A single market, top-rated first**

```json
{
  "collectListings": true,
  "locations": ["Austin, TX"],
  "maxListingsPerMarket": 50,
  "maxListings": 50
}
```

**Multi-market scan**

```json
{
  "collectListings": true,
  "locations": ["Austin, TX", "Nashville, TN", "Asheville, NC"],
  "maxListingsPerMarket": 100,
  "maxListings": 300,
  "adults": 2
}
```

**Find professional operators in a market**

```json
{
  "collectHosts": true,
  "hostLocations": ["Miami, FL"],
  "maxHosts": 200,
  "maxListingsPerMarket": 100
}
```

**Listings *and* portfolios in one run**

```json
{
  "collectListings": true,
  "locations": ["Austin, TX"],
  "maxListingsPerMarket": 150,
  "maxListings": 150,
  "collectHosts": true,
  "hostLocations": ["Austin, TX"],
  "maxHosts": 100
}
```

**Full listing detail including host attribution**

```json
{
  "collectListings": true,
  "locations": ["Lisbon, Portugal"],
  "maxListingsPerMarket": 60,
  "maxListings": 60,
  "includeHostDetails": true
}
```

**Enrich your own listing links**

```json
{
  "enrichListings": true,
  "listingUrls": [
    "https://www.airbnb.com/rooms/11442375",
    "https://www.airbnb.com/rooms/16842314"
  ],
  "maxListingsFromUrls": 50
}
```

**Market run with Slack alerts as rows land**

```json
{
  "collectListings": true,
  "locations": ["Bali, Indonesia"],
  "maxListingsPerMarket": 50,
  "maxListings": 50,
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

***

### Webhook delivery (optional)

Every row is **always saved to the Apify dataset first**. If you set `webhookUrl`, each new row is **also delivered in real time** to your own URL — ideal for CRMs, Slack, Zapier, Make, n8n, or a custom pipeline.

| Setting | Description |
|---------|-------------|
| `webhookUrl` | Your own http or https URL. Leave empty to use the dataset only |
| `webhookFormat` | `json` — the full row object. `slack` — a compact Slack incoming-webhook message with title, price, rating, area, host, and a link |

Webhook delivery is **best-effort**: a failed webhook never stops the run and never stops dataset writes. Failures are logged as a single fixed line.

***

### AI, LLM & MCP integration

Rows are **flat, predictable JSON** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, and custom agents. No nested provider structures to untangle.

#### Apify MCP (Model Context Protocol)

Connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and let an AI assistant:

- **Run** this Actor from a natural-language instruction
- **Read** the dataset straight into the conversation
- **Chain** it with other Actors (enrich → score → draft outreach)

```
User: "Map the Austin STR market — 50 well-rated 2-guest stays,
       then tell me which neighbourhoods look underpriced."
→ MCP runs the Actor with locations=["Austin, TX"], maxListings=50
→ MCP reads the dataset items
→ LLM clusters by location, compares price bands, and summarises the gaps
```

#### Example row for an LLM prompt

```json
{
  "type": "listing",
  "listingId": "11442375",
  "title": "Tiny Tasteful 3",
  "url": "https://www.airbnb.com/rooms/11442375",
  "city": "Austin",
  "location": "Austin, Texas, United States",
  "roomType": "Entire home/apt",
  "propertyType": "Home",
  "bedrooms": 1,
  "beds": 1,
  "baths": 1,
  "personCapacity": 2,
  "pricePerNight": 175,
  "currency": "USD",
  "rating": 4.89,
  "reviewCount": 481,
  "isGuestFavorite": true,
  "hostName": "Chet",
  "isSuperhost": true,
  "latitude": 30.27438,
  "longitude": -97.75658,
  "checkIn": "2026-11-06",
  "checkOut": "2026-11-08"
}
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "collectListings": true,
    "locations": ["Austin, TX", "Nashville, TN"],
    "maxListingsPerMarket": 75,
    "maxListings": 150,
    "includeHostDetails": true
  }'
```

Read the results:

```bash
## Dataset items
curl "https://api.apify.com/v2/datasets/{datasetId}/items?format=json&token=YOUR_TOKEN"

## Run summary (includes the paywall object)
curl "https://api.apify.com/v2/key-value-stores/{storeId}/records/OUTPUT?token=YOUR_TOKEN"
```

***

### Free plan sample vs paid plans

This Actor is a **paid Actor**. To keep the free tier useful for evaluation while still funding development:

- **Apify free plan:** a run returns a **small sample (2 results by default)** and then finishes cleanly with a message telling you to upgrade. The `paywall` object in the run summary reports `limited: true` and `freeTierMaxItems`.
- **Any paid Apify plan (Bronze and above):** the full, normal output with **no caps**. `paywall.isPaying` is `true`.
- The sample arrives **fast** — collection stops as soon as the sample is complete rather than running to the end and trimming, so a free evaluation takes seconds, not minutes.

No run ever fails because of this — the restriction is reported transparently in the run log and the run summary, never as an error.

***

### Reliability & performance

- **Streaming writes** — rows are saved to the dataset as soon as they are ready, so a long run does not pile up in memory.
- **512 MB default memory** — plenty of headroom; you rarely need to tune it.
- **Tuned for speed** — a run works on many items at once, so a market with host details attached finishes in seconds rather than minutes, and long runs stay quick.
- **Multi-market runs** — add as many markets as you need in one run, and they are worked through side by side.
- **Depth per market** — tuned by `maxListingsPerMarket`, so you get a meaningful slice of supply rather than a teaser.
- **Residential US proxy on by default** — recommended for reliable, consistent results on larger runs.
- **Automatic retries** — temporary rate limits and busy windows are retried with backoff, and the Actor rotates its connection when needed.
- **Graceful limits** — spending limits and free-tier caps stop the run cleanly instead of erroring out.

***

### Limits & compliance

- Only **publicly visible market data** is collected. No accounts, no logins, no private data.
- Guest identities, messages, calendars, and booking functionality are **out of scope**.
- Nightly pricing depends on the stay window and guest count you pass in — compare rows within the same window.
- Listing counts in the **Host & portfolio view** reflect **the markets you collected**, not a host's entire portfolio worldwide.
- Some listings do not publish a rating or review count; those fields are `null` rather than guessed.
- Not affiliated with, endorsed by, or sponsored by Airbnb. You are responsible for complying with applicable laws, platform terms, and local regulations.

***

### FAQ

**Do I need an Airbnb account?**
No. No account, login, or credentials are needed. Public market data only.

**How many results can I get per run?**
Each section has its own limit: `maxListingsPerMarket` and `maxListings` for listings, `maxHosts` for portfolios, `maxListingsFromUrls` for enriched links — with `maxItems` as an overall ceiling. A single market can return 100+ unique listings; multi-market runs scale from there.**How long does a run take?**

Seconds for a small market and a couple of minutes for a large, multi-market run. Runs sized by a limit finish as soon as that limit's rows exist — a 20-row run is quick even on a huge market. Asking for owner details on every listing (`includeHostDetails`) adds a little extra time per listing, and the Host & portfolio view adds a little more per portfolio. Applying a price or rating filter keeps the full sweep so the filter has something to choose from, which takes a little longer than an unfiltered, capped run. A busy window can add a short pause — the run retries on its own and keeps going.

**Why are prices different between runs?**
Nightly rates move with dates and guest count. The Actor uses the stay window you provide (or a sensible upcoming window if you leave it blank), so re-run with the same dates to compare like for like.

**Why is `price` sometimes different from `pricePerNight`?**
`price` is the headline figure for the whole stay window; `pricePerNight` is the per-night rate. Use `pricePerNight` to compare listings.

**Why are some fields `null`?**
Some markets and listings simply do not publish a rating, review count, or bed/bath breakdown. The Actor never invents values.

**Why did `pricePerNight` come back `null` for an enriched link?**
Per-night rates require a stay window, which only applies to market rows. The **Enrich listing URLs** section returns everything else about the listing.

**Why do `hostName` fields look like first names?**
That is how hosts present themselves publicly. The `hostUrl` is the reliable identifier — join on `hostId`.

**Can I get "entire home" only?**
Yes — set `roomTypes` to `entire_home`. To also exclude shared spaces, leave the other room types unselected.

**Can I find multi-property operators?**
Yes. Switch on **Host & portfolio view** with `minListingsPerHost` set to 2 or higher. You will get one row per host with their portfolio size and price band — and you can export listings and hosts together in the same run.

**Does it work outside the US?**
Yes. Pass any market in the world (`"Lisbon, Portugal"`, `"Bali, Indonesia"`) and choose the matching country in the connection settings if you want localized results.

**Can I schedule it?**
Yes. Use Apify Schedules with a JSON input to build a longitudinal dataset — daily or weekly runs give you price and rating trends over time.

**Can I stop early?**
Yes. `maxItems` caps the whole run, and each section's own limit caps its part of the output. The Actor stops cleanly the moment a limit is reached.

**Will it drain my compute?**
No. Memory stays light because rows stream out as they are collected, and the default 512 MB is more than enough.

**What happens on the free Apify plan?**
You receive a small sample (2 results by default) plus a clear upgrade message. Paid plans get the full, uncapped output.

**Do you support webhooks?**
Yes — `webhookUrl` + `webhookFormat` (`json` or `slack`). Rows are always written to the dataset as well.

**Can I use it with my own proxy?**
Yes. Open the connection settings and either keep the default Apify residential proxy or supply your own connection URLs.

***

### Troubleshooting

| Symptom | Likely cause | What to do |
|---------|--------------|------------|
| No rows returned | Market name not recognized, or the stay window is invalid | Use a clear market name (`"City, State"` or `"City, Country"`); leave dates empty to use the automatic window |
| Fewer rows than expected | The market genuinely has less supply, or a section limit was hit | Check `maxListingsPerMarket` / `maxListings`, or add more markets |
| `Webhook delivery failed for one record.` | Your URL rejected the delivery | Check the URL, its TLS certificate, and that it accepts JSON deliveries |
| Run stops early | Spending limit or free-tier sample reached | Check the run summary: `spendingLimitReached` / `freeTierLimitReached` tell you which |
| Price filters exclude everything | Filters compare the per-night rate | Widen the range; remember `pricePerNight` is per night, not per stay |

***

### Support, custom work & more Actors

Need something beyond this Actor? I build **custom scrapers**, **data pipelines**, and **full-stack applications** for startups and enterprises.

- **Email:** <dubem115@gmail.com>
- **GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- Custom Apify Actors for any site or data source
- Short-term-rental and real-estate data projects at scale
- LLM & MCP integrations on top of your data stack
- Web apps, dashboards, and automation tools

If this Actor saves you time, a review on the Apify Store helps a lot. Found a bug or need a field that is missing? Open an issue and it will be addressed.

***

*Airbnb Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `collectListings` (type: `boolean`):

Discover Airbnb listings for one or more markets. Switch this off if you only want host portfolios or to enrich links you already have.

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

One market per row, e.g. "Austin, TX", "Lisbon, Portugal", "Bali, Indonesia". Add several to cover multiple markets in one run. Prices and availability are shown for the stay window below.

## `maxListingsPerMarket` (type: `integer`):

How many listings to take from each market. The starting value is just an example — raise it for deep coverage of a single market. NOTE: on the Apify free plan the sample is capped to a small number of results per run; paid plans get the full value you set here.

## `maxListings` (type: `integer`):

Total listing rows to keep across all markets in this section. The highest-rated, most-reviewed stays are kept first. The starting value is just an example — raise it as high as you need. NOTE: the Apify free plan caps this to a small sample; upgrade to a paid plan for the full value you set here.

## `includeHostDetails` (type: `boolean`):

Attach the owner's name, profile link, and superhost status to each listing row. Adds a little extra time per listing. Always on for the Host & portfolio view.

## `collectHosts` (type: `boolean`):

Group the collected listings by owner to find professional operators and multi-property managers. Switch this on to also export one row per host.

## `hostLocations` (type: `array`):

One market per row, e.g. "Austin, TX". Leave empty to reuse the markets from the Listings section. Markets shared with the Listings section are only collected once.

## `maxHosts` (type: `integer`):

How many host rows to keep. Hosts with the most listings are kept first. The starting value is just an example — raise it as high as you need. NOTE: the Apify free plan caps this to a small sample; upgrade to a paid plan for the full value you set here.

## `enrichListings` (type: `boolean`):

Have a list of Airbnb listing links already? Switch this on to turn each link into a full, clean row with pricing, capacity, ratings, and owner attribution.

## `listingUrls` (type: `array`):

One listing link per row, for example https://www.airbnb.com/rooms/12345678. Each link returns one listing row with owner attribution and extra details.

## `maxListingsFromUrls` (type: `integer`):

How many of the supplied links to process in this run. The starting value is just an example — raise it as high as you need. NOTE: the Apify free plan caps this to a small sample; upgrade to a paid plan for the full value you set here.

## `checkIn` (type: `string`):

Optional. YYYY-MM-DD. Leave empty to use a sensible upcoming stay window automatically. Prices reflect the selected stay window.

## `checkOut` (type: `string`):

Optional. YYYY-MM-DD. Must be after the check-in date.

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

Number of adult guests for the stay window. Affects which stays qualify and the displayed price.

## `roomTypes` (type: `array`):

Optional. Restrict the market search to specific room types. Leave empty for all types.

## `maxItems` (type: `integer`):

Overall ceiling on the number of rows saved in this run, across listings, hosts, and enriched links. The starting value is just an example — raise it as high as you need. NOTE: on the Apify free plan the run is capped to a small sample; paid plans get the full value you set here.

## `maxRetries` (type: `integer`):

How many times to retry an item when the market is temporarily busy or rate limited.

## `webhookUrl` (type: `string`):

Optional. Every row is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new row is also POSTed to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets, n8n).

## `webhookFormat` (type: `string`):

json = the full row object. slack = a Slack-friendly message payload.

## `proxyConfiguration` (type: `object`):

Apify residential proxy (US) is enabled by default for reliable market data at scale. Change this only if you need a different country or your own connection.

## Actor input object example

```json
{
  "collectListings": true,
  "locations": [
    "Austin, TX"
  ],
  "maxListingsPerMarket": 10,
  "maxListings": 15,
  "includeHostDetails": false,
  "collectHosts": false,
  "hostLocations": [
    "Austin, TX"
  ],
  "maxHosts": 10,
  "enrichListings": false,
  "listingUrls": [],
  "maxListingsFromUrls": 10,
  "checkIn": "",
  "checkOut": "",
  "adults": 2,
  "roomTypes": [],
  "maxItems": 100,
  "maxRetries": 3,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Listing rows — price, rating, location, room type, host attribution. One row per listing.

## `hosts` (type: `string`):

Host / portfolio rows — listing counts per host, markets, price band, and average rating.

## `runSummary` (type: `string`):

Per-run metadata: the sections that ran, markets and host markets, stay window, rows exported, duplicates removed, markets without results, and the paywall object (detected, isPaying, pricingTier, blocked, limited, mode).

# 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 = {
    "collectListings": true,
    "locations": [
        "Austin, TX"
    ],
    "maxListingsPerMarket": 10,
    "maxListings": 15,
    "includeHostDetails": false,
    "collectHosts": false,
    "hostLocations": [
        "Austin, TX"
    ],
    "maxHosts": 10,
    "enrichListings": false,
    "listingUrls": [],
    "maxListingsFromUrls": 10,
    "checkIn": "",
    "checkOut": "",
    "adults": 2,
    "maxItems": 100,
    "maxRetries": 3,
    "webhookUrl": "",
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/airbnb-real-time-data").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 = {
    "collectListings": True,
    "locations": ["Austin, TX"],
    "maxListingsPerMarket": 10,
    "maxListings": 15,
    "includeHostDetails": False,
    "collectHosts": False,
    "hostLocations": ["Austin, TX"],
    "maxHosts": 10,
    "enrichListings": False,
    "listingUrls": [],
    "maxListingsFromUrls": 10,
    "checkIn": "",
    "checkOut": "",
    "adults": 2,
    "maxItems": 100,
    "maxRetries": 3,
    "webhookUrl": "",
    "webhookFormat": "json",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/airbnb-real-time-data").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 '{
  "collectListings": true,
  "locations": [
    "Austin, TX"
  ],
  "maxListingsPerMarket": 10,
  "maxListings": 15,
  "includeHostDetails": false,
  "collectHosts": false,
  "hostLocations": [
    "Austin, TX"
  ],
  "maxHosts": 10,
  "enrichListings": false,
  "listingUrls": [],
  "maxListingsFromUrls": 10,
  "checkIn": "",
  "checkOut": "",
  "adults": 2,
  "maxItems": 100,
  "maxRetries": 3,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/airbnb-real-time-data --silent --output-dataset

```

## MCP server setup

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

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/CfytuGKTko0F9me7S/builds/KIWc2FNgvYiWWxqPg/openapi.json