# Airbnb Rooms URLs Scraper (`simpleapi/airbnb-rooms-urls-scraper`) Actor

Airbnb Rooms URLs Scraper extracts room listing URLs from Airbnb’s search interface with precision. Ideal for scaling data pipelines, monitoring markets, building datasets, or feeding other Airbnb actors with clean, structured room URLs.

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

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🏡 What does Airbnb Rooms URLs Scraper do?

The Airbnb Rooms URLs Scraper is a powerful automation tool designed to extract clean, structured lists of Airbnb room URLs from Airbnb search results, city pages, or custom filters. It helps marketers, analysts, property managers, and data researchers gather actionable insights without manually browsing countless Airbnb listings.

Using this scraper, you can quickly gather URLs at scale—ideal for lead generation, pricing research, or competitor benchmarking. Unlike manual extraction or unreliable scripts floating around platforms like Airbnb scraper GitHub repositories, this tool provides stable, high-quality output.

For SEO specialists and growth teams, the scraper enables smarter content planning, research efficiency, and improved data workflows. It is also a safer alternative to risky Airbnb scraper Python scripts that may break due to Airbnb updates.

* * *

### 📌 What Airbnb Rooms URLs can I extract?

The Airbnb Rooms URLs Scraper can extract a wide range of URL types and metadata. Here's a quick overview:

| Data Type Extracted | Description |
| --- | --- |
| 🏠 Room Listing URLs | Direct URLs to Airbnb properties. |
| 🏙 City/Area-specific URLs | URLs filtered by location. |
| 💲 Price-filtered URLs | URLs grouped based on min/max pricing. |
| ⭐ Review-specific URLs | Listings with high ratings—useful for Airbnb reviews scraper workflows. |
| 🔎 Search Result URLs | Any URL from custom Airbnb search filters. |
| 🛏 Room-type URLs | Entire place, private room, shared room, etc. |
| 🗂 Pagination URLs | Extract URLs across multiple Airbnb pages for scalability. |

  

* * *

#### ⭐ Key Features of Airbnb Rooms URLs Scraper 🚀

*   Extract Unlimited URLs — Scale effortlessly beyond traditional tools like bnb toolbox scraper extension.  
      
    
*   Highly Accurate Output — Ensures clean URLs with no duplicates or broken results.  
      
    
*   Flexible Input Options — Works with city pages, search filters, or custom Airbnb categories.  
      
    
*   SEO-Friendly Data — Perfect for building topical maps, competitive analysis, or optimizing Airbnb-related content clusters.  
      
    
*   Integrates Easily With Workflows — Use with spreadsheets, APIs, or automation tools (safer and more reliable than random Airbnb scraper GitHub scripts).  
      
    
*   No Coding Required — Beginner-friendly interface; however, developers can integrate it with pipelines far more safely than using unstable Airbnb scraper Python snippets.  
      
    
*   Built for Apify — Fully compatible with Apify Airbnb Scraper and other automation actors.  
      
    
*   Smart Throttling & Compliance Awareness — Designed with respect to Airbnb scraping policy guidelines, ensuring responsible usage.  
      
    

* * *

### 🛠️ How to Use Airbnb Rooms URLs Scraper (Step-by-Step Guide) 📘

Here’s the simplest way to get started:

1.  Log in to Apify — Create a free account or sign in.  
      
    
2.  Select the Actor — Search for “Airbnb Rooms URLs Scraper” in the Apify Store.  
      
    
3.  Enter Input Data — Provide Airbnb search result URLs or city pages in the startUrls field.  
      
    
4.  Choose Options —  
      
    

*   Set limits on how many URLs to collect  
      
    
*   Enable pagination  
      
    
*   Choose room-type filters as needed  
      
    

6.  Run the Actor — Click Start, and the scraper will automatically extract all room listing URLs.  
      
    
7.  Download Results — Export the data as JSON, CSV, or Excel for further analysis.  
      
    

This smooth workflow is far more stable than DIY approaches using Airbnb API alternatives or third-party scripts found on Airbnb scraper GitHub or reddit scrape Airbnb discussions.

  

* * *

### 🎯 Use Cases for Airbnb Rooms URLs Scraper

Businesses, marketers, and researchers use this scraper for several real-world applications:

*   Market Research — Compare pricing, availability, and listing density across cities.  
      
    
*   Competitor Analysis — Identify top hosts, trends, and high-performing listings.  
      
    
*   Lead Generation — Build outreach lists for property managers, cleaners, agencies, and local businesses.  
      
    
*   SEO Content Planning — Identify keywords, room categories, and trending areas.  
      
    
*   Academic Research — Analyze Airbnb growth, tourism patterns, or real-estate metrics.  
      
    
*   Automation Pipelines — Combine with Airbnb reviews scraper to study guest sentiment.  
      
    
*   Investment Insights — Evaluate rental markets by collecting URLs and analyzing listing performance.  
      
    

* * *

### 💎 Why Choose Us?

Here’s why our Airbnb Rooms URLs Scraper stands out:

*   Superior Stability — Unlike random Airbnb scraper Python code, ours is fully maintained and professionally updated.  
      
    
*   Enterprise-Grade Scaling — Built for large datasets and continuous research workflows.  
      
    
*   Accuracy & Clean Data — Eliminates duplicates, malformed URLs, and unreliable patterns.  
      
    
*   Great for Automation — Works seamlessly with Apify Airbnb Scraper and advanced pipelines.  
      
    
*   Transparent, Ethical Use — Designed to operate responsibly within Airbnb scraping policy guidelines.  
      
    
*   Trusted by Agencies & Researchers — Ideal for SEO teams, analysts, and real-estate professionals.  
      
    

  

* * *

### 📊 How Many Results Can You Scrape with Airbnb Rooms URLs Scraper?

The scraper is engineered for high-volume performance, capable of retrieving thousands of Airbnb room URLs in a single run.

Because Airbnb listings can span hundreds of pages per city, the scraper intelligently handles:

*   Pagination across search results  
      
    
*   Multiple starting URLs  
      
    
*   Location-based filtering  
      
    
*   Room-type segmentation  
      
    
*   Price-range slicing  
      
    

In ideal conditions, you can extract:

*   5,000+ URLs per large city  
      
    
*   20,000+ URLs across national markets  
      
    
*   Unlimited URLs when using multiple query sets  
      
    

This gives analysts, marketing teams, and researchers the ability to explore market trends at massive scale—far beyond what browser extensions like bnb toolbox scraper extension can deliver.

The scraper also ensures consistent output, avoiding the maintenance problems common with open-source Airbnb scraper GitHub repositories.

* * *

### ⚖️ Is It Legal to Scrape Airbnb?

Scraping Airbnb data lives in a gray area—not inherently illegal, but it must be used responsibly. Platforms like Airbnb have terms of service and anti-automation rules, referred to generally as the Airbnb scraping policy.

Here’s what you should know:

*   Public data scraping is typically allowed, but subject to the platform’s terms.  
      
    
*   Private or user-sensitive data must not be scraped.  
      
    
*   Automating access may violate Airbnb’s TOS, so usage should be compliant and ethical.  
      
    
*   Always consult legal counsel if you plan on commercial use at scale.  
      
    

This scraper is designed to support responsible, policy-aware usage and does not bypass security, authentication, or protected endpoints like the Airbnb API.

* * *

### 🧩 Input Parameters

