# CarGurus Vehicle Listings Scraper (`automation-lab/cargurus-vehicle-listings-scraper`) Actor

Extract public CarGurus US vehicle listings with VIN, price, IMV, mileage, deal rating, days on market, dealer details, and search context.

- **URL**: https://apify.com/automation-lab/cargurus-vehicle-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## CarGurus Vehicle Listings Scraper

Extract public CarGurus US search inventory into structured vehicle records.
Get VIN, make, model, year, price, CarGurus Instant Market Value (IMV), mileage,
deal rating, days on market, dealer details, colors, features, and search context.

The Actor accepts the search URLs you already use on CarGurus.
It follows result pages, removes duplicate listing IDs, and saves one dataset row per vehicle.
No CarGurus login is required for the supported public search-results scope.

### What this Actor does

1. Validates one or more `cargurus.com` US search URLs.
2. Retrieves the public server-rendered search state.
3. Extracts listing, vehicle, pricing, deal, dealer, and inventory fields.
4. Follows search pagination until the result set ends or `maxItems` is reached.
5. Deduplicates listings across pages and across all supplied URLs.
6. Charges only for records accepted into the default dataset.

This version focuses on fields available in search results.
It does not require a second request to every detail page.
That keeps runs lighter and avoids claiming fields that were not proven for this scope.

### Who is it for

#### Vehicle dealers

Monitor competing inventory, compare advertised prices with CarGurus IMV,
and identify vehicles carrying a strong or weak deal rating.

#### Automotive analysts

Build repeatable samples by ZIP code, make, model, radius, price range,
condition, or other filters encoded in a CarGurus search URL.

#### Valuation and marketplace teams

Track price, mileage, days on market, and price-to-IMV differences
without manually copying search results.

#### Inventory and pricing monitors

Schedule the same search daily or weekly and load the dataset into a warehouse,
spreadsheet, webhook, or change-detection pipeline.

### Why use this Actor

- **Search-URL input:** configure the exact query in CarGurus and paste its URL.
- **Useful automotive fields:** VIN, stock number, IMV, deal score, dealer, and vehicle attributes.
- **Pagination:** collect more than the first search page.
- **Global deduplication:** overlapping searches do not create duplicate listing IDs in one run.
- **Typed output:** every saved row follows the dataset schema.
- **Lightweight route:** the default workflow does not download listing images or render a full browser.
- **Explicit failures:** a blocked or changed page is reported as an error, not silently returned as an empty result.

### Extracted data

| Group | Fields |
| --- | --- |
| Identity | `listingId`, `listingUrl`, `vin`, `stockNumber` |
| Vehicle | `title`, `make`, `model`, `year`, `trim`, `bodyType`, `condition` |
| Price and value | `price`, `totalPrice`, `carGurusImv`, `priceDifference` |
| Market signals | `dealRating`, `dealScore`, `daysOnMarket`, `distanceMiles` |
| Specifications | `mileage`, `fuelType`, `drivetrain`, `transmission`, `engine` |
| Appearance | `exteriorColor`, `interiorColor`, `features`, `imageUrl`, `imageCount` |
| Dealer | `dealerName`, `dealerId`, `dealerPhone`, `dealerCity`, `dealerRegion`, `dealerPostalCode` |
| Search context | `searchUrl`, `searchPage`, `totalSearchResults`, `scrapedAt` |

Fields are nullable because individual sellers and listings do not always provide every attribute.
`price` and IMV values are numeric US-dollar amounts when CarGurus supplies them.
`mileage` and `distanceMiles` use miles for the supported US scope.

### Pricing

The Actor uses pay per event (PPE).
The declared one-time start fee is **$0.005 per run**.
The per-listing fee is tiered by Apify plan:

| Apify plan | Price per saved listing |
| --- | ---: |
| Free | $0.000039446 |
| Bronze | $0.000034301 |
| Silver | $0.000026755 |
| Gold | $0.000020581 |
| Platinum | $0.000013720 |
| Diamond | $0.000010000 |

