# OLX Scraper 🛒 (6 countries, price alerts, no proxy) (`tagadanar/olx-scraper`) Actor

Scrape OLX classifieds across Poland, Portugal, Ukraine, Romania, Bulgaria and Kazakhstan: title, price, location, seller type, photos and attributes from OLX's own JSON API. Monitor mode alerts you to new listings only. No residential proxy needed. $0.50 per 1,000 listings.

- **URL**: https://apify.com/tagadanar/olx-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 listing scrapeds

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

## OLX Scraper: Price, Location, Photos & New-Listing Alerts

Pull structured classified-ad data from OLX. Give it a search term and a country and you get back a clean list of offers: title, price with currency, location, seller type, photos, the offer's attributes and its timestamps. It works across six OLX marketplaces: Poland, Portugal, Ukraine, Romania, Bulgaria and Kazakhstan.

It reads OLX's own offers API, so it is fast and returns complete records, not half-loaded page fragments. There is no browser to time out, no login, and no residential proxy requirement: it runs fine on plain datacenter IPs, so you are not paying a proxy surcharge on top of every listing the way most OLX scrapers make you. Turn on monitor mode and it remembers what it has already seen, so scheduled runs surface only the new listings and can post them straight to Slack.

### What you get per listing

| Field | Description |
| --- | --- |
| `title`, `url` | Offer title and the canonical OLX listing URL |
| `price` | Amount, currency, formatted label and whether it is negotiable (all null when the offer is free or unpriced) |
| `location` | City, district when present, and region |
| `sellerType` | `business` or `private` |
| `params` | The offer's own attributes flattened by key, e.g. condition, model, memory |
| `category` | Category slug for the offer |
| `photos`, `photosCount` | Up to 10 image URLs and the total photo count |
| `description` | Listing description, HTML stripped (full text with `fetchDetails`) |
| `createdAt`, `refreshedAt`, `validTo` | When it was posted, last bumped, and its expiry |
| `country`, `source` | The OLX country you searched, e.g. `pl` / `olx.pl` |

### Who uses it

- **Resellers and arbitrage** watching for underpriced items the moment they are listed.
- **Price and market research**: pull thousands of offers for a product and analyze asking prices, condition and location.
- **Dealers and shops** tracking competing listings for the categories they trade in.
- **Agents and data pipelines** that need classifieds data as clean JSON.

### Input examples

Scrape recent iPhone listings in Poland:

