# Airbnb Scraper — Listings, Prices, Reviews & Hosts (`innolabs/airbnb-scraper`) Actor

Airbnb scraper API: listings by location or URL with nightly and total prices for your dates, ratings, host, amenities, photos, coordinates, plus reviews. JSON/CSV/Excel.

- **URL**: https://apify.com/innolabs/airbnb-scraper.md
- **Developed by:** [Tristan Leroux](https://apify.com/innolabs) (community)
- **Categories:** Travel, Real estate
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper

Scrape **Airbnb listings by location or URL** with the **nightly and total price for your dates**,
discounts, ratings, review counts, Superhost and Guest favorite flags, beds, bedrooms and bathrooms,
coordinates and photos. Switch on **listing details** for the full description, every amenity, the
host profile, house rules, cancellation terms and sub-ratings, and **reviews** for guest reviews with
host responses — search, details and reviews in one actor, one run, one dataset. No login, no API key.
Export as JSON, CSV or Excel, or pull the data through the API.

### What does Airbnb Scraper do?

Airbnb Scraper reads what airbnb.com shows a visitor and turns it into clean rows:

- **Search by location** — type `Lisbon, Portugal`, `Brooklyn, NY` or `Lake Tahoe` and get the
  listings of that area, page after page. Airbnb shows about 270 listings per search; for bigger
  areas the scraper repeats the search in nightly price ranges automatically to go well beyond that.
- **Search URLs** — paste a search from airbnb.com with all your filters (property type, amenities,
  instant book, map area, ...) and get exactly those results.
- **Listing URLs** — paste `https://www.airbnb.com/rooms/...` links to track specific homes.
- **Prices for your dates** — with check-in and check-out you get the nightly rate, the total
  including fees and taxes, the crossed-out original price, the discount in percent and the full
  price breakdown (cleaning fee, discounts, taxes). Without dates Airbnb's suggested dates and
  their prices are reported per listing.
- **Guests, currency and price range** — adults and children, any currency (USD, EUR, GBP, ...),
  minimum and maximum price per night.
- **Listing details** (optional) — description, all amenities by category, host (name, ID,
  Superhost, verified, years hosting, response rate and time, about, languages), co-hosts, house
  rules, check-in and checkout times, pets and children policy, cancellation terms and
  availability for your dates, location description, sleeping arrangements, all photos and the
  six sub-ratings (cleanliness, accuracy, check-in, communication, location, value).
- **Reviews** (optional) — newest first: rating, text, language, English translation, date,
  reviewer name and ID, length of stay and the host's response.

### Use cases

- **Short-term rental investors** — size up a market before you buy: nightly rates, occupancy
  signals, ratings and the competition per neighbourhood.
- **Hosts and property managers** — benchmark your listing against nearby homes for the same dates,
  track competitors' prices and discounts, and see which amenities top-rated homes offer.
- **Travel and booking startups** — feed live prices, photos and coordinates into a search, map or
  comparison product.
- **Real estate and market researchers** — build datasets of supply, price levels and property
  types across cities and seasons.
- **Revenue and pricing teams** — schedule daily runs for fixed dates and watch how prices move.
- **Data and AI teams** — reviews with ratings and languages for sentiment analysis, descriptions and
  amenities for classification or LLM pipelines.

### How much does it cost?

You pay only for the rows you get (pay-per-event). Duplicates and rows over your `maxItems`
limit are never charged.

| Event | What you pay for | Free plan | Paid plans (from) |
| --- | --- | --- | --- |
| `listing` | One listing row from a search or listing URL (price, rating, location, photos) | $2.50 per 1,000 | $1.60 per 1,000 |
| `listing-detail` | One listing row with **Listing details** switched on (charged instead of `listing`) | $4.00 per 1,000 | $2.50 per 1,000 |
| `review` | One guest review row | $0.50 per 1,000 | $0.30 per 1,000 |

"Paid plans (from)" is the Gold-and-above price; Bronze ($2.20 / $3.50 / $0.40) and Silver
($1.90 / $3.00 / $0.35) plans sit in between. Apify also charges a tiny actor-start fee
($0.00005 per run).

Worked examples (Free plan prices):

1. **Price check of a city for one weekend** — 1,000 listings in Lisbon with your dates:
   1,000 × $2.50 / 1,000 = **$2.50** ($1.60 on Gold and above).
2. **Competitor deep dive** — 200 listings with details and their 20 newest reviews each:
   200 × $4.00 / 1,000 + 4,000 × $0.50 / 1,000 = $0.80 + $2.00 = **$2.80** ($1.70 on Gold and above).

The Apify Free plan includes $5 monthly credit, enough for about 2,000 listings every month.

### How to use Airbnb Scraper

In Apify Console:

1. Open Airbnb Scraper and click **Try for free**.
2. Type one or more **Locations** (the form is prefilled with `Lisbon, Portugal`) and/or paste
   Airbnb search or listing URLs.
3. Optionally set **Check-in** and **Check-out** dates, guests, currency and a price range.
4. Switch on **Listing details** and/or **Reviews** if you need them, and set **Max items**.
5. Click **Start**. 50 listings take a few seconds; 1,000 listings with dates about a minute.
6. Open the **Output** tab and export the dataset as JSON, CSV, Excel or HTML.

Through the API:

1. Get your API token in Apify Console → Settings → Integrations.
2. Call the actor with your input JSON (see [Integrations and API](#integrations-and-api)).
3. Read the dataset items from the run.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `locationQueries` | array | – | Locations as typed on airbnb.com: `Lisbon, Portugal`, `Brooklyn, NY`, `Lake Tahoe`. |
| `startUrls` | array | – | Airbnb search URLs (`https://www.airbnb.com/s/Paris/homes?...`) and/or listing URLs (`https://www.airbnb.com/rooms/12345678`); any Airbnb country domain. |
| `checkIn` / `checkOut` | string | – | Stay dates (`YYYY-MM-DD`) for exact prices. Without dates Airbnb's suggested dates are used and reported per row. |
| `adults` / `children` | integer | – | Guests; only listings for that many guests, prices for that group. |
| `currency` | string | `USD` | Currency of all prices (`EUR`, `GBP`, `CAD`, ...). |
| `priceMin` / `priceMax` | integer | – | Nightly price range in that currency. |
| `includeDetails` | boolean | `false` | Open every listing page: description, amenities, host, house rules, cancellation terms, sub-ratings, all photos. Billed as `listing-detail`. |
| `includeReviews` | boolean | `false` | Add guest reviews as separate rows (`type: "review"`). |
| `maxReviewsPerListing` | integer | `20` | Newest reviews per listing; `0` = all. |
| `maxItems` | integer | `1000` | Hard cap on rows for the whole run (listings plus reviews). |
| `maxListingsPerSearch` | integer | `0` | Cap per location or search URL; `0` = no cap. |
| `splitLargeSearches` | boolean | `true` | Repeat searches that hit Airbnb's ~270-listing cap in nightly price ranges. |
| `proxyConfiguration` | object | Apify Proxy | Proxy settings. |
| `debug` | boolean | `false` | Log every request. |

Example — two cities for a December weekend, two adults, prices in euros:

```json
{
    "locationQueries": ["Lisbon, Portugal", "Barcelona, Spain"],
    "checkIn": "2026-12-10",
    "checkOut": "2026-12-14",
    "adults": 2,
    "currency": "EUR",
    "maxItems": 1000
}
```

Example — a filtered search URL and one tracked listing, with details and the 10 newest reviews:

```json
{
    "startUrls": [
        "https://www.airbnb.com/s/Paris--France/homes?room_types%5B%5D=Entire%20home%2Fapt&min_bedrooms=2",
        "https://www.airbnb.com/rooms/9092386"
    ],
    "checkIn": "2026-12-17",
    "checkOut": "2026-12-20",
    "includeDetails": true,
    "includeReviews": true,
    "maxReviewsPerListing": 10,
    "maxItems": 500
}
```

### Output

One row per listing (`type: "listing"`), plus one row per review (`type: "review"`) when reviews
are on. Real listing row from 2026-11-05 with **Listing details**, shortened (photos, amenities,
rules and the description cut):

```json
{
    "type": "listing",
    "id": "9092386",
    "url": "https://www.airbnb.com/rooms/9092386?check_in=2026-12-10&check_out=2026-12-14&adults=2",
    "name": "Alfama - Amazing River View",
    "title": "Entire rental unit in Lisbon, Portugal",
    "propertyType": "Entire rental unit",
    "roomType": "Entire home/apt",
    "neighbourhood": "Santa Maria Maior",
    "city": "Lisbon",
    "latitude": 38.71171,
    "longitude": -9.12912,
    "rating": 4.93,
    "reviewCount": 881,
    "isSuperhost": true,
    "isGuestFavorite": true,
    "hostType": "Individual host",
    "badges": ["Guest favorite", "Superhost"],
    "bedrooms": 1,
    "beds": 1,
    "bathrooms": 1,
    "maxGuests": 2,
    "bedLabels": ["1 bedroom", "1 bed", "1 bath"],
    "currency": "EUR",
    "pricePerNight": 102.25,
    "totalPrice": 430.77,
    "originalPrice": null,
    "discountPercent": null,
    "nights": 4,
    "priceLabel": "€431 total",
    "priceBreakdown": [
        { "label": "4 nights x €102.25", "amount": 409.0 },
        { "label": "Discount from Airbnb", "amount": -10.23 },
        { "label": "Taxes", "amount": 32.0 }
    ],
    "checkIn": "2026-12-10",
    "checkOut": "2026-12-14",
    "adults": 2,
    "children": null,
    "photos": ["https://a0.muscache.com/im/pictures/df2fd0b1-3391-49af-89e3-215fcc05018c.jpg"],
    "thumbnail": "https://a0.muscache.com/im/pictures/df2fd0b1-3391-49af-89e3-215fcc05018c.jpg",
    "propertyId": null,
    "searchQuery": "https://www.airbnb.com/rooms/9092386",
    "position": null,
    "scrapedAt": "2026-11-05T09:19:04Z",
    "locationName": "Santa Maria Maior, Lisbon",
    "isExactLocation": false,
    "subRatings": { "accuracy": 4.95, "checkin": 4.92, "communication": 4.97, "value": 4.89, "cleanliness": 4.97, "location": 4.93 },
    "isNewListing": false,
    "isAvailable": true,
    "canInstantBook": true,
    "cancellationPolicy": "Free cancellation before December 5",
    "priceNote": "Your price is below the 60-day average",
    "description": "This small and charming apartment fully restored, offers a wonderful view over the old rooftops of Alfama ...",
    "highlights": [{ "title": "Beautiful and walkable", "description": "Guests say this area is scenic and it’s easy to get around." }],
    "amenities": [{ "group": "Internet and office", "title": "Wifi", "available": true, "subtitle": null }],
    "amenityNames": ["City skyline view", "River view", "Hair dryer", "Wifi", "Kitchen"],
    "host": {
        "id": "32293705",
        "name": "António",
        "isSuperhost": true,
        "isVerified": true,
        "rating": 4.89,
        "reviewCount": 2812,
        "yearsHosting": 11,
        "monthsHosting": 3,
        "responseRate": "100%",
        "responseTime": "Responds within an hour",
        "highlights": ["Speaks English and Portuguese", "Lives in Carcavelos, Portugal"],
        "profileUrl": "https://www.airbnb.com/users/show/32293705",
        "hostType": "INDIVIDUAL"
    },
    "coHosts": [{ "name": "Mariana", "isSuperhost": false }],
    "houseRules": [{ "group": "House rules", "title": "Quiet hours", "description": "10:00 PM - 7:00 AM" }],
    "checkInTime": null,
    "checkOutTime": null,
    "safetyAndProperty": ["Carbon monoxide alarm not reported", "Smoke alarm not reported", "Must climb stairs"],
    "petsAllowed": false,
    "childrenAllowed": false,
    "locationDescription": "A few minutes walking distance you can reach many cultural and historic attractions ...",
    "gettingAround": "Taxis, buses, trams and the subway are nearby. Santa Apolónia railway station is just 5 minutes walking distance.",
    "sleepingArrangements": [{ "room": "Bedroom", "beds": "1 double bed" }]
}
```

Review row:

```json
{
    "type": "review",
    "id": "1809350353139313050",
    "listingId": "9092386",
    "listingUrl": "https://www.airbnb.com/rooms/9092386",
    "rating": 5,
    "text": "Fijn verblijf, perfect voor een aantal dagen Lissabon",
    "language": "nl",
    "textTranslated": "Nice stay, perfect for a few days in Lisbon.",
    "createdAt": "2026-11-01T10:16:10Z",
    "localizedDate": "3 days ago",
    "stayHighlight": "Stayed a few nights",
    "reviewerName": "Valerie",
    "reviewerId": "337465191",
    "reviewerProfileUrl": "https://www.airbnb.com/users/show/337465191",
    "reviewerTenure": "7 years on Airbnb",
    "hostResponse": null,
    "hostResponseDate": null,
    "hostResponderName": null,
    "photos": [],
    "scrapedAt": "2026-11-05T09:19:05Z"
}
```

Field notes:

- Listings without **Listing details** contain the fields up to `scrapedAt`; search rows also have
  `neighbourhood` and `position` (rank in the search). The detail fields (from `locationName` on)
  are added with **Listing details**.
- `totalPrice` is what Airbnb shows as the total for the stay: on the default (US) proxy that is
  the price after discounts and before taxes ("$414 for 3 nights"); visitors from regions where
  Airbnb displays tax-inclusive totals get the total with taxes. `priceBreakdown` lists every line
  (nightly rate × nights, discounts, cleaning and resort fees, taxes where shown);
  `pricePerNight` is the nightly rate before fees, `originalPrice` the crossed-out total and
  `discountPercent` the saving against it.
- Without dates, `checkIn`/`checkOut` are Airbnb's suggested dates for that listing and the prices
  refer to them. Listing URLs without dates have no price.
- `cancellationPolicy`, `isAvailable` and `canInstantBook` refer to your dates.
- `roomType` is one of `Entire home/apt`, `Private room`, `Shared room`, `Hotel room`;
  `propertyType` is Airbnb's own label (`Apartment`, `Entire rental unit`, `Room in hotel`, ...).
- `rating` is `null` and `reviewCount` `0` for listings marked "New".

### Integrations and API

Run the actor and get the items back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/innolabs~airbnb-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locationQueries": ["Lisbon, Portugal"], "checkIn": "2026-12-10", "checkOut": "2026-12-14", "maxItems": 100}'
```

Python with [apify-client](https://docs.apify.com/api/client/python):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("innolabs/airbnb-scraper").call(
    run_input={
        "locationQueries": ["Barcelona, Spain"],
        "checkIn": "2026-12-10",
        "checkOut": "2026-12-14",
        "adults": 2,
        "currency": "EUR",
        "includeDetails": True,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["neighbourhood"], item["pricePerNight"], item["totalPrice"], item["rating"])
```

- **Make, Zapier, n8n** — use the Apify app/node to start the actor and send new listings or price
  drops to Google Sheets, Airtable, Slack or email.
- **Scheduling** — create a schedule in Apify Console (e.g. every morning for the same dates) to
  keep a daily price history of a market.
- **Webhooks** — trigger your pipeline when a run finishes.
- **AI agents (MCP)** — connect Claude, Cursor or other MCP clients through the Apify MCP server at
  https://mcp.apify.com and let your agent look up Airbnb prices and reviews.

### FAQ

#### Is it legal to scrape Airbnb?

The scraper only reads pages that Airbnb shows to every visitor without logging in; it does not
book, message hosts or access private data. Reviews contain reviewers' first names as published
by Airbnb; handle personal data according to the GDPR and your local laws. Check Airbnb's terms
for how you use the data. This actor is not affiliated with or endorsed by Airbnb.

#### How many listings can I get for a city?

Airbnb itself shows at most about 270 listings per search. With **Split large areas by price**
(on by default) the scraper repeats the search in about 15 nightly price ranges and halves the
ranges that are still full; duplicates are removed. In our tests one run for `Lisbon, Portugal`
returned 8,000 listings (about 12 minutes). You can also add search URLs for smaller areas
(neighbourhoods, map areas) or several locations.

#### Why do prices differ from what I see in my browser?

Prices depend on dates, number of guests, currency and the country Airbnb thinks you are in (taxes
and fee display rules differ by region). Set **Check-in**, **Check-out**, **Adults** and
**Currency** to get the price for your stay. Without dates, each listing comes with Airbnb's
suggested dates, so rows can have different dates.

#### Do I need proxies or an Airbnb account?

No account is needed. The default Apify Proxy works; when a request is refused the scraper switches
IP and retries automatically.

#### Can I scrape a single listing or my competitors' listings?

Yes, paste listing URLs (`https://www.airbnb.com/rooms/...`) into **Airbnb URLs**. With dates you
get the price, availability and cancellation terms for that stay; switch on **Listing details** for
the full listing page and **Reviews** for its reviews.

#### How are reviews sorted and how many can I get?

Newest first. **Max reviews per listing** limits them per listing (20 by default, 0 = all).
Reviews in other languages come with Airbnb's English translation in `textTranslated`.

#### What happens with listings that no longer exist?

They are reported in the log and in the run's `SUMMARY` record ("listing not found") and the run
continues with the other inputs. Failed inputs are never charged.

### Limits

- About 270 listings per search (Airbnb's limit); price splitting raises this for large areas but
  cannot guarantee every listing of a huge city.
- Search rows without dates show Airbnb's suggested dates and prices for them; bedroom, bed and
  bath counts appear on search rows when dates are set, and always with **Listing details**.
- Listing URLs without dates have no price.
- `checkInTime`/`checkOutTime` are filled only when the host lists them among the house rules.
- Host profiles beyond what the listing page shows (other listings of the host, full review history)
  and availability calendars for months ahead are not included.
- Experiences and services are not scraped, only stays (homes and hotels).

# Changelog

This Actor's version history is a separate document: https://apify.com/innolabs/airbnb-scraper/changelog.md

# Actor input Schema

## `locationQueries` (type: `array`):

Cities, regions, neighbourhoods or addresses, typed as on airbnb.com (e.g. 'Lisbon, Portugal', 'Brooklyn, NY', 'Lake Tahoe'). Each location returns up to about 270 listings per search; large areas are split by price automatically to go further (see 'Split large areas by price').

## `startUrls` (type: `array`):

Search result URLs copied from airbnb.com with all your filters (https://www.airbnb.com/s/Paris/homes?...) and/or listing URLs (https://www.airbnb.com/rooms/12345678). Any Airbnb country domain works.

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

Optional, YYYY-MM-DD. With check-in and check-out every listing gets the exact price for your stay (nightly rate, total with fees and taxes, discounts). Without dates Airbnb picks suggested dates per listing; those dates are in each row.

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

Optional, YYYY-MM-DD, after the check-in date.

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

Number of adult guests. Only listings for that many guests are returned and prices are for that group.

## `children` (type: `integer`):

Number of children (2–12 years).

## `currency` (type: `string`):

Three-letter currency code for all prices, e.g. USD, EUR, GBP, CAD, AUD, JPY.

## `priceMin` (type: `integer`):

Only listings from this nightly price (in the chosen currency).

## `priceMax` (type: `integer`):

Only listings up to this nightly price (in the chosen currency).

## `includeDetails` (type: `boolean`):

Adds description, all amenities, host profile (name, Superhost, years hosting, response rate), house rules, check-in/checkout times, cancellation terms and availability for your dates, location description, sleeping arrangements, all photos and sub-ratings (cleanliness, accuracy, ...). One extra page per listing, billed as 'listing with details'.

## `includeReviews` (type: `boolean`):

Adds guest reviews of every listing as separate rows (type 'review'): rating, text, language, English translation, date, reviewer, host response.

## `maxReviewsPerListing` (type: `integer`):

Newest reviews first. 0 = all reviews of every listing.

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

Hard cap on dataset rows for the whole run (listings plus reviews). The run stops cleanly when reached.

## `maxListingsPerSearch` (type: `integer`):

Cap per location / search URL, so one big city does not use up the whole run. 0 = no cap (only Max items applies).

## `splitLargeSearches` (type: `boolean`):

Airbnb shows at most about 270 listings per search. When a search hits that cap, it is repeated in nightly price ranges to reach more listings (duplicates are removed).

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

Apify Proxy settings. The default works for Airbnb; the scraper switches IP and retries automatically when a request is refused.

## `debug` (type: `boolean`):

Log every request with its status code.

## Actor input object example

```json
{
  "locationQueries": [
    "Lisbon, Portugal"
  ],
  "currency": "USD",
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerListing": 20,
  "maxItems": 50,
  "maxListingsPerSearch": 0,
  "splitLargeSearches": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

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

All items produced by the run, one JSON object per record.

# 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 = {
    "locationQueries": [
        "Lisbon, Portugal"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("innolabs/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 = {
    "locationQueries": ["Lisbon, Portugal"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("innolabs/airbnb-scraper").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 '{
  "locationQueries": [
    "Lisbon, Portugal"
  ],
  "maxItems": 50
}' |
apify call innolabs/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

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/xD05H5HMpOr6Emz2I/builds/fd0fqpZYZ95Umle3s/openapi.json