# OLX Brazil Scraper | Listings, Prices & Seller Data (`pedrocadev/olx-brazil-scraper`) Actor

\[💰 $100/500] Scrape OLX Brazil listings at scale. Extract titles, prices, descriptions, photos, seller details, location and category data from Brazil's largest classifieds marketplace by keyword or URL. Premium flat rate, enrichment included.

- **URL**: https://apify.com/pedrocadev/olx-brazil-scraper.md
- **Developed by:** [João Pedro Rodrigues](https://apify.com/pedrocadev) (community)
- **Categories:** E-commerce, Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## OLX Brazil Scraper

Extract listings from **OLX Brazil (olx.com.br)**, the largest classifieds site in the country with tens of millions of active ads. Give it search URLs, plain-text queries, or both. You get back structured data for every listing: title, price in BRL, photos, location down to neighbourhood level, category attributes and seller type. Turn on the detail option and you also get the full description, the seller's name and the CEP postal code.

**$100 per 500 listings.** Premium flat rate with detail enrichment included and no compute or platform charges on top.

### Why this scraper

✅ **Any olx.com.br URL works.** Search pages, category pages, state paths like `/imoveis/venda/estado-sp`. Copy the URL from your browser with the filters you already applied and paste it.

✅ **Keyword search built in.** No URL needed. Type `iPhone 13` or `apartamento` and pick one of the 27 states, or search all of Brazil at once.

✅ **Filters run inside OLX's own query.** Price range, seller type and sorting are sent to OLX, not applied after the fact. Filtered-out ads never reach your dataset and never cost you anything.

✅ **Real sorting at the source.** Most relevant, newest first, cheapest first or most expensive first. Verified against the live site, including the price-descending order most scrapers get wrong.

✅ **Clean, typed output.** Prices come as integers plus the display string. Timestamps come as ISO 8601 plus epoch seconds. Data is read from OLX's own page payload, so fields match exactly what the site shows.

✅ **No duplicates.** Mix as many URLs and queries as you want in one run. Rows are de-duplicated by listing ID.

✅ **Honest limits.** OLX serves at most ~5,000 listings per search. When you hit that ceiling, the log tells you to split by state or category. When a search returns nothing, the log repeats the exact keyword, state and price range you used so you know what to loosen.

### What you can build with it

**Real estate analysis.** Track apartment and house inventory by state, city and neighbourhood. Compare asking prices across regions. Sort by newest to catch fresh listings the day they appear.

**Lead generation.** Filter to business sellers only and you have a prospect list of dealerships, real-estate agencies and resellers, with names and regions. Feed it straight into your CRM.

**Resale and arbitrage.** Watch prices for iPhones, consoles, notebooks or car parts. Set a tight `maxPrice` and sort cheapest-first to surface underpriced listings before anyone else.

**Market monitoring.** Run it on a schedule, push new rows to Google Sheets or Slack, and you have an alerting system for new listings that match your criteria.

**Data products.** Keep a classifieds aggregator, price index or dashboard updated with fresh OLX data, photos included.

### How to use it

1. Paste an OLX URL into **Search or Category URLs**, or type keywords into **Search Queries** (or both).
2. Set **Max Results** to 30-100 for a first test.
3. Pick a sort order and, for keyword searches, a state.
4. Optionally set a price range or restrict to business sellers.
5. Run it. Export from the dataset as JSON, CSV or Excel when it finishes.

#### Example: scrape a category URL

```json
{
    "searchUrls": ["https://www.olx.com.br/imoveis/venda/estado-sp"],
    "maxResults": 100
}
```

#### Example: keyword search in one state, newest first

```json
{
    "searchQueries": ["iPhone 13"],
    "state": "RJ",
    "sortBy": "newest",
    "maxResults": 200
}
```

#### Example: apartments in MG between R$100k and R$500k, business sellers, cheapest first

```json
{
    "searchUrls": ["https://www.olx.com.br/imoveis/venda/estado-mg"],
    "minPrice": 100000,
    "maxPrice": 500000,
    "sortBy": "price_asc",
    "includeBusinessOnly": true,
    "maxResults": 500
}
```

#### Example: cars from two states plus keyword queries, with full seller data

```json
{
    "searchUrls": [
        "https://www.olx.com.br/autos-e-pecas/carros-vans-e-utilitarios/estado-sp",
        "https://www.olx.com.br/autos-e-pecas/carros-vans-e-utilitarios/estado-rj"
    ],
    "searchQueries": ["Honda Civic", "Toyota Corolla"],
    "state": "SP",
    "minPrice": 30000,
    "maxPrice": 80000,
    "sortBy": "price_asc",
    "enrichDetails": true,
    "maxResults": 1000
}
```

### Input settings

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | string\[] | | One or more OLX Brazil URLs. Search pages, category pages and state paths all work. |
| `searchQueries` | string\[] | `[]` | Plain-text search terms, e.g. `iPhone 13`, `Gol G5`, `Apartamento`. |
| `maxResults` | integer | `100` | Cap across all URLs and queries. `0` means unlimited (internal cap of 50,000). |
| `sortBy` | select | Most Relevant | Newest First, Price: Low to High or Price: High to Low. If a URL already carries a sort parameter, the URL wins for that source. |
| `state` | select | (any) | Limits plain-text queries to one state by UF code (`SP`, `RJ`, `MG`...). Invalid codes fail with a clear error. URLs keep their own state. |
| `minPrice` | integer | (none) | Lowest price in R$, applied inside the OLX query. |
| `maxPrice` | integer | (none) | Highest price in R$, applied inside the OLX query. |
| `includeBusinessOnly` | boolean | `false` | Keep only ads from professional sellers (lojas e profissionais). |
| `enrichDetails` | boolean | `false` | Also open each listing page to get description, seller name and CEP. Billed at the enriched rate, takes longer. |

### Output

One row per listing. Real example with `enrichDetails` on:

```json
{
    "listingId": "1529647315",
    "title": "Notebook Gamer HP Victus 15 - Ryzen 5 + RTX 2050 | 16GB DDR5 + 1TB SSD",
    "description": "Notebook gamer em perfeito estado de conservação, com pouquíssimas marcas de uso...",
    "url": "https://pr.olx.com.br/regiao-de-curitiba-e-paranagua/informatica/notebooks/notebook-gamer-hp-victus-15-1529647315",
    "price": 3800,
    "priceDisplay": "R$ 3.800",
    "currency": "BRL",
    "city": "Curitiba",
    "state": "PR",
    "neighborhood": "Boqueirão",
    "locationDisplay": "Curitiba, Boqueirão - DDD 41",
    "zipcode": "81750370",
    "categoryId": "19020",
    "categoryName": "Notebooks",
    "parentCategoryName": "Informática",
    "photos": [
        "https://img.olx.com.br/images/62/623693558761903.jpg",
        "https://img.olx.com.br/images/71/715605558796206.jpg"
    ],
    "thumbnailUrl": "https://img.olx.com.br/images/62/623693558761903.jpg",
    "imageCount": 6,
    "videoCount": 0,
    "properties": [
        { "name": "Marca", "value": "HP" },
        { "name": "Condição", "value": "Usado - Excelente" },
        { "name": "Memória RAM", "value": "16 GB" }
    ],
    "seller": {
        "name": "Júlio César",
        "type": "private",
        "id": "41206719",
        "phoneAvailable": true
    },
    "isBusiness": false,
    "isFeatured": false,
    "postedAt": "2026-08-26T15:57:23+00:00",
    "postedAtTimestamp": 1787759843,
    "lastBumpAgeSecs": 0,
    "ddd": "41",
    "searchUrl": null,
    "searchQuery": "notebook gamer",
    "scrapedAt": "2026-08-27T14:10:00+00:00"
}
```

#### All fields

| Field | Type | Description |
|---|---|---|
| `listingId` | string | Unique OLX listing ID |
| `title` | string | Listing headline |
| `description` | string | Full description text (needs `enrichDetails`) |
| `url` | string | Listing URL on the regional subdomain |
| `price` | number | Integer price in R$. `null` when the ad says "À combinar" |
| `priceDisplay` | string | Price as shown on the site |
| `currency` | string | Always `BRL` |
| `city` | string | City name |
| `state` | string | Two-letter UF code |
| `neighborhood` | string | Neighbourhood name |
| `locationDisplay` | string | OLX's combined location string |
| `zipcode` | string | CEP postal code (needs `enrichDetails`) |
| `ddd` | string | Phone area code of the region |
| `categoryId` | string | OLX category ID |
| `categoryName` | string | Category label, e.g. Notebooks |
| `parentCategoryName` | string | Top-level category, e.g. Informática (needs `enrichDetails`) |
| `properties` | object\[] | Category attributes: bedrooms, area, mileage, year, RAM and so on |
| `photos` | string\[] | All image URLs in original resolution |
| `thumbnailUrl` | string | First photo |
| `imageCount` | number | Number of photos |
| `videoCount` | number | Number of videos |
| `seller.name` | string | Seller name (needs `enrichDetails`) |
| `seller.type` | string | `business` or `private` |
| `seller.id` | string | OLX seller ID (needs `enrichDetails`) |
| `seller.phoneAvailable` | boolean | Whether the ad has a phone contact (needs `enrichDetails`) |
| `isBusiness` | boolean | Same as `seller.type == "business"` |
| `isFeatured` | boolean | Promoted ad slot |
| `postedAt` | string | When the ad was listed, ISO 8601 |
| `postedAtTimestamp` | number | Same, in epoch seconds |
| `lastBumpAgeSecs` | number | Seconds since the seller last bumped the ad |
| `searchUrl` | string | Which input URL produced the row |
| `searchQuery` | string | Which input query produced the row |
| `scrapedAt` | string | Collection time, ISO 8601 |

### Pricing

**$100 per 500 listings ($0.20 per result), pay per result.** You only pay for rows that land in your dataset. Platform usage is included, so there is nothing to add for compute, storage writes or run time.

| Run | What you pay |
|---|---|
| 100 listings | $20.00 |
| 500 listings | $100.00 |
| 1,000 listings | $200.00 |
| 5,000 listings | $1,000.00 |

Detail enrichment (full description, seller name and CEP from each listing's own page) is included at the same rate. Turn on `enrichDetails` and the price per result does not change.

### Tips for better results

- Start with `maxResults` between 30 and 100 to check the data, then scale up.
- Broad keywords beat long phrases. OLX matches loosely and tight phrases drop real ads.
- Prefer `minPrice`/`maxPrice` over filtering in your own pipeline. They run inside the OLX query, so filtered ads cost you nothing.
- The cheap end of OLX has R$1 placeholder ads. For a clean cheapest-first sweep, combine `sortBy: "price_asc"` with a sensible `minPrice`.
- Keep `enrichDetails` off unless you need descriptions, seller names or CEPs. Everything else comes at the standard rate.
- Need more than 5,000 listings from one category? Split into several URLs by state or sub-category and run them together. Duplicates are removed automatically.

### Run it from your own code

Like every Apify Actor, you can start runs over the API and pull results as JSON:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("pedrocadev/olx-brazil-scraper").call(run_input={
    "searchQueries": ["iphone 13"],
    "state": "SP",
    "sortBy": "newest",
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["priceDisplay"], item["city"])
```

The same works in JavaScript with `apify-client`, or with plain HTTP calls. You can also schedule runs in the Apify Console and connect webhooks, Zapier, Make, n8n, Google Sheets or Slack to each finished run.

### FAQ

**How fresh is the data?**
Every run fetches the live site. Nothing is cached or replayed.

**Can I get listings from a specific city?**
Yes. Open olx.com.br, filter to your city, copy the URL and paste it into `searchUrls`. City and neighbourhood also come back on every row, so you can filter after the run too.

**What happens with ads without a price?**
Ads marked "À combinar" come back with `price: null` and the original text in `priceDisplay`. If you set a price filter, they are excluded.

**Does it collect phone numbers?**
No. OLX hides phone numbers behind authentication. The `seller.phoneAvailable` flag tells you whether the ad has a phone contact at all.

**Why did my run return fewer listings than maxResults?**
The search simply has fewer matching ads, or OLX's ~5,000 per-search ceiling was reached. The run log states which one happened.

**Is scraping OLX legal?**
This Actor only reads publicly accessible listing pages, the same content any visitor sees. You are responsible for using the data in line with applicable law, OLX's terms and the LGPD, especially for any personal data such as seller names. Do not use the data for spam or fraud.

### Support

Found a bug or need a field that is not in the output? Open an issue on the Actor's **Issues** tab and it will be looked at quickly. Feature requests are welcome.

# Actor input Schema

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

Paste one or more OLX Brazil URLs. Search pages, category pages and state path URLs (e.g. <code>https://www.olx.com.br/imoveis/venda/estado-sp</code>) are all supported.

## `searchQueries` (type: `array`):

Plain-text search terms, for example <code>iPhone 13</code>, <code>Gol G5</code> or <code>Apartamento</code>. Each query runs on OLX Brazil and returns matching listings.

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

Maximum number of listings to collect across all URLs and queries. Set to <code>0</code> for unlimited (capped internally at 50,000). OLX itself serves at most ~5,000 listings per search URL.

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

Order in which listings are collected, applied at OLX's own query layer. If a Search URL already specifies a sort order, that URL's sort wins and this setting is ignored for it.

## `state` (type: `string`):

Restrict plain-text Search Queries to one Brazilian state by UF code. Search URLs already carry their own state and take precedence.

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

Only include listings priced at or above this amount in Brazilian Reais. Applied at OLX's native query layer, so you never pay for out-of-budget rows.

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

Only include listings priced at or below this amount in Brazilian Reais. Applied at OLX's native query layer.

## `includeBusinessOnly` (type: `boolean`):

Only include ads posted by business sellers (lojas e profissionais) and exclude private individuals.

## `enrichDetails` (type: `boolean`):

Also collect each listing's full description, seller name and CEP postal code by visiting the listing page. Billed at the higher enriched rate and only when the details are actually found. Runs take longer with this on.

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

Proxies to use for OLX requests. Residential proxies are recommended if runs get blocked from datacenter IPs.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.olx.com.br/imoveis/venda/estado-sp"
  ],
  "searchQueries": [],
  "maxResults": 100,
  "sortBy": "relevance",
  "includeBusinessOnly": false,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped OLX listings as JSON. Each item has title, price in BRL, photos, location, category, seller info and timestamps.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchUrls": [
        "https://www.olx.com.br/imoveis/venda/estado-sp"
    ],
    "maxResults": 100
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchUrls": ["https://www.olx.com.br/imoveis/venda/estado-sp"],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("pedrocadev/olx-brazil-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 '{
  "searchUrls": [
    "https://www.olx.com.br/imoveis/venda/estado-sp"
  ],
  "maxResults": 100
}' |
apify call pedrocadev/olx-brazil-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pedrocadev/olx-brazil-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/fON2h0ZI8RG7bq6Hl/builds/ScQwJWdC9FPj7baCx/openapi.json