A duplicate, rejected record, blocked response, or empty search is not charged as an item.
Normal Apify spending limits can cap a run.

#### Cost examples

At Bronze pricing:

- 10 saved listings: about **$0.00534** including the start fee.
- 100 saved listings: about **$0.00843** including the start fee.
- 1,000 saved listings: about **$0.03930** including the start fee.

At Free-plan pricing, 100 saved listings cost about **$0.00894** including the start fee.
Actual charges follow the active pricing displayed by Apify when the run starts.

### Getting started

1. Open CarGurus.com and create a US vehicle search.
2. Apply the location, make, model, price, radius, or condition filters you need.
3. Copy the resulting URL from the browser.
4. Open this Actor's Input tab.
5. Add the URL under **CarGurus search URLs**.
6. Set **Maximum listings** to a small value for the first run.
7. Leave proxy disabled unless you have a specific fallback requirement.
8. Click **Start**.
9. Open the **Vehicle listings** dataset view when the run finishes.
10. Export the results as JSON, CSV, Excel, XML, or another Apify-supported format.

### Input parameters

#### `startUrls`

Required array of one or more public HTTPS CarGurus US search URLs.
Each URL must use `cargurus.com` and a path beginning with `/Cars/`.
The Actor normalizes `cargurus.com` to `www.cargurus.com`.
A pasted `page` cursor is removed so each search starts from page one.
All other search-filter query parameters are preserved.

Example:

```json
{
  "startUrls": [
    {
      "url": "https://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### `maxItems`

Optional integer from 1 to 10,000.
The default is 100.
The limit applies globally across every URL, page, and unique listing in the run.
Pagination stops as soon as this number of rows has been saved.

#### `proxyConfiguration`

Optional Apify proxy configuration.
The Actor uses a public lightweight search-data surface by default.
If configured, the same sticky proxy session is kept for the pages of one search URL
and is also available to the direct CarGurus fallback.
Proxy traffic can add platform cost.

### Output example

The following abbreviated object reflects the current search-result output shape:

```json
{
  "listingId": "450352573",
  "listingUrl": "https://www.cargurus.com/details/450352573",
  "title": "2025 Toyota Camry",
  "vin": "4T1DAACK3SU620978",
  "make": "Toyota",
  "model": "Camry",
  "year": 2025,
  "trim": "SE FWD",
  "bodyType": "Sedan",
  "price": 32292,
  "totalPrice": 32292,
  "carGurusImv": 30837,
  "priceDifference": -1455,
  "mileage": 18329,
  "condition": "CPO",
  "daysOnMarket": 45,
  "dealRating": "FAIR_PRICE",
  "dealScore": 2.6836534,
  "stockNumber": "AB63325",
  "features": ["Adaptive Cruise Control", "Bluetooth", "Backup Camera"],
  "dealerName": "Capital Ford",
  "dealerCity": "Raleigh",
  "dealerRegion": "NC",
  "searchPage": 1,
  "totalSearchResults": 339,
  "scrapedAt": "2026-07-25T00:00:00.000Z"
}
```

Search inventory changes continuously.
The same query may return different IDs, ordering, prices, and totals later.

### Pagination and deduplication

The Actor reads CarGurus's reported page number and page count.
It increments the `page` query parameter and stops at the last page,
an empty listing page, or `maxItems`.

The stable deduplication key is `listingId`.
If two supplied search URLs overlap, the first accepted occurrence is saved
and later occurrences are skipped without an additional item charge.

Sponsored, priority, featured, and standard listing tiles are normalized
into the same output record when they contain a listing ID.
Non-listing UI tiles are ignored.

### Reliability and retry behavior

Temporary network failures, HTTP 429 responses, and temporary server errors
receive bounded retries with exponential backoff and jitter.
Deterministic blocked responses are not retried repeatedly on the same route.

The Actor verifies all of the following before parsing:

- HTTP status is successful.
- The response is HTML.
- CarGurus embedded Remix state is present.
- The state contains a route with search listing tiles.

If those checks fail, the run exits non-zero with a concise diagnostic.
This prevents a challenge page from looking like a valid zero-result search.

### No-result searches

A legitimate search can report zero matching listings.
In that case the run succeeds and the dataset remains empty.
This differs from a blocked or unrecognized page, which fails explicitly.

To verify an empty result, open the same search URL and check its filters.
Overly narrow price, radius, model, or condition filters commonly produce no inventory.

### Workflow examples

#### Daily dealer inventory watch

Schedule a ZIP/make/model URL every morning.
Store each run's dataset ID and compare listing IDs, price, mileage,
and days on market with the prior run.

#### Price-to-IMV analysis

Load `price`, `carGurusImv`, `priceDifference`, `dealRating`, and `dealScore`
into a spreadsheet or warehouse.
Group by year, trim, mileage band, or dealer region.

#### Dealer inventory enrichment

Join `vin` or `stockNumber` with an internal inventory table.
Use `dealerName`, location, and listing URL for review queues.
Do not treat public phone numbers as consent for unsolicited contact.

#### Regional supply comparison

Provide several comparable search URLs for different ZIP-code markets.
Use `searchUrl` as the source dimension and deduplicate overlapping vehicles automatically.

### API: cURL

Start a run and wait for completion:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cargurus-vehicle-listings-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"}],
    "maxItems": 20
  }'
```

