# Standvirtual Scraper (`solidcode/standvirtual-scraper`) Actor

\[💰 $0.90 / 1K] Extract car listings from Standvirtual.com, Portugal's largest car marketplace — price, year, mileage, fuel, gearbox, make/model, seller, location, and photos. Search by make/model + filters, or paste a search URL.

- **URL**: https://apify.com/solidcode/standvirtual-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Standvirtual Scraper

Pull car listings from Standvirtual.com — Portugal's largest car marketplace — at scale: price, registration year, mileage, fuel, gearbox, engine power, make/model/version, seller details, location, and full photo galleries for every live listing. Build a search from structured filters or paste a Standvirtual URL — no result cap, so you can sweep the entire 43,000+ car catalog. Built for car dealers, automotive market analysts, and lead-generation teams who need Portuguese car inventory without copying URLs and details by hand.

### Why This Scraper?

- **No result cap — sweep all 43,000+ live listings** — set max results to 0 and pull the entire Standvirtual catalog in one run, not a capped sample. The leading competing actor stops at 2,000 cars per run.
- **11 structured search filters, no URL-building** — combine make, model, fuel type, body type, gearbox, dealer/private seller, and price/year/mileage bands directly in the input form. Or paste a Standvirtual search URL and skip filters entirely.
- **29 fields per car** — price and currency, registration year, mileage, fuel type, gearbox, engine power (hp) and capacity (cc), body type, doors, seats, color, make/model/version, seller details, location, region, cover photo and full gallery, promoted/highlighted flags, listing date, and the timestamp each row was collected.
- **9 fuel types and 9 body types** — filter to Petrol, Diesel, LPG, Hybrid, Plug-in Hybrid, Electric, Hydrogen, Ethanol, or CNG; and City car, Compact, Sedan, Station wagon, SUV, Coupe, Convertible, Minivan, or Pickup.
- **Dealer-vs-private seller split** — every row carries `sellerType` (dealer or private) plus the seller name, so you can segment professional inventory from individual sellers for lead-gen or market analysis.
- **Optional full photo galleries** — flip one switch to collect every photo on each listing (often 30+ images per car), not just the single cover thumbnail.
- **Engine specs on every listing** — engine power in horsepower and displacement in cubic centimeters parsed into clean numeric fields, ready for spec comparison.
- **8 sort orders** — order results by relevance, newest, price (low/high), mileage (low/high), or year (newest/oldest) before extraction.
- **Native Portuguese data** — prices in euros, locations as Portuguese cities and districts, and fuel/body labels exactly as Standvirtual presents them.

### Use Cases

**Market Research**
- Map the entire live inventory of any make and model across Portugal
- Track median asking prices by fuel type, body style, or registration year
- Compare petrol vs. electric vs. hybrid supply and pricing over time
- Benchmark mileage-to-price curves across model years

**Dealer Intelligence**
- Monitor competitor dealer inventory by filtering on dealer seller type
- Watch how long specific models stay listed using the listing date field
- Identify which dealers carry the deepest stock in a segment
- Spot pricing gaps against your own showroom inventory

**Lead Generation**
- Build contact lists of private sellers by filtering on private seller type
- Capture seller names alongside each listing for outreach
- Target high-value segments by price, year, and make/model bands

**Price Monitoring**
- Track price changes on a saved search by re-running on a schedule
- Detect newly listed cars by sorting newest-first and watching listing dates
- Flag underpriced listings within a tight year and mileage band
- Compare promoted/highlighted listings against standard ones

**Data Enrichment & Integration**
- Feed structured Portuguese car data into valuation and analytics dashboards
- Power price-comparison and trade-in estimation tools
- Enrich CRM records with current market listings for a vehicle

### Getting Started

#### Scrape a Make and Model

The simplest way to start — name a make and model, keep the default limit:

```json
{
    "make": "BMW",
    "model": "Serie 3",
    "maxResults": 100
}
````

#### Filtered Search

Combine structured filters — diesel automatic SUVs under €25,000 from 2019 on, newest first:

```json
{
    "make": "Volkswagen",
    "fuelTypes": ["diesel"],
    "bodyTypes": ["suv"],
    "gearbox": "automatic",
    "priceMax": 25000,
    "yearMin": 2019,
    "sortBy": "newest",
    "maxResults": 500
}
```

#### Full Catalog from a Pasted URL

Paste any Standvirtual search URL and pull every matching listing with full photo galleries:

```json
{
    "searchUrls": [
        "https://www.standvirtual.com/carros/mercedes-benz/classe-c"
    ],
    "includePhotos": true,
    "maxResults": 0
}
```

#### Advanced Multi-Filter Run

```json
{
    "make": "Audi",
    "model": "A4",
    "fuelTypes": ["diesel", "plugin-hybrid"],
    "bodyTypes": ["sedan", "station-wagon"],
    "gearbox": "automatic",
    "sellerType": "dealer",
    "priceMin": 10000,
    "priceMax": 40000,
    "yearMin": 2018,
    "yearMax": 2023,
    "mileageMax": 120000,
    "sortBy": "priceAsc",
    "includePhotos": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | Paste one or more Standvirtual.com search-result URLs. When provided, these are used directly and the filter fields below are ignored. |

#### Build a Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | empty | Car manufacturer as shown on Standvirtual, e.g. "BMW", "Mercedes-Benz", "Renault". Leave empty for all makes. |
| `model` | string | empty | Model name, must match the chosen make, e.g. "Serie 3", "Classe C", "Clio". Leave empty for all models of the make. |
| `fuelTypes` | select\[] | `[]` | One or more of: Petrol, Diesel, LPG, Hybrid, Plug-in Hybrid, Electric, Hydrogen, Ethanol, CNG (Natural gas). Leave empty for all fuel types. |
| `bodyTypes` | select\[] | `[]` | One or more of: City car, Compact, Sedan, Station wagon, SUV / Off-road, Coupe, Convertible, Minivan / MPV, Pickup. Leave empty for all body types. |
| `gearbox` | select | `Any` | Transmission: Any, Manual, or Automatic. |
| `sellerType` | select | `Any` | Listing source: Any, Dealer / Business, or Private seller. |

#### Price, Year & Mileage

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | empty | Only include cars at or above this price, in euros. |
| `priceMax` | integer | empty | Only include cars at or below this price, in euros. |
| `yearMin` | integer | empty | Only include cars first registered in or after this year, e.g. 2018. |
| `yearMax` | integer | empty | Only include cars first registered in or before this year. |
| `mileageMax` | integer | empty | Only include cars at or below this odometer reading, in kilometers. |

#### Sorting & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most relevant` | Result order: Most relevant, Newest first, Price low→high, Price high→low, Mileage low→high, Mileage high→low, Year newest first, Year oldest first. |
| `maxResults` | integer | `100` | Maximum listings to extract per search URL or search. Set to 0 for unlimited (every listing the search returns). The last page is always returned in full, so you may receive a few more than this number. |
| `includePhotos` | boolean | `false` | When on, opens each listing to collect its full photo gallery (the `images` field). When off, you get a single cover photo per listing. |

### Output

Each car is one flat row in the dataset. Here's a representative result:

```json
{
    "id": "ID8Yabc1",
    "title": "BMW Serie 3 320 d Touring Auto",
    "url": "https://www.standvirtual.com/carros/anuncio/bmw-320-d-touring-ID8Yabc1.html",
    "make": "BMW",
    "model": "Serie 3",
    "version": "320 d Touring Auto",
    "price": 28900,
    "currency": "EUR",
    "year": 2020,
    "mileage": 84500,
    "fuelType": "Diesel",
    "gearbox": "Automatic",
    "enginePower": 190,
    "engineCapacity": 1995,
    "bodyType": "Station wagon",
    "doors": 5,
    "seats": 5,
    "color": "Black",
    "shortDescription": "Full service history, one owner, financing available.",
    "sellerType": "dealer",
    "sellerName": "Auto Stand Lisboa",
    "location": "Lisboa",
    "region": "Lisboa",
    "image": "https://ireland.apollo.olxcdn.com/v1/files/example-cover.jpg",
    "images": [
        "https://ireland.apollo.olxcdn.com/v1/files/example-1.jpg",
        "https://ireland.apollo.olxcdn.com/v1/files/example-2.jpg"
    ],
    "isPromoted": true,
    "isHighlighted": false,
    "createdAt": "2026-06-10T09:15:00Z",
    "scrapedAt": "2026-06-13T11:42:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Standvirtual listing identifier |
| `title` | string | Listing title as shown on Standvirtual |
| `url` | string | Direct link to the listing |
| `price` | number | Asking price |
| `currency` | string | Currency code (EUR) |
| `shortDescription` | string | Teaser description text (may be empty) |
| `createdAt` | string | Listing publish/update timestamp |
| `scrapedAt` | string | Timestamp (UTC) when this row was collected |

#### Vehicle Specs

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Manufacturer |
| `model` | string | Model name |
| `version` | string | Trim / version (e.g. "320 d Touring Auto") |
| `year` | number | First registration year |
| `mileage` | number | Odometer reading in kilometers |
| `fuelType` | string | Fuel type as labelled by Standvirtual |
| `gearbox` | string | Transmission type |
| `enginePower` | number | Engine power in horsepower |
| `engineCapacity` | number | Engine displacement in cubic centimeters |
| `bodyType` | string | Body style |
| `doors` | number | Number of doors |
| `seats` | number | Number of seats |
| `color` | string | Exterior color as labelled by Standvirtual |

#### Seller & Location

| Field | Type | Description |
|-------|------|-------------|
| `sellerType` | string | `dealer` or `private` |
| `sellerName` | string | Seller or dealership name |
| `location` | string | City or municipality |
| `region` | string | District or region |

#### Media & Flags

| Field | Type | Description |
|-------|------|-------------|
| `image` | string | Primary cover photo URL |
| `images` | string\[] | All photo URLs for the listing (full gallery when photo collection is on; otherwise the cover photo) |
| `isPromoted` | boolean | Promoted / featured ad flag |
| `isHighlighted` | boolean | Highlighted (premium top) ad flag |

### Tips for Best Results

- **Leave max results at 0 for full-catalog coverage** — that pulls every car a search returns, with no 2,000-listing ceiling. Use a small number first (10–50) to preview the data, then scale up.
- **Use the filter fields instead of building URLs** — naming the make, model, and bands in the input form is faster and less error-prone than crafting a Standvirtual URL by hand.
- **Turn on photo collection only when you need galleries** — it opens each listing individually, so runs take longer and cost more. Leave it off when the single cover photo is enough.
- **Filter seller type for the right job** — choose Private seller for private-owner lead lists, or Dealer / Business to monitor competitor dealer stock.
- **Keep numeric bands inside the live data range** — a price or year band entirely beyond what's on the market (e.g. years 2099–2100) is ignored by Standvirtual and returns the full result set. A single open-ended bound (just a minimum or just a maximum) always works.
- **Sort newest-first to catch fresh listings** — pair Newest first with the listing date field to detect cars added since your last run.
- **Common fuel and body filters are fully supported; rarer ones broaden automatically** — the everyday choices (Petrol, Diesel, LPG, Plug-in Hybrid, Electric; Compact, Sedan, Station wagon, SUV, Coupe, Convertible) are matched exactly. Less common options (e.g. Hydrogen, CNG, Pickup) fall back to a broader search when Standvirtual has no exact match for that day's stock — so if a niche fuel or body filter returns 0, remove it to widen the search.
- **Match make and model spelling to Standvirtual** — an unrecognized make is ignored and returns all cars, so use the exact names shown on the site (e.g. "Mercedes-Benz", not "Mercedes").

### Pricing

**From $0.90 per 1,000 results** — flat pay-per-result pricing that undercuts the leading Standvirtual actor on the market. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.10 | $0.10 | $0.09 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one car listing in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, dealer intelligence, and lead generation. You are responsible for complying with applicable laws and Standvirtual's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as seller names) in line with GDPR and other applicable privacy regulations.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Standvirtual.com search-result URLs. Go to standvirtual.com, set your filters in the browser (make, model, price, year, fuel...), and copy the URL from the address bar. When provided, these are used directly and the filter fields below are ignored.

## `make` (type: `string`):

Car manufacturer as shown on Standvirtual, e.g. 'BMW', 'Mercedes-Benz', 'Renault'. Leave empty for all makes. Ignored when search URLs are provided.

## `model` (type: `string`):

Model name as shown on Standvirtual (must match the chosen Make), e.g. 'Serie 3', 'Classe C', 'Clio'. Leave empty for all models of the chosen make.

## `fuelTypes` (type: `array`):

Only include cars with these fuel types. Leave empty for all fuel types.

## `bodyTypes` (type: `array`):

Only include cars with these body types. Leave empty for all body types.

## `gearbox` (type: `string`):

Transmission type.

## `sellerType` (type: `string`):

Only include listings from this kind of seller. 'Dealer / Business' keeps professional sellers; 'Private seller' keeps individuals. This is applied to each listing after it is fetched, so it never hides any results that match your other filters.

## `priceMin` (type: `integer`):

Only include cars at or above this price, in euros. Leave empty for no lower bound.

## `priceMax` (type: `integer`):

Only include cars at or below this price, in euros. Leave empty for no upper bound.

## `yearMin` (type: `integer`):

Only include cars first registered in or after this year, e.g. 2018. Leave empty for no lower bound.

## `yearMax` (type: `integer`):

Only include cars first registered in or before this year. Leave empty for no upper bound.

## `mileageMax` (type: `integer`):

Only include cars at or below this odometer reading, in kilometers, e.g. 150000. Leave empty for no upper bound.

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

How to order the search results before they are extracted. Ignored when search URLs already include a sort order.

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

Maximum number of listings to extract per search URL or search. Set to 0 for unlimited (gets every listing the search returns). Results come in pages, and the last page is always returned in full — so you may receive a few more than this number.

## `includePhotos` (type: `boolean`):

When on, the actor opens each listing to collect its full photo gallery (the 'images' field). When off, you get a single cover photo per listing. Turning this on roughly doubles the work per listing, so it takes longer and costs more — leave it off unless you need every photo.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.standvirtual.com/carros/bmw/serie-3"
  ],
  "fuelTypes": [],
  "bodyTypes": [],
  "gearbox": "any",
  "sellerType": "any",
  "sortBy": "relevance",
  "maxResults": 100,
  "includePhotos": false
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of car listings with key fields.

## `specs` (type: `string`):

Make, model, year, mileage, fuel, gearbox, and engine details for each listing.

## `seller` (type: `string`):

Seller type and location information for each listing.

# 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 = {
    "searchUrls": [
        "https://www.standvirtual.com/carros/bmw/serie-3"
    ],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "gearbox": "any",
    "sellerType": "any",
    "sortBy": "relevance",
    "maxResults": 100,
    "includePhotos": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/standvirtual-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 = {
    "searchUrls": ["https://www.standvirtual.com/carros/bmw/serie-3"],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "gearbox": "any",
    "sellerType": "any",
    "sortBy": "relevance",
    "maxResults": 100,
    "includePhotos": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/standvirtual-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 '{
  "searchUrls": [
    "https://www.standvirtual.com/carros/bmw/serie-3"
  ],
  "make": "",
  "model": "",
  "fuelTypes": [],
  "bodyTypes": [],
  "gearbox": "any",
  "sellerType": "any",
  "sortBy": "relevance",
  "maxResults": 100,
  "includePhotos": false
}' |
apify call solidcode/standvirtual-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Standvirtual Scraper",
        "description": "[💰 $0.90 / 1K] Extract car listings from Standvirtual.com, Portugal's largest car marketplace — price, year, mileage, fuel, gearbox, make/model, seller, location, and photos. Search by make/model + filters, or paste a search URL.",
        "version": "1.0",
        "x-build-id": "iGlLRdQXi5xZcSNXu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~standvirtual-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-standvirtual-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/solidcode~standvirtual-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-standvirtual-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/solidcode~standvirtual-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-standvirtual-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrls": {
                        "title": "Standvirtual search URLs",
                        "type": "array",
                        "description": "Paste one or more Standvirtual.com search-result URLs. Go to standvirtual.com, set your filters in the browser (make, model, price, year, fuel...), and copy the URL from the address bar. When provided, these are used directly and the filter fields below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Car manufacturer as shown on Standvirtual, e.g. 'BMW', 'Mercedes-Benz', 'Renault'. Leave empty for all makes. Ignored when search URLs are provided."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model name as shown on Standvirtual (must match the chosen Make), e.g. 'Serie 3', 'Classe C', 'Clio'. Leave empty for all models of the chosen make."
                    },
                    "fuelTypes": {
                        "title": "Fuel type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars with these fuel types. Leave empty for all fuel types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "petrol",
                                "diesel",
                                "lpg",
                                "hybrid",
                                "plugin-hybrid",
                                "electric",
                                "hydrogen",
                                "ethanol",
                                "cng"
                            ],
                            "enumTitles": [
                                "Petrol",
                                "Diesel",
                                "LPG",
                                "Hybrid",
                                "Plug-in Hybrid",
                                "Electric",
                                "Hydrogen",
                                "Ethanol",
                                "CNG (Natural gas)"
                            ]
                        }
                    },
                    "bodyTypes": {
                        "title": "Body type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include cars with these body types. Leave empty for all body types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "city-cars",
                                "compact",
                                "sedan",
                                "station-wagon",
                                "suv",
                                "coupe",
                                "cabrio",
                                "minivan",
                                "pickup"
                            ],
                            "enumTitles": [
                                "City car",
                                "Compact",
                                "Sedan",
                                "Station wagon",
                                "SUV / Off-road",
                                "Coupe",
                                "Convertible",
                                "Minivan / MPV",
                                "Pickup"
                            ]
                        }
                    },
                    "gearbox": {
                        "title": "Gearbox",
                        "enum": [
                            "any",
                            "manual",
                            "automatic"
                        ],
                        "type": "string",
                        "description": "Transmission type.",
                        "default": "any"
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "any",
                            "dealer",
                            "private"
                        ],
                        "type": "string",
                        "description": "Only include listings from this kind of seller. 'Dealer / Business' keeps professional sellers; 'Private seller' keeps individuals. This is applied to each listing after it is fetched, so it never hides any results that match your other filters.",
                        "default": "any"
                    },
                    "priceMin": {
                        "title": "Minimum price (EUR)",
                        "minimum": 0,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Only include cars at or above this price, in euros. Leave empty for no lower bound."
                    },
                    "priceMax": {
                        "title": "Maximum price (EUR)",
                        "minimum": 0,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Only include cars at or below this price, in euros. Leave empty for no upper bound."
                    },
                    "yearMin": {
                        "title": "Minimum registration year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include cars first registered in or after this year, e.g. 2018. Leave empty for no lower bound."
                    },
                    "yearMax": {
                        "title": "Maximum registration year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include cars first registered in or before this year. Leave empty for no upper bound."
                    },
                    "mileageMax": {
                        "title": "Maximum mileage (km)",
                        "minimum": 0,
                        "maximum": 2000000,
                        "type": "integer",
                        "description": "Only include cars at or below this odometer reading, in kilometers, e.g. 150000. Leave empty for no upper bound."
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "newest",
                            "priceAsc",
                            "priceDesc",
                            "mileageAsc",
                            "mileageDesc",
                            "yearDesc",
                            "yearAsc"
                        ],
                        "type": "string",
                        "description": "How to order the search results before they are extracted. Ignored when search URLs already include a sort order.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max results per URL",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to extract per search URL or search. Set to 0 for unlimited (gets every listing the search returns). Results come in pages, and the last page is always returned in full — so you may receive a few more than this number.",
                        "default": 100
                    },
                    "includePhotos": {
                        "title": "Fetch all photos for each listing",
                        "type": "boolean",
                        "description": "When on, the actor opens each listing to collect its full photo gallery (the 'images' field). When off, you get a single cover photo per listing. Turning this on roughly doubles the work per listing, so it takes longer and costs more — leave it off unless you need every photo.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
