# KAYAK Car Rental Scraper (`solidcode/kayak-scraper`) Actor

\[💰 $1.3 / 1K] Extract car rental offers from KAYAK — vehicle class, rental agency, daily and total prices, mileage and fuel policies, cancellation terms, and direct booking links. Search by location and dates or paste KAYAK URLs.

- **URL**: https://apify.com/solidcode/kayak-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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

## KAYAK Car Rental Scraper

Pull live car-rental offers from KAYAK at scale — vehicle class, rental agency, booking provider, daily and total prices, mileage and fuel policies, free-cancellation terms, and a direct booking link for every offer. Search by city, airport code, or a pasted KAYAK URL, with one-way trips, custom dates and times, and driver-age-aware pricing all supported. Built for travel agencies, price-comparison sites, and fleet and corporate-travel analysts who need clean, structured rental pricing without hand-crafting KAYAK URLs or babysitting a browser.

### Why This Scraper?

- **Both the rental agency and the booking provider on every offer** — each row names the agency (Hertz, Avis, Budget, Enterprise…) *and* the provider it's bookable through (Priceline, Expedia, the agency direct…), so you see who supplies the car and who sells it.
- **9 car classes you can filter** — Small/Economy, Medium/Intermediate, Large/Full-size, SUV, Van/Minivan, Luxury, Special, Pickup Truck, and Convertible.
- **One-way rentals fully supported** — set a different drop-off location and the actor builds the correct cross-city search, no manual URL surgery.
- **Driver-age-aware pricing** — pass the main driver's age and KAYAK applies under-25 surcharges and over-70 availability rules, so quotes match what a real renter would see.
- **Complete rental terms per offer** — mileage policy (limited or unlimited, with the actual mileage cap), fuel policy, known fees, payment type (prepay vs. pay-at-counter), and free-cancellation terms — all inline, no second lookup.
- **Direct booking link on every row** — a deep `bookingUrl` that lands on the exact offer, plus the supplier's own `siteUrl`, ready to drop into a "Book now" button.
- **Thousands of offers per search** — a single broad search returns 6,900+ offers across every agency and class, paginated automatically to exhaustion when you set Max Results to 0.
- **3 sort modes** — Recommended, Cheapest first, and Best value, matching KAYAK's own ranking so your top rows are the ones a shopper would actually see first.
- **Zero hand-built URLs** — type a city or airport code and pick your dates; the actor resolves the location and assembles the search for you, or paste any KAYAK car-rental URL to scrape it directly.

### Use Cases

**Travel Agencies & OTAs**
- Power a car-rental comparison page with live agency-vs-provider pricing
- Surface the cheapest qualifying offer per car class for a client itinerary
- Quote one-way rentals between two cities in seconds
- Show full rental terms (mileage, fuel, cancellation) before a customer commits

**Price Monitoring & Revenue Management**
- Track daily and total rental rates across agencies for the same dates
- Watch how prices shift by pickup time, lead time, and driver age
- Benchmark your fleet's pricing against Hertz, Avis, Budget, and Enterprise
- Detect when a competitor undercuts you on a key route

**Corporate & Fleet Travel**
- Build approved-supplier rate sheets for employee bookings
- Compare prepay vs. pay-at-counter totals for expense forecasting
- Identify unlimited-mileage offers for long-distance assignments
- Audit which agencies serve a given airport and at what price

**Market Research & Data Products**
- Analyze car-class availability and pricing across destinations
- Map which booking providers carry which agencies in each market
- Feed structured rental data into dashboards, BI tools, and pricing models
- Study seasonal and day-of-week pricing patterns at scale

### Getting Started

#### Simple — search a city for two weeks out

Just a pickup location; dates default to two weeks from today for a one-week rental.

