# AutoUncle Italy Scraper (`solidcode/autouncle-it-scraper`) Actor

\[💰 $1.3 / 1K] Extract used-car listings from AutoUncle.it. Get price, AutoUncle price rating, mileage, year, fuel, transmission, dealer, location, and images. Search by make/model + filters, or paste a search URL.

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

## Pricing

from $1.30 / 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

## AutoUncle Italy Scraper

Pull used-car listings from AutoUncle.it at scale — make, model, trim, price, registration year, mileage, fuel, transmission, body, engine power, dealer, location, photos, and AutoUncle's own deal rating on every car. AutoUncle aggregates inventory from hundreds of Italian dealers into one comparison grid, and this actor turns that grid into clean, structured rows. Built for car dealers benchmarking competitor pricing, market analysts tracking the Italian used-car market, and deal hunters chasing underpriced cars who need fresh AutoUncle data without hand-building search links one page at a time.

### Why This Scraper?

- **AutoUncle's price rating on every row** — the `priceRating` deal score ("Super prezzo", "Ottimo prezzo", "Buon prezzo", "Prezzo equo", "Prezzo nella media", "Prezzo alto") tells you at a glance how each asking price compares to the market. This is AutoUncle's signature data — raw classifieds don't have it.
- **Estimated savings vs market value** — the `savingText` field captures AutoUncle's "Sotto il valore di mercato 1.200 €" estimate, quantifying how far below (or above) market each car is priced in euros.
- **Numeric AND formatted price and mileage** — every car ships both `priceValue` (12900) for sorting and filtering and `price` ("12.900 €") for display, plus `mileageKm` (85000) alongside `mileage` ("85.000 km").
- **31 fields per listing** — far beyond price and title: trim, engine power in CV and kW, displacement, fuel consumption, CO2 emissions, days online, price trend, verified-dealer flags, and more on a single flat row.
- **Seven fuel filters and six body filters** — narrow to Petrol, Diesel, Electric, Hybrid, Plug-in Hybrid, LPG, or Natural gas (CNG); and Sedan, Station wagon, SUV, Coupe, Convertible, or Minivan.
- **Precise price, year, and mileage bounds** — set exact `priceMin`/`priceMax`, `yearMin`/`yearMax`, and `mileageMax` limits and the results are held to them exactly, even where AutoUncle's own URL filters can't express the range.
- **Build a search without a URL** — type a make and model (e.g. Volkswagen / Golf) and the actor assembles the AutoUncle search for you; non-technical users never touch the address bar.
- **Selectable image resolution** — choose small, medium, or large listing photos to balance file size against quality across thousands of cars.
- **Full Italian-market dealer coverage** — AutoUncle aggregates listings from hundreds of Italian dealers, including the source dealer name, city, province, and a verified-dealer flag on every car.

### Use Cases

**Dealer Pricing Intelligence**
- Benchmark your own stock against competitor asking prices for the same make, model, and year
- Spot cars priced "Sotto il valore di mercato" before they sell
- Track the `priceTrend` on comparable listings to time price changes
- Monitor how long competitor cars stay listed with `daysOnline`

**Market Research & Analytics**
- Map used-car inventory across the Italian market by make, model, and fuel type
- Analyze price-per-year and mileage distributions for any model
- Compare petrol, diesel, hybrid, and electric pricing across body types
- Feed registration-year and mileage data into depreciation models

**Deal Hunting & Arbitrage**
- Surface every car rated "Super prezzo" or "Ottimo prezzo" in your budget
- Filter to cars priced below market value, then sort by estimated saving
- Find clean low-mileage examples under a hard `mileageMax` ceiling
- Cross-shop a model across regions to find the cheapest source dealer

**Lead Generation**
- Build dealer lists with name, city, and province from the Italian market
- Identify dealers carrying a specific make or premium inventory
- Target verified dealers for trade or sourcing outreach
- Enrich a CRM with current dealer stock and pricing

### Getting Started

#### Search by Make and Model

The simplest way to start — just a make and model:

```json
{
    "make": "Volkswagen",
    "model": "Golf",
    "maxResults": 50
}
````

#### Filtered Search

Narrow by fuel, transmission, year, and price:

```json
{
    "make": "BMW",
    "model": "3 Series",
    "fuelTypes": ["diesel"],
    "transmission": "automatico",
    "yearMin": 2019,
    "priceMax": 25000,
    "mileageMax": 80000,
    "maxResults": 200
}
```

#### Using AutoUncle URLs

Set your filters on autouncle.it, copy the URL from the address bar, and paste it in:

```json
{
    "searchUrls": [
        "https://www.autouncle.it/it/auto-usate/Audi/A3",
        "https://www.autouncle.it/it/auto-usate/Fiat/Panda/f-benzina"
    ],
    "imageResolution": "large",
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | — | One or more AutoUncle.it search-result URLs, used directly. Set your filters on autouncle.it, then copy the URL from the address bar. When provided, the filter fields below are ignored. |

#### Build a Search

Used only when no search URLs are provided. Leave any field empty to skip that filter.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | — | Car manufacturer as shown on AutoUncle, e.g. "Volkswagen", "BMW", "Fiat". Leave empty for all makes. |
| `model` | string | — | Model name (must match the chosen make), e.g. "Golf", "3 Series", "Panda". Leave empty for all models. |
| `fuelTypes` | string\[] | — | Only include these fuel types: Petrol, Diesel, Electric, Hybrid, Plug-in Hybrid, LPG, Natural gas (CNG). |
| `bodyTypes` | string\[] | — | Only include these body types: Sedan, Station wagon, SUV, City car, Coupe, Convertible, Minivan / MPV, Pickup. |
| `transmission` | select | `Any` | Gearbox type: Any, Manual, or Automatic. |

#### Price, Year & Mileage

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

#### Limits & Images

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum listings per search URL or search. Set to 0 for unlimited (every listing the search returns). |
| `imageResolution` | select | `Medium` | Resolution of listing images: Small, Medium, or Large. Higher resolution means larger files. |

### Output

Each car listing is one flat row. Here's a representative result:

```json
{
    "id": "123456789",
    "title": "Volkswagen Golf 2.0 TDI Comfortline",
    "subtitle": "DSG Comfortline 150 CV",
    "make": "Volkswagen",
    "model": "Golf",
    "price": "18.900 €",
    "priceValue": 18900,
    "currency": "EUR",
    "priceRating": "Buon prezzo",
    "savingText": "Sotto il valore di mercato 1.200 €",
    "priceTrend": "-5%",
    "daysOnline": 12,
    "registrationYear": 2019,
    "mileage": "85.000 km",
    "mileageKm": 85000,
    "fuelType": "Diesel",
    "bodyType": "Berlina",
    "transmission": "Automatico",
    "color": "Grigio",
    "doors": 5,
    "power": "150 CV (110 kW)",
    "consumption": "4.5 L/100km",
    "co2Emissions": "118 g/km",
    "location": "51042 Firenze (FI), Toscana",
    "seller": "AutoScout24",
    "dealerVerified": true,
    "availabilityVerified": true,
    "imageUrl": "https://images.autouncle.com/it/car_images/medium_abc123.webp",
    "imageAlt": "Volkswagen Golf 2.0 TDI",
    "detailUrl": "https://www.autouncle.it/it/d/123456789-volkswagen-golf",
    "sourceUrl": "https://www.autouncle.it/it/auto-usate/Volkswagen/Golf"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | AutoUncle listing identifier |
| `title` | string | Full car headline (make, model, trim) |
| `subtitle` | string | Trim / version detail, when distinct from the title |
| `make` | string | Manufacturer |
| `model` | string | Model name |
| `detailUrl` | string | Direct AutoUncle listing URL |
| `sourceUrl` | string | The search URL this listing came from |

#### Pricing & Deal Rating

| Field | Type | Description |
|-------|------|-------------|
| `price` | string | Formatted price, e.g. "18.900 €" |
| `priceValue` | number | Numeric price in euros, for sorting and filtering |
| `currency` | string | Price currency (EUR) |
| `priceRating` | string | AutoUncle deal rating, e.g. "Ottimo prezzo", "Buon prezzo" |
| `savingText` | string | Estimated saving vs market value, e.g. "Sotto il valore di mercato 1.200 €" |
| `priceTrend` | string | Recent price movement on this listing, e.g. "-5%" |
| `daysOnline` | number | How many days the listing has been online |

#### Specs

| Field | Type | Description |
|-------|------|-------------|
| `registrationYear` | number | First registration year |
| `mileage` | string | Formatted mileage, e.g. "85.000 km" |
| `mileageKm` | number | Numeric mileage in kilometers |
| `fuelType` | string | Fuel type (Benzina, Diesel, Elettrica, ...) |
| `bodyType` | string | Body type (Berlina, SUV, Station wagon, ...) |
| `transmission` | string | Gearbox (Manuale / Automatico) |
| `power` | string | Engine power, e.g. "150 CV (110 kW)" |
| `consumption` | string | Fuel consumption, e.g. "4.5 L/100km" |
| `co2Emissions` | string | CO2 emissions, e.g. "118 g/km" |
| `color` | string | Exterior color, when published |
| `doors` | number | Number of doors, when published |

#### Dealer & Location

| Field | Type | Description |
|-------|------|-------------|
| `seller` | string | Source dealer name |
| `location` | string | City, province, and region, e.g. "51042 Firenze (FI), Toscana" |
| `dealerVerified` | boolean | Whether AutoUncle marks the dealer as verified |
| `availabilityVerified` | boolean | Whether the listing's availability is verified |

#### Media

| Field | Type | Description |
|-------|------|-------------|
| `imageUrl` | string | Main listing photo at the chosen resolution |
| `imageAlt` | string | Photo alt text |

### Tips for Best Results

- **Start small** — set `maxResults` to 25-50 on your first run to confirm the data matches your needs, then scale up.
- **Use `priceRating` to spot deals fast** — sort or filter your export on `priceRating` and `savingText` to surface every car rated "Super prezzo" or "Ottimo prezzo" priced below market, the fastest path to an underpriced car.
- **Bounds are applied precisely** — `priceMin`, `priceMax`, `yearMin`, `yearMax`, and `mileageMax` hold the results to your exact limits, even on ranges AutoUncle's own filters can't express, so there's no manual cleanup afterward.
- **Paste a URL for advanced filter combinations** — if you need a filter beyond the make/model fields, set everything on autouncle.it and paste the address-bar URL; it takes priority over the filter fields.
- **Combine numeric fields in exports** — `priceValue` and `mileageKm` are numbers, so you can sort, average, and chart them directly in Sheets or Excel without cleaning formatted text.
- **Mix multiple searches in one run** — paste several `searchUrls` to pull several models or regions in a single job.
- **Match makes and models to AutoUncle's spelling** — use the names exactly as they appear on AutoUncle (e.g. "Volkswagen", "Golf") for the most reliable results.

### Pricing

**From $1.30 per 1,000 results** — predictable pay-per-result pricing that undercuts comparable AutoUncle scrapers. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.16 | $0.15 | $0.14 | $0.13 |
| 1,000 | $1.55 | $1.45 | $1.40 | $1.30 |
| 10,000 | $15.50 | $14.50 | $14.00 | $13.00 |
| 100,000 | $155.00 | $145.00 | $140.00 | $130.00 |

A "result" is any car listing row 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, pricing analysis, and lead generation on publicly available used-car listings. Users are responsible for complying with applicable laws and AutoUncle's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data (such as dealer contact details) in line with applicable privacy regulations.

# Actor input Schema

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

Paste one or more AutoUncle.it search-result URLs. Go to autouncle.it, 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 AutoUncle, e.g. 'Volkswagen', 'BMW', 'Fiat'. Leave empty for all makes. Ignored when search URLs are provided.

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

Model name as shown on AutoUncle (must match the chosen Make), e.g. 'Golf', '3 Series', 'Panda'. Leave empty for all models.

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

## `transmission` (type: `string`):

Gearbox type.

## `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. 100000. Leave empty for no upper bound.

## `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 of 25, and the last page is always returned in full — so you may receive a few more than this number.

## `imageResolution` (type: `string`):

Resolution of listing images. Higher resolution means larger files.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.autouncle.it/it/auto-usate/Volkswagen/Golf"
  ],
  "fuelTypes": [],
  "bodyTypes": [],
  "transmission": "any",
  "maxResults": 100,
  "imageResolution": "medium"
}
```

# Actor output Schema

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

Table of car listings with key fields.

## `pricing` (type: `string`):

Price, AutoUncle price rating, and savings for each listing.

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

Dealer 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.autouncle.it/it/auto-usate/Volkswagen/Golf"
    ],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "transmission": "any",
    "maxResults": 100,
    "imageResolution": "medium"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/autouncle-it-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.autouncle.it/it/auto-usate/Volkswagen/Golf"],
    "make": "",
    "model": "",
    "fuelTypes": [],
    "bodyTypes": [],
    "transmission": "any",
    "maxResults": 100,
    "imageResolution": "medium",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/autouncle-it-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.autouncle.it/it/auto-usate/Volkswagen/Golf"
  ],
  "make": "",
  "model": "",
  "fuelTypes": [],
  "bodyTypes": [],
  "transmission": "any",
  "maxResults": 100,
  "imageResolution": "medium"
}' |
apify call solidcode/autouncle-it-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoUncle Italy Scraper",
        "description": "[💰 $1.3 / 1K] Extract used-car listings from AutoUncle.it. Get price, AutoUncle price rating, mileage, year, fuel, transmission, dealer, location, and images. Search by make/model + filters, or paste a search URL.",
        "version": "1.0",
        "x-build-id": "ry4IiIREEjgge4k0L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~autouncle-it-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-autouncle-it-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~autouncle-it-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-autouncle-it-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~autouncle-it-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-autouncle-it-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": "AutoUncle search URLs",
                        "type": "array",
                        "description": "Paste one or more AutoUncle.it search-result URLs. Go to autouncle.it, 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 AutoUncle, e.g. 'Volkswagen', 'BMW', 'Fiat'. Leave empty for all makes. Ignored when search URLs are provided."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model name as shown on AutoUncle (must match the chosen Make), e.g. 'Golf', '3 Series', 'Panda'. Leave empty for all models."
                    },
                    "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": [
                                "benzina",
                                "diesel",
                                "elettrica",
                                "ibrida",
                                "ibrida-plugin",
                                "gpl",
                                "metano"
                            ],
                            "enumTitles": [
                                "Petrol",
                                "Diesel",
                                "Electric",
                                "Hybrid",
                                "Plug-in Hybrid",
                                "LPG",
                                "Natural gas (CNG)"
                            ]
                        }
                    },
                    "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": [
                                "berlina",
                                "station-wagon",
                                "suv",
                                "city-car",
                                "coupe",
                                "cabrio",
                                "monovolume",
                                "pick-up"
                            ],
                            "enumTitles": [
                                "Sedan",
                                "Station wagon",
                                "SUV",
                                "City car",
                                "Coupe",
                                "Convertible",
                                "Minivan / MPV",
                                "Pickup"
                            ]
                        }
                    },
                    "transmission": {
                        "title": "Transmission",
                        "enum": [
                            "any",
                            "manuale",
                            "automatico"
                        ],
                        "type": "string",
                        "description": "Gearbox type.",
                        "default": "any"
                    },
                    "priceMin": {
                        "title": "Minimum price (EUR)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "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": 1000000,
                        "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": 1950,
                        "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": 1950,
                        "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. 100000. Leave empty for no upper bound."
                    },
                    "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 of 25, and the last page is always returned in full — so you may receive a few more than this number.",
                        "default": 100
                    },
                    "imageResolution": {
                        "title": "Image resolution",
                        "enum": [
                            "small",
                            "medium",
                            "large"
                        ],
                        "type": "string",
                        "description": "Resolution of listing images. Higher resolution means larger files.",
                        "default": "medium"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
