# Leilão de Veículos Brasil: Copart, Superbid (`allanmxr/brazil-vehicle-auctions-scraper`) Actor

Clean JSON of car, motorcycle and truck auction lots from 10 Brazilian sources: Copart, Superbid, Freitas, Sodré Santoro, Loop, VIP, Detran-SP and more. Current bid, year, mileage, location, salvage flag and optional FIPE discount. Filter by model, brand, state and price. No login or API key.

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

## Pricing

from $3.00 / 1,000 vehicle lots

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 Vehicle Auctions Scraper: Copart, Superbid, Sodré and more

Scrape car, motorcycle and truck auction lots from **10 Brazilian auction sources** in a single run and get one clean, flat dataset: Copart Brasil, Superbid (which includes Sold Leilões and Kron Leilões), Freitas Leiloeiro, Sodré Santoro, Rogério Menezes, Loop Leilões, VIP Leilões, Mega Leilões, Palácio dos Leilões and the Detran-SP auctions run by Sumaré Leilões.

Search by model, filter by brand, year, price, mileage, state, city, accident history and auction date, and optionally compare every lot with its **FIPE table price** to find cars sold below market. No login and no API keys are needed.

### Who it is for

Car dealers and resellers, auction buyers, parts and salvage buyers, price analysts and insurers who need every Brazilian auction lot in one place.

### Input

The input form has five sections.

**Search**

| Field | Description |
|---|---|
| `searchTerms` | Vehicle names, e.g. `["onix", "corolla xei"]`. A lot matches when it contains every word of at least one term. Empty means all vehicles. |
| `vehicleType` | `car` (default, includes SUVs and pickups), `motorcycle`, `truck` or `other`. Auction houses without that type are skipped. |
| `brands` | Only these brands (Chevrolet, Volkswagen, Toyota...). |
| `maxItems` | Maximum lots in the dataset, shared fairly across auction houses. No upper limit. |

**Filters**

| Field | Description |
|---|---|
| `yearMin`, `yearMax` | Model year range. Lots with an unreadable year are skipped when set. |
| `priceMin`, `priceMax` | In BRL, compared with the current bid or, without bids, the starting price. |
| `mileageMax` | In km. Lots whose auction house does not publish mileage are kept (check `mileageKm`). |
| `states`, `cities` | Where the vehicle is. |
| `damage` | `all`, `no_damage` or `damaged_only` (accident, insurance recovery, flood, scrap). |
| `auctionDateFrom`, `auctionDateTo` | Auction end date range (start date when the end is unknown). |

**Sources**: pick the auction houses. Sodré Santoro needs a browser, so it uses more compute. The others are read over plain HTTP.

**FIPE**: `includeFipe` adds the FIPE price. `minFipeDiscountPct` keeps only lots at least that far below FIPE, best first (it turns FIPE on and checks every candidate before `maxItems` is applied, so the run takes longer). `fipeApiToken` is optional.

**Advanced**: `proxyConfiguration`, used only by Sodré Santoro (Brazilian residential IPs). The other houses, Copart included, are read without a proxy.

#### Example input

```json
{
    "searchTerms": ["onix", "corolla"],
    "brands": ["CHEVROLET", "TOYOTA"],
    "yearMin": 2021,
    "priceMax": 90000,
    "states": ["SP", "RJ"],
    "damage": "no_damage",
    "includeFipe": true,
    "minFipeDiscountPct": 15,
    "maxItems": 100
}
```

### Output

One flat item per lot, the same fields for every auction house:

- Identity: `source`, `lotId`, `url`, `title`, `imageUrl`
- Vehicle: `vehicleType`, `brand`, `model`, `version`, `yearManufacture`, `yearModel`, `fuel`, `transmission`, `mileageKm` (fuel, transmission and mileage only when the auction house publishes them)
- Seller: `seller`, `origin`
- Location: `city`, `state`
- Price in BRL: `currentBid` (null when nobody bid), `startingPrice` (when there is no bid yet), `hasBids`
- Schedule: `auctionStart`, `auctionEnd` (ISO 8601 with the `-03:00` offset)
- Condition: `condition` (normalized: `sucata`, `grande monta`, `media monta`, `pequena monta`, `alagamento`, `incendio`, `recuperado`, `colisao`, `sinistro`, or null) and `isSalvage`
- FIPE (optional): `fipePrice`, `fipeModel`, `fipePriceMin`, `fipePriceMax`, `fipeDiscountPct`

```json
{
    "source": "loop",
    "lotId": "60093782",
    "url": "https://loopleiloes.com.br/leilao/exclusivo-financeiras/chevrolet-onix-hatch-1-0-12v-flex-5p-mec-2021-2022/2817/173882",
    "title": "CHEVROLET ONIX HATCH 1.0 12V Flex 5p Mec. 2021/2022",
    "vehicleType": "car",
    "brand": "CHEVROLET",
    "model": "ONIX",
    "version": "HATCH 1.0 12V Flex 5p Mec.",
    "yearManufacture": 2021,
    "yearModel": 2022,
    "fuel": "flex",
    "transmission": "manual",
    "mileageKm": 126219,
    "seller": "ITAPEVA VII MULTICARTEIRA FIDC NP",
    "city": "São José Dos Pinhais",
    "state": "PR",
    "currentBid": 29000,
    "startingPrice": null,
    "hasBids": true,
    "currency": "BRL",
    "auctionStart": "2026-11-18T14:03:00-03:00",
    "auctionEnd": "2026-11-18T14:03:00-03:00",
    "condition": null,
    "isSalvage": false
}
```

### Supported auction houses

| Key | Auction house | How it is read |
|---|---|---|
| `copart` | Copart Brasil | HTTP with a Chrome TLS fingerprint, no proxy |
| `superbid` | Superbid Exchange, including Sold Leilões and Kron Leilões (Kronberg), which sell on the same platform | HTTP |
| `freitas` | Freitas Leiloeiro | HTTP |
| `sodre` | Sodré Santoro | Browser + Brazilian residential proxy |
| `rogerio-menezes` | Rogério Menezes | HTTP (often no open auction) |
| `loop` | Loop Leilões | HTTP |
| `vip` | VIP Leilões | HTTP, paced (see below) |
| `mega-leiloes` | Mega Leilões | HTTP |
| `palacio-leiloes` | Palácio dos Leilões | HTTP |
| `detran-sp` | Detran-SP auctions run by Sumaré Leilões | HTTP, off by default (see below) |

One source failing (site down, layout change, blocked IP) never stops the others. `RUN_SUMMARY` in the key-value store has the status, listed and pushed counts and time of each source, plus the FIPE result counters. A source that has no open auction is `ok` with a `note`; one whose page layout no longer matches is `failed`, and the run status message lists it under `problems`.

### How a run works (and why it is cheap)

1. Each house is listed with its own filters whenever it has them, and the rest is filtered right away.
2. The list is cut to `maxItems`, taking lots from each house in turn.
3. Only the lots that stay get the extra page requests (seller, city, mileage, accident text) and the FIPE lookup.
4. Lots are pushed per house in batches, so a slow house never delays the others, and the time limit of each house is derived from the time left in the run.

Detran-SP is **not selected by default** either: about 80% of its lots are scrap (`condition` is `sucata`) and the rest are cars with documents. Detran-SP hands each auction to an outside auctioneer; this source reads the ones Sumaré Leilões runs, which is where the open Detran-SP lots are today. A full listing takes about 1 minute. Lots without bids carry the opening price in `startingPrice`; lots with bids carry `currentBid`.

VIP Leilões rate limits its search to about one request every 6 seconds, so a full VIP listing takes about 15 minutes. That is why **VIP is not selected by default**: add `vip` to `sources` when you want it, and use filters, search terms and `maxItems` to keep the run short.

### FIPE price comparison

