# Turo Scraper - Car Rentals, Prices & Hosts (`parsebird/turo-scraper`) Actor

Scrape Turo car rental listings by city, airport or vehicle URL. Get daily prices, dated trip totals, ratings, trips, specs, features, photos, location and public host profiles. Filter by make, year and rating, monitor markets with incremental runs, export JSON, CSV, Excel.

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

## Pricing

from $0.99 / 1,000 vehicles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Turo Scraper - Car Rentals, Prices & Hosts

Turo Scraper extracts car rental listings from [Turo.com](https://turo.com) by city, airport or vehicle URL, with daily prices, dated trip quotes, ratings, trips, specs, photos and public host profiles.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search any Turo city or airport for your exact trip dates, filter by make, model year and rating, and get the real trip total Turo quotes for each vehicle plus 40+ fields of specs and host data, ready for pricing analysis or market monitoring.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```text
Turo Scraper (Apify actor parsebird/turo-scraper) scrapes Turo.com car rental listings. Call it with the Apify API client: client.actor("parsebird/turo-scraper").call(run_input={"mode": "search", "locations": ["Miami, Florida"], "makes": ["Tesla"], "startDateTime": "2026-11-10T10:00", "endDateTime": "2026-11-13T10:00", "maxItems": 20, "fetchDetails": true}). Inputs: mode (string, "search" or "url", default "search"); locations (array of city/airport/address strings, search mode); makes (array, filtered by Turo); minYear, maxYear (integer); minRating (number 0-5, excludes unrated); urls (array of Turo vehicle listing links or numeric IDs, url mode); startDateTime, endDateTime (local "YYYY-MM-DDTHH:MM", both or neither; default is a 3-day trip starting in 7 days); fetchDetails (boolean, default true, adds specs, features, description and public host profile); maxItems (integer, default 20, 0 = no limit, Turo returns up to about 200 vehicles per location); incrementalMode (boolean), stateKey (string), emitUnchanged (boolean), emitExpired (boolean) for monitoring; resumeFromRunId (string); proxy (object, default Apify Residential US). Output: one row per vehicle with id, url, title, make, model, year, trim, vehicleType, rating, numberOfReviews, completedTrips, hostId, isAllStarHost, city, state, country, latitude, longitude, location, thumbnailUrl, images, averageDailyPrice {amount, currency}, tripTotal, currency, quotedDailyPrice, quote, quoteStatus, startDateTime, endDateTime, detailStatus, hostStatus, coverage, scopeId, scrapedAt; with fetchDetails also features, dailyMileageLimit, weekly/monthly discounts, description, basicCarDetails, owner, host, searchVehicle, detail; in incremental mode also changeType, changedFields, firstSeenAt, lastSeenAt. API docs: https://apify.com/parsebird/turo-scraper/api. Get a token: https://console.apify.com/settings/integrations
```

### What is Turo Scraper?

**Turo Scraper** is an unofficial **Turo API alternative** that pulls public vehicle listings from [Turo](https://turo.com), the peer-to-peer car sharing marketplace. Give it a city, airport or address plus your trip dates, and it returns every vehicle Turo shows for that search with its **average daily price, the dated trip total Turo quotes, rating, completed trips, location, photos and host**. With details turned on, each vehicle also gets its **full specifications, features, mileage limits, discounts and the host's public profile**.

The easiest way to try it: keep the example location, click **Start**, and download your Turo data as JSON, CSV or Excel a minute later.

### What can Turo Scraper do?

- 🔎 **Search by location**: cities, airports, neighborhoods or addresses, several at once, with duplicates across overlapping searches removed.
- 🔗 **Scrape vehicle URLs**: paste Turo listing links (or bare vehicle IDs) to track specific cars.
- 📅 **Dated trip quotes**: get the trip total and discounted daily price Turo quotes for *your* dates, not only the headline daily rate.
- 🚗 **Filters**: make (applied by Turo itself), minimum and maximum model year, minimum guest rating.
- 👤 **Host enrichment**: public host bio, member-since date, verifications, ratings and number of trips.
- 📈 **Market monitoring**: Incremental mode remembers a baseline and returns only new, updated, reappeared or expired vehicles on each scheduled run.
- ⏯️ **Resume**: continue an interrupted run without paying for the same vehicles twice.
- 🌎 **US and Canada tested**: prices come back in the market's own currency (USD, CAD).

Because it runs on the Apify platform, you also get [scheduling](https://docs.apify.com/platform/schedules), a full [REST API](https://docs.apify.com/api/v2), [integrations](https://apify.com/integrations) with Google Sheets, Zapier, Make, Slack and webhooks, and exports to JSON, CSV, Excel, XML and HTML.

### What data can you extract from Turo?

| Field | Description |
|-------|-------------|
| `id`, `url` | Turo vehicle ID and public listing link |
| `title`, `make`, `model`, `year`, `trim` | Vehicle identity, e.g. "2020 Tesla Model 3" |
| `vehicleType` | `CAR`, `SUV`, `PASSENGER_MINIVAN`, `VAN`, ... |
| `rating`, `numberOfReviews`, `completedTrips` | Guest rating, review count and completed trips |
| `averageDailyPrice` | Average daily price from the search card, with currency |
| `tripTotal`, `quotedDailyPrice`, `currency` | Dated quote for your trip window, before taxes and checkout add-ons |
| `quote` | Full quote: line items, discounts, items not included (protection plan) |
| `city`, `state`, `country`, `latitude`, `longitude`, `location` | Pickup area; Turo marks the precision (e.g. `APPROXIMATE`) |
| `thumbnailUrl`, `images` | JPG thumbnail and every listing photo |
| `hostId`, `isAllStarHost`, `owner`, `host` | Host ID, All-Star status, public owner block and host profile |
| `features`, `basicCarDetails` | Features (Bluetooth, backup camera, ...) and specs (seats, doors, fuel, range, transmission) |
| `dailyMileageLimit`, `weeklyDiscountPercentage`, `monthlyDiscountPercentage` | Mileage allowance and long-trip discounts |
| `coverage` | How the search went: returned count, Turo's total, whether the scan was complete |
| `changeType`, `changedFields`, `firstSeenAt`, `lastSeenAt` | Incremental mode only |

### How to scrape Turo

1. Open [Turo Scraper](https://apify.com/parsebird/turo-scraper) and click **Try for free** to open it in Apify Console.
2. Choose **Search by location** and add one or more locations, e.g. `Los Angeles, California` or `LAX airport`.
3. Optionally add **Makes** (e.g. `Tesla`), **Min year**, **Max year** and **Min rating**.
4. Set **Trip start** and **Trip end** as `2026-11-10T10:00`, or leave both empty for a 3-day trip starting in 7 days.
5. Keep **Scrape full details and host profile** on for specs and host data, or turn it off for a cheaper, faster price scan.
6. Set **Max vehicles** and click **Start**.
7. Download the dataset as JSON, CSV or Excel, or read it through the [API](https://apify.com/parsebird/turo-scraper/api).

To track specific cars instead, choose **Vehicle URLs** and paste listing links such as `https://turo.com/us/en/car-rental/united-states/gardena-ca/tesla/model-3/3802323`.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | No | `search` | `search` (locations and trip dates) or `url` (vehicle listing links) |
| `locations` | array | In search mode | — | Cities, airports or addresses (prefill: `Los Angeles, California`) |
| `makes` | array | No | — | Vehicle makes, filtered by Turo, e.g. `Tesla` |
| `minYear` / `maxYear` | integer | No | — | Model year range, applied before the output limit |
| `minRating` | number | No | — | Minimum guest rating; excludes unrated vehicles |
| `urls` | array | In URL mode | — | Turo vehicle listing links ending in the numeric ID, or bare IDs |
| `startDateTime` / `endDateTime` | string | No | 7 days out, 3 days | Local trip window `YYYY-MM-DDTHH:MM`; set both or neither |
| `fetchDetails` | boolean | No | `true` | Adds specs, features, description and the public host profile |
| `maxItems` | integer | No | `20` | Maximum vehicles; `0` = no limit (Turo still caps each location at about 200) |
| `resumeFromRunId` | string | No | — | Skip vehicles an interrupted run with the same input already saved; they count toward `maxItems` |
| `incrementalMode` | boolean | No | `false` | Output only new and changed vehicles compared with the last run |
| `stateKey` | string | No | derived | Name of the saved baseline; use one per monitored search |
| `emitUnchanged` | boolean | No | `false` | Also output (and bill) unchanged vehicles in Incremental mode |
| `emitExpired` | boolean | No | `false` | Also output (and bill) vehicles no longer listed, after a complete scan |
| `proxy` | object | No | Residential US | Turo blocks datacenter IPs; the default works out of the box |

**Example: filtered search with fixed dates**

```json
{
  "mode": "search",
  "locations": ["Chicago, Illinois"],
  "makes": ["Tesla"],
  "minYear": 2020,
  "minRating": 4.5,
  "startDateTime": "2026-11-10T10:00",
  "endDateTime": "2026-11-13T10:00",
  "maxItems": 15
}
```

**Example: weekly monitoring of one market**

```json
{
  "mode": "search",
  "locations": ["Miami, Florida"],
  "makes": ["Porsche"],
  "maxItems": 0,
  "fetchDetails": false,
  "incrementalMode": true,
  "stateKey": "miami-porsche",
  "emitExpired": true
}
```

### Output example

Each vehicle is one row. This is a real row from a Los Angeles run; `images`, `quote`, `basicCarDetails` and `host` are shortened, and the raw `owner`, `searchVehicle` and `detail` objects are left out.

```json
{
  "id": "3093988",
  "url": "https://turo.com/us/en/car-rental/united-states/los-angeles-ca/tesla/model-3/3093988",
  "title": "2025 Tesla Model 3",
  "make": "Tesla",
  "model": "Model 3",
  "year": 2025,
  "trim": "Long Range",
  "vehicleType": "CAR",
  "rating": 4.9655,
  "numberOfReviews": 87,
  "completedTrips": 95,
  "hostId": 24656711,
  "isAllStarHost": true,
  "isNewListing": false,
  "badges": [],
  "city": "Los Angeles",
  "state": "CA",
  "country": "US",
  "latitude": 34.06051750775368,
  "longitude": -118.24597729419747,
  "location": {
    "city": "Los Angeles",
    "state": "CA",
    "country": "US",
    "latitude": 34.06051750775368,
    "longitude": -118.24597729419747,
    "precision": {
      "accuracy": 0.09320565,
      "level": "APPROXIMATE"
    },
    "timeZone": "America/Los_Angeles",
    "distanceFromSearch": {
      "value": 0.43,
      "unit": "MILES"
    }
  },
  "thumbnailUrl": "https://images.turo.com/media/vehicle/images/EaNS_BC0To63jarvo2GzzQ.620x372.jpg",
  "images": [
    "https://images.turo.com/media/vehicle/images/EaNS_BC0To63jarvo2GzzQ.jpg",
    "https://images.turo.com/media/vehicle/images/X4_nk9hGTbep4mywRcwqjQ.jpg"
  ],
  "averageDailyPrice": {
    "amount": 75.06,
    "currency": "USD"
  },
  "tripTotal": 450.36,
  "tripTotalBeforeDiscount": 478.16,
  "currency": "USD",
  "quotedDailyPrice": 150.12,
  "quote": {
    "totalTripPrice": {
      "amount": 450.36,
      "currencyCode": "USD"
    },
    "vehicleDailyPriceAfterDiscount": {
      "amount": 150.12,
      "currencyCode": "USD"
    },
    "nonIncludedLineItems": [
      {
        "type": "PROTECTION",
        "title": "Protection plan"
      }
    ]
  },
  "quoteStatus": "complete",
  "startDateTime": "2026-10-11T10:00",
  "endDateTime": "2026-10-14T10:00",
  "detailStatus": "complete",
  "hostStatus": "complete",
  "numberOfFavorites": 593,
  "features": [
    "AUX input",
    "Backup camera",
    "Bike rack",
    "Blind spot warning",
    "Bluetooth",
    "GPS",
    "Heated seats",
    "Keyless entry",
    "Pet friendly",
    "Sunroof",
    "Toll pass",
    "USB charger",
    "USB input"
  ],
  "dailyMileageLimit": {
    "scalar": 250,
    "unit": "MI",
    "unlimited": false
  },
  "weeklyDiscountPercentage": 23,
  "monthlyDiscountPercentage": 50,
  "listingCreatedAt": "2025-03-21T05:02:09+00:00",
  "description": null,
  "basicCarDetails": {
    "numberOfSeats": 5,
    "numberOfDoors": 4,
    "fuelTypeAndGradeLabel": "Electric",
    "transmissionLabel": "Automatic"
  },
  "host": {
    "memberSince": {
      "month": 4,
      "year": 2022
    },
    "ratingsFromRenters": {
      "overall": 4.9,
      "overallRatingToHundredth": 4.94
    },
    "numberOfRentalsFromRenters": 484,
    "verifications": [
      "Phone number verified",
      "Email verified",
      "Approved to drive",
      "Reviewed",
      "Listed a car"
    ]
  },
  "coverage": {
    "query": "Los Angeles, California",
    "resolvedLocation": "Los Angeles, CA, USA",
    "returned": 200,
    "totalHits": 5369,
    "matchedFilters": 200,
    "complete": false,
    "reason": "max_items"
  },
  "scopeId": "ccf116587f21d91079434a8d",
  "scrapedAt": "2026-10-04T10:03:38+00:00"
}
```

`averageDailyPrice` is the search-card rate Turo shows before dates are applied. `tripTotal` and `quotedDailyPrice` are the dated quote for your trip window, before taxes, fees and the protection plan chosen at checkout. `detailStatus` and `hostStatus` are `complete`, `not_requested` or `unavailable`. `coverage.reason` is `source_end` (Turo returned everything), `source_cap` (Turo stopped at its per-location cap) or `max_items` (your limit was reached).

You can download the dataset in JSON, CSV, Excel, XML or HTML from the **Storage** tab.

### How to use the Turo Scraper API

**Python** ([apify-client](https://docs.apify.com/api/client/python)):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("parsebird/turo-scraper").call(run_input={
    "mode": "search",
    "locations": ["Los Angeles, California"],
    "startDateTime": "2026-11-10T10:00",
    "endDateTime": "2026-11-13T10:00",
    "maxItems": 50,
})
for car in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(car["title"], car["tripTotal"], car["currency"], car["url"])
```

**JavaScript** ([apify-client](https://docs.apify.com/api/client/js)):

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('parsebird/turo-scraper').call({
    mode: 'url',
    urls: ['https://turo.com/us/en/car-rental/united-states/gardena-ca/tesla/model-3/3802323'],
    fetchDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].title, items[0].quotedDailyPrice, items[0].host?.memberSince);
```

### Use cases

- **Turo hosts**: benchmark your daily rate and trip totals against similar cars in your city before you set prices.
- **Fleet investors**: find which makes, model years and vehicle types earn the most trips and best ratings in a market.
- **Rental companies and analysts**: track Turo supply and pricing by city, airport and season.
- **Travel and mobility apps**: show peer-to-peer rental options and real dated prices next to other options.
- **Market monitoring**: schedule daily or weekly runs in Incremental mode to catch new listings, price changes and cars leaving the platform.

### How it works

1. Each location is matched to Turo's own place lookup, the same one the Turo search box uses.
2. Turo's search returns the vehicles available for your dates near that place (up to about 200 per location), filtered by make on Turo's side.
3. Year and rating filters are applied, duplicates across locations are dropped, and the output limit is applied.
4. Trip quotes for your dates are requested in batches of 20 vehicles.
5. With details on, each vehicle's public listing data and its host's public profile are added (one profile request per host, reused across that host's cars).
6. Rows are saved and billed as they are ready, so a stopped run keeps what it already scraped.

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

Turo Scraper uses pay-per-event pricing. You pay for vehicles returned, plus a small enrichment fee for each vehicle whose public host profile was fetched.

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| Vehicle returned (`vehicle-scraped`) | $1.49 / 1,000 | $1.29 / 1,000 | $1.09 / 1,000 | **$0.99 / 1,000** |
| Host profile enrichment (`host-profile-enriched`) | $0.99 / 1,000 | $0.89 / 1,000 | $0.79 / 1,000 | **$0.69 / 1,000** |

For example, 100 vehicles with full details and host profiles cost about $0.25 on the Free plan; 100 vehicles with details turned off cost about $0.15. Vehicles whose host profile could not be fetched are not charged the enrichment fee, and in Incremental mode unchanged vehicles are not charged unless you turn on **Also return unchanged vehicles**. Apify's free plan includes monthly platform credit you can use to try the actor. Set a maximum cost per run in the run options to cap spending.

### FAQ

**Why did I get about 200 vehicles when Turo says there are thousands?**
Turo's search returns at most about 200 vehicles per location, even when `totalHits` is much higher. The `coverage` object on each row shows `returned` and `totalHits`. For wider coverage, add nearby cities, neighborhoods and airports, or split the search with the **Makes** filter.

**Why did I get fewer vehicles than Max vehicles?**
Year and rating filters run on the vehicles Turo returned, so a narrow filter can leave fewer matches. Turo also only returns vehicles available for your trip dates.

**What is the difference between `averageDailyPrice` and `quotedDailyPrice`?**
`averageDailyPrice` is the rate on Turo's search card. `quotedDailyPrice` and `tripTotal` come from the quote Turo calculates for your exact trip window, including trip-length discounts, before taxes, fees and the protection plan.

**What date format should I use?**
Local time at the pickup location as `YYYY-MM-DDTHH:MM`, e.g. `2026-11-10T10:00`. Set both start and end, or leave both empty for a 3-day trip starting 7 days from the run date.

**Why is `description` empty?**
`description` holds the host's listing text only when Turo's public listing data includes it, and for many vehicles it is empty. Turo Scraper never fills it with made-up text.

**How does Incremental mode work?**
The first run saves a baseline of vehicles under your **Monitor name**. Later runs with the same name output only `NEW`, `UPDATED` (with `changedFields`), `REAPPEARED` and, with **Also return vehicles no longer listed**, `EXPIRED` vehicles. Expired rows are only produced after a complete scan, so for big cities add a make filter or a smaller area to stay under Turo's per-location cap. Keep fixed trip dates for the cleanest price comparisons.

**My run stopped early. Can I continue it?**
Yes. Start a new run with the same input and paste the old run's ID into **Resume run ID**. Vehicles already saved by that run are skipped, are not billed again, and count toward **Max vehicles**, so the two runs together return up to your limit.

**Which countries work?**
Turo Scraper was tested with cities in the United States and Canada. Prices are returned in the market currency, shown in the `currency` field.

**Can I use Turo Scraper through an API or with AI agents?**
Yes. Use the [API tab](https://apify.com/parsebird/turo-scraper/api), the Python or JavaScript client above, or connect it to AI agents through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

**Something is not working. What should I do?**
Open an issue on the [Issues tab](https://apify.com/parsebird/turo-scraper/issues) with your run ID. We read every report.

### Is it legal to scrape Turo?

Turo Scraper collects only data that Turo shows publicly to any visitor without logging in, such as listing details, prices and public host profiles. It does not access private accounts, bookings or messages. Host profiles can include personal data such as first names and photos, which may be protected by laws like the GDPR or CCPA, so only collect what you need and make sure you have a legitimate reason to process it. Review [Turo's terms](https://turo.com/us/en/policies/terms) and consult a lawyer if you are unsure. For background, read Apify's guide [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other travel and rental scrapers

| Actor | What it does |
|-------|--------------|
| [Kayak Car Rental Scraper](https://apify.com/parsebird/kayak-car-rental-scraper) | Rental car offers and prices from Kayak |
| [Airbnb Scraper & API](https://apify.com/parsebird/airbnb-scraper) | Airbnb listings, prices, hosts and availability |
| [Airbnb Reviews Scraper](https://apify.com/parsebird/airbnb-reviews-scraper) | Guest reviews for Airbnb listings |
| [Expedia Reviews Scraper](https://apify.com/parsebird/expedia-reviews-scraper) | Hotel reviews from Expedia |
| [Ryanair Flight Scraper](https://apify.com/parsebird/ryanair-flight-scraper) | Ryanair fares and daily flight schedules |

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/turo-scraper/changelog.md

# Actor input Schema

## `mode` (type: `string`):

<b>Search</b>: find vehicles around one or more locations. <b>Vehicle URLs</b>: scrape specific Turo vehicle listings.

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

Add cities, airports or addresses, e.g. <code>Los Angeles, California</code>, <code>Miami, FL</code>, <code>LAX airport</code>. Turo returns up to about 200 vehicles per location, so add nearby cities or airports for wider coverage. Used in <b>Search</b> mode.

## `makes` (type: `array`):

Only search these vehicle makes, e.g. <code>Tesla</code>, <code>BMW</code>, <code>Mercedes-Benz</code>. Turo applies this filter on its side. Leave empty for all makes. Used in <b>Search</b> mode.

## `minYear` (type: `integer`):

Only return vehicles of this model year or newer. Applied to the search results before the output limit. Used in <b>Search</b> mode.

## `maxYear` (type: `integer`):

Only return vehicles of this model year or older. Applied to the search results before the output limit. Used in <b>Search</b> mode.

## `minRating` (type: `number`):

Only return vehicles with at least this guest rating (0 to 5), e.g. <code>4.5</code>. Unrated vehicles are excluded when set. Used in <b>Search</b> mode.

## `urls` (type: `array`):

Add Turo vehicle listing links ending in the numeric vehicle ID, e.g. <code>https://turo.com/us/en/car-rental/united-states/gardena-ca/tesla/model-3/3802323</code>. A bare vehicle ID also works. Search pages and host profiles are not supported. Used in <b>Vehicle URLs</b> mode.

## `startDateTime` (type: `string`):

Local trip start as <code>YYYY-MM-DDTHH:MM</code>, e.g. <code>2026-11-10T10:00</code>. Leave both trip fields empty for a 3-day trip starting 7 days from today.

## `endDateTime` (type: `string`):

Local trip end as <code>YYYY-MM-DDTHH:MM</code>, after the trip start, e.g. <code>2026-11-13T10:00</code>. Set it together with the trip start.

## `fetchDetails` (type: `boolean`):

Add the listing description, specifications, features, protection, mileage limits and the public host profile (bio, verifications, ratings) to each vehicle. Adds one <b>host-profile</b> event per vehicle whose host profile was fetched.

## `maxItems` (type: `integer`):

Maximum vehicles to return in total. Set <code>0</code> for no limit (Turo's own cap of about 200 vehicles per location still applies).

## `resumeFromRunId` (type: `string`):

Paste the ID of an interrupted run (timed out, aborted or out of budget) to skip the vehicles it already saved. They count toward <b>Max vehicles</b>. Use exactly the same locations, makes, filters, trip dates or URLs as that run.

## `incrementalMode` (type: `boolean`):

Remember what earlier runs returned and output only vehicles that are new, changed (price, rating, trips and more) or back on Turo. Use it with scheduled runs to monitor a market. Rows carry <code>changeType</code>, <code>changedFields</code>, <code>firstSeenAt</code> and <code>lastSeenAt</code>.

## `stateKey` (type: `string`):

Name for the saved baseline, e.g. <code>miami-weekly</code>. Use a different name for each search you monitor. Leave empty to derive one from the locations, makes, filters and trip dates.

## `emitUnchanged` (type: `boolean`):

In monitoring mode, also output (and bill) vehicles that did not change since the last run.

## `emitExpired` (type: `boolean`):

In monitoring mode, also output (and bill) vehicles from the baseline that were not found this time. Only emitted after a complete scan with no output limit cut-off.

## `proxy` (type: `object`):

Turo blocks datacenter IPs. The default Apify Residential proxy works out of the box.

## Actor input object example

```json
{
  "mode": "search",
  "locations": [
    "Los Angeles, California"
  ],
  "fetchDetails": true,
  "maxItems": 20,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "mode": "search",
    "locations": [
        "Los Angeles, California"
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "mode": "search",
    "locations": ["Los Angeles, California"],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/turo-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "locations": [
    "Los Angeles, California"
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parsebird/turo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/turo-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IF1ulvpk6WuJS7vnH/builds/CuwndqhjeTyUruvAa/openapi.json
