# Turo Car Rental Scraper - Prices, Cars & Hosts (`lulzasaur/turo-scraper`) Actor

Scrape Turo.com car rental listings by city or airport. Get make, model, year, daily price, rating, trip count, host info, location and images for any trip dates. Filter by vehicle type, fuel and price. Uses residential proxies to handle anti-bot.

- **URL**: https://apify.com/lulzasaur/turo-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Turo Car Rental Scraper

Scrape real-time car rental listings from [Turo.com](https://turo.com) — the world's largest peer-to-peer car-sharing marketplace. Search any city or airport for any trip dates and get structured data on every available car: make, model, year, daily price, rating, trip count, host status, location, and images.

Great for price comparison, market research, fleet/host analytics, and travel apps.

### Features

- Search by **city, address, or airport** (multiple locations per run)
- Custom **trip date/time** windows (or sensible defaults)
- Filter by **vehicle type** and **fuel type**
- **Sort** by relevance, price, or distance
- Clean, normalized JSON output with daily prices in real currency
- Handles Turo's **DataDome anti-bot** via a real browser + **residential proxies**

### Why residential proxies?

Turo is protected by **DataDome**, which returns HTTP 403 to datacenter IPs and plain HTTP clients on every path — including its internal API. This Actor loads Turo's search page in a real Chromium browser (passing the DataDome challenge), then replays Turo's internal `/api/v2/search` endpoint using the browser's session, so it must run with **residential proxies** (the default).

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQueries` | array | Locations to search (e.g. `"Los Angeles, CA"`, `"Miami, FL"`, `"SFO"`) |
| `startDate` / `endDate` | string | Trip dates `YYYY-MM-DD` (defaults: +7 days, 3-day trip) |
| `startTime` / `endTime` | string | Pickup/return time `HH:mm` (default `10:00`) |
| `driverAge` | integer | Driver age for pricing (default `30`) |
| `vehicleType` | array | `CAR`, `SUV`, `MINIVAN`, `TRUCK`, `VAN`, `CARGO_VAN`, `BOX_TRUCK` |
| `fuelType` | array | `GAS`, `HYBRID`, `ELECTRIC`, `DIESEL` |
| `sortBy` | string | `RELEVANCE`, `PRICE_LOW`, `PRICE_HIGH`, `DISTANCE` |
| `maxResults` | integer | Max cars per location (default `30`, up to ~200) |
| `proxyConfiguration` | object | Defaults to Apify **RESIDENTIAL** proxies (required) |

#### Example input

```json
{
    "searchQueries": ["Los Angeles, CA", "Miami, FL"],
    "startDate": "2026-07-12",
    "endDate": "2026-07-15",
    "vehicleType": ["SUV"],
    "fuelType": ["ELECTRIC"],
    "sortBy": "PRICE_LOW",
    "maxResults": 30,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output

Each car is one dataset record:

```json
{
    "id": 3613768,
    "make": "BMW",
    "model": "5 Series",
    "year": 2021,
    "vehicleType": "CAR",
    "pricePerDay": 54.42,
    "currency": "USD",
    "rating": 4.95,
    "tripCount": 20,
    "isAllStarHost": true,
    "isNewListing": false,
    "hostId": 33962137,
    "location": {
        "city": "Los Angeles",
        "state": "CA",
        "country": "US",
        "lat": 34.0598,
        "lng": -118.2577,
        "distanceMiles": 0.93,
        "isDelivery": false
    },
    "tags": ["Unlimited miles"],
    "badges": [],
    "imageUrl": "https://images.turo.com/media/vehicle/images/-16A5MLcR8udCPWV2OSI9Q.720x480.heic",
    "listingUrl": "https://turo.com/us/en/los-angeles-ca/bmw-5-series-2021-3613768",
    "searchQuery": "Los Angeles, CA",
    "scrapedAt": "2026-06-19T23:30:00.000Z"
}
```

### Notes & limits

- Turo returns up to ~200 cars per search; `totalHits` (total matches) can be in the thousands but only the first batch is returned by the search API.
- Host display name, trim, and instant-book status are not exposed in the search response (only in per-listing detail pages); the search-level fields above are what Turo returns.
- This Actor is for public listing data and market research. Respect Turo's Terms of Service and applicable laws.

# Actor input Schema

## `searchQueries` (type: `array`):

Cities, addresses, or airport codes to search for rental cars (e.g. 'Los Angeles, CA', 'Miami, FL', 'SFO')

## `startDate` (type: `string`):

Pickup date (YYYY-MM-DD). Defaults to 7 days from now if empty.

## `endDate` (type: `string`):

Return date (YYYY-MM-DD). Defaults to 3 days after the start date if empty.

## `startTime` (type: `string`):

Pickup time (HH:mm, 24h)

## `endTime` (type: `string`):

Return time (HH:mm, 24h)

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

Driver age used for pricing/eligibility (Turo prices differ for under-25 drivers)

## `vehicleType` (type: `array`):

Filter by vehicle type (leave empty for all)

## `fuelType` (type: `array`):

Filter by fuel/engine type (leave empty for all)

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

Sort order of results

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

Maximum number of cars to return per location (0 = all, up to ~200 returned by Turo per search)

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

Proxy settings. RESIDENTIAL proxies are REQUIRED — Turo uses DataDome anti-bot which blocks datacenter IPs with HTTP 403.

## Actor input object example

```json
{
  "searchQueries": [
    "Los Angeles, CA"
  ],
  "startTime": "10:00",
  "endTime": "10:00",
  "driverAge": 30,
  "vehicleType": [],
  "fuelType": [],
  "sortBy": "RELEVANCE",
  "maxResults": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "Los Angeles, CA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/turo-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 = { "searchQueries": ["Los Angeles, CA"] }

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/turo-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 '{
  "searchQueries": [
    "Los Angeles, CA"
  ]
}' |
apify call lulzasaur/turo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Turo Car Rental Scraper - Prices, Cars & Hosts",
        "description": "Scrape Turo.com car rental listings by city or airport. Get make, model, year, daily price, rating, trip count, host info, location and images for any trip dates. Filter by vehicle type, fuel and price. Uses residential proxies to handle anti-bot.",
        "version": "1.0",
        "x-build-id": "ypuRNtkUMK0jGj9r9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~turo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-turo-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/lulzasaur~turo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-turo-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/lulzasaur~turo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-turo-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": {
                    "searchQueries": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities, addresses, or airport codes to search for rental cars (e.g. 'Los Angeles, CA', 'Miami, FL', 'SFO')",
                        "default": [
                            "Los Angeles, CA"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Trip Start Date",
                        "type": "string",
                        "description": "Pickup date (YYYY-MM-DD). Defaults to 7 days from now if empty."
                    },
                    "endDate": {
                        "title": "Trip End Date",
                        "type": "string",
                        "description": "Return date (YYYY-MM-DD). Defaults to 3 days after the start date if empty."
                    },
                    "startTime": {
                        "title": "Pickup Time",
                        "type": "string",
                        "description": "Pickup time (HH:mm, 24h)",
                        "default": "10:00"
                    },
                    "endTime": {
                        "title": "Return Time",
                        "type": "string",
                        "description": "Return time (HH:mm, 24h)",
                        "default": "10:00"
                    },
                    "driverAge": {
                        "title": "Driver Age",
                        "minimum": 18,
                        "maximum": 75,
                        "type": "integer",
                        "description": "Driver age used for pricing/eligibility (Turo prices differ for under-25 drivers)",
                        "default": 30
                    },
                    "vehicleType": {
                        "title": "Vehicle Types",
                        "type": "array",
                        "description": "Filter by vehicle type (leave empty for all)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "CAR",
                                "SUV",
                                "MINIVAN",
                                "TRUCK",
                                "VAN",
                                "CARGO_VAN",
                                "BOX_TRUCK"
                            ],
                            "enumTitles": [
                                "Cars",
                                "SUVs",
                                "Minivans",
                                "Trucks",
                                "Vans",
                                "Cargo vans",
                                "Box trucks"
                            ]
                        },
                        "default": []
                    },
                    "fuelType": {
                        "title": "Fuel Types",
                        "type": "array",
                        "description": "Filter by fuel/engine type (leave empty for all)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "GAS",
                                "HYBRID",
                                "ELECTRIC",
                                "DIESEL"
                            ],
                            "enumTitles": [
                                "Gas",
                                "Hybrid",
                                "Electric",
                                "Diesel"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "RELEVANCE",
                            "PRICE_LOW",
                            "PRICE_HIGH",
                            "DISTANCE"
                        ],
                        "type": "string",
                        "description": "Sort order of results",
                        "default": "RELEVANCE"
                    },
                    "maxResults": {
                        "title": "Max Results per Location",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of cars to return per location (0 = all, up to ~200 returned by Turo per search)",
                        "default": 30
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. RESIDENTIAL proxies are REQUIRED — Turo uses DataDome anti-bot which blocks datacenter IPs with HTTP 403.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
