# VRBO Scraper — Vacation Rental Data, Pricing & Availability (`jaxay/vrbo-scraper`) Actor

Scrape VRBO listings with full pricing, amenities, house rules, availability, images & reviews. Pay per result. No coding required.

- **URL**: https://apify.com/jaxay/vrbo-scraper.md
- **Developed by:** [Jaxay Prajapati](https://apify.com/jaxay) (community)
- **Categories:** Lead generation, Travel, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Scraper — Extract Vacation Rental Data, Pricing & Availability

**VRBO Scraper** extracts rich, structured data from [VRBO.com](https://www.vrbo.com) vacation rental listings — including fee-inclusive pricing, full amenities, house rules, availability, and 20-30+ images per property. Just enter a location and dates, and get clean JSON output ready for analysis. **You only pay for results you get.**

> 💡 No coding required. Enter your search in the input tab, click Start, and download your data as JSON, CSV, or Excel.

---

### What does VRBO Scraper do?

VRBO Scraper searches any location worldwide and extracts **25+ data fields** per listing — far more than any other VRBO scraping tool available today.

✅ **Pricing** — Nightly rate + fee-inclusive total price + cleaning/service/tax breakdown
✅ **Property details** — Bedrooms, bathrooms, max guests, property type
✅ **Full amenities** — 25-40 items per listing (WiFi, pool, parking, kitchen, etc.)
✅ **House rules** — Check-in/out times, pet policy, smoking, events, age limits
✅ **Availability** — Whether the property is available + minimum/maximum stay
✅ **Images** — Full gallery with 20-30+ high-resolution image URLs
✅ **Location** — Latitude/longitude coordinates + neighborhood description
✅ **Guest ratings** — Rating score + review count
✅ **Booking flags** — Instant book, free cancellation, pets allowed
✅ **Reviews** — Overall summary, category scores, and up to 5 recent guest reviews (optional, anonymized)
✅ **Currency** — Detected from the listing's price symbol (USD, EUR, GBP, JPY, INR)

#### What data can you extract from VRBO?

| Data Point | Example |
|-----------|---------|
| Title | "Peaceful 2BR king beds suite next to DT w/ pool" |
| Nightly price | $94 |
| Total price | $1,313 (fee-inclusive) |
| Cleaning / Service / Taxes | $0 / $0 / $0 (when not itemized; often bundled into `total_price`) |
| Currency | USD (always — site is hardcoded to en_US) |
| Property type | Apartment, House, Condo, Hotel |
| Bedrooms / Bathrooms | 2 / 2 |
| Max guests | 6 |
| Amenities | Free wifi, Pool, Kitchen, Parking, Washer... (25-40 items) |
| Rating | 9.2 / 10 |
| Reviews | 23 |
| Pets allowed | ✅ true |
| Check-in time | "Check in after 4:00 PM" |
| Check-out time | "Check out before 10:00 AM" |
| Minimum stay | 1 night |
| Description | Full property description (HTML stripped) |
| House rules | Complete list of rules |
| Latitude / Longitude | 30.235172, -97.72347 |
| Neighborhood | "East Riverside - Oltorf, a neighborhood in Austin..." |
| Images | 13-32 high-res image URLs |
| Review summary | "9.4/10 Exceptional" + "12 verified reviews" |
| Review categories | ["Cleanliness 9.8", "Communication 10.0", ...] |
| Recent reviews | Up to 5 anonymized reviews: rating, full text, stay info, review_id |

---

### Why scrape VRBO? Use cases for VRBO data

🏠 **Real Estate Investors** — Analyze revenue potential before buying a vacation rental property. Compare nightly rates, occupancy indicators, and total fee-inclusive pricing across neighborhoods.

📊 **Property Managers** — Monitor competitor pricing in your market. Track ratings, review counts, amenity offerings, and availability patterns. Schedule weekly runs to catch pricing changes.

📈 **STR Analytics Platforms** — Feed structured VRBO data into your dashboards. Clean JSON output integrates with Snowflake, BigQuery, S3, or any data pipeline.

🔍 **Market Researchers** — Study vacation rental supply, pricing trends, amenity patterns, and availability across US and international markets.

🌐 **Travel Aggregators** — Pull listing data, images, and availability for display or comparison tools. Full image galleries included at no extra cost.

---

### How to scrape VRBO listings

1. Go to the [VRBO Scraper input tab](https://console.apify.com/actors/ME4n4wBCpTZnSAt2h/input)
2. Enter a **location** (e.g. "Miami Beach, FL" or "Austin, Texas")
3. Optionally set **check-in** and **check-out** dates (YYYY-MM-DD format)
4. Set **max_listings** to control how many results you want (default: 50, max: 1,000)
5. Toggle **Include Property Details** for amenities, description, house rules, and coordinates
6. Toggle **Include Availability** for minimum stay and availability status
7. Toggle **Include Reviews** for review summary, category scores, and up to 5 anonymized recent reviews per listing
8. Click **Start** and wait for results
9. Download your data as **JSON**, **CSV**, **Excel**, or export via API

> 💡 **Tip:** Start with `include_details: false` for a fast market scan. Enable it when you need the full dataset for deeper analysis.

---

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

VRBO Scraper uses **pay-per-result** pricing. You only pay for listings successfully extracted — zero results means zero charge.

- **$0.005** per actor run (one-time start fee)
- **$0.004** per listing extracted ($4.00 per 1,000 listings)
- **$0.001** per listing when `include_reviews` is enabled ($1.00 per 1,000 listings) — only charged when reviews are successfully extracted

| Scrape size | Estimated cost |
|------------|---------------|
| 50 listings | ~$0.21 |
| 200 listings | ~$0.81 |
| 500 listings | ~$2.01 |
| 1,000 listings | ~$4.01 |
| 1,000 listings + reviews | ~$5.01 |

💰 **Free tier:** Apify's free plan includes $5/month platform credits — enough to scrape ~1,000 listings per month at no cost.

---

### VRBO Scraper vs other VRBO scrapers

| Feature | This Actor | Other VRBO Scrapers |
|---------|-----------|-------------------|
| Fee-inclusive total price | ✅ | ❌ Nightly only |
| Full amenities (25-40 items) | ✅ | ❌ |
| Property description | ✅ | ❌ |
| House rules + check-in/out times | ✅ | ❌ |
| Pets allowed flag | ✅ | ❌ |
| Availability + min/max stay | ✅ | ❌ |
| Image gallery (20-30+ images) | ✅ | ❌ Thumbnail only |
| Latitude / longitude | ✅ | ❌ |
| Neighborhood description | ✅ | ❌ |
| Free cancellation flag | ✅ | ❌ |
| Instant Book flag | ✅ | ❌ |
| Review summary + categories | ✅ Optional | ❌ |
| Recent guest reviews (up to 5, anonymized) | ✅ Optional | ❌ |
| Smart location resolution | ✅ Any city worldwide | ❌ Brittle matching |
| Crash recovery | ✅ Streaming output | ❌ All-or-nothing |
| Auto-healing on VRBO updates | ✅ All 6 hashes | ❌ Breaks silently |
| Pricing model | Pay-per-result | Flat monthly fee |

---

### Input configuration

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `location` | string | ✅ | — | Search location (e.g. "Miami Beach, FL") |
| `check_in` | string | — | — | Check-in date (YYYY-MM-DD) |
| `check_out` | string | — | — | Check-out date (YYYY-MM-DD) |
| `max_listings` | integer | — | 50 | Max listings to scrape (1–1,000) |
| `include_details` | boolean | — | false | Fetch amenities, description, house rules, lat/lng |
| `include_availability` | boolean | — | false | Fetch availability status and min/max stay |
| `include_reviews` | boolean | — | false | Fetch review summary, category scores, and up to 5 anonymized recent reviews per listing |

#### Example: Fast market scan

```json
{
    "location": "Miami Beach, FL",
    "check_in": "2026-12-20",
    "check_out": "2026-12-27",
    "max_listings": 100
}
````

#### Example: Full investment research

```json
{
    "location": "Austin, Texas",
    "check_in": "2026-07-01",
    "check_out": "2026-07-07",
    "max_listings": 50,
    "include_details": true,
    "include_availability": true,
    "include_reviews": true
}
```

#### Location query tips

Use the most specific location name possible:

| Query | Result |
|-------|--------|
| `"Miami Beach, FL"` | ✅ Miami Beach, Florida, USA |
| `"Austin, Texas"` | ✅ Austin, TX, USA |
| `"London, England, United Kingdom"` | ✅ London, UK |
| `"Melbourne, Victoria, Australia"` | ✅ Melbourne, Australia |
| `"Cancun, Quintana Roo, Mexico"` | ✅ Cancún, Mexico |

> 💡 For ambiguous queries like "London" or "Melbourne", non-US matches are preferred. Add the state/country to get a specific US city.
>
> Neighborhood and POI queries are also supported — e.g. `"Queens"`, `"Manhattan"`, `"SoHo"` — and will resolve correctly even though VRBO returns them as NEIGHBORHOOD rather than CITY geo types.

***

### Output example

You can download the dataset extracted by VRBO Scraper in various formats such as **JSON**, **CSV**, **HTML**, or **Excel**.

Here's a real sample output with all fields:

```json
{
    "listing_id": "2482015",
    "title": "Peaceful 2BR king beds suite next to DT w/ pool",
    "url": "https://www.vrbo.com/2482015?chkin=2026-06-06&chkout=2026-06-20",
    "property_type": "Apartment",
    "nightly_price": 94,
    "total_price": 1313,
    "cleaning_fee": 0,
    "service_fee": 0,
    "taxes": 0,
    "currency": "USD",
    "bedrooms": 2,
    "bathrooms": 2,
    "max_guests": 6,
    "amenities": [
        "Free wifi", "Air conditioning", "Kitchen", "Refrigerator",
        "Dishwasher", "Microwave", "Pool", "Washing machine", "Dryer",
        "Parking", "Coffee maker", "Pet friendly"
    ],
    "rating": 9.2,
    "total_reviews": 23,
    "instant_book": false,
    "free_cancellation": false,
    "pets_allowed": true,
    "description": "Welcome to your new home in Riverside - a fast-growing community right next to Downtown Austin...",
    "house_rules": [
        "Check in after 4:00 PM",
        "Minimum age to rent: 18",
        "Check out before 10:00 AM",
        "Pets allowed",
        "Smoking is not permitted"
    ],
    "check_in_time": "Check in after 4:00 PM",
    "check_out_time": "Check out before 10:00 AM",
    "minimum_stay": 1,
    "maximum_stay": 999,
    "available": true,
    "latitude": 30.235172,
    "longitude": -97.72347,
    "neighborhood": "East Riverside - Oltorf, a neighborhood in Austin...",
    "thumbnail_url": "https://media.vrbo.com/.../1f5a362e.jpg",
    "image_urls": [
        "https://media.vrbo.com/.../1f5a362e.jpg",
        "https://media.vrbo.com/.../3ea74f67.jpg",
        "https://media.vrbo.com/.../73a3c401.jpg"
    ],
    "review_summary": {
        "overall_text": "9.2/10 Wonderful",
        "review_count_text": "23 verified reviews"
    },
    "review_categories": [
        "Cleanliness 8.4",
        "Check-in 9.4",
        "Communication 9.6",
        "Location 9.0",
        "Listing accuracy 9.4",
        "Value for money 8.0"
    ],
    "recent_reviews": [
        {
            "review_id": "6a03d0c0f3e117606d0abfb9",
            "rating_text": "8/10 Good",
            "text": "Overall the place was nice, but could use a few upgrades. Parking was convenient and close to entrance...",
            "stay_info": "Stayed 1 night in Apr 2026"
        },
        {
            "review_id": "69c2b0ba29803057f04fe143",
            "rating_text": "6/10 Okay",
            "text": "It was fine. It is a dated property but it felt safe and location was good...",
            "stay_info": "Stayed 4 nights in Mar 2026"
        }
    ]
}
```

#### Field reference

| Field | Mode | Description |
|-------|------|-------------|
| `listing_id` | Basic | VRBO's unique property ID |
| `title` | Basic | Full listing title |
| `url` | Basic | Clean listing URL with dates |
| `property_type` | Basic | Apartment, House, Condo, Hotel, etc. |
| `nightly_price` | Basic | Per-night rate |
| `total_price` | Basic | Full stay total (fee-inclusive) |
| `cleaning_fee` | Basic | Cleaning fee line item (0 if not itemized) |
| `service_fee` | Basic | Service/booking fee line item (0 if not itemized) |
| `taxes` | Basic | Occupancy/vacation tax line item (0 if not itemized) |
| `currency` | Basic | ISO currency code. Always `USD` in practice because the actor hits the en\_US site; the field is empty only as a defensive fallback when no currency symbol is recognized in the price text. |
| `bedrooms` | Basic | Number of bedrooms |
| `bathrooms` | Basic | Number of bathrooms |
| `max_guests` | Basic | Maximum occupancy |
| `rating` | Basic | Guest rating out of 10 |
| `total_reviews` | Basic | Number of reviews |
| `instant_book` | Basic | Whether instant booking is available |
| `free_cancellation` | Basic | Whether free cancellation is offered |
| `thumbnail_url` | Basic | First listing image |
| `image_urls` | Basic | All gallery images (20-30+) |
| `amenities` | Details | Full amenity list (25-40 items) |
| `description` | Details | Complete property description |
| `house_rules` | Details | All house rules |
| `check_in_time` | Details | e.g. "Check in after 4:00 PM" |
| `check_out_time` | Details | e.g. "Check out before 11:00 AM" |
| `pets_allowed` | Details | Boolean, parsed from rules + amenities |
| `latitude` | Details | Approximate coordinates |
| `longitude` | Details | Approximate coordinates |
| `neighborhood` | Details | Area description paragraph |
| `minimum_stay` | Availability | Minimum nights required |
| `maximum_stay` | Availability | Maximum nights (999 = no limit) |
| `available` | Availability | Whether property is available for dates |
| `review_summary.overall_text` | Reviews | e.g. "9.4/10 Exceptional" |
| `review_summary.review_count_text` | Reviews | e.g. "12 verified reviews" |
| `review_categories` | Reviews | List of category scores (Cleanliness, Communication, etc.) |
| `recent_reviews[]` | Reviews | Up to 5 most recent reviews (anonymized: rating, text, stay info, review\_id — no reviewer name) |

***

### Integrations and scheduling

VRBO Scraper works with all Apify platform features out of the box:

⏰ **Scheduled runs** — Set up weekly or daily runs in Apify Console → Schedules to track pricing changes over time.

🔗 **API access** — Trigger runs and fetch results programmatically from any language.

📊 **Export anywhere** — Google Sheets, Snowflake, BigQuery, S3, webhooks, or direct download.

🔌 **Make.com / Zapier** — Output is clean, flat JSON. Works with no-code automation tools without custom mapping.

#### Run via Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("jaxay/vrbo-src").call(run_input={
    "location": "Miami Beach, FL",
    "check_in": "2026-12-20",
    "check_out": "2026-12-27",
    "max_listings": 200,
    "include_details": True,
    "include_availability": True,
    "include_reviews": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["nightly_price"], item["pets_allowed"])
```

#### Run via Apify API (JavaScript)

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

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

const run = await client.actor('jaxay/vrbo-src').call({
    location: 'Austin, Texas',
    check_in: '2026-07-01',
    check_out: '2026-07-07',
    max_listings: 100,
    include_details: true,
    include_reviews: true,
});

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

***

### Performance and speed tips

| Configuration | Listings | Estimated Time |
|--------------|----------|----------------|
| Basic (search only) | 10 | ~40-60s |
| Basic (search only) | 50 | ~70-90s |
| Basic (search only) | 200 | ~140-180s |
| With `include_details` | 10 | ~70-100s |
| Full enrichment (details + availability) | 10 | ~120-180s |
| Full enrichment (details + availability) | 50 | ~5-8min |
| Full enrichment + reviews | 10 | ~4-6min |
| Full enrichment + reviews | 50 | ~14-20min |

> Times shown are on a clean, unthrottled proxy IP.
> On a throttled IP, add 10-15s for warmup recovery.
> On a warm run (KV cache has fresh hashes), discovery
> is skipped and runs are typically 5-10s faster.

🚀 **Speed tips:**

- Leave `include_details`, `include_availability`, and `include_reviews` off for fast market scans
- Enable them only when you need amenities, description, availability, or review data
- Run during off-peak hours (early morning US time) for fewer rate limits
- Use `max_listings` to cap run time on large markets

***

### Roadmap — What's coming next

#### 🔜 Phase 3 — Scrape by URL or listing ID

Skip search entirely. Provide specific VRBO listing URLs or property IDs and get full data for those exact properties.

```json
{
    "listing_urls": [
        "https://www.vrbo.com/456572",
        "https://www.vrbo.com/3787326"
    ]
}
```

Perfect for monitoring competitors, tracking your comparable set, or watching specific investment targets.

#### 📋 Phase 4 — Advanced filters & market analytics

Filter results by bedrooms, price range, rating, pets, and instant book directly in the input — no post-processing needed.

```json
{
    "location": "Miami Beach, FL",
    "filters": {
        "min_bedrooms": 2,
        "max_nightly_price": 300,
        "pets_allowed": true,
        "min_rating": 8.0
    }
}
```

Also planned: market summary output — average nightly rate, median total price, occupancy estimate, and top amenities by neighborhood.

***

### Is it legal to scrape VRBO?

This actor only accesses publicly visible data on VRBO.com — no login
required, no private information, no personal data is collected. It
operates the same way any person would when browsing VRBO in a web browser.

> Our scrapers are ethical and do not extract any private user data, such
> as email addresses, gender, or location. They only extract what the user
> has chosen to share publicly. We therefore believe that our scrapers,
> when used for ethical purposes by Apify users, are safe. However, you
> should be aware that your results could contain personal data. Personal
> data is protected by the GDPR in the European Union and by other
> regulations around the world. You should not scrape personal data unless
> you have a legitimate reason to do so. If you're unsure whether your
> reason is legitimate, consult your lawyers.

***

### FAQ

**Q: Do I need my own proxies?**
No. The actor uses Apify's built-in residential proxy infrastructure, included in Apify paid plans.

**Q: What if VRBO rate limits the requests?**
The actor retries automatically up to 7 times with exponential backoff. Failed listings are skipped — you are never charged for failed extractions.

**Q: Can I scrape international VRBO listings?**
Yes. Use full location names for best accuracy:

- ✅ `"London, England, United Kingdom"`
- ✅ `"Melbourne, Victoria, Australia"`
- ✅ `"Cancun, Quintana Roo, Mexico"`
- ✅ `"Paris, Île-de-France, France"`

**Q: Why is `host_name` empty?**
VRBO hides host identity on search and detail pages until after booking. This is a VRBO platform restriction, not a scraper limitation.

**Q: Why are `cleaning_fee`, `service_fee`, and `taxes` showing 0?**
The actor parses these from VRBO's itemized line items in the price breakdown. They're populated when VRBO surfaces them as separate line items. Many listings bundle all fees into `total_price` without itemizing — in that case the three fields are 0 and `total_price` is the only authoritative number. If you need exact fees, the detail page often shows a more detailed breakdown than the search card; consider running with `include_details: true`.

**Q: Why is `currency` empty for some listings?**
The actor always hits the en\_US site (`siteId: 9001001`, locale `en_US`), so in practice every listing has currency `USD`. The actor still detects the symbol from the price text (`$` → USD, `€` → EUR, `£` → GBP, `¥` → JPY, `₹` → INR) as a defensive safety net for forward compatibility — the field is empty only if the response contains no recognized symbol. Empty means "unknown," not "USD."

**Q: How accurate are latitude and longitude?**
Coordinates are extracted from VRBO's map URL — accurate to the neighborhood level. Exact addresses are not disclosed by VRBO.

**Q: How do I get full-resolution images?**
Remove the `?impolicy=resizecrop&ra=fit&rw=455&rh=455` query string from any `image_urls` entry to get the original full-size image.

**Q: How are review counts counted?**
When `include_reviews` is enabled, the actor fetches each listing's review summary (overall rating + category scores) and up to 5 most recent individual review records. The full review count is shown in the `review_count_text` field (e.g., "12 verified reviews") but only the 5 most recent full review records are included. Charge is $0.001 per listing where reviews are successfully extracted (summary OR recent review records).

**Q: Why is there no reviewer name in `recent_reviews[]`?**
Reviewer names are personal data. The actor intentionally omits `reviewer_name` (and all guest photos) to comply with PII best practices. Each review record contains only the rating, full text, stay info, and review ID.

**Q: What's the recommended `max_listings` for full enrichment?**
200-300 per run. For larger datasets split into multiple runs. Basic mode handles 1,000 comfortably.

**Q: Can I scrape a specific listing by URL?**
Coming in Phase 3. For now, search by location and filter results by `listing_id`.

**Q: How often is this actor maintained?**
Actively maintained. All 6 persisted query hashes (typeahead, search, detail, availability, reviews, review records) are hardcoded constants used on every run — zero HTTP overhead for hash lookup. If VRBO rotates a hash, the per-query wrapper auto-discovers the new value mid-run and persists it for the next run. Breaking changes are fixed within days.

**Q: Something isn't working — where do I report issues?**
Use the **Issues** tab on this Actor's page. We actively monitor and respond to all reports. We're also open to building custom solutions — reach out via the Issues tab.

***

### Technical details

- Pure HTTP requests — no headless browser, no Playwright, no Puppeteer
- Streaming output — results appear in real-time, partial results always saved
- Per-item error isolation — one bad listing never crashes the entire run
- Auto-healing GraphQL hash refresh — all 6 persisted query hashes (typeahead, search, detail, availability, reviews, review\_records) are hardcoded constants; if VRBO rotates one, the per-query wrapper auto-discovers the new value mid-run and persists it for next time
- Concurrent enrichment — 5 listings enriched in parallel for speed
- Parallel JS bundle download — 5-bundle concurrent batches during hash discovery
- Exponential backoff retry — up to 7 attempts on rate limits (429s)
- Residential proxy support via Apify's proxy infrastructure
- Smart multi-level location disambiguation for any city worldwide, with NEIGHBORHOOD/POI fallback
- Per-run discovery cache — cold start with rotated hashes performs one discovery, not six

# Actor input Schema

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

Where to search (e.g. 'Miami Beach, FL', 'Aspen, CO', 'Maui, HI')

## `check_in` (type: `string`):

Optional. Format: YYYY-MM-DD

## `check_out` (type: `string`):

Optional. Format: YYYY-MM-DD

## `max_listings` (type: `integer`):

Maximum number of listings to scrape (1-1000)

## `include_details` (type: `boolean`):

Fetch full property details: amenities, description, house rules, lat/lng. Slower but richer data.

## `include_availability` (type: `boolean`):

Fetch availability calendar and minimum stay requirements.

## `include_reviews` (type: `boolean`):

Fetch review summary (overall rating, category scores) and up to 5 most recent reviews per listing. Slower and adds a small per-listing charge.

## Actor input object example

```json
{
  "location": "Miami Beach, FL",
  "check_in": "",
  "check_out": "",
  "max_listings": 50,
  "include_details": false,
  "include_availability": false,
  "include_reviews": false
}
```

# 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 = {
    "location": "Miami Beach, FL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jaxay/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 = { "location": "Miami Beach, FL" }

# Run the Actor and wait for it to finish
run = client.actor("jaxay/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 '{
  "location": "Miami Beach, FL"
}' |
apify call jaxay/vrbo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VRBO Scraper — Vacation Rental Data, Pricing & Availability",
        "description": "Scrape VRBO listings with full pricing, amenities, house rules, availability, images & reviews. Pay per result. No coding required.",
        "version": "0.1",
        "x-build-id": "5jjltg22LOlWCWU7b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jaxay~vrbo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jaxay-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/jaxay~vrbo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jaxay-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/jaxay~vrbo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jaxay-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",
                "required": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search (e.g. 'Miami Beach, FL', 'Aspen, CO', 'Maui, HI')"
                    },
                    "check_in": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Optional. Format: YYYY-MM-DD",
                        "default": ""
                    },
                    "check_out": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Optional. Format: YYYY-MM-DD",
                        "default": ""
                    },
                    "max_listings": {
                        "title": "Max Listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape (1-1000)",
                        "default": 50
                    },
                    "include_details": {
                        "title": "Include Property Details",
                        "type": "boolean",
                        "description": "Fetch full property details: amenities, description, house rules, lat/lng. Slower but richer data.",
                        "default": false
                    },
                    "include_availability": {
                        "title": "Include Availability",
                        "type": "boolean",
                        "description": "Fetch availability calendar and minimum stay requirements.",
                        "default": false
                    },
                    "include_reviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Fetch review summary (overall rating, category scores) and up to 5 most recent reviews per listing. Slower and adds a small per-listing charge.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
