# Coches.net Vehicle Listings Scraper (`automation-lab/coches-net-vehicle-listings-scraper`) Actor

Extract public Coches.net used-car listings with prices, mileage, specifications, images, financing, warranty, location, and seller/dealer context.

- **URL**: https://apify.com/automation-lab/coches-net-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

## Coches.net Vehicle Listings Scraper

Extract public Spanish used-car inventory from Coches.net into clean JSON.

Get vehicle IDs, URLs, cash and finance prices, year, mileage, fuel, power, location, seller context, warranty signals, and images from search pages.

Optionally visit each advertisement for model, body type, color, transmission, doors, seats, engine displacement, description, and full-size images.

### What this Actor does

Coches.net Vehicle Listings Scraper accepts public Coches.net search-result URLs and vehicle-detail URLs.

For a search URL, it:

1. requests the public page with browser-like headers;
2. reads the structured listing state embedded by Coches.net;
3. normalizes every vehicle into one dataset record;
4. follows consecutive `pg` pages within your limit;
5. deduplicates advertisements by stable Coches.net ad ID;
6. optionally enriches every result from its detail page.

For a vehicle URL, it returns one enriched record from the page's structured vehicle data.

No Coches.net account, login, or private API token is required.

### Who should use it

#### Vehicle dealers

Monitor competing inventory, advertised prices, mileage bands, price reductions, finance terms, and professional seller activity.

#### Automotive analysts

Build repeatable snapshots for market supply, geographic availability, make/model mix, and used-car valuation research.

#### Marketplaces and pricing tools

Normalize public listings before matching them to internal vehicle catalogs or valuation models.

#### Lead and sales teams

Discover professional sellers, dealerships, warranty offers, and inventory segments for compliant business research.

#### Data teams

Schedule recurring runs and send stable JSON records to a warehouse, spreadsheet, webhook, or BI pipeline.

### Why use this Actor

- **Complete search cards:** reads the page's embedded initial results rather than relying only on the first visually rendered cards.
- **Two cost profiles:** use fast search-only extraction or optional detail enrichment.
- **Stable deduplication:** every row carries the source ad ID and canonical URL.
- **Explicit limits:** cap pages and accepted records independently.
- **Typed output:** prices and mileage are numbers, images are arrays, and timestamps are ISO strings.
- **HTTP-first:** no browser is launched for ordinary runs, reducing runtime and memory.
- **Proxy-ready:** an optional Apify proxy configuration is available for challenged or larger runs.

### Extracted data

| Field | Meaning |
| --- | --- |
| `listingId` | Stable Coches.net advertisement ID |
| `url` | Canonical public detail URL |
| `title` | Advertised make, model, and trim |
| `make`, `model`, `trim` | Normalized vehicle identity fields |
| `price`, `currency` | Cash price and `EUR` currency |
| `originalPrice`, `priceLabel` | Previous price and Coches.net price-position label |
| `financingText` | Finance price, payment, term, and TAE summary when present |
| `year` | Model or production year |
| `mileageKm` | Odometer mileage in kilometers |
| `fuel` | Fuel or powertrain type |
| `horsepower` | Advertised metric horsepower (`CV`) |
| `location` | City and province |
| `sellerType` | `private` or `professional` |
| `sellerName`, `sellerRating` | Public seller/dealer context when present |
| `warrantyText` | Advertised warranty signal or duration |
| `images` | Public vehicle image URLs |
| `bodyType`, `color` | Detail-page vehicle characteristics |
| `transmission`, `doors`, `seats` | Detail-page configuration |
| `engineDisplacementCc` | Engine displacement in cubic centimeters |
| `description` | Public advertiser comments |
| `sourceSearchUrl` | Search page that yielded the record |
| `detailEnriched` | Whether a detail page was successfully parsed |
| `scrapedAt` | UTC extraction time |

Fields can be absent when Coches.net does not provide them for an advertisement.

### Quick start