```json
{
    "pickupLocation": "Los Angeles"
}
````

#### Filtered — SUVs only, cheapest first, specific dates

```json
{
    "pickupLocation": "LAX",
    "pickupDate": "2026-07-15",
    "returnDate": "2026-07-22",
    "carType": ["SUV"],
    "sortBy": "cheapest",
    "maxResults": 100
}
```

#### Advanced — one-way rental, young driver, custom times

```json
{
    "pickupLocation": "Los Angeles",
    "dropoffLocation": "San Diego",
    "pickupDate": "2026-08-01",
    "pickupTime": "08:00",
    "returnDate": "2026-08-05",
    "returnTime": "18:00",
    "driverAge": 22,
    "sortBy": "best",
    "currency": "USD",
    "maxResults": 200
}
```

#### Power-user — scrape pasted KAYAK URLs directly

```json
{
    "startUrls": [
        "https://www.kayak.com/cars/Los-Angeles,CA/2026-07-15/2026-07-22"
    ],
    "maxResults": 0
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `pickupLocation` | string | `"Los Angeles"` | City, airport code, or place to pick up the car (e.g. "Los Angeles", "LAX", "Paris"). |
| `dropoffLocation` | string | *(empty)* | Where to return the car for a one-way rental (e.g. "San Diego", "SAN"). Leave empty to return it to the pickup location. |

#### Dates & Driver

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `pickupDate` | string | *(today + 14 days)* | Pickup date in YYYY-MM-DD format. Dates in the past are automatically moved forward. |
| `pickupTime` | select | `10:00 AM` | Time of day you pick up the car (hourly options from Midnight to 11:00 PM). |
| `returnDate` | string | *(pickup + 7 days)* | Return date in YYYY-MM-DD format. Must be on or after the pickup date. |
| `returnTime` | select | `10:00 AM` | Time of day you return the car (hourly options from Midnight to 11:00 PM). |
| `driverAge` | integer | `30` | Age of the main driver (18–99). KAYAK adjusts availability and pricing for drivers under 25 or over 70. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Recommended` | Result ranking: Recommended, Cheapest first, Closest pickup, or Best value. |
| `carType` | multi-select | *(all types)* | Keep only these vehicle classes: Small/Economy, Medium/Intermediate, Large/Full-size, SUV, Van/Minivan, Luxury, Special, Pickup truck, Convertible. Leave empty for every car type. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | select | `US Dollar (USD)` | Preferred display currency (20 ISO options). Prices may be returned in the rental market's local currency; every row reports the actual currency it was priced in. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Maximum rental offers to collect per search. Set to 0 to collect every available offer. Results arrive in pages of roughly 90–110 offers, so a small value still returns one full page. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste full KAYAK car-rental result URLs to scrape them directly. When provided, these override the search fields above. Expired dates are automatically moved forward. |

### Output

One row per rental offer (a single car × provider pairing). Here's a representative result:

```json
{
    "resultId": "c-9f3a17b2e4",
    "searchId": "Rk0aXyZ9pQ",
    "sourceType": "AGENCY",
    "providerName": "Priceline",
    "providerCode": "PRIC",
    "agencyName": "Hertz",
    "agencyCode": "ZE",
    "carType": "Toyota Corolla or similar",
    "carTypeGroups": ["small", "economy"],
    "pricePerDay": { "price": 36, "currency": "USD", "localizedPrice": "$36" },
    "priceTotal": { "price": 254, "currency": "USD", "localizedPrice": "$254" },
    "price": { "price": 254, "currency": "USD", "localizedPrice": "$254" },
    "currencyCode": "USD",
    "knownFees": [{ "name": "Young driver fee", "amount": 27 }],
    "paymentType": "PAY_AT_COUNTER",
    "mileagePolicyType": "UNLIMITED",
    "mileageTotalLimit": "Unlimited mileage",
    "fuelPolicy": { "type": "FULL_TO_FULL" },
    "freeCancellationPolicy": { "isFree": true, "deadline": "2026-07-14" },
    "pickupLocation": "Los Angeles",
    "pickupDate": "2026-07-15",
    "returnDate": "2026-07-22",
    "pickupLocationDetails": { "name": "Los Angeles Intl Airport (LAX)", "displayDistance": "At airport" },
    "bookingUrl": "https://www.kayak.com/in?...",
    "siteUrl": "https://www.hertz.com/...",
    "vehicleDetail": { "doors": 4, "seats": 5, "bags": 2, "transmission": "AUTOMATIC" },
    "image": "https://content.r9cdn.net/...",
    "sourceUrl": "https://www.kayak.com/cars/Los-Angeles,CA-c16078/2026-07-15/2026-07-22?sort=rank_a"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `resultId` | string | Unique identifier for this offer |
| `searchId` | string | KAYAK search identifier the offer came from |
| `sourceType` | string | Offer source category (e.g. agency rate type) |
| `agencyName` | string | Rental agency display name (Hertz, Avis, Budget…) |
| `agencyCode` | string | Rental agency code |
| `providerName` | string | Booking provider the offer is sold through |
| `providerCode` | string | Booking provider code |
| `carType` | string | Vehicle name and class (e.g. "Toyota Corolla or similar") |
| `carTypeGroups` | string\[] | Vehicle category groups (small, suv, luxury…) |
| `vehicleDetail` | object | Vehicle specifications (doors, seats, bags, transmission class) where provided by KAYAK |
| `image` | string | Vehicle image URL |

#### Pricing & Fees

| Field | Type | Description |
|-------|------|-------------|
| `pricePerDay` | object | Daily price (amount, currency, localized display string) |
| `priceTotal` | object | Total price for the full rental period |
| `price` | object | Primary price KAYAK highlights for the offer |
| `currencyCode` | string | ISO currency code the prices were actually returned in |
| `knownFees` | array | Known fee line items (e.g. young-driver fee) |
| `paymentType` | string | Payment mode (prepay, pay-at-counter, deposit) |

#### Rental Policies

| Field | Type | Description |
|-------|------|-------------|
| `mileagePolicyType` | string | Mileage policy: limited or unlimited |
| `mileageTotalLimit` | string | Human-readable mileage limit text |
| `fuelPolicy` | object | Fuel policy details (e.g. full-to-full) |
| `freeCancellationPolicy` | object | Free-cancellation terms and deadline |

#### Location & Trip

| Field | Type | Description |
|-------|------|-------------|
| `pickupLocation` | string | Requested pickup location |
| `pickupDate` | string | Pickup date (ISO) |
| `returnDate` | string | Return date (ISO) |
| `pickupLocationDetails` | object | Location context (airport name/code, distance from terminal) |

#### Links

| Field | Type | Description |
|-------|------|-------------|
| `bookingUrl` | string | Deep link to book this specific offer |
| `siteUrl` | string | Supplier's own website URL |
| `sourceUrl` | string | The KAYAK search URL the row came from |

### Tips for Best Results

- **Set the driver's age accurately** — KAYAK changes both availability and price for drivers under 25 and over 70, so the wrong age produces quotes a real renter could never book.
- **When filtering to a rare car class, keep Max Results generous** — car-type filtering is applied across the whole result set, so a narrow class like Convertible or Special may sit deep in the list; allow enough results for the matches to surface.
- **Use Cheapest first to find the price floor** — it ranks offers low-to-high so the very first rows are the lowest qualifying totals for your dates.
- **Match pickup and return times to the real trip** — KAYAK returns different inventory and pricing for an 8:00 AM pickup versus a 6:00 PM pickup, so set the times you'd actually rent at.
- **Set Max Results to 0 to capture a whole market** — broad searches can exceed 6,900 offers across every agency and class; the actor paginates to exhaustion automatically.
- **Read `currencyCode` on each row, not just the input** — prices are sometimes returned in the rental market's local currency, and every row always carries the currency it was actually priced in, so totals are never mislabeled.
- **Paste competitor or saved KAYAK URLs** — the Advanced URLs field accepts full result links and even heals expired dates, so old bookmarks keep working without edits.

### Pricing

**$1.30 per 1,000 results** — a flat, pay-per-result rate that undercuts comparable car-rental scrapers on the Apify Store. No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.13 |
| 1,000 | $1.30 |
| 10,000 | $13.00 |
| 100,000 | $130.00 |

A "result" is a single rental offer row in your dataset. There are no compute charges — you pay only for the offers returned. Apify platform plan fees may apply separately.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate travel research, price comparison, and market analysis. You are responsible for complying with applicable laws and KAYAK's Terms of Service. Use the data responsibly, respect rate and volume limits, and do not use it for spam, misrepresentation, or any unlawful purpose. Always verify final prices and rental terms with the agency before booking.

# Actor input Schema

## `pickupLocation` (type: `string`):

City, airport code, or place to pick up the car (e.g. 'Los Angeles', 'LAX', 'Paris'). Leave the Advanced URLs field empty to use this.

## `dropoffLocation` (type: `string`):

Where to return the car for a one-way rental (e.g. 'San Diego', 'SAN'). Leave empty to return the car to the same place you picked it up.

## `pickupDate` (type: `string`):

Date you pick up the car, in YYYY-MM-DD format (e.g. 2026-07-15). Leave empty to default to two weeks from today. Dates in the past are automatically moved forward.

## `pickupTime` (type: `string`):

Time of day you pick up the car.

## `returnDate` (type: `string`):

Date you return the car, in YYYY-MM-DD format. Leave empty to default to one week after the pickup date. Must be on or after the pickup date.

## `returnTime` (type: `string`):

Time of day you return the car.

## `driverAge` (type: `integer`):

Age of the main driver. KAYAK adjusts availability and pricing for drivers under 25 or over 70, so set this accurately.

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

How KAYAK should rank the rental offers.

## `carType` (type: `array`):

Only keep these vehicle classes in the results. Leave empty to include every car type. Note: KAYAK has no server-side car-type filter, so the actor fetches the search and keeps only the matching offers — pick a smaller Max Results when filtering to a rare class.

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

Preferred display currency (ISO 4217 code). KAYAK applies it where it supports the currency, but many offers come straight from the rental market and report their own local currency. Each result row carries a 'currencyCode' field — that value is authoritative for the prices on that row. Pick a currency here to nudge KAYAK, then read 'currencyCode' on each row to know what the prices are actually in.

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

Maximum number of rental offers to collect per search. Set to 0 to collect all available offers. Results are delivered in pages of roughly 90–110 offers, so a small value (e.g. 10) will still return one full page.

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

Advanced: paste one or more full KAYAK car-rental result URLs to scrape them directly (e.g. 'https://www.kayak.com/cars/Los-Angeles,CA/2026-07-15/2026-07-22'). When provided, these override the search fields above. Expired dates are automatically moved forward.

## Actor input object example

```json
{
  "pickupLocation": "Los Angeles",
  "pickupTime": "10:00",
  "returnTime": "10:00",
  "driverAge": 30,
  "sortBy": "recommended",
  "carType": [],
  "currency": "USD",
  "maxResults": 50,
  "startUrls": []
}
```

# Actor output Schema

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

Table of car rental offers with vehicle, agency, and price.

# 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 = {
    "pickupLocation": "Los Angeles",
    "pickupTime": "10:00",
    "returnTime": "10:00",
    "driverAge": 30,
    "sortBy": "recommended",
    "carType": [],
    "currency": "USD",
    "maxResults": 50,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/kayak-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 = {
    "pickupLocation": "Los Angeles",
    "pickupTime": "10:00",
    "returnTime": "10:00",
    "driverAge": 30,
    "sortBy": "recommended",
    "carType": [],
    "currency": "USD",
    "maxResults": 50,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/kayak-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 '{
  "pickupLocation": "Los Angeles",
  "pickupTime": "10:00",
  "returnTime": "10:00",
  "driverAge": 30,
  "sortBy": "recommended",
  "carType": [],
  "currency": "USD",
  "maxResults": 50,
  "startUrls": []
}' |
apify call solidcode/kayak-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "KAYAK Car Rental Scraper",
        "description": "[💰 $1.3 / 1K] Extract car rental offers from KAYAK — vehicle class, rental agency, daily and total prices, mileage and fuel policies, cancellation terms, and direct booking links. Search by location and dates or paste KAYAK URLs.",
        "version": "1.0",
        "x-build-id": "fxGka86NIeaPxDHWM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~kayak-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-kayak-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/solidcode~kayak-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-kayak-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/solidcode~kayak-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-kayak-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": {
                    "pickupLocation": {
                        "title": "Pickup Location",
                        "type": "string",
                        "description": "City, airport code, or place to pick up the car (e.g. 'Los Angeles', 'LAX', 'Paris'). Leave the Advanced URLs field empty to use this.",
                        "default": "Los Angeles"
                    },
                    "dropoffLocation": {
                        "title": "Drop-off Location",
                        "type": "string",
                        "description": "Where to return the car for a one-way rental (e.g. 'San Diego', 'SAN'). Leave empty to return the car to the same place you picked it up."
                    },
                    "pickupDate": {
                        "title": "Pickup Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Date you pick up the car, in YYYY-MM-DD format (e.g. 2026-07-15). Leave empty to default to two weeks from today. Dates in the past are automatically moved forward."
                    },
                    "pickupTime": {
                        "title": "Pickup Time",
                        "enum": [
                            "00:00",
                            "06:00",
                            "07:00",
                            "08:00",
                            "09:00",
                            "10:00",
                            "11:00",
                            "12:00",
                            "13:00",
                            "14:00",
                            "15:00",
                            "16:00",
                            "17:00",
                            "18:00",
                            "19:00",
                            "20:00",
                            "21:00",
                            "22:00",
                            "23:00"
                        ],
                        "type": "string",
                        "description": "Time of day you pick up the car.",
                        "default": "10:00"
                    },
                    "returnDate": {
                        "title": "Return Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Date you return the car, in YYYY-MM-DD format. Leave empty to default to one week after the pickup date. Must be on or after the pickup date."
                    },
                    "returnTime": {
                        "title": "Return Time",
                        "enum": [
                            "00:00",
                            "06:00",
                            "07:00",
                            "08:00",
                            "09:00",
                            "10:00",
                            "11:00",
                            "12:00",
                            "13:00",
                            "14:00",
                            "15:00",
                            "16:00",
                            "17:00",
                            "18:00",
                            "19:00",
                            "20:00",
                            "21:00",
                            "22:00",
                            "23:00"
                        ],
                        "type": "string",
                        "description": "Time of day you return the car.",
                        "default": "10:00"
                    },
                    "driverAge": {
                        "title": "Driver Age",
                        "minimum": 18,
                        "maximum": 99,
                        "type": "integer",
                        "description": "Age of the main driver. KAYAK adjusts availability and pricing for drivers under 25 or over 70, so set this accurately.",
                        "default": 30
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "recommended",
                            "cheapest",
                            "distance",
                            "best"
                        ],
                        "type": "string",
                        "description": "How KAYAK should rank the rental offers.",
                        "default": "recommended"
                    },
                    "carType": {
                        "title": "Car Types",
                        "type": "array",
                        "description": "Only keep these vehicle classes in the results. Leave empty to include every car type. Note: KAYAK has no server-side car-type filter, so the actor fetches the search and keeps only the matching offers — pick a smaller Max Results when filtering to a rare class.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "SMALL",
                                "MEDIUM",
                                "LARGE",
                                "SUV",
                                "VAN",
                                "LUXURY",
                                "SPECIAL",
                                "PICKUPTRUCK",
                                "CONVERTIBLE"
                            ],
                            "enumTitles": [
                                "Small / Economy",
                                "Medium / Intermediate",
                                "Large / Full-size",
                                "SUV",
                                "Van / Minivan",
                                "Luxury",
                                "Special",
                                "Pickup truck",
                                "Convertible"
                            ]
                        }
                    },
                    "currency": {
                        "title": "Preferred Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "BRL",
                            "MXN",
                            "INR",
                            "CNY",
                            "HKD",
                            "SGD",
                            "NZD",
                            "ZAR",
                            "AED"
                        ],
                        "type": "string",
                        "description": "Preferred display currency (ISO 4217 code). KAYAK applies it where it supports the currency, but many offers come straight from the rental market and report their own local currency. Each result row carries a 'currencyCode' field — that value is authoritative for the prices on that row. Pick a currency here to nudge KAYAK, then read 'currencyCode' on each row to know what the prices are actually in.",
                        "default": "USD"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of rental offers to collect per search. Set to 0 to collect all available offers. Results are delivered in pages of roughly 90–110 offers, so a small value (e.g. 10) will still return one full page.",
                        "default": 50
                    },
                    "startUrls": {
                        "title": "KAYAK Car Rental URLs",
                        "type": "array",
                        "description": "Advanced: paste one or more full KAYAK car-rental result URLs to scrape them directly (e.g. 'https://www.kayak.com/cars/Los-Angeles,CA/2026-07-15/2026-07-22'). When provided, these override the search fields above. Expired dates are automatically moved forward.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