For larger runs, use the asynchronous `/runs` endpoint,
then read items from the run's default dataset.
Keep tokens in environment variables rather than source code.

### API: JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
    startUrls: [{
        url: 'https://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152',
    }],
    maxItems: 100,
};

const run = await client.actor('automation-lab/cargurus-vehicle-listings-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use `client.actor(...).start(input)` when your application should not wait synchronously.

### API: Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/cargurus-vehicle-listings-scraper").call(
    run_input={
        "startUrls": [
            {
                "url": "https://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"
            }
        ],
        "maxItems": 100,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### MCP integration

#### Claude Code

Add the Actor to Claude Code through Apify MCP:

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

#### Claude Desktop

Add the following remote server in Claude Desktop's MCP configuration:

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

#### Cursor

Open Cursor Settings → Tools & MCP, add a remote server named `apify`,
and use the same `https://mcp.apify.com?tools=automation-lab/cargurus-vehicle-listings-scraper` URL.

#### VS Code

Add an HTTP MCP server named `apify` in the VS Code MCP settings
with the same Actor-specific URL shown above.

Example prompts for MCP usage:

- “Using MCP, run the CarGurus scraper for this Raleigh Camry search and return 25 listings.”
- “Use the MCP CarGurus tool to compare price with IMV and rank the strongest deals.”
- “Through MCP, group these vehicle listings by dealer and compute median mileage.”

Your MCP client still needs authorization to run paid Apify Actors.

### Integrations and exports

Apify datasets can be exported to JSON, CSV, Excel, XML, RSS, or HTML.
Use schedules for recurring monitoring.
Use webhooks to notify a service when a run succeeds or fails.
Use Make, Zapier, Google Sheets, or your own API client for downstream automation.

For longitudinal monitoring, persist the run date and dataset ID externally.
The Actor's default dataset is run-specific and does not merge historical snapshots.

### Limits and responsible scaling

- V1 supports public CarGurus US search URLs only.
- Canadian and UK domains are not accepted.
- Detail-page-only fields are outside the current contract.
- Search ranking and available inventory can change between requests.
- CarGurus can change its embedded state or anti-bot behavior.
- Very broad searches can have many pages; use `maxItems` and schedules responsibly.
- Optional proxy settings may increase transfer cost.
- The Actor does not download image files; it returns the primary image URL.
- A saved phone number is public source data, not proof of marketing consent.

### Legal and responsible use

You are responsible for ensuring that your collection and use comply with
CarGurus terms, applicable laws, contractual duties, and data-protection rules.
Collect only the fields and volume needed for a legitimate purpose.

Public availability does not remove obligations around personal data,
database rights, automated access, retention, or unsolicited communications.
Do not use output for discrimination, deception, harassment, or prohibited outreach.
When unsure, obtain legal advice for your jurisdiction and workflow.

### Troubleshooting

#### “Only public CarGurus US search URLs are supported”

Confirm the URL begins with `https://www.cargurus.com/Cars/`.
Do not use a vehicle detail URL, Canadian domain, UK domain, shortened URL,
or third-party redirect.

#### The run succeeds with zero rows

Open the same search and check whether its filters currently return inventory.
A price ceiling or narrow radius can validly produce zero listings.

#### The run fails with an embedded-state error

The source returned a blocked, incomplete, or changed page.
Retry later, reduce parallel scheduled runs, or configure an appropriate Apify proxy.
If the error persists, include the run URL and redacted input in a support report.

#### The dataset has fewer rows than the search total

`maxItems` is a hard global cap.
Overlapping pages or URLs are deduplicated by listing ID.
The source total can also change while pagination is in progress.

#### A field is missing on some rows

CarGurus and individual sellers do not provide every field for every listing.
Use null-safe downstream logic and key joins on `listingId` or `vin` when available.

### Related Automation Lab Actors

- [Cars.com Vehicle Listings Scraper](https://apify.com/automation-lab/cars-com-vehicle-listings-scraper) — compare inventory from another US marketplace.
- [AutoTrader UK Car Listings Scraper](https://apify.com/automation-lab/autotrader-uk-car-listings-scraper) — use for UK AutoTrader searches rather than CarGurus US URLs.

These Actors have separate source contracts and pricing.
They are not required by this Actor.

### FAQ

#### Does this Actor require a CarGurus account?

No. The supported V1 workflow uses public US search-result data and does not log in.

#### Can I pass several search URLs?

Yes. Results share one global `maxItems` limit and one listing-ID deduplication set.

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

No. V1 intentionally emits fields proven in search inventory.
This makes the route lighter and keeps the output contract honest.

#### Can I schedule it?

Yes. Scheduling is a core use case for dealer inventory, pricing,
and days-on-market monitoring.

#### Are prices guaranteed to be current?

No. Output reflects the source at extraction time.
Always use `scrapedAt` and re-run searches when freshness matters.

#### Will an empty search incur item charges?

No item event is charged when no listing record is saved.
The one-time start event still applies.

#### How are duplicates handled?

The first occurrence of a listing ID is saved.
Later occurrences in the same run are skipped without another item charge.

#### Can I scrape Canada or the UK?

Not in V1. Use an Actor whose documented source contract covers that domain.

# Actor input Schema

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

One or more public CarGurus.com US search result URLs. Add filters such as ZIP code, make, model, price, or radius on CarGurus, then paste the resulting URLs here.

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

Maximum number of unique vehicle listing records saved across all search URLs.

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

Optional proxy settings. The Actor uses a public structured-data route by default and can use your configured proxy for protected fallback requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing all unique scraped CarGurus listings.

# 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://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cargurus-vehicle-listings-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://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cargurus-vehicle-listings-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://www.cargurus.com/Cars/l-Used-Toyota-Camry-Raleigh-d292_L25152"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/cargurus-vehicle-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CarGurus Vehicle Listings Scraper",
        "description": "Extract public CarGurus US vehicle listings with VIN, price, IMV, mileage, deal rating, days on market, dealer details, and search context.",
        "version": "0.1",
        "x-build-id": "aHLDmW7zwe5sMWHA6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cargurus-vehicle-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cargurus-vehicle-listings-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~cargurus-vehicle-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cargurus-vehicle-listings-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~cargurus-vehicle-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cargurus-vehicle-listings-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": "CarGurus search URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more public CarGurus.com US search result URLs. Add filters such as ZIP code, make, model, price, or radius on CarGurus, then paste the resulting URLs here.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique vehicle listing records saved across all search URLs.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The Actor uses a public structured-data route by default and can use your configured proxy for protected fallback requests.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
