# Otomoto.pl Car Listings Scraper (`solidcode/otomoto-pl-scraper`) Actor

\[💰 $4 / 1K] Extract car listings from Otomoto.pl, Poland's largest auto marketplace — price, make, model, year, mileage, fuel, gearbox, specs, equipment, seller phone, location & photos. Search by make/model, price, year, mileage, fuel, body type & region, or paste any Otomoto URL.

- **URL**: https://apify.com/solidcode/otomoto-pl-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 9 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Otomoto.pl Car Listings Scraper

Pull car and vehicle listings from Otomoto.pl — Poland's largest automotive marketplace — at scale: prices with Otomoto's price-rating badge, full specifications, equipment lists, every gallery photo, seller details, CEPiK verification, and map coordinates for each listing. Build a search from plain filters or paste any Otomoto URL — no hand-crafted links required. Built for car dealers, market analysts, valuation teams, and lead-generation specialists who need fresh Polish used-car data without browsing thousands of listings by hand.

### Why This Scraper?

- **Search by plain filters, not raw URLs** — pick make, model, condition, fuel, body, gearbox, seller type, region, and price/year/mileage ranges; the actor builds the Otomoto search for you, so non-technical users never touch a search link.
- **16 Polish voivodeship region filters** — narrow to Mazowieckie, Śląskie, Małopolskie, or any of the 16 regions to target a specific local market.
- **8 fuel types including LPG, CNG, electric, plug-in hybrid, and hydrogen** — go far beyond petrol/diesel to isolate alternative-fuel and EV inventory.
- **10 body-type filters** — sedan, hatchback, estate (kombi), SUV, coupe, convertible, minivan, compact, pickup, and city car.
- **16 vehicle spec fields per listing** — engine capacity (cc), power (HP), gearbox, drivetrain, doors, seats, colour, trim name, plus VIN on about 9 in 10 cars and the Polish first-registration date on about 4 in 10.
- **Seller phone numbers on ~98% of dealer listings** — plus dealer name, private-vs-dealer type, and a seller ID that groups every car from the same dealer, when contact collection is enabled.
- **Every gallery photo at full resolution** — the complete image URL set per listing plus an image count and thumbnail, not just the cover shot.
- **CEPiK verification flag and geo coordinates** — each row carries the official Polish vehicle-registry verification status plus latitude/longitude for mapping and territory analysis.
- **Otomoto's own BELOW/IN/ABOVE market badge, plus 5 sort orders** — see how Otomoto rates each asking price against the market, and order results by price, year, mileage, or most recently listed.

### Use Cases

**Dealer Market Research**

- Track competing dealer inventory by make, model, and region
- Benchmark your asking prices against live market listings
- Spot pricing gaps using Otomoto's price-rating badge
- Monitor how fast specific models turn over in a voivodeship

**Price Analysis & Valuation**

- Build used-car valuation models from real listing prices, mileage, and year
- Compare petrol vs. diesel vs. EV pricing across the same model
- Analyze depreciation curves by first-registration date and mileage
- Feed live PLN pricing into appraisal and trade-in tools

**Lead Generation**

- Collect dealer and private-seller contact details for outreach
- Identify dealers carrying high-value or in-demand inventory
- Build targeted seller lists filtered by region and brand
- Find listings without CEPiK verification to offer inspection services

**Inventory Sourcing & Arbitrage**

- Find underpriced cars flagged with a favorable price rating
- Source specific trims, fuel types, or body styles for buyers
- Track newly listed vehicles by sorting on most recently listed
- Locate damaged-condition cars for repair-and-resell operations

**Automotive Research**

- Study EV and hybrid adoption across Polish regions
- Map the fuel-type mix of the Polish used-car market
- Analyze feature and equipment trends by segment
- Track seasonal supply and pricing shifts over time

### Getting Started

#### Search by Make

The simplest run — every listing for a single brand:

```json
{
    "make": "bmw",
    "maxResults": 100
}
```

#### Filtered Market Search

Combine structured filters to target an exact segment:

```json
{
    "make": "audi",
    "model": "a4-avant",
    "condition": "used",
    "fuelType": ["diesel"],
    "bodyType": ["estate"],
    "gearbox": "automatic",
    "region": "mazowieckie",
    "priceMin": 40000,
    "priceMax": 90000,
    "yearMin": 2017,
    "mileageMax": 150000,
    "sortBy": "priceAsc",
    "maxResults": 500
}
```

#### Paste an Otomoto URL

Already have a saved search? Paste the URL and the filters above are ignored:

```json
{
    "startUrls": [
        "https://www.otomoto.pl/osobowe/volkswagen/golf",
        "https://www.otomoto.pl/osobowe/oferta/toyota-corolla-ID6H4abc.html"
    ],
    "includeSellerContacts": true,
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste one or more Otomoto URLs — a search results page, a brand/category page, or an individual listing. When provided, the search filters below are ignored. |

#### Search Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `make` | string | `""` | Car brand, e.g. "bmw", "audi", "volkswagen". Leave empty for all makes. |
| `model` | string | `""` | Exact Otomoto model slug for the chosen make, e.g. "seria-3" (BMW), "golf" (VW), "a4-avant" (Audi). Leave empty for all models; an unrecognized slug returns all listings for the make. |
| `keyword` | string | `""` | Optional free-text term (best effort). For dependable filtering, use make, model, and the structured filters. |
| `condition` | select | `Any` | Any, New, Used, or Damaged. |
| `fuelType` | string\[] | `[]` | One or more of Petrol, Diesel, LPG, Hybrid, Plug-in Hybrid, Electric, CNG, Hydrogen. Empty = all. |
| `bodyType` | string\[] | `[]` | One or more of Sedan, Hatchback, Estate, SUV, Coupe, Convertible, Minivan, Compact, Pickup, City car. Empty = all. |
| `gearbox` | select | `Any` | Any, Manual, or Automatic. |
| `sellerType` | select | `Any` | Any, Private seller, or Dealer / business. |
| `region` | select | `Any region` | Limit to one of 16 Polish voivodeships, or search all of Poland. |

#### Price, Year & Mileage

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | `null` | Lowest price in PLN. Leave empty for no lower bound. |
| `priceMax` | integer | `null` | Highest price in PLN. Leave empty for no upper bound. |
| `yearMin` | integer | `null` | Earliest production year (e.g. 2015). |
| `yearMax` | integer | `null` | Latest production year. |
| `mileageMax` | integer | `null` | Maximum mileage in kilometres. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Relevance` | Relevance, Price (low/high), Year (newest first), Mileage (low to high), or Recently listed. |
| `includeListingDetails` | boolean | `true` | Enrich each result from its full listing page (complete specs, equipment, all photos, seller location, description). Disable for a faster, lighter run. |
| `includeSellerContacts` | boolean | `false` | Also collect the listing's seller phone number. Slower, because each listing page is opened. |
| `maxResults` | integer | `100` | Exact number of listings to return across all searches and URLs — ask for 100 and you get 100, never more. Set to 0 for unlimited (capped at roughly 160,000 per search as a safety limit). |

### Output

Each listing is one flat row in the dataset. Here's a real result from a recent run, with full details and seller contacts enabled:

```json
{
    "listingId": "6150499017",
    "url": "https://www.otomoto.pl/osobowe/oferta/mercedes-benz-klasa-e-ID6IeRL3.html",
    "title": "Mercedes-Benz Klasa E 300de 9G-TRONIC AMG Line NIGHT Edition",
    "price": 174700,
    "priceCurrency": "PLN",
    "priceEvaluation": "BELOW",
    "make": "mercedes-benz",
    "model": "klasa-e",
    "version": "300de 9G-TRONIC AMG Line NIGHT Edition",
    "year": 2024,
    "mileage": 166000,
    "fuelType": "plugin-hybrid",
    "gearbox": "automatic",
    "transmission": "rear-wheel",
    "engineCapacity": 1993,
    "enginePower": 313,
    "bodyType": "sedan",
    "color": "grey",
    "doorCount": 4,
    "seatCount": 5,
    "condition": "Used",
    "vin": "W1KLH0JB0RA028383",
    "firstRegistration": "2024-09-03",
    "sellerName": "Daw-Trans",
    "sellerType": "Dealer",
    "sellerId": "18421165",
    "sellerPhone": "691 865 012",
    "city": "Włocławek",
    "region": "Kujawsko-pomorskie",
    "latitude": 52.65975,
    "longitude": 19.07799,
    "imageUrls": [
        "https://ireland.apollo.olxcdn.com/v1/files/eyJhbGciOiJIUzI1NiIsInR5…/image",
        "https://ireland.apollo.olxcdn.com/v1/files/eyJmbiI6IjQ5Nm9oN29kOHNu…/image"
    ],
    "imageCount": 40,
    "thumbnailUrl": "https://ireland.apollo.olxcdn.com/v1/files/s1i32hlkcuks-OTOMOTOPL/image;s=640x480",
    "features": [
        "Apple CarPlay",
        "Android Auto",
        "Interfejs Bluetooth",
        "Klimatyzacja automatyczna: dwustrefowa",
        "Tapicerka skórzana",
        "Kamera cofania"
    ],
    "isPromoted": false,
    "isHighlighted": false,
    "cepikVerified": false,
    "description": "Mercedes W214 E300DE 313PS\nSilnik diesel 197 km + silnik elektryczny 116 km o zasięgu do 100 km\nLampy DIGITAL LED Matrix\nZawieszenie pneumatyczne…",
    "createdAt": "2026-09-10T16:17:23Z",
    "sourceUrl": "https://www.otomoto.pl/osobowe?search%5Bprivate_business%5D=business",
    "scrapedAt": "2026-09-10T21:45:10.320796+00:00"
}
```

Long arrays and text are shortened above for readability — this listing actually carries 40 photo URLs and 63 equipment entries, and the full description text.

**A note on value formats.** Vehicle attributes come through in Otomoto's own vocabulary, which is deliberate and useful:

- `make`, `model`, `fuelType`, `gearbox`, `transmission`, `bodyType` and `color` are lowercase Otomoto keys — `mercedes-benz`, `klasa-e`, `plugin-hybrid`, `automatic`, `rear-wheel`, `sedan`, `grey`. The `make` and `model` values paste straight back into this actor's own `make` and `model` inputs, so you can chain a broad sweep into targeted follow-up runs without any lookup table.
- `condition`, `sellerType`, `city` and `region` come through capitalised and ready to read — `Used`, `Dealer`, `Włocławek`, `Kujawsko-pomorskie`.
- `features` and `description` are the seller's own Polish text, exactly as published on Otomoto.

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Otomoto listing identifier (stable deduplication key) |
| `url` | string | Canonical listing URL |
| `title` | string | Listing headline as shown on Otomoto |
| `price` | number | Numeric price |
| `priceCurrency` | string | Currency — `PLN` on every listing |
| `priceEvaluation` | string | Otomoto's price-rating badge: `BELOW`, `IN` or `ABOVE` market. Around 6 in 10 listings carry a rating; empty when Otomoto has not rated the listing |
| `condition` | string | `Used`, `New` or `Damaged`. Left empty when the listing itself states no condition — this happens on a small share of cars cross-posted from OLX, and an empty value is more honest than a guess |
| `createdAt` | string | When the listing was published or last refreshed, e.g. `2026-09-10T16:17:23Z` |
| `sourceUrl` | string | The search or listing URL this row was discovered from |
| `scrapedAt` | string | Timestamp of extraction, e.g. `2026-09-10T21:45:10.320796+00:00` |

#### Vehicle Specs

