# VRBO Search Results Scraper (`cirkit/vrbo-search-scraper`) Actor

Scrape VRBO vacation rentals and Expedia hotels from search results by destination, dates, and guests. Returns property name, price, location, ID, photos, amenities, ratings, and direct booking URL. No browser overhead.

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

## Pricing

from $1.80 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does this actor do?

The VRBO Search Results Scraper extracts vacation rental and hotel data from VRBO search results pages without manual copy-pasting. Give it a destination, dates, and guest count, and the actor returns structured JSON: property name, price, location, ID, booking URL, photos, amenities, and ratings. It is a fast, headless data scraper for vacation rental analytics, property managers, and travel aggregators that need fresh inventory from vrbo.com via a simple API.

Because VRBO and Expedia share the same backend, this VRBO scraper returns vacation rentals from VRBO plus Expedia-listed hotels for the same destination. Use the propertyType filter to narrow down to vacation rentals only (best for STR comp analysis) or hotels only.

### What data does it extract?

The VRBO Search Results Scraper extracts the following fields per property:

- `id` - Unique VRBO/Expedia property ID
- `name` - Listing title
- `location` - Neighborhood or city as shown on the card
- `url` - Direct booking URL on vrbo.com
- `priceFormatted` - Current displayed nightly price (e.g. "$138")
- `priceLabel` - Total price with date range (e.g. "$551 total for 4 nights")
- `propertyType` - One of VACATION_RENTAL, HOTEL, or UNKNOWN
- `propertyTypeLabel` - Subtype text (e.g. "Entire home by Vrbo")
- `bedrooms`, `bathrooms`, `sleeps` - Capacity figures when shown
- `amenities` - Featured amenities from the search card
- `photos` - Property image URLs
- `rating` - Guest rating on the 10-point scale (when present)
- `reviewCount` - Number of reviews
- `searchedLocation` - The original search input that produced this record

### How to use this actor

1. Set one or more destinations in `locations` (e.g. "Pigeon Forge, Tennessee", "Asheville, North Carolina").
2. Set `checkIn` and `checkOut` dates in YYYY-MM-DD format.
3. Click Start. The actor returns the first N results per location, capped by `maxResults`.

For higher-precision targeting, pass VRBO regionIds in the `regionIds` array. The actor uses VRBO residential proxy routing and parses search results server-side, so a 50-property scrape typically completes in under a minute.

### Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `locations` | string[] | `["Pigeon Forge, Tennessee"]` | Destinations to search |
| `regionIds` | string[] | `[]` | Optional VRBO regionIds for exact targeting |
| `checkIn` | string | today + 30 days | YYYY-MM-DD |
| `checkOut` | string | check-in + 5 days | YYYY-MM-DD |
| `adults` | int | 2 | Number of guests, 1 to 16 |
| `maxResults` | int | 50 | Max properties per location, 1 to 500 |
| `propertyType` | string | `ALL` | `ALL`, `VACATION_RENTAL_ONLY`, or `HOTEL_ONLY` |
| `currency` | string | `USD` | Display currency |
| `locale` | string | `en_US` | Response locale |
| `proxyConfiguration` | object | Apify RESIDENTIAL US | Proxy config |

### Output format

Each record is a JSON object like:

```json
{
    "id": "9762789",
    "name": "Cozy cabin near Pigeon Forge Parkway",
    "location": "Pigeon Forge",
    "url": "https://www.vrbo.com/9762789ha",
    "priceFormatted": "$138",
    "priceLabel": "$551 total for 4 nights",
    "propertyType": "VACATION_RENTAL",
    "propertyTypeLabel": "Entire cabin by Vrbo",
    "bedrooms": 3,
    "bathrooms": 2,
    "sleeps": 8,
    "amenities": ["Pool", "Kitchen", "Washer and dryer"],
    "photos": ["https://images.trvl-media.com/..."],
    "rating": 9.6,
    "reviewCount": 124,
    "searchedLocation": "Pigeon Forge, Tennessee"
}
````

### Pricing

This VRBO Search Results Scraper uses pay-per-event pricing:

| Event | Price |
|-------|-------|
| Per result | $0.0018 |

Apify subscription tiers (Bronze, Silver, Gold) apply standard discounts automatically. A typical search of 50 properties costs approximately $0.09 in dataset charges. Apify residential proxy and compute are billed separately at standard rates.

### Frequently asked questions

#### Does this VRBO scraper return Expedia hotels too?

Yes. VRBO and Expedia share the same backend, so a single search returns both vacation rentals and hotels. Use `propertyType` to filter to one or the other.

#### Do I need to log in to VRBO?

No. The actor scrapes public search results only. No VRBO account or credentials are needed.

#### How fresh is the data?

Real time. Every run hits vrbo.com live and returns current listings, prices, and availability for the requested dates. Repeat runs will reflect new listings and price changes.

#### Why might my search return a different city than expected?

VRBO uses IP-based geolocation to resolve ambiguous destination strings. If your search keeps returning the wrong region, find the exact `regionId` on a working vrbo.com search URL and pass it in `regionIds` for exact targeting.

#### Can I scrape historical prices?

The VRBO API only returns current availability and prices for the requested dates. To track price history, schedule the actor on a daily or weekly cadence and store snapshots over time.

### Other actors you might like

- [Airbnb Search Results Scraper](https://apify.com/store)
- [Airbnb Listing Detail Scraper](https://apify.com/store)
- [Booking.com Hotels Scraper](https://apify.com/store)

# Actor input Schema

## `locations` (type: `array`):

List of destinations to search (city, neighborhood, region, or country). VRBO resolves each string server-side. For exact region targeting on heavily-trafficked queries, use regionIds instead.

## `regionIds` (type: `array`):

VRBO regionId values for exact region targeting. Bypasses destination text resolution. Find the regionId in any VRBO search URL after performing the search in a browser (e.g. ?regionId=6054439 for Pigeon Forge).

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

Check-in date in YYYY-MM-DD format. Defaults to today + 30 days.

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

Check-out date in YYYY-MM-DD format. Defaults to check-in + 5 days.

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

Number of adult guests (1 to 16).

## `maxResults` (type: `integer`):

Maximum properties to extract per location (1 to 500). The actor paginates through VRBO search pages until this cap is hit or results run out.

## `propertyType` (type: `string`):

Filter results. VACATION\_RENTAL\_ONLY excludes hotels (best for STR analytics and property managers). HOTEL\_ONLY returns hotels only. ALL returns everything (default).

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

Currency for displayed prices (USD, EUR, GBP, ...).

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

Response locale (en\_US, es\_MX, fr\_FR, ...).

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

Residential US proxies are required for reliable VRBO scraping (Akamai Bot Manager blocks datacenter IPs).

## Actor input object example

```json
{
  "locations": [
    "Pigeon Forge, Tennessee",
    "Asheville, North Carolina",
    "Destin, Florida"
  ],
  "regionIds": [
    "6054439",
    "6022527"
  ],
  "checkIn": "2026-08-01",
  "checkOut": "2026-08-05",
  "adults": 2,
  "maxResults": 50,
  "propertyType": "ALL",
  "currency": "USD",
  "locale": "en_US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "locations": [
        "Pigeon Forge, Tennessee"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/vrbo-search-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 = {
    "locations": ["Pigeon Forge, Tennessee"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/vrbo-search-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 '{
  "locations": [
    "Pigeon Forge, Tennessee"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call cirkit/vrbo-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VRBO Search Results Scraper",
        "description": "Scrape VRBO vacation rentals and Expedia hotels from search results by destination, dates, and guests. Returns property name, price, location, ID, photos, amenities, ratings, and direct booking URL. No browser overhead.",
        "version": "0.1",
        "x-build-id": "c6b2cZSI4hf5JwPbu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~vrbo-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-vrbo-search-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/cirkit~vrbo-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-vrbo-search-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/cirkit~vrbo-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-vrbo-search-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": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "List of destinations to search (city, neighborhood, region, or country). VRBO resolves each string server-side. For exact region targeting on heavily-trafficked queries, use regionIds instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regionIds": {
                        "title": "Region IDs (optional)",
                        "type": "array",
                        "description": "VRBO regionId values for exact region targeting. Bypasses destination text resolution. Find the regionId in any VRBO search URL after performing the search in a browser (e.g. ?regionId=6054439 for Pigeon Forge).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Defaults to today + 30 days."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Defaults to check-in + 5 days."
                    },
                    "adults": {
                        "title": "Number of guests",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests (1 to 16).",
                        "default": 2
                    },
                    "maxResults": {
                        "title": "Max properties per location",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum properties to extract per location (1 to 500). The actor paginates through VRBO search pages until this cap is hit or results run out.",
                        "default": 50
                    },
                    "propertyType": {
                        "title": "Property type filter",
                        "enum": [
                            "ALL",
                            "VACATION_RENTAL_ONLY",
                            "HOTEL_ONLY"
                        ],
                        "type": "string",
                        "description": "Filter results. VACATION_RENTAL_ONLY excludes hotels (best for STR analytics and property managers). HOTEL_ONLY returns hotels only. ALL returns everything (default).",
                        "default": "ALL"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency for displayed prices (USD, EUR, GBP, ...).",
                        "default": "USD"
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Response locale (en_US, es_MX, fr_FR, ...).",
                        "default": "en_US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential US proxies are required for reliable VRBO scraping (Akamai Bot Manager blocks datacenter IPs)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