With `includeFipe` on, each lot is matched against the public FIPE table through the free parallelum.com.br API:

- One FIPE entry fits: `fipePrice` and `fipeModel` are filled.
- A few entries fit equally well (the title leaves the trim out): only `fipePriceMin` and `fipePriceMax` are filled, the price band of those entries.
- Nothing fits, or too many: the fields stay `null`. The Actor never guesses. `RUN_SUMMARY` counts the reasons.

`fipeDiscountPct` is `(1 - bid / FIPE) * 100`, using `currentBid` or, without bids, `startingPrice`. Opening bids are often symbolic, so check `hasBids`. The free API allows about 1,000 requests a day; add `fipeApiToken` for more.

### Compute and memory

Sodré Santoro runs in Chromium (images, fonts and styles are blocked to save bandwidth) through a Brazilian residential proxy, so the Actor defaults to 1024 MB and most of the cost of a run that includes it is proxy traffic. Runs without it use well under 200 MB and no proxy. Brands in the input are sent to Copart and Sodré as search words, which keeps that traffic small.

Loop Leilões blocks lot page requests from some datacenter IPs. When that happens its lots keep the data from the listing (no seller or auction end) and a warning is logged.

### Pricing

Pay per event: **US$ 3.00 per 1,000 lots** (US$ 0.003 per lot, event `result-item`), charged for each lot written to the dataset. Platform usage (compute and proxy) is included. Filters are applied before charging and `maxItems` is capped by your run's maximum charge.

| Lots | Cost |
|---|---|
| 100 | US$ 0.30 |
| 1,000 | US$ 3.00 |
| 10,000 | US$ 30.00 |

The Actor also runs without pay-per-event pricing.

### FAQ

**Can I scrape everything?** Leave `searchTerms` empty and raise `maxItems`.

**Are the prices final?** No. They are the current bid or the opening price. Buyer commission and fees are not included.

**Why did a source return 0 items?** The house may have no open lots for your filters (Rogério Menezes often has none), or it blocked the request. Check `RUN_SUMMARY`.

**How is a lot marked as salvage?** From structured fields where the house has them (Copart loss type, Sodré accident field, VIP origin) and from keywords such as sinistro, sucata, monta and colisão elsewhere. "Sem sinistro" is not a match.

**Is this legal?** The Actor reads public pages and public search endpoints. You are responsible for using the data in line with each site's terms and the applicable laws, including LGPD.

### Em português

Raspador de **leilão de carros, motos e caminhões no Brasil**: Copart, Superbid (Sold e Kron), Freitas, Sodré Santoro, Rogério Menezes, Loop, VIP, Mega Leilões, Palácio dos Leilões e Detran-SP em um único dataset. Filtre por modelo, marca, ano, preço, quilometragem, estado, cidade e sinistro, e compare cada lote com a **tabela FIPE** para achar carro abaixo do mercado. Sem login e sem chave de API.

Buscas típicas: leilão de carro sem sinistro em São Paulo, Onix e Corolla em leilão, carro de leilão abaixo da FIPE, leilão de moto e de caminhão.

**Preço:** US$ 3,00 por 1.000 lotes (US$ 0,003 por lote entregue). Exemplo: 100 lotes custam US$ 0,30.

### Other Actors by the same author