| Field | Type | Description |
|-------|------|-------------|
| `make` | string | Otomoto brand key, lowercase — `bmw`, `audi`, `mercedes-benz`. Pastes straight back into the `make` input |
| `model` | string | Otomoto model key, lowercase — `x3`, `klasa-e`, `a4-limousine`. Pastes straight back into the `model` input |
| `version` | string | Trim as the seller wrote it — `M340i xDrive`, `300de 9G-TRONIC AMG Line NIGHT Edition`. Present on roughly 7 in 10 listings |
| `year` | integer | Production year |
| `mileage` | integer | Mileage in kilometres |
| `fuelType` | string | `petrol`, `diesel`, `hybrid`, `plugin-hybrid`, `electric`, `petrol-lpg`. Note that LPG cars come back as `petrol-lpg` while the matching input value is `lpg` |
| `gearbox` | string | `manual` or `automatic` |
| `transmission` | string | Drivetrain — `front-wheel`, `rear-wheel`, `all-wheel-permanent`, `all-wheel-auto`, `all-wheel-lock`. Present on roughly 9 in 10 listings |
| `engineCapacity` | integer | Engine displacement in cc (empty on most electric cars) |
| `enginePower` | integer | Power in HP |
| `bodyType` | string | `sedan`, `combi`, `suv`, `compact`, `minivan`, `coupe`, `cabrio`, `city-car`, `mini`. Otomoto's own wording differs from the input names in two places: an estate comes back as `combi` and a convertible as `cabrio` |
| `color` | string | Exterior colour — `black`, `grey`, `white`, `silver`, `navy-blue`, and so on |
| `doorCount` | integer | Number of doors |
| `seatCount` | integer | Number of seats, when the seller stated it (roughly 9 in 10 listings) |
| `vin` | string | VIN, when the seller published it (roughly 9 in 10 listings) |
| `firstRegistration` | string | First registration date as `YYYY-MM-DD`, e.g. `2024-09-03`. Around 4 in 10 listings carry one — older and imported cars usually do, brand-new and electric stock often does not |

#### Seller & Location

| Field | Type | Description |
|-------|------|-------------|
| `sellerName` | string | Seller / dealer name |
| `sellerType` | string | `Private` or `Dealer` |
| `sellerId` | string | Seller identifier — groups every listing from the same dealer |
| `sellerPhone` | string | Phone number, filled on about 98% of listings when seller contacts are enabled (empty otherwise) |
| `city` | string | Polish city name, e.g. `Warszawa` |
| `region` | string | Voivodeship, e.g. `Mazowieckie` |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Media & Signals

| Field | Type | Description |
|-------|------|-------------|
| `imageUrls` | string\[] | Full-resolution gallery image URLs — the complete set, often 20–40 per listing |
| `imageCount` | integer | Number of images (always matches the length of `imageUrls`) |
| `thumbnailUrl` | string | Primary thumbnail at 640×480 |
| `features` | string\[] | Equipment list in the seller's Polish, e.g. `ABS`, `Tempomat`, `Elektryczne szyby przednie`, `Kamera cofania` |
| `description` | string | The seller's own description as plain text with line breaks, no markup (detail mode only) |
| `isPromoted` | boolean | Promoted / featured listing flag |
| `isHighlighted` | boolean | Highlighted listing flag |
| `cepikVerified` | boolean | CEPiK (Polish vehicle registry) verification flag |

### Tips for Best Results

- **Start small** — set `maxResults` to 20–50 on a first run to confirm the data fits your needs, then scale up.
- **Toggle details for speed vs. depth** — set `includeListingDetails` to `false` for a fast price sweep (search-result fields only); set it to `true` for full specs, VIN, equipment, all photos, and seller location.
- **Paste a fully-filtered Otomoto search URL** to mirror an exact saved search — any filter you applied on the website is preserved, and the structured filters are skipped.
- **Phone numbers require detail mode** — enabling `includeSellerContacts` opens each listing page, so combine it with a tight filter and a modest `maxResults` to keep runs efficient.
- **Use `region` to segment by market** — running the same make/model across each voivodeship reveals regional pricing differences that a national search hides.
- **Lean on structured filters over `keyword`** — make, model, fuel, body, and the price/year/mileage ranges are exact; the free-text keyword is best-effort and may not narrow results.
- **Chain a broad sweep into targeted runs** — the `make` and `model` values in the output are the same keys the inputs accept, so you can run one wide search, pick the models that matter (`klasa-e`, `a4-limousine`, `seria-3`), and feed them straight back in without looking anything up.
- **Sort by "Recently listed"** to capture fresh inventory first when monitoring a market on a schedule.
- **Expect some gaps on optional fields** — VIN, trim name, seat count, price rating and first-registration date depend on what each seller filled in, so filter on them rather than assuming every row has them.

### Pricing

**From $4.00 per 1,000 results** — undercuts comparable Otomoto data tools while delivering richer specs, photos, and verified seller details. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.425 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.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, valuation, and lead generation. You are responsible for complying with applicable laws and Otomoto.pl's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal data (such as seller contact details) in line with GDPR and local privacy regulations.

