# OtoMoto Scraper (`rastriq/otomoto-scraper`) Actor

Scrapes car listings from OtoMoto.pl (Poland). Extracts price, mileage, year, fuel type, location and more.

- **URL**: https://apify.com/rastriq/otomoto-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## OtoMoto Scraper — Poland Car Listings

**OtoMoto Scraper** extracts structured car listing data from [otomoto.pl](https://www.otomoto.pl), Poland's largest online automotive marketplace. Use this Apify Actor to collect prices, specifications, seller details and images from over 200,000 active vehicle listings without writing a single line of code.

### What is OtoMoto Scraper?

OtoMoto is Poland's number-one platform for buying and selling cars, motorcycles and commercial vehicles. Owned by OLX Group (part of the Adevinta network), it hosts more than 200,000 passenger-car listings at any given time, posted by private sellers and professional dealers across all 16 voivodeships.

**OtoMoto Scraper** connects to the platform's server-side rendered pages and extracts the embedded `__NEXT_DATA__` payload, meaning it works without a headless browser, keeps costs low and runs fast. Each run produces a clean, structured dataset ready for analysis, dashboards or integration into your data pipeline.

Typical use cases include used-car price monitoring and benchmarking across the Polish market, market analysis segmented by brand, model, fuel type or region, dealer inventory tracking and lead generation, cross-border price comparisons within the EU, and feeding automotive intelligence dashboards or valuation models.

### What data does OtoMoto Scraper extract?

Every listing is returned as a flat JSON object with 20 fields:

| Emoji | Field | Description |
|-------|-------|-------------|
| :id: | `id` | OtoMoto listing ID |
| :blue\_car: | `title` | Full listing title |
| :factory: | `make` | Car brand (BMW, Audi, Toyota, Mercedes-Benz...) |
| :car: | `model` | Model name (Seria 3, A4, Corolla...) |
| :wrench: | `version` | Trim level or engine variant |
| :calendar: | `year` | First registration year |
| :straight\_ruler: | `km` | Mileage in kilometres |
| :horse: | `hp` | Engine horsepower |
| :moneybag: | `price` | Asking price in PLN |
| :currency\_exchange: | `currency` | Currency code — always PLN |
| :fuelpump: | `fuel_type` | Benzyna, Diesel, Elektryczny, Hybryda, LPG |
| :gear: | `gearbox` | Manualna or Automatyczna |
| :earth\_africa: | `origin` | Kraj (domestic) or imported |
| :cityscape: | `city` | Seller city |
| :round\_pushpin: | `region` | Voivodeship / administrative region |
| :office: | `is_professional` | `true` for dealers, `false` for private sellers |
| :camera: | `img_url` | Primary listing image URL |
| :link: | `url` | Direct link to the listing on OtoMoto |
| :globe\_with\_meridians: | `source` | Always `otomoto` |
| :clock1: | `scraped_at` | ISO 8601 extraction timestamp |

### How to use OtoMoto Scraper

1. **Go to the Actor page** — Navigate to the OtoMoto Scraper page on Apify and click **Start**.
2. **Configure your filters** — Set the brand, model, fuel type, price range or year range to narrow results. Leave fields empty to scrape the full catalogue.
3. **Set limits** — Use `maxPages` and `maxItems` to control how many listings are collected. The defaults (3 pages / 50 items) are great for a quick test.
4. **Choose a proxy** — For best results, select Apify Residential proxies with a Poland (`PL`) country hint. Datacenter proxies may also work for small runs.
5. **Run the Actor** — Click **Start** and watch the log. OtoMoto Scraper will paginate through the search results and push each listing to the default dataset.
6. **Download your data** — When the run finishes, open the **Output** tab. Export as **JSON**, **CSV** or **Excel** — ready to open in any spreadsheet, BI tool or database.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | *(empty)* | Car brand to filter (e.g. `BMW`, `Audi`, `Mercedes-Benz`) |
| `model` | string | *(empty)* | Car model to filter (e.g. `Seria-3`, `A4`) |
| `fuel` | string | *(empty)* | Fuel type: `benzyna`, `diesel`, `elektryczny`, `hybryda`, `lpg` |
| `minPrice` | integer | *(empty)* | Minimum price in PLN |
| `maxPrice` | integer | *(empty)* | Maximum price in PLN |
| `minYear` | integer | *(empty)* | Minimum first registration year |
| `maxYear` | integer | *(empty)* | Maximum first registration year |
| `maxPages` | integer | 3 | Maximum number of search-result pages to scrape |
| `maxItems` | integer | 50 | Maximum total listings to return |

### Output example

```json
{
  "id": "otomoto-12345",
  "title": "BMW Seria 3 320d xDrive M Sport",
  "make": "BMW",
  "model": "Seria 3",
  "version": "320d xDrive",
  "year": 2021,
  "km": 52000,
  "hp": 190,
  "price": 159900,
  "currency": "PLN",
  "fuel_type": "Diesel",
  "gearbox": "Automatyczna",
  "origin": "Kraj",
  "city": "Warszawa",
  "region": "Mazowieckie",
  "is_professional": true,
  "img_url": "https://ireland.apollo.olxcdn.com/v1/files/abc123.jpg",
  "url": "https://www.otomoto.pl/osobowe/oferta/bmw-seria-3-320d-ID12345.html",
  "source": "otomoto",
  "scraped_at": "2026-07-01T10:30:00Z"
}
```

### Pricing

OtoMoto Scraper uses Apify's pay-per-event pricing model:

- **Actor start**: $0.005 per run
- **Listing scraped**: $0.001 per result

That works out to roughly **$1.00 per 1,000 listings**. A full-catalogue run of 200,000+ listings costs approximately $200. You can keep costs down by setting tight filters and using `maxItems` to cap the output.

### Related Actors

Looking for car listings from other European markets? Check out these scrapers by [Rastriq](https://apify.com/rastriq):

- [Nettiauto Scraper](https://apify.com/rastriq/nettiauto-scraper) — Finland's largest car marketplace
- [Polovni Automobili Scraper](https://apify.com/rastriq/polovni-automobili-scraper) — Serbia's leading auto platform
- [Coches.net Scraper](https://apify.com/rastriq/coches-net-scraper) — Spain's top car classifieds

Combine multiple scrapers to build a pan-European automotive price intelligence dataset.

### FAQ

**Is scraping OtoMoto legal?**
OtoMoto Scraper accesses only publicly available listing pages — the same information any visitor sees in a browser. It does not bypass authentication, CAPTCHAs or access restrictions. Always review the platform's terms of service and your local regulations before running large-scale extractions.

**Does OtoMoto Scraper require a login?**
No. All data is extracted from public search-result pages. No OtoMoto account is needed.

**How many results can I get?**
OtoMoto typically hosts over 200,000 passenger-car listings. OtoMoto Scraper can collect all of them in a single run — just set `maxItems` high enough and allow sufficient pages. For most analytical use cases, filtering by brand, model or region and collecting 1,000–10,000 listings is both fast and affordable.

**How often should I run it?**
Listings on OtoMoto change daily. For price monitoring, a weekly or bi-weekly schedule gives a good balance between freshness and cost. For real-time alerts, you can run the Actor hourly on a narrow filter set.

### Resumen en espanol

**OtoMoto Scraper** extrae datos estructurados de anuncios de coches en [otomoto.pl](https://www.otomoto.pl), el mayor marketplace de vehiculos de Polonia. Recopila precio, kilometraje, ano, tipo de combustible, ubicacion e imagen de mas de 200.000 anuncios activos. Los resultados se exportan en JSON, CSV o Excel, listos para analisis de mercado, monitorizacion de precios o integracion con herramientas de BI. Desarrollado por [Rastriq](https://rastriq.io).

# Actor input Schema

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

Car make to filter (e.g. BMW, Audi, Mercedes-Benz)

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

Car model to filter (e.g. Seria-3, A4)

## `fuel` (type: `string`):

Fuel type: benzyna, diesel, elektryczny, hybryda, lpg

## `minPrice` (type: `integer`):

Minimum price filter

## `maxPrice` (type: `integer`):

Maximum price filter

## `minYear` (type: `integer`):

Minimum first registration year

## `maxYear` (type: `integer`):

Maximum first registration year

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

Maximum number of search result pages to scrape

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

Maximum number of listings to return

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

Apify proxy configuration

## Actor input object example

```json
{
  "maxPages": 3,
  "maxItems": 50
}
```

# Actor output Schema

## `results` (type: `string`):

Car listings extracted from OtoMoto. Each item contains title, make, model, year, km, price, fuel type, location and image.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/otomoto-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/otomoto-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 '{}' |
apify call rastriq/otomoto-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/LQe2J8Hb8lDc8cZmM/builds/jBGzLPOrl0MncP5EB/openapi.json