# Turo Vehicle Listings and Price Scraper (`automation-lab/turo-vehicle-listings-price-scraper`) Actor

🚗 Extract public Turo rental cards by US destination and make with vehicle details, daily prices, trip totals, ratings, locations, images, and listing URLs.

- **URL**: https://apify.com/automation-lab/turo-vehicle-listings-price-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Vehicle Listings and Price Scraper

Export public Turo rental cards by destination and make into a clean dataset of vehicles, daily prices, displayed trip totals, ratings, review counts, images, and listing links.

Use the Turo Vehicle Listings and Price Scraper when you need repeatable rental-market data instead of copying cards from destination pages by hand. Give it one or more public US Turo destination/make URLs, choose a result limit, and receive typed JSON, CSV, Excel, XML, or RSS output through Apify.

- 🚗 Compare like-for-like vehicles in a destination.
- 💵 Build daily-price and displayed-trip-total benchmarks.
- ⭐ Track rating, review-count, and new-listing signals.
- 🗺️ Preserve destination and vehicle-location context.
- 🔗 Keep the public source, listing, and image URLs for verification.

The actor works on anonymous public pages and does not require a Turo account, cookies, or user credentials.

### What does the Turo scraper do?

The actor opens public Turo US destination/make pages such as a Tesla rental page for Washington, DC. It finds every visible vehicle card and transforms the card into a flat, analysis-ready record.

A run can process several source pages and stop at a global `maxItems` limit. Duplicate listing URLs are saved only once. If Turo returns a block page or the page has no extractable vehicle cards, the run fails clearly instead of silently returning an empty successful dataset.

This first release intentionally focuses on fields visible on the anonymous landing-page cards. It does not claim account-only data, hidden host identifiers, taxes, detailed fee breakdowns, or booking availability that the source does not expose on this surface.

### Who is it for? Turo data extractor use cases

#### Turo hosts and fleet operators

Compare your vehicles with visible rentals of the same make in nearby destinations. Schedule the actor to refresh a small market sample and watch changes in daily prices or newly listed competitors.

#### Rental-market analysts

Collect consistent observations across destinations, makes, and dates displayed by Turo. Join exports in a warehouse or spreadsheet to calculate medians, ranges, rating distributions, and inventory mix.

#### Travel and automotive data teams

Feed public rental cards into destination dashboards, vehicle research workflows, and price-monitoring products. The source URL and scrape timestamp make every observation traceable.

#### Developers and automation teams

Run the actor by API, webhook, schedule, Zapier, Make, Google Sheets, or Apify MCP. The flat output is easy to validate and does not require parsing website HTML downstream.

### Why use this Turo price scraper?

- **Structured output:** prices and counts are numbers, not presentation strings.
- **Source context:** each row carries the destination, source page, listing URL, and scrape time.
- **Conservative scope:** only independently visible public data is returned.
- **Anti-bot handling:** a proxy-backed browser and resource blocking handle the supported Turo surface efficiently.
- **Fail-closed behavior:** unsupported URLs and complete extraction failures return a non-zero run.
- **Deduplication:** repeated listing URLs across input pages are emitted once per run.
- **Apify integrations:** download results or connect them to your existing workflow without maintaining infrastructure.

### What Turo vehicle data can you extract?

| Field | Type | Description |
|---|---|---|
| `vehicleName` | string | Vehicle title shown on the card, such as `Tesla Model Y` |
| `make` | string | Vehicle make inferred from the page/card context |
| `model` | string | Model portion of the visible vehicle title |
| `year` | integer | Model year shown on the card |
| `rating` | number | Public numeric rating when shown |
| `reviewCount` | integer | Public parenthesized rating/review count when shown |
| `isNewListing` | boolean | Whether the card says `New listing` |
| `dailyPrice` | number | Displayed price per day in USD |
| `tripTotal` | number | Displayed total for the page's trip dates |
| `currency` | string | `USD` for the supported US route |
| `tripStartDate` | date | Start date displayed by the public page |
| `tripEndDate` | date | End date displayed by the public page |
| `imageUrl` | URL | Public vehicle image URL |
| `listingUrl` | URL | Public Turo vehicle listing URL |
| `vehicleLocation` | string | Location shown in the image/card context when available |
| `destination` | string | Destination represented by the source page |
| `sourceUrl` | URL | Exact Turo destination/make page supplied to the actor |
| `scrapedAt` | date-time | UTC extraction timestamp |