#### Example Input (JSON)
```json
{
  "startUrls": [
    "https://www.airbnb.com/rooms/53997462",
    "https://www.airbnb.com/rooms/12937",
    "New York City apartment",
    "host_username"
  ],
  "sort_order": "relevant",
  "max_comments": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output Format

#### Example Output (JSON)

```json
{
  "url": "https://www.airbnb.com/rooms/53997462",
  "propertyType": "Entire condo",
  "personCapacity": 2,
  "rating": {
    "accuracy": 4.9,
    "checking": 5.0,
    "cleanliness": 5.0,
    "communication": 5.0,
    "location": 5.0,
    "value": 5.0,
    "guestSatisfaction": 4.98,
    "reviewsCount": 49
  },
  "amenities": [
    {
      "title": "Bathroom",
      "values": [
        {
          "title": "Hair dryer",
          "subtitle": "",
          "icon": "SYSTEM_HAIRDRYER",
          "available": true
        }
      ]
    },
    {
      "__typename": "Amenity",
      "available": true,
      "title": "Wifi",
      "icon": "SYSTEM_WI_FI"
    }
  ],
  "highlights": []
}
```

## ❓ FAQ — Airbnb Rooms URLs Scraper

#### 1. Does this scraper use the official Airbnb API?

No — Airbnb does not provide a public API for listing URLs. This tool processes public web data only.

#### 2. Is this better than Airbnb scraper GitHub scripts?

Yes. GitHub scripts often break; this tool is maintained, scalable, and reliable.

#### 3. Can I combine this with an Airbnb reviews scraper?

Absolutely! Many users pair both tools to analyze listings and guest sentiment.

#### 4. Do I need coding skills?

No. Although developers can extend it, the tool requires zero coding.

#### 5. Can this avoid Airbnb’s scraping detection?

It follows ethical, compliance-oriented behavior and does not bypass security.

#### 6. Does it work for every country?

Yes — it supports all publicly accessible Airbnb markets.

#### 7. Can I export results to Excel?

Yes — download in Excel, CSV, JSON, or integrate via API.

### 🏁 Conclusion

The Airbnb Rooms URLs Scraper offers a fast, reliable, and scalable way to collect Airbnb listing URLs for research, marketing, and automation. 💡 Whether you're analyzing markets, planning SEO content, or building data-driven workflows, this tool delivers clean, actionable insights with ease. 🚀

### What are other Airbnb scraping tools?

If you want to scrape specific Airbnb data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [Airbnb Availability Calendar](https://apify.com/simpleapi/airbnb-availability-calendar) | [Airbnb Occupancy Scraper](https://apify.com/simpleapi/airbnb-occupancy-scraper) |
| [Airbnb Email Scraper](https://apify.com/simpleapi/airbnb-email-scraper) | [Airbnb Phone Number Scraper](https://apify.com/simpleapi/airbnb-phone-number-scraper) |
| [Airbnb Full Year Price Tracker Scraper](https://apify.com/simpleapi/airbnb-full-year-price-tracker-scraper) | [Airbnb Review Scraper](https://apify.com/simpleapi/airbnb-review-scraper) |
| [Airbnb Image Scraper](https://apify.com/simpleapi/airbnb-image-scraper) | [Airbnb Scraper](https://apify.com/simpleapi/airbnb-scraper) |
| [Airbnb Images Scraper](https://apify.com/simpleapi/airbnb-Images-scraper) |  |

# Actor input Schema

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

List of Airbnb properties to scrape. Example property URL: https://www.airbnb.com/rooms/668146487515150072

## `enrichUserProfiles` (type: `boolean`):

If enabled, the actor makes extra requests for each host/co-host in every listing to get more detailed user info. This increases cost and runtime. If a profile is private or there's an unexpected error, it will be skipped and won't appear in the output.

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

Select date in format YYYY-MM-DD.

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

Select date in format YYYY-MM-DD.

## `locale` (type: `string`):

Localized results in this locale will be extracted (language and region).

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

Currency that will be extracted for prices.

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

Number of adult guests.

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

Number of children.

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

Number of infants.

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

Number of pets.

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

Choose which proxies to use. By default the actor starts with NO proxy, and falls back to datacenter → residential proxies automatically if blocked. Leave empty or set useApifyProxy to false for no proxy.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.airbnb.com/rooms/53997462",
    "https://www.airbnb.com/rooms/12937"
  ],
  "enrichUserProfiles": false,
  "locale": "en-US",
  "currency": "USD",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items (one per listing)

# 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": [
        "https://www.airbnb.com/rooms/53997462",
        "https://www.airbnb.com/rooms/12937"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/airbnb-rooms-urls-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": [
        "https://www.airbnb.com/rooms/53997462",
        "https://www.airbnb.com/rooms/12937",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/airbnb-rooms-urls-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.airbnb.com/rooms/53997462",
    "https://www.airbnb.com/rooms/12937"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/airbnb-rooms-urls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Rooms URLs Scraper",
        "description": "Airbnb Rooms URLs Scraper extracts room listing URLs from Airbnb’s search interface with precision. Ideal for scaling data pipelines, monitoring markets, building datasets, or feeding other Airbnb actors with clean, structured room URLs.",
        "version": "0.1",
        "x-build-id": "myOgKnHRNa6PHCKX2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~airbnb-rooms-urls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-airbnb-rooms-urls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/simpleapi~airbnb-rooms-urls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-airbnb-rooms-urls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/simpleapi~airbnb-rooms-urls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-airbnb-rooms-urls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Airbnb properties to scrape. Example property URL: https://www.airbnb.com/rooms/668146487515150072",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichUserProfiles": {
                        "title": "Enrich User Profiles",
                        "type": "boolean",
                        "description": "If enabled, the actor makes extra requests for each host/co-host in every listing to get more detailed user info. This increases cost and runtime. If a profile is private or there's an unexpected error, it will be skipped and won't appear in the output.",
                        "default": false
                    },
                    "checkIn": {
                        "title": "Check-In Date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Select date in format YYYY-MM-DD."
                    },
                    "checkOut": {
                        "title": "Check-Out Date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Select date in format YYYY-MM-DD."
                    },
                    "locale": {
                        "title": "Locale",
                        "enum": [
                            "en-US",
                            "az-AZ",
                            "id-ID",
                            "bs-BA",
                            "ca-ES",
                            "cs-CZ",
                            "sr-ME",
                            "da-DK",
                            "de-DE",
                            "de-AT",
                            "de-CH",
                            "de-LU",
                            "et-EE",
                            "en-AU",
                            "en-CA",
                            "en-GB",
                            "en-GY",
                            "en-IN",
                            "en-IE",
                            "en-NZ",
                            "en-SG",
                            "en-AE",
                            "es-AR",
                            "es-BZ",
                            "es-BO",
                            "es-CL",
                            "es-CO",
                            "es-CR",
                            "es-EC",
                            "es-SV",
                            "es-ES",
                            "es-US",
                            "es-GT",
                            "es-HN",
                            "es-419",
                            "es-MX",
                            "es-NI",
                            "es-PA",
                            "es-PY",
                            "es-PE",
                            "es-VE",
                            "fr-BE",
                            "fr-CA",
                            "fr-FR",
                            "fr-CH",
                            "fr-LU",
                            "ga-IE",
                            "hr-HR",
                            "xh-ZA",
                            "zu-ZA",
                            "is-IS",
                            "it-IT",
                            "it-CH",
                            "sw-XX",
                            "lv-LV",
                            "lt-LT",
                            "hu-HU",
                            "mt-MT",
                            "ms-MY",
                            "nl-BE",
                            "nl-NL",
                            "no-NO",
                            "pl-PL",
                            "pt-BR",
                            "pt-PT",
                            "ro-RO",
                            "sq-AL",
                            "sk-SK",
                            "sl-SI",
                            "sr-RS",
                            "fi-FI",
                            "sv-SE",
                            "tl-PH",
                            "vi-VN",
                            "tr-TR",
                            "el-GR",
                            "bg-BG",
                            "mk-MK",
                            "ru-RU",
                            "uk-UA",
                            "ka-GE",
                            "hy-AM",
                            "he-IL",
                            "ar-XX",
                            "hi-IN",
                            "th-TH",
                            "ko-KR",
                            "ja-JP",
                            "zh-US",
                            "zh-TW-US",
                            "zh-CN",
                            "zh-HK",
                            "zh-TW"
                        ],
                        "type": "string",
                        "description": "Localized results in this locale will be extracted (language and region).",
                        "default": "en-US"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "CZK",
                            "AUD",
                            "BRL",
                            "BGN",
                            "CAD",
                            "CLP",
                            "CNY",
                            "COP",
                            "CRC",
                            "HRK",
                            "DKK",
                            "EGP",
                            "AED",
                            "EUR",
                            "GHS",
                            "HKD",
                            "HUF",
                            "INR",
                            "IDR",
                            "ILS",
                            "JPY",
                            "KZT",
                            "KES",
                            "MYR",
                            "MXN",
                            "MAD",
                            "TWD",
                            "NZD",
                            "NOK",
                            "PEN",
                            "PHP",
                            "PLN",
                            "GBP",
                            "QAR",
                            "RON",
                            "SAR",
                            "SGD",
                            "ZAR",
                            "KRW",
                            "SEK",
                            "CHF",
                            "THB",
                            "TRY",
                            "UGX",
                            "UAH",
                            "UYU",
                            "VND"
                        ],
                        "type": "string",
                        "description": "Currency that will be extracted for prices.",
                        "default": "USD"
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Number of adult guests."
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of children."
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of infants."
                    },
                    "pets": {
                        "title": "Pets",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of pets."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default the actor starts with NO proxy, and falls back to datacenter → residential proxies automatically if blocked. Leave empty or set useApifyProxy to false for no proxy."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