- [Brazil Public Tenders Scraper](https://apify.com/allanmxr/brazil-public-tenders)
- [Brazil Real Estate Scraper](https://apify.com/allanmxr/brazil-real-estate-scraper)
- [Brazil Real Estate Auctions Scraper](https://apify.com/allanmxr/brazil-real-estate-auctions)
- [Mexico Vehicle Auctions Scraper](https://apify.com/allanmxr/mexico-vehicle-auctions-scraper)

### Run locally

```bash
uv venv --python 3.12 .venv
uv pip install -p .venv/bin/python -r requirements.txt
.venv/bin/playwright install chromium
mkdir -p storage/key_value_stores/default
echo '{"searchTerms": ["onix"], "yearMin": 2020, "maxItems": 50}' > storage/key_value_stores/default/INPUT.json
.venv/bin/python -m src
```

Results land in `storage/datasets/default`.

# Actor input Schema

## `searchTerms` (type: `array`):

Vehicle names, for example "onix" or "corolla xei". A lot matches when it contains every word of at least one term (accents and case are ignored). Leave empty to list all vehicles, up to Max items.

## `vehicleType` (type: `string`):

Cars, motorcycles, trucks (and buses) or other vehicles. Auction houses without that type are skipped.

## `brands` (type: `array`):

Only lots of these brands. Leave empty for all brands.

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

Maximum number of lots in the dataset, shared across the auction houses (each one contributes in turn, so one big house does not use up the limit). You are charged per lot returned.

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

Skip vehicles older than this model year. Lots whose year cannot be read are skipped when a year filter is set.

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

Skip vehicles newer than this model year.

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

Compared with the current bid, or the starting price when there is no bid yet.

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

Compared with the current bid, or the starting price when there is no bid yet.

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

Lots whose auction house does not publish the mileage are kept, check the mileageKm field.

## `states` (type: `array`):

Only lots located in these Brazilian states. Leave empty for the whole country.

## `cities` (type: `array`):

Only lots located in these cities, for example "Campinas" (accents and case are ignored).

## `damage` (type: `string`):

Lots with accident (sinistro), insurance recovery, flood or scrap history are flagged isSalvage = true. Pick which ones to keep.

## `auctionDateFrom` (type: `string`):

Only lots whose auction ends on or after this date.

## `auctionDateTo` (type: `string`):

Only lots whose auction ends on or before this date.

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

Which auction houses to scrape. VIP Leilões is off by default because it only allows about one request every 6 seconds (a full listing takes ~15 min); select it if you want it. Detran-SP is also off by default: about 80% of its lots are scrap, so select it when you want them.

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

Adds fipePrice, fipeModel and fipeDiscountPct from the public FIPE API (parallelum.com.br). When several FIPE models fit equally well, only fipePriceMin and fipePriceMax are filled. The free API allows about 1,000 requests a day.

## `minFipeDiscountPct` (type: `number`):

Only lots at least this far below the FIPE price, best first. Turns the FIPE comparison on and checks every candidate lot before applying Max items, so the run takes longer.

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

Optional token from fipe.online to raise the FIPE API rate limit.

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

Only Sodre Santoro uses it (it needs a Brazilian residential IP). Copart and the other auction houses are read without a proxy.

## Actor input object example

```json
{
  "searchTerms": [
    "onix"
  ],
  "vehicleType": "car",
  "maxItems": 20,
  "yearMin": 2020,
  "damage": "all",
  "sources": [
    "superbid",
    "freitas",
    "loop",
    "mega-leiloes",
    "palacio-leiloes"
  ],
  "includeFipe": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  }
}
```

# Actor output Schema

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

All scraped items 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 = {
    "searchTerms": [
        "onix"
    ],
    "maxItems": 20,
    "yearMin": 2020,
    "sources": [
        "superbid",
        "freitas",
        "loop",
        "mega-leiloes",
        "palacio-leiloes"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("allanmxr/brazil-vehicle-auctions-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 = {
    "searchTerms": ["onix"],
    "maxItems": 20,
    "yearMin": 2020,
    "sources": [
        "superbid",
        "freitas",
        "loop",
        "mega-leiloes",
        "palacio-leiloes",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("allanmxr/brazil-vehicle-auctions-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 '{
  "searchTerms": [
    "onix"
  ],
  "maxItems": 20,
  "yearMin": 2020,
  "sources": [
    "superbid",
    "freitas",
    "loop",
    "mega-leiloes",
    "palacio-leiloes"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  }
}' |
apify call allanmxr/brazil-vehicle-auctions-scraper --silent --output-dataset

```

## MCP server setup

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