1. Open the Actor input page.
2. Add one or more public Coches.net search or vehicle URLs.
3. Set `maxItems` to the maximum number of unique vehicles you need.
4. Set `maxPagesPerUrl` for each search URL.
5. Leave `includeDetails` off for low-cost inventory monitoring.
6. Enable `includeDetails` when you need technical specifications or descriptions.
7. Optionally configure an Apify proxy for larger scheduled workloads.
8. Start the run and open the **Vehicle listings** dataset view.

A useful first input is:

```json
{
  "startUrls": [
    { "url": "https://www.coches.net/toyota/segunda-mano/madrid/" }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 1,
  "includeDetails": false
}
````

### Input parameters

#### `startUrls`

Required array of public HTTPS Coches.net URLs.

Supported forms:

- search pages such as `https://www.coches.net/toyota/segunda-mano/madrid/`;
- paged search URLs such as `...?pg=3`;
- semantic vehicle detail URLs ending in `-<ad-id>-covo.aspx`.

Other domains and non-HTTPS URLs fail validation before any data is saved.

#### `maxItems`

Maximum unique vehicle rows across all start URLs.

Range: 1 to 10,000.

The Actor stops scheduling new pages and detail requests when the limit is reached.

#### `maxPagesPerUrl`

Maximum consecutive pages requested for each search URL.

Range: 1 to 100.

If a URL already has `pg=3`, the Actor starts at page 3 and continues from there.

#### `includeDetails`

When false, search output already includes prices, finance data, mileage, power, seller context, warranty signals, and image arrays.

When true, the Actor also requests each vehicle page for technical specifications and advertiser comments.

Direct vehicle URLs are always parsed as detail pages.

#### `proxyConfiguration`

Optional Apify Proxy configuration.

Start without a proxy for small runs.

For repeated or larger workloads, a residential Spanish proxy session can improve request consistency, but it adds transfer cost.

### Output example

A search result resembles:

```json
{
  "listingId": "70000001",
  "url": "https://www.coches.net/example-hybrid-70000001-covo.aspx",
  "title": "EXAMPLE Model Hybrid Advance",
  "make": "EXAMPLE",
  "model": "Model",
  "trim": "Hybrid Advance",
  "price": 18990,
  "currency": "EUR",
  "originalPrice": 19990,
  "priceLabel": "Buen precio",
  "year": 2021,
  "mileageKm": 48500,
  "fuel": "Híbrido",
  "horsepower": 150,
  "location": "Madrid Capital, Madrid",
  "sellerType": "professional",
  "sellerName": "Example Motors Madrid",
  "sellerRating": 4.6,
  "warrantyText": "24 months",
  "images": [
    "https://a.ccdn.es/cnet/vehicles/example/photo.jpg"
  ],
  "sourceSearchUrl": "https://www.coches.net/segunda-mano/madrid/?pg=1",
  "detailEnriched": false,
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

The example uses anonymized values; live rows contain current public advertisements.

### Pagination and limits

Search pagination uses Coches.net's `pg` query parameter.

Each `startUrls` entry has its own `maxPagesPerUrl` allowance.

The global `maxItems` limit applies after deduplication.

When multiple searches contain the same vehicle, only the first accepted record is charged and saved.

An empty final page ends pagination normally.

An HTTP challenge, invalid content type, or exhausted retry sequence is treated as an error rather than a successful empty result.

### Pricing

The Actor uses pay per event pricing.

The current source declares:

- **Start:** $0.005 once per run.
- **Vehicle item:** $0.00001 per saved item on every platform tier.

Illustrative Actor charges are:

| Saved vehicles | Estimated Actor charge |
| ---: | ---: |
| 1 | $0.00501 |
| 10 | $0.00510 |
| 100 | $0.00600 |
| 1,000 | $0.01500 |

Apify compute and proxy usage can vary with enrichment mode, retries, and proxy selection.

The Console shows the applicable event prices before you start a paid run.

### Search-only versus enriched runs

Choose search-only mode for frequent inventory and price snapshots.

It usually provides the best cost and speed because one page contains up to dozens of structured listings.

Choose enriched mode when your workflow needs:

- body type;
- color;
- transmission;
- doors and seats;
- engine displacement;
- advertiser description;
- detail-page full-size images.

A detail page that cannot be enriched after retries is logged clearly, while the useful search record is preserved with `detailEnriched: false`.

### Scheduling and monitoring

Use an Apify schedule for daily or hourly inventory snapshots.

Keep the same search filters between runs to make price and supply comparisons meaningful.

Use `listingId` as the primary key in downstream storage.

Compare `price`, `originalPrice`, and `scrapedAt` to detect changes.

Store historical snapshots outside the Actor dataset if your workflow needs longitudinal analysis.

Datasets belong to individual runs and do not mix stale records from earlier executions.

### Integration patterns

#### Inventory monitoring

Schedule one search URL per make, model, or province and upsert rows by `listingId`.

#### Price intelligence

Group by make, model, year, mileage band, and location, then calculate median asking prices.

#### Dealer discovery

Filter `sellerType` to `professional`, then aggregate inventory by `sellerName` and rating.

#### Marketplace enrichment

Run direct detail URLs for records already selected by an upstream matching process.

#### Alerts

Use a webhook or automation to notify when a new ID appears below a target price.

### API with cURL

Replace `APIFY_TOKEN` with your Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~coches-net-vehicle-listings-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://www.coches.net/toyota/segunda-mano/madrid/"}],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
    "includeDetails": false
  }'
```

