# Hasznaltauto.hu Scraper - Hungarian Used Car Marketplace (`trev0n/hasznaltauto-scraper`) Actor

Extract used-car and vehicle listings from Hasznaltauto.hu — Hungary's largest car marketplace. Prices, year, mileage, fuel, transmission, equipment, photos, seller and dealer info across cars, motorcycles, trucks, trailers, motorhomes, caravans and buses. Includes incremental monitoring.

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

## Pricing

from $2.00 / 1,000 listing results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

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

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

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

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

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

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

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

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


# README

## 🚗 Hasznaltauto.hu Scraper — Hungarian Used Car Marketplace

🎯 **Extract every used-car, motorcycle, truck and camper listing from Használtautó.hu — Hungary's #1 vehicle marketplace with 100,000+ live ads — in minutes, not weeks.**

This scraper collects complete, structured vehicle data: prices in HUF and EUR, year, mileage, fuel type, transmission, engine specs, full equipment lists, photo galleries, seller and dealership details. Perfect for market analysis, price tracking, lead generation and inventory monitoring.

### 🚀 What Does It Do?

This scraper automatically browses Használtautó.hu and collects **structured, ready-to-use data** from vehicle listings. No manual browsing needed — just set your filters and hit Start.

💡 **Two modes of operation:**

1. **🔍 Discovery Mode** — pick a vehicle category (cars, motorcycles, light commercial vehicles, trucks, buses, caravans & motorhomes, trailers, machinery), optionally narrow by brand and model, and let the scraper walk through every result page.
2. **📋 Direct URL Mode** — paste specific Használtautó.hu listing or ad URLs and get exactly those scraped.

Plus a headline extra: **📡 Incremental Monitoring** — run it on a schedule and receive only NEW, UPDATED or REAPPEARED ads. The first run builds a baseline; every later run outputs just the changes, which keeps recurring monitoring extremely cheap.

### 👥 Who Is This For?

| 🏢 Use Case                         | 💬 How It Helps                                                                            |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| 📊 **Car dealerships**              | Track competitor pricing and stock across Hungary, spot underpriced trade-in opportunities |
| 💰 **Vehicle traders & importers**  | Find arbitrage deals between the Hungarian market and neighbouring countries               |
| 📈 **Market analysts & fintechs**   | Build price indexes, residual-value models and market reports from real asking prices      |
| 🔎 **Car buyers & flippers**        | Monitor a saved search daily and be the first to call when a bargain appears               |
| 🤝 **Lead generation agencies**     | Collect dealership names, locations and inventory for B2B outreach                         |
| 🛡️ **Insurers & leasing companies** | Verify declared vehicle values against live market data                                    |

### ✨ Features

- 🚗 **All 8 vehicle categories** — cars, motorcycles, light commercial vehicles, trucks, buses, caravans & motorhomes, trailers and machinery
- 🏷️ **Full pricing data** — asking price in HUF and EUR, straight from each ad
- 📋 **Complete specs** — year, mileage, fuel, transmission, engine size, power, body type, color, condition
- 🧰 **Full equipment lists** — every option and extra the seller ticked, from ISOFIX to head-up display
- 📸 **Full photo galleries** — direct links to every high-resolution photo of each vehicle
- 🏪 **Seller intelligence** — dealer vs. private seller, dealership name and street address
- 📡 **Incremental monitoring** — schedule it and only pay for NEW / UPDATED / REAPPEARED ads, with repost detection
- 🎛️ **Smart Filters** — price range, year range, fuel type and transmission filters on top of brand/model targeting
- 🧹 **Deduplication** — every ad appears exactly once per run, even across overlapping searches
- ⚡ **Fast & Scalable** — collect thousands of listings per run with automatic pagination
- 📤 **Export Anywhere** — Download results as JSON, CSV, Excel, or push to Google Sheets, Zapier, Make, or your CRM

### 🎛️ Filters & Options