# Actor input Schema

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

Paste one or more Otomoto.pl URLs — a search results page, a brand/category page, or an individual listing (e.g. 'https://www.otomoto.pl/osobowe/bmw' or a single car page). When you provide URLs here, the search filters below are ignored. Handy when you already have a saved Otomoto search.

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

Car brand, e.g. 'bmw', 'audi', 'volkswagen', 'toyota'. Leave empty for all makes.

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

Exact Otomoto model slug for the chosen make, e.g. 'seria-3' (BMW), 'golf' (Volkswagen), 'a4-avant' (Audi). Copy it from an Otomoto URL. Leave empty for all models. An unrecognized slug returns all listings for the make.

## `keyword` (type: `string`):

Optional free-text term, e.g. 'kombi', 'panorama', 'salon polska'. Best-effort only — Otomoto does not expose a reliable public free-text filter, so this may not narrow results. For dependable filtering, use Make, Model, and the structured filters below. Leave empty to skip.

## `condition` (type: `string`):

Filter by vehicle condition.

## `fuelType` (type: `array`):

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

## `bodyType` (type: `array`):

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

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

Transmission type.

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

Filter listings by who is selling.

## `region` (type: `string`):

Limit results to a Polish voivodeship. Leave as 'Any region' to search all of Poland.

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

Only include cars at or above this price, in Polish złoty. Leave empty for no lower bound.

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

Only include cars at or below this price, in Polish złoty. Leave empty for no upper bound.

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

Only include cars produced in or after this year (e.g. 2015). Leave empty for any age.

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

Only include cars produced in or before this year. Leave empty for any age.

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

Only include cars with at most this many kilometres on the clock. Leave empty for any mileage.

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

How to order the search results. Defaults to Otomoto's relevance ranking.

## `includeListingDetails` (type: `boolean`):

When enabled, every result is enriched from its full listing page (complete specifications, equipment list, all gallery images, seller location, description). Disable for a faster, lighter run that returns only the fields shown on the search results.

## `includeSellerContacts` (type: `boolean`):

When enabled, the actor also collects available dealer/seller phone numbers. This makes the run slower because each listing page must be opened to reveal the contact details.

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

Maximum number of car listings to return in total across all searches and URLs. The actor stops exactly at this number, so you are never charged for results you didn't ask for. Set to 0 for unlimited (a single search is then capped at roughly 160,000 listings as a safety limit).

## Actor input object example

```json
{
  "startUrls": [],
  "make": "",
  "model": "",
  "keyword": "",
  "condition": "any",
  "fuelType": [],
  "bodyType": [],
  "gearbox": "any",
  "sellerType": "any",
  "region": "any",
  "sortBy": "relevance",
  "includeListingDetails": true,
  "includeSellerContacts": false,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of car listings with key fields like make, model, year, price, mileage, fuel, and location.

## `details` (type: `string`):

Full per-listing rows including specifications, equipment, seller contacts, coordinates, and images.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [],
    "make": "",
    "model": "",
    "keyword": "",
    "condition": "any",
    "fuelType": [],
    "bodyType": [],
    "gearbox": "any",
    "sellerType": "any",
    "region": "any",
    "sortBy": "relevance",
    "includeListingDetails": true,
    "includeSellerContacts": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/otomoto-pl-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [],
    "make": "",
    "model": "",
    "keyword": "",
    "condition": "any",
    "fuelType": [],
    "bodyType": [],
    "gearbox": "any",
    "sellerType": "any",
    "region": "any",
    "sortBy": "relevance",
    "includeListingDetails": True,
    "includeSellerContacts": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/otomoto-pl-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "make": "",
  "model": "",
  "keyword": "",
  "condition": "any",
  "fuelType": [],
  "bodyType": [],
  "gearbox": "any",
  "sellerType": "any",
  "region": "any",
  "sortBy": "relevance",
  "includeListingDetails": true,
  "includeSellerContacts": false,
  "maxResults": 100
}' |
apify call solidcode/otomoto-pl-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solidcode/otomoto-pl-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8ELHWHWgX6AmcA1Ua/builds/HtEAhtQxLc7A7GKl2/openapi.json