# Airbnb Listings Scraper (`fetch_cat/airbnb-listings-scraper`) Actor

Scrape public Airbnb listings from search pages and room URLs with prices, ratings, review counts, amenities, images, and listing metadata.

- **URL**: https://apify.com/fetch_cat/airbnb-listings-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Travel, Real estate, Automation
- **Features:** Limited permissions
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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

Export public Airbnb listing data from search pages, room URLs, or a location search. Airbnb Listings Scraper returns listing IDs, titles, visible search prices, ratings, review counts, images and available location details for rental-market research—not review text or booking quotes.

### Quick start

Start with a small location search and explicit direct access:

```json
{
  "location": "New York, NY",
  "maxItems": 10,
  "currency": "USD",
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Run the Actor, then open its dataset to export JSON, CSV or Excel. Public fields vary by page. Login-only data is not supported. A run with no usable listings currently fails, and a start charge may still apply.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Choose a public example to see its settings before starting a run:

- [Scrape Airbnb Search and Room URLs](https://apify.com/fetch_cat/airbnb-listings-scraper/examples/airbnb-search-and-room-urls)
- [Compare Airbnb Supply in Austin](https://apify.com/fetch_cat/airbnb-listings-scraper/examples/airbnb-austin-market-supply)
- [Scrape Airbnb Listings in New York](https://apify.com/fetch_cat/airbnb-listings-scraper/examples/airbnb-new-york-listings)

### What you get

One row per saved listing identity, with its room URL and available public fields. Search results can include visible prices, ratings and review counts. Room pages can supply amenity labels but no current price. Missing values remain empty rather than becoming booking or availability claims.

### Who is it for?

- **Rental-market researchers** reviewing public listing supply by destination.
- **Property analysts** preparing comparable search-price observations for specified travel dates.
- **Hospitality data teams** organizing public listing identities, ratings and location signals for their own dashboards.

### How you can use the data

- **Build a New York rental supply sheet.** Search `New York, NY` with a small `maxItems`, then export `listingId`, `title`, `url`, `rating` and `reviewsCount`. Review source links before using the sheet as a market sample.
- **Compare dated search prices.** Supply both stay dates with a generated location search and keep currency, guests and dates consistent across exports. Use `priceText` and `scrapedAt` to preserve the original observation. A search-card price is not a final booking total, and room pages return no price.
- **Compare listing identities over time.** Join saved exports by `listingId` in your own workflow to review changed fields. Scheduling and change detection require separate setup.
- **Review location signals cautiously.** Available coordinates are approximate and do not establish an exact property address.

Results follow source-page order, with duplicate listing IDs skipped within a run. There is no custom sort or guarantee of exhaustive supply, availability or an exact result count.

### Input settings

Provide at least one source: `location`, `startUrls`, `resumeUrls` or `resumeState`. Sources are combined, not mutually exclusive. Trip filters apply to generated location searches. Explicit URLs keep their own filters.

| Setting | JSON key | Purpose |
| --- | --- | --- |
| Airbnb start URLs | `startUrls` | Public HTTPS Airbnb search or room URLs, as strings or `{ "url": "..." }` objects. |
| Location search | `location` | Generate a destination search, for example `New York, NY`. |
| Stay dates | `checkIn`, `checkOut` | Real `YYYY-MM-DD` dates, supplied together. Checkout must be later. |
| Adults | `adults` | Adult count for generated searches. Form default `1`. |
| Guests and pets | `children`, `infants`, `pets` | Extra guests for generated searches. Pets show pet-friendly stays. |
| Price range | `priceMin`, `priceMax` | Airbnb's nightly price filter in the search currency for generated searches. Airbnb compares the discounted price; the rate in its price breakdown may differ from the filter amount. |
| Rooms | `minBeds`, `minBedrooms`, `minBathrooms` | Minimum beds, bedrooms and bathrooms for generated searches. |
| Currency | `currency` | Generated-search preference and output fallback, not currency conversion. |
| Maximum listings | `maxItems` | Overall cap. Form default `20`, omitted API value `25`. |
| Maximum run time | `maxRunSeconds` | Processing cutoff, default and maximum `270` seconds. |
| Resume source URLs | `resumeUrls` | Whole unstarted URLs from `PENDING_URLS`. |
| Resume state | `resumeState` | Checkpoint entries from `PENDING_WORK`, including already-saved IDs. |
| Proxy configuration | `proxyConfiguration` | Form prefill is direct. Omitted API settings use managed proxy. See field help for choices and charges. |

#### Example inputs

Use a search URL when you need specific Airbnb filters:

```json
{
  "startUrls": [{ "url": "https://www.airbnb.com/s/New-York--NY/homes" }],
  "maxItems": 10,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

For generated searches, add dates together:

```json
{
  "location": "Paris, France",
  "checkIn": "2027-03-10",
  "checkOut": "2027-03-15",
  "adults": 2,
  "children": 1,
  "pets": 1,
  "priceMin": 80,
  "priceMax": 250,
  "minBedrooms": 2,
  "currency": "EUR",
  "maxItems": 10,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output data

This abbreviated example shows the shape only, not a measured listing or booking quote:

```json
{
  "url": "https://www.airbnb.com/rooms/123456789",
  "listingId": "123456789",
  "title": "Example listing",
  "price": null,
  "priceText": null,
  "rating": null,
  "reviewsCount": null,
  "amenities": [],
  "imageUrls": [],
  "source": "listing"
}
```

| Fields | Meaning |
| --- | --- |
| `url`, `listingId` | Canonical room URL and stable listing ID. |
| `title`, `name` | Public name.  `name` repeats `title` for compatibility. |
| `roomType`, `category`, `location` | Available public type/category/location labels. Category is search-only. |
| `price`, `priceText`, `currency` | Parsed visible search-card price, original text and inferred/fallback currency. Room-page prices are always `null`. |
| `rating`, `reviewsCount` | Available average rating and review count, not review text. |
| `badges`, `isSuperhost` | Search badges and page-derived Superhost signal.  `false` is not a verified absence. |
| `amenities` | Available room-page amenity labels. Empty for search results. |
| `imageUrls` | Available public listing image URLs. |
| `latitude`, `longitude` | Available approximate coordinates, not guaranteed exact addresses. |
| `priceCheckIn`, `priceCheckOut`, `nights` | The stay dates and number of nights the search-card price is for. Airbnb picks dates when you give none. |
| `pricePerNight`, `priceQualifier`, `originalPrice` | Nightly rate shown in Airbnb's price breakdown (or displayed per-night card price); it may include discounts and is not a guaranteed pre-discount rate. It is not calculated from the stay total. The qualifier is Airbnb's unmodified text, such as `total`, `night`, or `for 5 nights`. `originalPrice` is the crossed-out card price, on the same basis as the card's shown price, not necessarily a nightly amount. |
| `hostType`, `isGuestFavorite` | `Business host` or `Individual host`, and whether the card shows a Guest favorite badge. Search results only. |
| `source`, `scrapedAt` | `search` or `listing`, and extraction timestamp. |

Optional scalar values may be `null`. Arrays may be empty. Search and room pages provide different fields. Room pages do not return full descriptions, reviews, host profiles or current prices through this Actor.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

This Actor uses pay-per-event pricing:

- `start` is a one-time event after input and proxy setup, when extraction begins.
- `result` is an event for each validated listing admitted for saving. Invalid records and source-error diagnostics are not result rows. If saving fails after the event, a charge can exist without a saved row.

Use `maxItems` and `maxRunSeconds` to bound work. Even a run with no usable output can incur the start event. Proxy service charges may apply separately.

See the [live Pricing tab](https://apify.com/fetch_cat/airbnb-listings-scraper/pricing) for current rates and discounts.

### Tips for best results

- **Start with a small destination search.** Inspect 10 listings before increasing the result cap.
- **Choose the right source for the fields you need.** Search pages can provide visible prices, while room pages provide available amenity labels and no current price.
- **Keep comparison conditions with your export.** Save stay dates, guests, currency and collection time alongside the dataset.
- **Inspect the summary before continuing interrupted work.** Use the relevant saved pending-work record rather than repeating already saved listings.

### Limits and caveats

Only public HTTPS Airbnb search (`/s/...`) and room (`/rooms/...`) pages are accepted. No login, private booking, guest, messaging or host-dashboard data is accessed. Airbnb can block requests or change its pages. Missing fields and fewer results than requested are possible.

A visible search price is not a final booking total. Dates, fees, taxes and availability can change it. Room-page output does not include a price.

Usable rows from other sources are retained when an isolated source fails. `RUN_SUMMARY` records source errors and unfinished work. A successful run with some rows is not proof every source worked. If no rows are extracted, the run fails.

When the time cutoff leaves unstarted work, use `PENDING_WORK` as `resumeState`. Its `skipListingIds` prevent replaying rows already saved from an interrupted page. `PENDING_URLS` can be passed as `resumeUrls` for whole unstarted pages. Failed or challenged pages are diagnostics, not automatic resume work. These checkpoint records are written only when relevant and do not guarantee a later run will reach the source.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~airbnb-listings-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "location": "New York, NY",
  "maxItems": 10,
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
JSON
```

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/airbnb-listings-scraper').call({
  "location": "New York, NY",
  "maxItems": 10,
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/airbnb-listings-scraper').call(run_input={'location': 'New York, NY', 'maxItems': 10, 'currency': 'USD', 'proxyConfiguration': {'useApifyProxy': False}})
print(client.dataset(run['defaultDatasetId']).list_items().items)
```

#### API usage and integrations notes

This endpoint starts asynchronously. Use the returned run's `defaultDatasetId` to retrieve items after it finishes.

#### MCP and AI agents notes

Follow the official guide for your client's authentication. Ask an agent: “Collect up to 10 public New York Airbnb listings with explicit direct access, then summarize available ratings and review counts.” Check nullable fields and `RUN_SUMMARY` before interpreting missing data as a market fact.

### MCP and AI agents

You can ask your AI assistant to collect data with **Airbnb Listings Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **Airbnb Listings Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/airbnb-listings-scraper"
    }
  }
}
```

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **Airbnb Listings Scraper** by Fetch Cat, or give it the identifier `fetch_cat/airbnb-listings-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Use Fetch Cat’s Airbnb Listings Scraper to collect up to 5 listings in New York, NY, with explicit direct access. Show listing IDs, titles, ratings and source links, marking unavailable fields.”
- “Search Paris with this scraper for 10–15 March 2027, 2 adults, EUR and at most 5 listings. Keep price text and collection time in a table, and label these as visible search prices rather than booking quotes.”
- “Collect up to 5 listings from the public Airbnb search URL I provide. Export listing IDs and source links so I can compare them with my earlier dataset, and explain any partial-source warnings in the summary.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/airbnb-listings-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Is this an Airbnb listings API alternative?

It produces structured public listing data through the Apify API. It is not an official Airbnb API, does not log in, and cannot guarantee complete inventory or access to unavailable pages.

#### Can I export Airbnb listings as CSV or JSON?

Yes. Open the dataset after the run and choose an export format, or retrieve items using the Apify API. It returns listing metadata and review counts, not review text.

#### Why are prices or amenities missing?

Room-page prices are not extracted. Search prices depend on the visible card and chosen dates. Amenities are extracted only from room pages when available. Supplying trip dates affects generated location searches, not explicit URLs.

#### What should I check when a run returns no data?

Confirm the public source URL and inspect the run error and `RUN_SUMMARY` when available. Try a small known destination. A block does not prove that a listing is private or deleted. No-output runs currently fail rather than guarantee an empty success.

### Related Actors

- [Airbnb Reviews Scraper](https://apify.com/fetch_cat/airbnb-reviews-scraper) — collect public guest reviews in a separate workflow.

- [Rightmove Property Listings Scraper](https://apify.com/fetch_cat/rightmove-property-listings-scraper) — research property listings alongside rental supply.

- [Google Hotels Scraper](https://apify.com/fetch_cat/google-hotels-scraper) — compare public hotel-search data.

- [Tripadvisor Reviews Scraper](https://apify.com/fetch_cat/tripadvisor-reviews-scraper) — research traveler feedback in a separate workflow.

- [Yandex Maps Scraper](https://apify.com/fetch_cat/yandex-maps-scraper) — add destination place research.

- [Apple App Store Reviews Scraper](https://apify.com/fetch_cat/apple-app-store-reviews-scraper) — investigate travel-app feedback separately from property listings.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/airbnb-listings-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/airbnb-listings-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

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

# Actor input Schema

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

Public HTTPS Airbnb search (/s/...) or room (/rooms/...) URLs. Provide these, a location, or resume work; they are combined when supplied together. Preserve filters in a search URL when you need an exact search.

## `location` (type: `string`):

Optional Airbnb location search, for example New York, NY. Used in addition to start URLs when provided.

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

Optional real YYYY-MM-DD date for generated location searches only. Supply checkOut too, later than checkIn. Does not modify explicit start or resume URLs.

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

Optional real YYYY-MM-DD date for generated location searches only. Supply checkIn too. Does not modify explicit start or resume URLs.

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

Maximum listing records saved across all inputs, from 1 to 10000. The form default is 20; API calls omitting this field use 25. This is a cap, not a guarantee of availability.

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

Optional three-letter currency code for generated location searches and output fallback, for example USD, EUR, or GBP. Does not change explicit URLs or convert prices. The form prefills USD; API omission leaves the fallback unset.

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

Number of adult guests for generated location searches.

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

Number of children (ages 2-12). Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `infants` (type: `integer`):

Number of infants (under 2). Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `pets` (type: `integer`):

Number of pets; Airbnb then shows pet-friendly stays. Applies to generated location searches only; explicit start and resume URLs keep their own filters.

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

Lowest nightly price in the search currency, as Airbnb's price filter applies it. Applies to generated location searches only; explicit start and resume URLs keep their own filters.

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

Highest nightly price in the search currency, as Airbnb's price filter applies it (discounted price). Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `minBeds` (type: `integer`):

Only stays with at least this many beds. Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `minBedrooms` (type: `integer`):

Only stays with at least this many bedrooms. Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `minBathrooms` (type: `integer`):

Only stays with at least this many bathrooms. Applies to generated location searches only; explicit start and resume URLs keep their own filters.

## `maxRunSeconds` (type: `integer`):

Stop cleanly before the platform timeout and save unfinished source URLs for a later resume run.

## `resumeUrls` (type: `array`):

Optional public Airbnb source URLs saved in PENDING_URLS by an earlier partial run. Use Resume state when it is available for an interrupted search page.

## `resumeState` (type: `array`):

Optional advanced checkpoint from PENDING_WORK. It avoids replaying listing IDs already saved from an interrupted search-results page.

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

The form prefills useApifyProxy=false for direct requests. API/task omission preserves the SDK managed-proxy default; it is not the form prefill. Explicit useApifyProxy=false with no custom URLs opts out. Valid proxyUrls use your custom proxies; managed groups/country settings are passed through unchanged. Configured proxies are used from the first request, with no automatic direct-to-proxy fallback. Invalid or unsupported settings fail before proxy setup and extraction. Proxy service charges may apply separately; never share credentials in support reports.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.airbnb.com/s/New-York--NY/homes"
    },
    {
      "url": "https://www.airbnb.com/rooms/50633275"
    }
  ],
  "location": "New York, NY",
  "checkIn": "",
  "checkOut": "",
  "maxItems": 20,
  "currency": "USD",
  "adults": 1,
  "maxRunSeconds": 270,
  "resumeUrls": [],
  "resumeState": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.airbnb.com/s/New-York--NY/homes"
        },
        {
            "url": "https://www.airbnb.com/rooms/50633275"
        }
    ],
    "location": "New York, NY",
    "checkIn": "",
    "checkOut": "",
    "currency": "USD",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/airbnb-listings-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 = {
    "startUrls": [
        { "url": "https://www.airbnb.com/s/New-York--NY/homes" },
        { "url": "https://www.airbnb.com/rooms/50633275" },
    ],
    "location": "New York, NY",
    "checkIn": "",
    "checkOut": "",
    "currency": "USD",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/airbnb-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.airbnb.com/s/New-York--NY/homes"
    },
    {
      "url": "https://www.airbnb.com/rooms/50633275"
    }
  ],
  "location": "New York, NY",
  "checkIn": "",
  "checkOut": "",
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/airbnb-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/airbnb-listings-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/n51Ee7Cz2xtpFLGx7/builds/kWawSbhHEDocqMBqt/openapi.json