```json
{
  "country": "pl",
  "query": ["iphone"],
  "maxResults": 200
}
````

Several searches at once, with a price ceiling:

```json
{
  "country": "ro",
  "query": ["playstation 5", "xbox series x"],
  "priceMax": 2000,
  "maxResults": 500
}
```

A new-listings alert feed (schedule this and point it at Slack):

```json
{
  "country": "pt",
  "query": ["iphone 15 pro"],
  "priceMax": 900,
  "monitorMode": true,
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ"
}
```

### Output sample

```json
{
  "offerId": "1060219957",
  "title": "iPhone 17 Pro Max 256GB",
  "price": { "value": 5599, "currency": "PLN", "label": "5 599 zł", "negotiable": false },
  "location": { "city": "Tychy", "district": null, "region": "Śląskie" },
  "params": { "state": "Używane", "phonemodel": "iPhone 17 Pro Max", "builtinmemory_phones": "256GB" },
  "category": "electronics",
  "sellerType": "business",
  "photosCount": 7,
  "photos": ["https://ireland.apollo.olxcdn.com/v1/files/awlrhgkydqb22-PL/image;s=800x600"],
  "createdAt": "2026-03-12T09:39:53+01:00",
  "refreshedAt": "2026-07-07T10:28:38+02:00",
  "validTo": "2026-07-23T12:48:35+02:00",
  "country": "pl",
  "source": "olx.pl",
  "url": "https://www.olx.pl/d/oferta/...html"
}
```

### Pricing

You pay per listing returned. Platform usage is included in the price, so there is no subscription, no minimum and no usage line on your bill.

| Event | Price |
| --- | --- |
| Listing scraped | $0.002 per listing ($2 per 1,000) |
| Digest sent (monitor mode) | $0.03 per digest |

### FAQ

**Which countries are supported?** Six OLX marketplaces: Poland (`pl`), Portugal (`pt`), Ukraine (`ua`), Romania (`ro`), Bulgaria (`bg`) and Kazakhstan (`kz`). Pick one per run with the `country` input. Each is a separate marketplace with its own listings and currency.

**Does it need a proxy?** No. The OLX API answers plain requests, so the actor uses no proxy at all and there is nothing to configure.

**Does it get seller phone numbers?** No. OLX puts private seller phone numbers behind a login, so this actor does not scrape or promise them. You get the public offer, its price, location and photos.

**How do I only get new listings?** Turn on `monitorMode` and schedule the actor. It remembers offers from previous runs (per `monitorName`) and returns only new ones, and it can post them to a webhook or Slack.

**How many listings can I pull?** As many as the search has. Raise `maxResults`; the actor paginates through OLX for you, and pagination is not capped.

**Can I filter by category or region?** Yes. Pass the numeric `categoryId` or `regionId` (both appear in OLX category and region URLs), plus `priceMin` / `priceMax` for a price band.

### For AI agents and MCP

Every field comes back as clean, typed JSON, so this actor drops straight into an agent tool or an MCP server. Point your agent at a search term and a country and it gets a structured feed of live classifieds with no HTML parsing.

***

### Something missing?

If you need an extra field, another OLX country, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More monitors and data Actors are on [my profile](https://apify.com/tagadanar).

*OLX scraper, OLX classifieds API, scrape OLX.pl, OLX price data, classifieds monitor, second-hand marketplace scraper, OLX Poland Portugal Ukraine Romania, new listings alert, reselling arbitrage feed.*

# Actor input Schema

## `country` (type: `string`):

Which OLX country site to search. Each country is a separate marketplace.

## `query` (type: `array`):

One search per entry. Use a product or keyword, e.g. <code>iphone</code>, <code>playstation 5</code>, <code>rower</code>.

## `categoryId` (type: `integer`):

Optional. Restrict to one OLX category by its numeric id (visible in the OLX category URL). Leave empty to search all categories.

## `regionId` (type: `integer`):

Optional. Restrict to one OLX region by its numeric id. Leave empty to search the whole country.

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

Optional. Only return offers priced at or above this amount (in the country's currency).

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

Optional. Only return offers priced at or below this amount (in the country's currency).

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

Total offers to return across all searches.

## `fetchDetails` (type: `boolean`):

Fetch each offer's detail page for the complete description. Slower and uses one extra request per offer.

## `monitorMode` (type: `boolean`):

Remember offers seen on previous runs and return only new listings. Combine with a schedule and a webhook for a new-listings alert feed.

## `monitorName` (type: `string`):

Label for the remembered-listings set. Use different names to track different searches independently.

## `webhookUrl` (type: `string`):

Optional. In monitor mode, new offers are posted here as a digest (Slack incoming webhook or any endpoint accepting JSON).

## Actor input object example

```json
{
  "country": "pl",
  "query": [
    "iphone"
  ],
  "maxResults": 20,
  "fetchDetails": false,
  "monitorMode": false,
  "monitorName": "default"
}
```

# Actor output Schema

## `listings` (type: `string`):

One item per offer in the default dataset.

# 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 = {
    "query": [
        "iphone"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/olx-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 = {
    "query": ["iphone"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/olx-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 '{
  "query": [
    "iphone"
  ],
  "maxResults": 20
}' |
apify call tagadanar/olx-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Scraper 🛒 (6 countries, price alerts, no proxy)",
        "description": "Scrape OLX classifieds across Poland, Portugal, Ukraine, Romania, Bulgaria and Kazakhstan: title, price, location, seller type, photos and attributes from OLX's own JSON API. Monitor mode alerts you to new listings only. No residential proxy needed. $0.50 per 1,000 listings.",
        "version": "0.1",
        "x-build-id": "3oIeq72Ho9anTdX3y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~olx-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-olx-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/tagadanar~olx-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-olx-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/tagadanar~olx-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-olx-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",
                "required": [
                    "query"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "pl",
                            "pt",
                            "ua",
                            "ro",
                            "bg",
                            "kz"
                        ],
                        "type": "string",
                        "description": "Which OLX country site to search. Each country is a separate marketplace.",
                        "default": "pl"
                    },
                    "query": {
                        "title": "Search terms",
                        "minItems": 1,
                        "type": "array",
                        "description": "One search per entry. Use a product or keyword, e.g. <code>iphone</code>, <code>playstation 5</code>, <code>rower</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category id",
                        "type": "integer",
                        "description": "Optional. Restrict to one OLX category by its numeric id (visible in the OLX category URL). Leave empty to search all categories."
                    },
                    "regionId": {
                        "title": "Region id",
                        "type": "integer",
                        "description": "Optional. Restrict to one OLX region by its numeric id. Leave empty to search the whole country."
                    },
                    "priceMin": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. Only return offers priced at or above this amount (in the country's currency)."
                    },
                    "priceMax": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. Only return offers priced at or below this amount (in the country's currency)."
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Total offers to return across all searches.",
                        "default": 40
                    },
                    "fetchDetails": {
                        "title": "Fetch full description per offer",
                        "type": "boolean",
                        "description": "Fetch each offer's detail page for the complete description. Slower and uses one extra request per offer.",
                        "default": false
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new listings)",
                        "type": "boolean",
                        "description": "Remember offers seen on previous runs and return only new listings. Combine with a schedule and a webhook for a new-listings alert feed.",
                        "default": false
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "type": "string",
                        "description": "Label for the remembered-listings set. Use different names to track different searches independently.",
                        "default": "default"
                    },
                    "webhookUrl": {
                        "title": "Webhook / Slack URL",
                        "type": "string",
                        "description": "Optional. In monitor mode, new offers are posted here as a digest (Slack incoming webhook or any endpoint accepting JSON)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```