| Option                        | What It Does                                                                                                     |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| 🚙 **Vehicle Category**       | Choose cars, motorcycles, light commercial vehicles, trucks, buses, caravans & motorhomes, trailers or machinery |
| 🏭 **Brand & Model**          | Target one make (e.g. BMW) or a specific model (e.g. BMW 320)                                                    |
| 💰 **Price Range**            | Keep only ads between your minimum and maximum price in forints                                                  |
| 📅 **Year Range**             | Limit results to vehicles manufactured within a year range                                                       |
| ⛽ **Fuel Type**              | Petrol, diesel, electric, hybrid — match any fuel label                                                          |
| ⚙️ **Transmission**           | Automatic-only or manual-only filtering                                                                          |
| 📄 **Full Ad Details**        | Optionally open every ad for equipment lists, galleries, seller address and full specs                           |
| 📡 **Incremental Monitoring** | Emit only new/changed ads on recurring runs, with optional expired-ad alerts                                     |
| 🔢 **Max Results**            | Control how many items to extract per run                                                                        |
| 🔗 **Direct URLs**            | Optionally provide specific URLs to scrape                                                                       |

### 📦 What You Get (Output Fields)

Every vehicle ad includes:

#### 🚗 Vehicle Identity

| Field    | Example                                                                           |
| -------- | --------------------------------------------------------------------------------- |
| id       | `23296982`                                                                        |
| url      | `https://www.hasznaltauto.hu/szemelyauto/bmw/225/bmw_225xe_iperformance-23296982` |
| title    | `BMW 225xe iPerformance Advantage (Automata)`                                     |
| make     | `BMW`                                                                             |
| model    | `225`                                                                             |
| trim     | `225xe iPerformance Advantage (Automata)`                                         |
| category | `szemelyauto`                                                                     |

#### 📋 Technical Specs

| Field        | Example                           |
| ------------ | --------------------------------- |
| year         | `2016`                            |
| month        | `2`                               |
| fuel         | `Hibrid (Benzin)`                 |
| transmission | `Automata (6 fokozatú tiptronic)` |
| mileage      | `186366`                          |
| engineCm3    | `1499`                            |
| powerKw      | `100`                             |
| powerHp      | `136`                             |
| bodyType     | `Egyterű`                         |
| color        | `Szürke`                          |
| condition    | `Normál`                          |
| drive        | `Összkerék`                       |

#### 💰 Pricing

| Field    | Example   |
| -------- | --------- |
| price    | `4470000` |
| currency | `HUF`     |
| priceEur | `12548`   |

#### 🏪 Seller

| Field      | Example                   |
| ---------- | ------------------------- |
| sellerType | `dealer`                  |
| sellerName | `AUTO26.HU`               |
| location   | `1151, Külső Fóti út 26.` |

#### 📸 Content

| Field       | Example                                                                                 |
| ----------- | --------------------------------------------------------------------------------------- |
| options     | `["bőr belső", "tempomat", "ISOFIX rendszer", ...]`                                     |
| images      | `["https://img.hasznaltautocdn.com/2048x1536/23296982/28573446.jpg", ...]`              |
| imageCount  | `30`                                                                                    |
| description | `BMW 225xe iPerformance Advantage eladó. A vételár 3 év műszaki garanciát tartalmaz...` |
| scrapedAt   | `2026-07-14T18:30:00.000Z`                                                              |

### 📊 Example Output