Poll the returned run or use the synchronous dataset endpoint when appropriate for your integration.

### API with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor(
  'automation-lab/coches-net-vehicle-listings-scraper'
).call({
  startUrls: [{ url: 'https://www.coches.net/toyota/segunda-mano/madrid/' }],
  maxItems: 20,
  maxPagesPerUrl: 1,
  includeDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor(
    "automation-lab/coches-net-vehicle-listings-scraper"
).call(run_input={
    "startUrls": [
        {"url": "https://www.coches.net/toyota/segunda-mano/madrid/"}
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
    "includeDetails": False,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### MCP setup

Add the Actor to Claude Code through Apify MCP:

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

#### Claude Desktop

Add the following remote server configuration to Claude Desktop.

#### Cursor

Use the same JSON in Cursor's MCP settings.

#### VS Code

Add the same remote endpoint through your VS Code MCP configuration.

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

Example prompts:

- “Scrape the first 50 Toyota listings in Madrid and summarize median price by year.”
- “Extract this Coches.net vehicle URL and return its engine, mileage, seller type, and images.”
- “Compare professional and private seller inventory from these two searches.”

### Reliability and retries

Requests use Spanish desktop navigation headers and bounded timeouts.

Transient network errors, HTTP 429 responses, and temporary server errors are retried up to three times with backoff.

Deterministic invalid URLs and unsupported domains are not retried.

The Actor validates HTML content types and recognizable vehicle data.

Search results are read from embedded structured state first, with rendered cards as a fallback.

Detail output is read from schema.org `Car` JSON-LD.

### Limitations

Coches.net can change page structure, embedded state, availability, or anti-bot rules without notice.

Search ordering and total inventory can change between paginated requests.

The Actor extracts public asking prices, not completed sale prices.

Finance terms are normalized into text because fields and offers vary by seller.

Seller fields are absent when the public advertisement does not provide them.

Search-only records do not contain every technical field available on the detail page.

Detail enrichment increases runtime and request volume.

A proxy can improve access consistency but cannot guarantee access to every page.

### Responsible use

Use the Actor only for data you are authorized to collect and process.

Review Coches.net terms, robots guidance, and applicable Spanish and EU law for your use case.

Do not use public seller information for spam, harassment, discrimination, or unlawful profiling.

Apply an appropriate retention policy to any personal information present in public advertisements.

Respect deletion and correction requests in downstream systems.

This Actor does not bypass login controls or access private account data.

### Troubleshooting

#### “Only Coches.net URLs are supported”

Use an `https://www.coches.net/...` public search or detail URL.

Remove redirectors, shortened links, and URLs from other Motor sites.

#### The run returns fewer items than `maxItems`

The search may have ended, duplicate IDs may have appeared across URLs, or `maxPagesPerUrl` may be too low.

Check the logs for page counts and upstream response errors.

#### Detail fields are missing

Confirm `includeDetails` is enabled for search input.

Inspect warnings for ads whose detail request could not be enriched.

Direct detail URLs are always enriched.

#### The source returns a challenge

Retry with an Apify proxy configuration and conservative page limits.

For larger workloads, use a stable Spanish residential session rather than rotating identity on every request.

#### How do I reduce cost?

Use `includeDetails: false`, request only necessary pages, and avoid downloading data you do not need downstream.

### FAQ

#### Does it require a Coches.net login?

No. The Actor targets public search and vehicle pages.

#### Can I scrape any make, model, or province?

Yes, when you provide the corresponding public Coches.net search URL.

#### Can I start from page 3?

Yes. Supply a URL with `pg=3`; pagination continues from that page.

#### Are duplicate vehicles charged twice?

No. Duplicate ad IDs within the same run are skipped before charging and saving.

#### Does it download image files?

No. It extracts public image URLs, which keeps transfer and storage lower.

#### Is the data real time?

The Actor returns what Coches.net exposes when each page is requested. It does not guarantee that a seller has not changed or removed a vehicle moments later.

#### Can I use the data for valuation?

Yes as one asking-price input, but combine it with appropriate quality controls and other evidence. Asking prices are not sale prices.

### Related Automation Lab Actors

- [OTOMOTO Scraper](https://apify.com/automation-lab/otomoto-scraper) for Polish vehicle-market comparisons.
- [Mercado Libre Listing Scraper](https://apify.com/automation-lab/mercado-libre-listing-scraper) for broader Latin American marketplace listings.

Use Coches.net Vehicle Listings Scraper when the source-of-truth workflow is Spanish Coches.net inventory.

### Support

If a run fails, include the public input URL, run ID, mode, and the first relevant log error in your report.

Do not include Apify tokens, proxy passwords, private datasets, or unrelated personal data.

# Actor input Schema

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

One or more public Coches.net search pages or vehicle detail URLs. Search pages are paginated automatically.

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

Stop after saving this many unique vehicle listings across all URLs.

## `maxPagesPerUrl` (type: `integer`):

Maximum consecutive search-result pages to request for each search URL.

## `includeDetails` (type: `boolean`):

Fetch every vehicle ad to add model, body, color, transmission, doors, seats, description, and full-size images. This is slower and may require a proxy at scale.

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

Optional Apify Proxy settings. Residential Spanish sessions can improve reliability for larger runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.coches.net/toyota/segunda-mano/madrid/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 1,
  "includeDetails": false
}
```

# Actor output Schema

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

Default dataset containing all unique vehicle records saved by this run.

# 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.coches.net/toyota/segunda-mano/madrid/"
        }
    ],
    "maxItems": 20,
    "maxPagesPerUrl": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/coches-net-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.coches.net/toyota/segunda-mano/madrid/" }],
    "maxItems": 20,
    "maxPagesPerUrl": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/coches-net-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.coches.net/toyota/segunda-mano/madrid/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 1
}' |
apify call automation-lab/coches-net-vehicle-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Coches.net Vehicle Listings Scraper",
        "description": "Extract public Coches.net used-car listings with prices, mileage, specifications, images, financing, warranty, location, and seller/dealer context.",
        "version": "0.1",
        "x-build-id": "EC3sez4FIoaLtc4Fl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~coches-net-vehicle-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-coches-net-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~coches-net-vehicle-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-coches-net-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~coches-net-vehicle-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-coches-net-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": "Coches.net URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more public Coches.net search pages or vehicle detail URLs. Search pages are paginated automatically.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum vehicles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique vehicle listings across all URLs.",
                        "default": 100
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per search URL",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum consecutive search-result pages to request for each search URL.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Enrich from vehicle detail pages",
                        "type": "boolean",
                        "description": "Fetch every vehicle ad to add model, body, color, transmission, doors, seats, description, and full-size images. This is slower and may require a proxy at scale.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Residential Spanish sessions can improve reliability for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