Optional rating and review fields are omitted for cards marked as new listings when Turo does not show them.

### Supported Turo URLs

Use public HTTPS pages under this route pattern:

```text
https://turo.com/us/en/car-rental/united-states/{destination-slug}/{make-slug}
````

Working examples include:

```text
https://turo.com/us/en/car-rental/united-states/washington-dc/tesla
https://turo.com/us/en/car-rental/united-states/los-angeles-ca/porsche
https://turo.com/us/en/car-rental/united-states/miami-fl/bmw
```

The actor rejects non-Turo URLs, account pages, vehicle detail pages, and routes outside the public US destination/make scope before launching a browser.

### How to scrape Turo vehicle listings

1. Open the actor's **Input** tab.
2. Add one or more public Turo destination/make URLs.
3. Set **Maximum vehicle listings** to a small first-run limit such as 5.
4. Keep the prefilled US residential proxy configuration.
5. Click **Start** and wait for the run to finish.
6. Open the **Dataset** tab to inspect the vehicle rows.
7. Export the data as JSON, CSV, Excel, XML, or RSS, or connect an integration.

For recurring intelligence, create a schedule only after confirming that your chosen destination pages consistently expose the inventory you expect.

### Input parameters

#### Turo destination and make URLs

`startUrls` is required and accepts 1–20 request-list entries. Each URL must match the supported route. Providing exact URLs makes every recurring run deterministic and auditable.

#### Maximum vehicle listings

`maxItems` is a global cap from 1 to 200. The default is 10 and the prefill is 5. A small cap is ideal for tests; use a larger value when combining multiple pages or collecting the complete visible card set.

#### Proxy configuration

`proxyConfiguration` defaults to Apify Proxy, the `RESIDENTIAL` group, and country `US`. Turo's direct datacenter delivery is protected by Cloudflare, so disabling the working proxy without supplying equivalent custom proxy URLs is rejected.

### Example Turo scraper input

```json
{
  "startUrls": [
    {
      "url": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

To compare two markets in one run, add a second valid source URL. The limit applies across the combined results.

### Example output

```json
{
  "vehicleName": "Tesla Model Y",
  "make": "Tesla",
  "model": "Model Y",
  "year": 2021,
  "rating": 4.94,
  "reviewCount": 71,
  "isNewListing": false,
  "dailyPrice": 48,
  "tripTotal": 338,
  "currency": "USD",
  "tripStartDate": "2026-07-18",
  "tripEndDate": "2026-07-21",
  "imageUrl": "https://images.turo.com/media/vehicle/images/example.jpg",
  "listingUrl": "https://turo.com/us/en/suv-rental/united-states/fairfax-va/tesla/model-y/2372140",
  "vehicleLocation": "Fairfax, VA",
  "destination": "Washington, DC",
  "sourceUrl": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla",
  "scrapedAt": "2026-07-16T07:20:44.834Z"
}
```

Values change with live source inventory, page dates, location, and Turo pricing.

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

The actor uses pay-per-event pricing: **$0.005 per run** plus a tiered charge for each vehicle row saved. Higher Apify subscription tiers receive lower per-result rates.

| Apify tier | Price per vehicle | 10 vehicles plus start |
|---|---:|---:|
| Free | $0.009656 | about $0.1016 |
| Bronze | $0.0083965 | about $0.0890 |
| Silver | $0.0065493 | about $0.0705 |
| Gold | $0.0050379 | about $0.0554 |
| Platinum | $0.0033586 | about $0.0386 |
| Diamond | $0.002351 | about $0.0285 |

A representative nine-card public page completed in about 33 seconds. Use `maxItems: 5` for a low-cost first run. Because Turo requires a browser and residential traffic, the actor blocks non-essential images, media, fonts, and analytics to reduce bandwidth and compute.

The actor's **Pricing** tab is authoritative. You can also set a maximum total run charge in Apify to enforce your own budget ceiling.

### Turo price monitoring workflow

A useful recurring workflow is:

1. Create one input per destination/make market.
2. Keep the same URLs and result limit between runs.
3. Schedule daily or weekly execution.
4. Export each dataset to a table keyed by `listingUrl` and `scrapedAt`.
5. Compare `dailyPrice`, `tripTotal`, `rating`, and `isNewListing` over time.
6. Alert only on changes meaningful to your pricing or fleet decisions.

Remember that the public page's displayed trip dates can move over time. Store `tripStartDate` and `tripEndDate` with every observation before comparing totals.

### Data quality and validation

The actor validates the host and route before opening Turo. During extraction it requires a vehicle title, year, daily price, trip total, image URL, and listing URL before emitting a row. Optional fields are included only when independently visible.

Results are deduplicated by `listingUrl`. Prices remove currency symbols and thousands separators and are stored as numbers. Dates are normalized to `YYYY-MM-DD`; `scrapedAt` is UTC ISO 8601.

For audit-sensitive work, retain `sourceUrl`, `listingUrl`, and `scrapedAt` and periodically compare a sample with the public source.

### Tips for reliable Turo extraction

- 🎯 Use exact destination/make landing URLs rather than broad Turo pages.
- 🧪 Start with 5 results and inspect the dataset before scaling.
- 🇺🇸 Keep a US proxy country because V1 supports the US route.
- 🔁 Schedule conservatively; public inventory and prices can change naturally.
- 🧩 Split unrelated markets into separate actor tasks for clearer monitoring.
- 📅 Compare `tripTotal` only when the displayed start and end dates are equivalent.
- 🔗 Treat `listingUrl` as the durable row key rather than the card position.

### Integrations

#### Google Sheets price benchmark

Use the Google Sheets integration to append each run. Build a pivot table by `destination`, `make`, and `scrapedAt`, then calculate median daily price and listing counts.

#### Webhook inventory alert

Attach a succeeded-run webhook. Fetch the dataset, compare listing URLs with the prior snapshot, and notify Slack when `isNewListing` is true or a tracked price crosses your threshold.

#### Warehouse market panel

Send JSON rows to BigQuery, Snowflake, PostgreSQL, or another warehouse. Partition by scrape date and preserve the page trip-date fields to avoid mixing unlike totals.

#### Make or Zapier workflow

Trigger runs from a schedule or spreadsheet row, wait for completion, and pass normalized records into a dashboard, CRM note, or internal travel tool.

### API usage: run the Turo scraper programmatically

Replace `APIFY_TOKEN` with your token. The actor ID is `automation-lab/turo-vehicle-listings-price-scraper`.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/turo-vehicle-listings-price-scraper').call({
  startUrls: [{ url: 'https://turo.com/us/en/car-rental/united-states/washington-dc/tesla' }],
  maxItems: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/turo-vehicle-listings-price-scraper').call(run_input={
    'startUrls': [{'url': 'https://turo.com/us/en/car-rental/united-states/washington-dc/tesla'}],
    'maxItems': 5,
})
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~turo-vehicle-listings-price-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://turo.com/us/en/car-rental/united-states/washington-dc/tesla"}],"maxItems":5}'
```

### Use the Turo scraper with MCP and AI agents

Apify MCP lets Claude Code, Claude Desktop, Cursor, and VS Code run the actor as a tool.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/turo-vehicle-listings-price-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/turo-vehicle-listings-price-scraper"
    }
  }
}
```

Example prompts:

- “Run the Turo vehicle scraper for this Washington Tesla URL with a limit of five and summarize the daily-price range.”
- “Compare Porsche rental cards from my Los Angeles and Miami source URLs.”
- “Export the current dataset and flag new listings with ratings missing.”

### Scheduling and automation

Open **Schedules** in Apify Console, choose the actor or a saved task, and select a cadence. Weekly runs are a sensible starting point for market benchmarking. Daily runs may suit active fleet-pricing workflows.

Keep the input stable when comparing history. If you change destination pages, makes, or result limits, record that change alongside your analysis so inventory shifts are not mistaken for source changes.

### Limitations

- V1 supports public US destination/make landing pages only.
- It extracts the finite set of cards exposed by that landing page; it does not claim exhaustive Turo search inventory.
- Displayed totals depend on the dates selected by the public page.
- Host IDs, All-Star Host status, coordinates, detailed fees, and true booking availability are not exposed by this V1 surface.
- Turo can change HTML, anti-bot rules, inventory, prices, or regional availability without notice.
- Residential proxy access is required for reliable execution and may be subject to your Apify plan.
- An unsupported, blocked, or zero-card page fails rather than returning a misleading empty success.

### Is it legal to scrape public Turo data?

This actor accesses anonymous public pages. Web scraping legality depends on jurisdiction, purpose, contract terms, and the data you collect. You are responsible for complying with Turo's terms, applicable laws, robots guidance, privacy obligations, database rights, and rate limits.

Do not use the actor to collect private account data, evade access controls, identify individuals unlawfully, or make automated decisions that violate consumer or privacy law. Minimize collection, secure exports, and keep only what your legitimate use case needs.

This information is general guidance, not legal advice.

### Troubleshooting

#### Why did the run reject my URL?

The URL must be HTTPS on `turo.com` and match `/us/en/car-rental/united-states/{destination}/{make}`. Vehicle-detail, account, international, and generic home-page URLs are intentionally outside scope.

#### Why did the run fail with an anti-bot or no-cards message?

Keep the prefilled US residential proxy configuration and retry once later. Confirm that the page opens publicly and contains vehicle cards. Persistent zero-card extraction is treated as a real failure so monitors do not ingest false empty snapshots.

#### Why is a rating missing?

Turo may label a card as a new listing and show no rating or review count. In that case, `isNewListing` is true and optional rating fields are omitted.

#### Why did prices change between runs?

Turo inventory and pricing are live, and the destination page's displayed trip dates move. Compare rows with matching `tripStartDate` and `tripEndDate` before treating a difference as a market-price change.

### FAQ: frequently asked questions

#### Does this actor require a Turo login?

No. It targets anonymous public destination/make pages and never asks for account credentials.

#### Can I scrape several makes or destinations?

Yes. Add up to 20 supported URLs. `maxItems` is shared across all source pages in the run.

#### Does it visit every vehicle detail page?

No. It extracts the public landing-page cards. This keeps the product conservative and avoids claiming fields absent from the source surface.

#### Can I export to CSV or Excel?

Yes. Open the dataset and choose JSON, CSV, Excel, XML, or RSS. You can also retrieve items through the dataset API.

#### Is this actor affiliated with Turo?

No. It is an independent data-extraction tool and is not endorsed by or affiliated with Turo.

### Related vehicle data scrapers

- [Autotrader Canada Vehicle Listings Scraper](https://apify.com/automation-lab/autotrader-canada-vehicle-listings-scraper) — research used-vehicle marketplace inventory and prices.
- [BOVAG Vehicle Listings Scraper](https://apify.com/automation-lab/bovag-vehicle-listings-scraper) — collect Dutch dealer vehicle listings.
- [NHTSA Vehicle Complaints Scraper](https://apify.com/automation-lab/nhtsa-vehicle-complaints-scraper) — enrich vehicle research with public safety complaints.

Use these actors for automotive-market or safety datasets. Use this actor specifically for public Turo rental-card price benchmarking.

### Support

If a supported page fails, open an issue from the actor's Apify Store page. Include the run URL, the exact public Turo source URL, expected card count, and whether the page opened in a normal anonymous browser. Do not include account credentials or private personal information.

# Actor input Schema

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

Add public US Turo destination/make pages, for example a Tesla rental page for Washington, DC. Only turo.com/us/en/car-rental/united-states/... URLs are accepted.

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

Stop after saving this many unique Turo vehicle cards across all source pages. Keep the first run small.

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

Use a US residential proxy for reliable Turo access. The working prefill is already configured.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla"
        }
    ],
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/turo-vehicle-listings-price-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 = {
    "startUrls": [{ "url": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla" }],
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/turo-vehicle-listings-price-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 '{
  "startUrls": [
    {
      "url": "https://turo.com/us/en/car-rental/united-states/washington-dc/tesla"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call automation-lab/turo-vehicle-listings-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Turo Vehicle Listings and Price Scraper",
        "description": "🚗 Extract public Turo rental cards by US destination and make with vehicle details, daily prices, trip totals, ratings, locations, images, and listing URLs.",
        "version": "0.1",
        "x-build-id": "gT2YsGmDC1YOduB4l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~turo-vehicle-listings-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-turo-vehicle-listings-price-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/automation-lab~turo-vehicle-listings-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-turo-vehicle-listings-price-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/automation-lab~turo-vehicle-listings-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-turo-vehicle-listings-price-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Turo destination and make URLs",
                        "type": "array",
                        "description": "Add public US Turo destination/make pages, for example a Tesla rental page for Washington, DC. Only turo.com/us/en/car-rental/united-states/... URLs are accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum vehicle listings",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Stop after saving this many unique Turo vehicle cards across all source pages. Keep the first run small.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use a US residential proxy for reliable Turo access. The working prefill is already configured.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