```json
{
    "id": "23296982",
    "url": "https://www.hasznaltauto.hu/szemelyauto/bmw/225/bmw_225xe_iperformance_advantage-23296982",
    "title": "BMW 225 225xe iPerformance Advantage (Automata)",
    "make": "BMW",
    "model": "225",
    "trim": "225xe iPerformance Advantage (Automata)",
    "category": "szemelyauto",
    "year": 2016,
    "month": 2,
    "fuel": "Hibrid (Benzin)",
    "transmission": "Automata (6 fokozatú tiptronic)",
    "mileage": 186366,
    "engineCm3": 1499,
    "powerKw": 100,
    "powerHp": 136,
    "price": 4470000,
    "currency": "HUF",
    "priceEur": 12548,
    "condition": "Normál",
    "bodyType": "Egyterű",
    "color": "Szürke",
    "drive": "Összkerék",
    "seats": 5,
    "doors": 5,
    "sellerType": "dealer",
    "sellerName": "AUTO26.HU",
    "location": "1151, Külső Fóti út 26.",
    "options": ["bőr belső", "tempomat", "ISOFIX rendszer", "multifunkciós kormánykerék"],
    "images": ["https://img.hasznaltautocdn.com/2048x1536/23296982/28573446.jpg"],
    "imageCount": 30,
    "description": "BMW 225xe iPerformance Advantage (Automata) eladó. A vételár 3 év műszaki garanciát tartalmaz...",
    "scrapedAt": "2026-07-14T18:30:00.000Z"
}
````

### 📋 Dataset Views

The Apify Console gives you **4 ready-made table views** to quickly browse your results:

| View                   | What It Shows                                                         |
| ---------------------- | --------------------------------------------------------------------- |
| 📊 **Overview**        | Title, make, model, year, mileage, fuel, price and seller at a glance |
| 💰 **Pricing & specs** | Price in HUF and EUR next to engine, power, body type and condition   |
| 🏪 **Sellers**         | Dealer names, addresses and seller types — perfect for lead lists     |
| 📡 **Monitoring**      | Change type, first/last seen and repost flags for scheduled runs      |

### ❓ FAQ

**🤔 How many ads can it collect?**
As many as you need — the cars section alone has over 100,000 live ads. Set Max Results to 0 for unlimited, or cap the run at any number.

**🤔 What's the difference between the fast mode and Full Ad Details?**
The fast mode reads everything visible on result pages (title, price, year, mileage, fuel, seller). Full Ad Details additionally opens every ad to grab the complete equipment list, all photos, the seller's address and the full spec sheet.

**🤔 How does incremental monitoring save money?**
The first run stores a fingerprint of every ad. Later runs compare against it and only output ads that are new, changed or came back — typically 80–95% fewer records charged on a daily schedule.

**🤔 Can I track when a car is sold?**
Yes — enable "Emit expired ads" in monitoring mode and you'll get an EXPIRED record the day an ad disappears.

**🤔 Can I export the data?**
Yes — JSON, CSV, Excel, XML, HTML, RSS. You can also push data directly to Google Sheets, Zapier, Make, or any webhook/API endpoint.

**🤔 How often should I run this?**
For fresh data, run daily or weekly. You can schedule automatic runs on Apify with just a few clicks.

**🤔 Does it work with proxies?**
Yes — residential proxies are recommended for the best results. The scraper works with Apify's built-in proxy service.

### 🛠️ Need Custom Filters or Features?

**I'm happy to customize this scraper for your specific needs!** 🤝

Whether you need:

- 🎯 Additional filters (mileage range, body type, region, dealer-only, specific equipment)
- 📊 Extra data fields or custom output formats
- 🔄 Integration with your CRM, Google Sheets, or database
- ⏰ Scheduled scraping with automatic deduplication
- 🌐 Scraping from other car marketplace platforms alongside Használtautó.hu

👉 **Don't hesitate to reach out via private message** — I respond quickly and I'm always open to building exactly what you need. No request is too small or too specific!

### ⚖️ Legal & Ethical Use

This scraper collects **only publicly available information** from Használtautó.hu. It does not access private data, bypass authentication, or collect personal contact details of private individuals. Please use the data responsibly and in compliance with applicable laws and platform terms of service.

# Actor input Schema

## `category` (type: `string`):

Which vehicle section to browse. Ignored if you provide Start URLs below.

## `brand` (type: `string`):

Vehicle brand to browse, e.g. "BMW", "Mercedes-Benz", "Suzuki". Leave empty to browse the whole category.

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

Model within the brand, e.g. "320", "golf", "octavia". Requires a brand. Leave empty for all models.

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

Direct hasznaltauto.hu URLs to scrape — browse listings (e.g. https://www.hasznaltauto.hu/szemelyauto/bmw) or single ad pages. When provided, these override the category/brand/model above.

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

Stop after collecting this many ads across all pages. Set 0 for unlimited.

## `maxPages` (type: `integer`):

Stop after this many result pages per listing (about 25 ads per page). Set 0 for all pages.

## `detailEnrichment` (type: `boolean`):

Visit every ad page to add the complete equipment list, full description, all gallery photos, seller name/address, body type, color, condition and full technical specs. Slower — each ad costs one extra page view.

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

Only keep ads at or above this price in Hungarian forints. 0 = no minimum.

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

Only keep ads at or below this price in Hungarian forints. 0 = no maximum.

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

Only keep vehicles manufactured in or after this year. 0 = no minimum.

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

Only keep vehicles manufactured in or before this year. 0 = no maximum.

## `fuelType` (type: `string`):

Only keep ads whose fuel matches, e.g. "benzin", "dízel", "elektromos", "hibrid". Substring match as shown on the site. Leave empty for all.

## `transmissionType` (type: `string`):

"automata" keeps only automatic vehicles; "manuális" keeps only the rest. Leave empty for all.

## `incrementalMode` (type: `boolean`):

Track state across runs and emit only NEW / UPDATED / REAPPEARED ads. The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring of a search.

## `stateKey` (type: `string`):

Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically.

## `emitUnchanged` (type: `boolean`):

Also output ads whose content didn't change since the last run.

## `emitExpired` (type: `boolean`):

Also output a record for ads that disappeared since the last run (changeType = EXPIRED) — usually means the vehicle was sold.

## `skipReposts` (type: `boolean`):

Drop new ads detected as reposts of a recently expired one (same content, new id).

## `maxConcurrency` (type: `integer`):

How many listings to process in parallel (each runs its own stealth browser and pays its own Cloudflare clearance). Pagination within a listing stays sequential. Keep modest.

## `maxRequestRetries` (type: `integer`):

How many times to retry a page that didn't clear the Cloudflare challenge.

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

hasznaltauto.hu blocks datacenter IPs at the Cloudflare layer — RESIDENTIAL proxies are required. Hungarian IPs clear the challenge most reliably.

## Actor input object example

```json
{
  "category": "szemelyauto",
  "brand": "bmw",
  "model": "320",
  "maxResults": 25,
  "maxPages": 0,
  "detailEnrichment": false,
  "priceMin": 0,
  "priceMax": 0,
  "yearMin": 0,
  "yearMax": 0,
  "fuelType": "dízel",
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "skipReposts": false,
  "maxConcurrency": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "HU"
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "brand": "bmw",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "HU"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trev0n/hasznaltauto-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 = {
    "brand": "bmw",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "HU",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("trev0n/hasznaltauto-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 '{
  "brand": "bmw",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "HU"
  }
}' |
apify call trev0n/hasznaltauto-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hasznaltauto.hu Scraper - Hungarian Used Car Marketplace",
        "description": "Extract used-car and vehicle listings from Hasznaltauto.hu — Hungary's largest car marketplace. Prices, year, mileage, fuel, transmission, equipment, photos, seller and dealer info across cars, motorcycles, trucks, trailers, motorhomes, caravans and buses. Includes incremental monitoring.",
        "version": "0.1",
        "x-build-id": "pdaMJhw90TspqHpgN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trev0n~hasznaltauto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trev0n-hasznaltauto-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/trev0n~hasznaltauto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trev0n-hasznaltauto-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/trev0n~hasznaltauto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trev0n-hasznaltauto-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": {
                    "category": {
                        "title": "Vehicle category",
                        "enum": [
                            "szemelyauto",
                            "motor",
                            "kishaszonjarmu",
                            "haszonjarmu",
                            "autobusz",
                            "lakokocsi",
                            "potkocsi",
                            "munkagep"
                        ],
                        "type": "string",
                        "description": "Which vehicle section to browse. Ignored if you provide Start URLs below.",
                        "default": "szemelyauto"
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Vehicle brand to browse, e.g. \"BMW\", \"Mercedes-Benz\", \"Suzuki\". Leave empty to browse the whole category."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model within the brand, e.g. \"320\", \"golf\", \"octavia\". Requires a brand. Leave empty for all models."
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Direct hasznaltauto.hu URLs to scrape — browse listings (e.g. https://www.hasznaltauto.hu/szemelyauto/bmw) or single ad pages. When provided, these override the category/brand/model above.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after collecting this many ads across all pages. Set 0 for unlimited.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many result pages per listing (about 25 ads per page). Set 0 for all pages.",
                        "default": 0
                    },
                    "detailEnrichment": {
                        "title": "Fetch full ad details",
                        "type": "boolean",
                        "description": "Visit every ad page to add the complete equipment list, full description, all gallery photos, seller name/address, body type, color, condition and full technical specs. Slower — each ad costs one extra page view.",
                        "default": false
                    },
                    "priceMin": {
                        "title": "Minimum price (Ft)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep ads at or above this price in Hungarian forints. 0 = no minimum.",
                        "default": 0
                    },
                    "priceMax": {
                        "title": "Maximum price (Ft)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep ads at or below this price in Hungarian forints. 0 = no maximum.",
                        "default": 0
                    },
                    "yearMin": {
                        "title": "Minimum year",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep vehicles manufactured in or after this year. 0 = no minimum.",
                        "default": 0
                    },
                    "yearMax": {
                        "title": "Maximum year",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep vehicles manufactured in or before this year. 0 = no maximum.",
                        "default": 0
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "type": "string",
                        "description": "Only keep ads whose fuel matches, e.g. \"benzin\", \"dízel\", \"elektromos\", \"hibrid\". Substring match as shown on the site. Leave empty for all."
                    },
                    "transmissionType": {
                        "title": "Transmission",
                        "enum": [
                            "",
                            "automata",
                            "manuális"
                        ],
                        "type": "string",
                        "description": "\"automata\" keeps only automatic vehicles; \"manuális\" keeps only the rest. Leave empty for all."
                    },
                    "incrementalMode": {
                        "title": "Incremental monitoring mode",
                        "type": "boolean",
                        "description": "Track state across runs and emit only NEW / UPDATED / REAPPEARED ads. The first run builds a baseline; later runs charge only for the diff — ideal for cheap recurring monitoring of a search.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "type": "string",
                        "description": "Custom identifier for the monitoring baseline. Leave empty to derive it from the search config automatically."
                    },
                    "emitUnchanged": {
                        "title": "Emit unchanged ads",
                        "type": "boolean",
                        "description": "Also output ads whose content didn't change since the last run.",
                        "default": false
                    },
                    "emitExpired": {
                        "title": "Emit expired ads",
                        "type": "boolean",
                        "description": "Also output a record for ads that disappeared since the last run (changeType = EXPIRED) — usually means the vehicle was sold.",
                        "default": false
                    },
                    "skipReposts": {
                        "title": "Skip reposts",
                        "type": "boolean",
                        "description": "Drop new ads detected as reposts of a recently expired one (same content, new id).",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "How many listings to process in parallel (each runs its own stealth browser and pays its own Cloudflare clearance). Pagination within a listing stays sequential. Keep modest.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max page retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many times to retry a page that didn't clear the Cloudflare challenge.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "hasznaltauto.hu blocks datacenter IPs at the Cloudflare layer — RESIDENTIAL proxies are required. Hungarian IPs clear the challenge most reliably.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "HU"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
