# VRBO Vacation Rental Scraper (`automation-lab/vrbo-scraper`) Actor

Scrape VRBO vacation rental listings. Extract prices, ratings, amenities, photos, and geo-coordinates for any destination and date range. Pay per result.

- **URL**: https://apify.com/automation-lab/vrbo-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, Real estate
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-event

## 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

## VRBO Vacation Rental Scraper

Extract vacation rental listings from VRBO — the world's largest vacation rental marketplace owned by Expedia Group. Scrape property names, prices, ratings, amenities, photos, coordinates, and host information for any destination and date range. No API key needed. Export to JSON, CSV, or Excel. Pay per result.

### What does VRBO Scraper do?

VRBO Scraper lets you collect vacation rental data from [vrbo.com](https://www.vrbo.com) without needing an API key or developer access. Simply provide a destination and date range, and the scraper will:

- Search for available vacation rentals matching your criteria
- Extract pricing, ratings, and availability information
- Collect amenities, photos, and property details
- Return geo-coordinates, city, and state information
- Handle pagination automatically to retrieve large result sets

Perfect for travel tech companies, real estate analysts, pricing researchers, property managers benchmarking their listings, and anyone needing VRBO rental data at scale.

### Who is it for

**Property managers and Airbnb/VRBO hosts** use this to benchmark their listings against local competition — compare prices, occupancy patterns, and amenity offerings to stay competitive without manual research.

**Short-term rental investors** use it to evaluate markets before purchasing. Pull rental prices for 2-3 bedroom properties in target neighborhoods, calculate potential revenue, and compare dozens of markets in hours instead of weeks.

**Travel tech developers** integrate VRBO data into apps — price comparison tools, availability aggregators, or destination guides. The structured JSON output drops directly into your database or data pipeline.

**Real estate analysts and researchers** use this to study vacation rental market dynamics, pricing trends, seasonal patterns, and geographic distribution of inventory. Academic and commercial researchers get structured, timestamped data ready for analysis.

**Property management companies** use bulk scraping to monitor competitor listings across multiple markets and automatically update their pricing strategy.

### Why use it

- **No VRBO API needed** — no registration, no rate limits, no developer approval required
- **Date-aware pricing** — prices reflect your actual check-in/check-out dates, not generic estimates
- **Pay only for results** — PPE pricing means you never pay for failed runs or bot blocks
- **GPS coordinates included** — every listing includes latitude/longitude for mapping and geo-analysis
- **Multiple destinations in one run** — search 10 cities simultaneously, results combined automatically
- **Full amenities list** — captures the complete amenities from each property detail page

### Data you can extract

| Field | Description |
|-------|-------------|
| `id` | VRBO property ID |
| `name` | Property listing title |
| `url` | Full VRBO URL for the property |
| `propertyType` | Property type (Cabin, Condo, House, etc.) |
| `description` | Full property description |
| `rating` | Guest rating score (0–10 scale) |
| `reviewCount` | Total number of guest reviews |
| `latitude` / `longitude` | GPS coordinates |
| `city` / `state` / `country` | Location details |
| `pricePerNight` | Nightly price for requested dates (USD) |
| `totalPrice` | Total price for requested stay (when available) |
| `bedrooms` / `bathrooms` | Room counts |
| `maxOccupancy` | Maximum guest capacity |
| `amenities` | List of property amenities |
| `photos` | Photo URLs |
| `hostName` | Host/owner name |
| `instantBook` | Whether instant booking is available |
| `minNightStay` | Minimum night stay requirement |

### How much does it cost to scrape VRBO vacation rentals?

This actor uses **Pay Per Event (PPE)** pricing — you only pay for the listings you actually receive:

- **Actor start**: $0.00009 (one-time per run, covers startup costs)
- **Per listing**: $0.20 per vacation rental listing extracted (tiered discounts for higher-volume subscribers)

#### Cost examples

| Use case | Listings | Estimated cost |
|----------|----------|---------------|
| Quick market check | 10 listings | ~$2.00 |
| Neighborhood analysis | 50 listings | ~$10.00 |
| Full market research | 200 listings | ~$40.00 |
| Bulk data collection | 1,000 listings | ~$200.00 |

**Free plan**: Apify's free tier includes $5 of monthly usage — enough for ~25 VRBO listings at no cost.

> **Note:** VRBO uses Akamai bot protection requiring residential proxy, which accounts for the higher per-listing price compared to simple scrapers. Runs against destinations with high proxy resistance may occasionally produce fewer results — re-running typically resolves this.

### How to scrape VRBO listings (step by step)

1. Go to the [VRBO Scraper page](https://apify.com/automation-lab/vrbo-scraper) on Apify Store
2. Click **Try for free**
3. In the **Destinations** field, enter one or more destination names (e.g., "Smoky Mountains, TN")
4. Optionally set **Check-in Date** and **Check-out Date** for date-aware pricing
5. Set **Max Listings** to control how many results to fetch (default: 10 for the first run)
6. Click **Start** and wait for the scraper to finish (typically 1–3 minutes for 10 listings)
7. Download your results as JSON, CSV, or Excel from the **Dataset** tab

### Input parameters

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `locationQueries` | string[] | Yes* | Destinations to search (e.g., "Smoky Mountains, TN", "Maui, HI") |
| `startUrls` | string[] | No | Direct VRBO URLs to scrape (search pages or property pages) |
| `checkIn` | string | No | Check-in date (YYYY-MM-DD format). Defaults to tomorrow. |
| `checkOut` | string | No | Check-out date (YYYY-MM-DD format). Defaults to 5 days after check-in. |
| `adults` | number | No | Number of adults (default: 2) |
| `children` | number | No | Number of children (default: 0) |
| `maxListings` | number | No | Maximum listings to scrape (default: 50, 0 = unlimited) |
| `minBedrooms` | number | No | Filter by minimum bedroom count |
| `maxPrice` | number | No | Maximum nightly price filter (USD) |
| `sortBy` | string | No | Sort order: RELEVANCE, PRICE_LOW_TO_HIGH, PRICE_HIGH_TO_LOW, REVIEWS (default: RELEVANCE) |
| `scrapeDetails` | boolean | No | Visit individual property pages for full amenities (default: true) |

*Either `locationQueries` or `startUrls` is required.

#### Example input

```json
{
  "locationQueries": ["Smoky Mountains, TN", "Gatlinburg, TN"],
  "checkIn": "2025-09-01",
  "checkOut": "2025-09-07",
  "adults": 4,
  "children": 0,
  "maxListings": 50,
  "minBedrooms": 2,
  "sortBy": "RELEVANCE",
  "scrapeDetails": true
}
````

### Output

Each listing is saved as a structured JSON object in the dataset. Download as JSON, CSV, or Excel from the Apify Console.

#### Example output

```json
{
  "id": "95071426",
  "name": "Secluded Mountain Getaway - Spring Sale",
  "url": "https://www.vrbo.com/95071426",
  "propertyType": null,
  "description": null,
  "rating": 9.2,
  "reviewCount": 67,
  "latitude": 35.804789,
  "longitude": -83.640079,
  "city": "Sevierville",
  "state": "TN",
  "country": "USA",
  "address": null,
  "pricePerNight": 172,
  "currency": "USD",
  "totalPrice": null,
  "bedrooms": 1,
  "bathrooms": 1,
  "maxOccupancy": 4,
  "amenities": ["Hot tub", "Kitchen", "Free WiFi", "Air conditioning", "Outdoor Space", "Parking available"],
  "photos": ["https://media.vrbo.com/lodging/96000000/95080000/95071500/95071426/eaf1de1b.jpg"],
  "hostName": null,
  "instantBook": false,
  "minNightStay": null,
  "checkin": "2025-09-01",
  "checkout": "2025-09-07",
  "scrapedAt": "2026-04-03T05:00:00.000Z"
}
```

### Tips for better results

- **Set dates for accurate pricing** — VRBO prices are date-dependent. Always set `checkIn`/`checkOut` to get real nightly rates.
- **Use `sortBy: PRICE_LOW_TO_HIGH`** when building affordability datasets to get the most relevant listings first.
- **Batch large requests** — for 500+ listings, split across multiple destination queries to improve reliability.
- **Filter with `minBedrooms`** — property managers usually only want 2+ bedroom properties; filtering reduces cost and scraping time.
- **Use `startUrls`** to scrape a pre-filtered VRBO search URL (e.g., a search with specific amenity filters applied in the browser).

### Integrations

- **Google Sheets** — Use the Apify Google Sheets integration to stream VRBO listings directly into a spreadsheet for live price monitoring dashboards.
- **Make / Zapier** — Trigger the scraper on a schedule and push new listings to your CRM, Slack channel, or property management system automatically.
- **Airtable** — Build a vacation rental market analysis database by loading VRBO data into Airtable with automated field mapping.
- **Webhooks** — Configure a webhook to notify your application when the scraper completes and new listings are available.
- **Python / Pandas** — Download the JSON dataset and analyze pricing distributions, seasonal trends, or geographic clusters with a few lines of Python.

### Use with the Apify API

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/vrbo-scraper').call({
  locationQueries: ['Smoky Mountains, TN'],
  checkIn: '2025-09-01',
  checkOut: '2025-09-07',
  adults: 2,
  maxListings: 50,
  scrapeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/vrbo-scraper').call(run_input={
    'locationQueries': ['Smoky Mountains, TN'],
    'checkIn': '2025-09-01',
    'checkOut': '2025-09-07',
    'adults': 2,
    'maxListings': 50,
    'scrapeDetails': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~vrbo-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "locationQueries": ["Smoky Mountains, TN"],
    "checkIn": "2025-09-01",
    "checkOut": "2025-09-07",
    "adults": 2,
    "maxListings": 50,
    "scrapeDetails": true
  }'
```

### Use with AI (MCP / Claude)

VRBO Scraper is available as an MCP (Model Context Protocol) tool — use it directly from Claude Desktop, Cursor, VS Code, or any MCP-compatible AI environment.

#### Claude Code (terminal)

```bash
claude mcp add --transport http vrbo-scraper https://mcp.apify.com?tools=automation-lab/vrbo-scraper
```

#### Claude Desktop / Cursor / VS Code

Add this to your MCP config file (`claude_desktop_config.json` or `.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "vrbo-scraper": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/vrbo-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Example prompts

- *"Scrape the top 50 vacation rentals in Gatlinburg, TN for Labor Day weekend (Sep 1–7) with at least 2 bedrooms and show me the price distribution."*
- *"Get all VRBO listings in Miami Beach under $300/night for 2 adults and export to CSV."*
- *"Find vacation rentals in Maui available next month, sorted by price, and compare prices per bedroom."*

### VRBO-specific notes

#### Why Playwright?

VRBO loads search results and property data via client-side JavaScript (React + Apollo GraphQL). Pure HTTP requests return incomplete or empty pages. Playwright renders the full page including JavaScript to capture all property data.

#### Listing types

VRBO has two types of listings:

- **Standard vacation rentals** (`/NNNN` URLs) — individual properties with bedroom/bath/occupancy details
- **Hotel-style multi-unit properties** (`/pdp/lo/NNNN` URLs) — resort-style accommodations without per-unit bedroom counts

Both types are scraped, but hotel-style listings may have `null` for bedroom/bathroom counts.

#### Search results

VRBO's search results are date-aware — prices shown on search pages reflect the actual nightly rate for your requested dates. The scraper captures this pricing from search result cards.

#### Amenity data

The scraper captures the **Popular Amenities** section (typically 4–8 amenities) that VRBO highlights for each property. Full amenity lists are available when the property's Apollo state loads after page hydration.

### Frequently asked questions

**Q: Does this require a VRBO account?**
A: No. The scraper accesses publicly available listing data without authentication.

**Q: How many listings can I scrape in one run?**
A: Set `maxListings` to your desired count. For large datasets (500+), we recommend batching by destination or date range to improve reliability.

**Q: Can I scrape a specific property URL?**
A: Yes! Use `startUrls` with any VRBO property URL (e.g., `https://www.vrbo.com/741398`).

**Q: Why are some listings missing bedrooms or price data?**
A: Hotel-style multi-unit properties don't have per-unit bedroom counts. Prices require date parameters — the scraper uses dateless detail page URLs to get full amenity data from VRBO's SSR cache, so prices come from the search card view.

**Q: What destinations does this support?**
A: Any destination you can search on vrbo.com — cities, regions, landmarks, addresses.

**Q: I got 0 results — what happened?**
A: VRBO's Akamai bot protection occasionally blocks requests. The scraper uses residential proxies and session rotation to minimize this, but some runs may return fewer results than expected. Try re-running with the same input — bot challenges are intermittent.

**Q: Is this compliant with VRBO's terms of service?**
A: This scraper accesses only publicly available data. Always review VRBO's terms of service and consult legal counsel before using scraped data commercially.

### Related scrapers

- [Airbnb Scraper](https://apify.com/automation-lab/airbnb-scraper) — Scrape Airbnb listings with pricing, reviews, host info, and availability calendar
- [Booking.com Scraper](https://apify.com/automation-lab/booking-scraper) — Extract hotel and vacation rental listings from Booking.com
- [Tripadvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper) — Collect hotel, restaurant, and attraction data from TripAdvisor

### Legal disclaimer

This actor scrapes publicly available data from VRBO's website. Users are solely responsible for ensuring their use of this data complies with VRBO's Terms of Service, applicable laws (including GDPR, CCPA), and any other relevant regulations. The actor author provides no warranty for the accuracy or completeness of scraped data.

### Support

If you encounter issues or have questions, please [open an issue](https://github.com/apify/apify-issues/issues) or contact us through the Apify console.

# Actor input Schema

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

Enter destination names to search (e.g., "Austin, TX", "Smoky Mountains, TN", "Miami Beach, FL"). Each destination will be searched separately.

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

Paste direct VRBO search URLs or individual listing URLs. Useful for pre-filtered searches.

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

Check-in date in YYYY-MM-DD format. Defaults to tomorrow if not set.

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

Check-out date in YYYY-MM-DD format. Defaults to +5 days if not set.

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

Number of adult guests.

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

Number of child guests.

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

Maximum number of listings to extract per destination. Set to 0 for unlimited.

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

Minimum number of bedrooms.

## `maxPrice` (type: `integer`):

Maximum price per night in USD. Leave empty for no limit.

## `sortBy` (type: `string`):

How to sort results from VRBO.

## `scrapeDetails` (type: `boolean`):

Visit each listing page to extract full description, all amenities, photos, and host details. Slower but more complete data.

## Actor input object example

```json
{
  "locationQueries": [
    "Austin, TX"
  ],
  "adults": 2,
  "children": 0,
  "maxListings": 10,
  "minBedrooms": 0,
  "sortBy": "RELEVANCE",
  "scrapeDetails": 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 = {
    "locationQueries": [
        "Austin, TX"
    ],
    "adults": 2,
    "children": 0,
    "maxListings": 10,
    "sortBy": "RELEVANCE",
    "scrapeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/vrbo-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": ["Austin, TX"],
    "adults": 2,
    "children": 0,
    "maxListings": 10,
    "sortBy": "RELEVANCE",
    "scrapeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/vrbo-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 '{
  "locationQueries": [
    "Austin, TX"
  ],
  "adults": 2,
  "children": 0,
  "maxListings": 10,
  "sortBy": "RELEVANCE",
  "scrapeDetails": false
}' |
apify call automation-lab/vrbo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VRBO Vacation Rental Scraper",
        "description": "Scrape VRBO vacation rental listings. Extract prices, ratings, amenities, photos, and geo-coordinates for any destination and date range. Pay per result.",
        "version": "0.1",
        "x-build-id": "JXUufE8j9QrpfmVZc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~vrbo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-vrbo-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/automation-lab~vrbo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-vrbo-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/automation-lab~vrbo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-vrbo-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",
                "properties": {
                    "locationQueries": {
                        "title": "🏖️ Destinations",
                        "type": "array",
                        "description": "Enter destination names to search (e.g., \"Austin, TX\", \"Smoky Mountains, TN\", \"Miami Beach, FL\"). Each destination will be searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "Paste direct VRBO search URLs or individual listing URLs. Useful for pre-filtered searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "checkIn": {
                        "title": "📅 Check-in Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Defaults to tomorrow if not set."
                    },
                    "checkOut": {
                        "title": "📅 Check-out Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Defaults to +5 days if not set."
                    },
                    "adults": {
                        "title": "👥 Adults",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "children": {
                        "title": "👶 Children",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of child guests.",
                        "default": 0
                    },
                    "maxListings": {
                        "title": "📊 Max Listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per destination. Set to 0 for unlimited.",
                        "default": 50
                    },
                    "minBedrooms": {
                        "title": "🛏️ Min Bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum number of bedrooms.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "💰 Max Price Per Night",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum price per night in USD. Leave empty for no limit."
                    },
                    "sortBy": {
                        "title": "🔀 Sort By",
                        "enum": [
                            "RELEVANCE",
                            "PRICE_LOW_TO_HIGH",
                            "PRICE_HIGH_TO_LOW",
                            "REVIEWS"
                        ],
                        "type": "string",
                        "description": "How to sort results from VRBO.",
                        "default": "RELEVANCE"
                    },
                    "scrapeDetails": {
                        "title": "🔎 Scrape Full Listing Details",
                        "type": "boolean",
                        "description": "Visit each listing page to extract full description, all amenities, photos, and host details. Slower but more complete data.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
