# Webmotors Scraper + FIPE: Mobiauto, OLX, Kavak (`allanmxr/brazil-used-cars-scraper`) Actor

Used cars for sale in Brazil from Webmotors, Mobiauto, OLX Autos and Kavak in one flat dataset, each listing compared with the FIPE table: FIPE price, FIPE code and % above or below. Filter by brand, model, year, state, city, price, mileage, gearbox and dealer or private seller. No login or API key.

- **URL**: https://apify.com/allanmxr/brazil-used-cars-scraper.md
- **Developed by:** [Allan Marcelino](https://apify.com/allanmxr) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 used car listings

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?

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

## Brazil Used Cars Scraper: Webmotors, Mobiauto, OLX + FIPE

Used cars for sale in Brazil from **Webmotors, Mobiauto, OLX Autos and Kavak** in one flat dataset, and every listing compared with the **FIPE table**: FIPE price, FIPE code and how many % the asking price is above or below it. Search by brand, model, model year, state and city, filter by price, mileage, gearbox and dealer or private seller, or keep only the cars priced below FIPE.

No login, no API key, no browser. Runs in 256 MB.

### Why this one

- **Four portals, one schema.** The same field names, the same units and the same vocabulary (`automatic`, `flex`, `dealer`) whatever the source, so you can sort the whole market in one table.
- **FIPE built in.** Each listing gets `fipe_price`, `fipe_code`, `fipe_model` and `fipe_diff_pct` (negative = below FIPE), matched by brand, model year, engine size, transmission and trim. Webmotors listings also carry the FIPE percentage the portal itself shows, so they have a FIPE price even when the API is not reached.
- **Deal filter.** `Only deals below FIPE = -10` returns only cars at least 10% under the FIPE reference.
- **Private sellers stay private.** No names, phones or e-mails of individuals, ever (LGPD). Dealer names are kept where the portal marks the seller as a company.

### Input

| Field | What it does |
|---|---|
| Sources | Webmotors, Mobiauto and OLX Autos by default. Kavak (its own stock, almost all in São Paulo) is optional. |
| Brand, Model | For example `Honda` and `Civic`, `Volkswagen` (or `VW`) and `Polo`, `Chevrolet` (or `GM`) and `Onix`. Leave both empty for every car of the place. A brand or model a portal does not know is skipped on that portal, never replaced by its whole stock. |
| Model year from / to | Model year range. |
| State, City | UF and city name. Empty state means the whole country. |
| Minimum / Maximum price, Maximum mileage | In BRL and km. |
| Transmission | Any, manual, or automatic (includes CVT and automated). |
| Seller type | Any, dealer or private. |
| Compare with FIPE | On by default. |
| Only deals below FIPE (max difference %) | For example `-10`. |
| FIPE API token | Optional token from fipe.online to raise the FIPE request budget. |
| Max items | You pay per listing; the budget is shared equally between the sources. |

Example:

```json
{
  "sources": ["webmotors", "mobiauto", "olx"],
  "brand": "Toyota",
  "model": "Corolla",
  "state": "SP",
  "minYear": 2020,
  "maxYear": 2023,
  "maxMileageKm": 80000,
  "transmission": "automatic",
  "maxFipeDiffPct": -5,
  "maxItems": 200
}
```

### Output

One item per listing:

```json
{
  "source": "webmotors",
  "listing_id": "81532253",
  "url": "https://www.webmotors.com.br/comprar/honda/civic/20-16v-flexone-sport-4p-cvt/4-portas/2020/81532253",
  "title": "HONDA CIVIC 2.0 16V FLEXONE SPORT 4P CVT 2020",
  "brand": "HONDA",
  "model": "CIVIC",
  "version": "2.0 16V FLEXONE SPORT 4P CVT",
  "year_manufacture": 2020,
  "year_model": 2020,
  "mileage_km": 80000,
  "transmission": "cvt",
  "fuel": "flex",
  "color": "Preto",
  "body_type": "Sedã",
  "doors": 4,
  "price": 109500,
  "city": "São Paulo",
  "state": "SP",
  "seller_type": "private",
  "seller_name": null,
  "cover_image": "https://image.webmotors.com.br/_fotos/anunciousados/gigante/2026/202610/20261024/hondacivic2016vflexonesport4pcvt-WMIMAGEM1655014846.jpg",
  "images": ["https://image.webmotors.com.br/_fotos/anunciousados/gigante/2026/202610/20261024/hondacivic2016vflexonesport4pcvt-WMIMAGEM1655014846.jpg"],
  "fipe_code": "014092-9",
  "fipe_model": "Civic Sedan SPORT 2.0 Flex 16V Aut.4p",
  "fipe_price": 109897,
  "fipe_diff_pct": -0.4,
  "fipe_match_confidence": "high",
  "fipe_source": "api",
  "fipe_reference_month": "novembro de 2026",
  "published_at": null,
  "scraped_at": "2026-11-19T01:21:22.732120+00:00"
}
```

What each portal has:

| Field | Webmotors | Mobiauto | OLX | Kavak |
|---|---|---|---|---|
| Year of manufacture | yes | yes | no | no |
| Color | yes | no | yes | no |
| Fuel | from the version | yes | yes | from the version |
| Seller type | dealer or private | dealer | dealer or private | dealer (Kavak) |
| Dealer name | yes | no | no | Kavak |
| Photos | all | all | all | one |
| Published date | no | no | yes | no |

### FIPE

Prices come from the public FIPE API (parallelum), which allows about 1000 requests a day per IP. The Actor caches every request within a run and spends at most 300 of them without a token (3000 with one). A search for one model in a few years needs about 30 requests whatever the number of listings; an open search across all brands runs out sooner, and later listings then get no FIPE price (Webmotors listings still get one from the portal's own FIPE percentage, marked `fipe_source: "listing"`). `fipe_match_confidence` is `high` when one FIPE version clearly wins and `medium` when it is close; unmatched listings have null FIPE fields.

### Limits

- Filters run on the portals' own servers wherever they support them (price, mileage, years, gearbox, private seller), so selective searches stay fast and cheap.
- A single search reaches at most 10,000 listings on Webmotors and 5,000 on OLX; narrow by state, years or price for more.
- One request at a time per portal, with a pause between requests.
- iCarros is not included: it switched off its classifieds search.
- No CAPTCHA solving, no login. If a portal answers with an interactive challenge the source stops and the others carry on (see `RUN_SUMMARY` in the key-value store).

### Pricing

Pay per event: one `listing` event per car in the dataset. Filters run before the charge, so listings that do not pass your filters are never billed.

### Em português

**Carros usados à venda no Brasil com comparação FIPE.** Busque carros seminovos e usados na Webmotors, Mobiauto, OLX Autos e Kavak de uma vez só, com preço, quilometragem, ano, câmbio, combustível, cor, cidade, UF, fotos e link, e veja quanto cada anúncio está acima ou abaixo da tabela FIPE.

- **Carros usados em São Paulo, Rio de Janeiro, Belo Horizonte, Curitiba, Porto Alegre** ou qualquer cidade: escolha a UF e a cidade.
- **Abaixo da FIPE:** use `maxFipeDiffPct: -10` para listar só carros pelo menos 10% abaixo da FIPE, ótimo para revenda, repasse e lojistas.
- **Loja ou particular:** filtre por tipo de vendedor. Nome, telefone e e-mail de particular nunca saem (LGPD).
- **Exemplos de busca:** Honda Civic usado SP, Chevrolet Onix seminovo, Toyota Corolla automático abaixo da FIPE, Volkswagen Polo em Campinas, Jeep Compass diesel, Hyundai HB20 até 60 mil.

Pesquisa de preço de carro usado, monitoramento de estoque de concorrentes, precificação de seminovos e análise de mercado automotivo com a tabela FIPE em um só dataset.

# Actor input Schema

## `sources` (type: `array`):

Portals to search. The listing budget (Max items) is shared equally between them. Kavak (own stock, almost all in São Paulo) is off by default.

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

Car brand as written on the portals, for example Honda, Volkswagen, Chevrolet, Fiat, Toyota.

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

Model name, for example Civic, Onix, HR-V, Corolla Cross. Needs a brand.

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

Oldest model year to include.

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

Newest model year to include.

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

State (UF) where the car is sold. Leave empty for the whole country.

## `city` (type: `string`):

City name, for example Campinas. Needs the state above.

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

Lowest asking price in reais.

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

Highest asking price in reais.

## `maxMileageKm` (type: `integer`):

Highest odometer reading in kilometers.

## `transmission` (type: `string`):

Automatic includes CVT and automated gearboxes.

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

Dealers (stores, dealerships, rental companies) or private sellers. Private sellers are never named in the output.

## `includeFipe` (type: `boolean`):

Adds the FIPE reference price, FIPE code and the difference in % for every listing, from the public FIPE API.

## `maxFipeDiffPct` (type: `integer`):

Keeps only listings whose price is at most this % above or below FIPE. Use -10 for cars at least 10% below FIPE. Listings without a FIPE price are dropped.

## `fipeApiToken` (type: `string`):

Token from fipe.online. Without it the run uses at most 300 FIPE API requests (about one model in all its versions and years per run is fine); with it, up to 3000.

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

Maximum number of listings to return (you pay per listing).

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

Leave empty: the Actor starts without a proxy and moves to Apify Proxy only when a portal blocks it.

## Actor input object example

```json
{
  "sources": [
    "webmotors",
    "mobiauto",
    "olx"
  ],
  "brand": "Honda",
  "model": "Civic",
  "minYear": 2018,
  "maxYear": 2022,
  "state": "SP",
  "transmission": "any",
  "sellerType": "any",
  "includeFipe": true,
  "maxItems": 20
}
```

# Actor output Schema

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

All listings 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 = {
    "sources": [
        "webmotors",
        "mobiauto",
        "olx"
    ],
    "brand": "Honda",
    "model": "Civic",
    "minYear": 2018,
    "maxYear": 2022,
    "state": "SP",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("allanmxr/brazil-used-cars-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 = {
    "sources": [
        "webmotors",
        "mobiauto",
        "olx",
    ],
    "brand": "Honda",
    "model": "Civic",
    "minYear": 2018,
    "maxYear": 2022,
    "state": "SP",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("allanmxr/brazil-used-cars-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 '{
  "sources": [
    "webmotors",
    "mobiauto",
    "olx"
  ],
  "brand": "Honda",
  "model": "Civic",
  "minYear": 2018,
  "maxYear": 2022,
  "state": "SP",
  "maxItems": 20
}' |
apify call allanmxr/brazil-used-cars-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,allanmxr/brazil-used-cars-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/rl6bcaIDVfF7jXkED/builds/aMq9hvscPphmLyV2z/openapi.json
