# FIPE Brazil Vehicle Prices Scraper (`parseforge/fipe-brazil-vehicle-prices-scraper`) Actor

Scrapes official FIPE vehicle price tables for cars, motorcycles, and trucks in Brazil. Returns flat rows with reference prices, filterable by vehicle type, brand, and model.

- **URL**: https://apify.com/parseforge/fipe-brazil-vehicle-prices-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Automation
- **Stats:** 14 total users, 5 monthly users, 94.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 result items

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?

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### FIPE Brazil Vehicle Prices Scraper

**Scrape official FIPE vehicle price tables for cars, motorcycles, and trucks in Brazil.** Get current and historical reference prices by brand and model, with filters for vehicle type and name. Export to CSV, JSON, Excel, or XML.

The FIPE table is the standard reference for vehicle pricing in Brazil, used by insurers, dealers, and buyers. This actor reads the official FIPE data directly, so you get the same reference prices without manual lookups or screen scraping. Filter by vehicle type (carros, motos, caminhões) and by brand or model name to collect exactly the rows you need.

| Who uses it | What they scrape FIPE for |
|---|---|
| Insurance companies | Automating vehicle valuation for policy underwriting and claims |
| Car dealerships | Monitoring market reference prices to price used inventory competitively |
| Market researchers | Tracking price trends across brands and models over time |
| Developers building automotive apps | Feeding current FIPE prices into pricing calculators or comparison tools |

### What it does

This Actor collects FIPE vehicle price records by vehicle type, brand, and model, and returns each one as a flat row with the official reference price and identifying details.

- 🚗 **Vehicle type filter:** choose cars, motorcycles, or trucks to narrow the dataset.
- 🔍 **Brand and model filters:** case-insensitive substring match on brand or model name, e.g. 'Fiat' or 'Uno'.
- 📊 **Flat row output:** each vehicle price is returned as a single record with all identifying fields.
- ⚙️ **Flexible volume:** set a maximum number of records per run, from 1 to 1,000,000.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with FIPE data

**📋 Insurance policy underwriting.**

An insurance company runs the actor daily for all car models to keep its valuation database current for new policy quotes.

**🚙 Used car pricing.**

A dealership filters by brand 'Fiat' and model 'Uno' to get the official reference price for every year and variant, then sets its lot prices accordingly.

**📈 Market trend analysis.**

A researcher collects monthly FIPE prices for popular truck models to track depreciation curves and publish a market report.

**🛠️ App data pipeline.**

A developer schedules the actor to refresh FIPE prices weekly and feeds the JSON output into a vehicle pricing API for a consumer app.

### Why choose this scraper

|  | What you get |
|---|---|
| **Official FIPE data** | Reference prices from the source used across Brazil |
| **No manual lookups** | Automate collection instead of querying the FIPE website by hand |
| **Flexible filtering** | Target specific brands or models with substring matching |
| **Structured output** | Clean rows ready for CSV, JSON, Excel, or XML export |

### How it compares

No other Store actor targets FIPE the same way, so the honest comparison is with the alternatives teams actually weigh.

| | FIPE Brazil Vehicle Prices Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When FIPE changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor with a vehicle type and optional brand or model name filters. Filters run as the data is read, so only matching vehicle prices reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "vehicleType": "carros"
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "vehicleType": "carros"
}
```

### Pricing

Pay-per-result: **$0.01867 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.87 |
| 1,000 results | $18.67 |
| 10,000 results | $186.70 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [FIPE Brazil Vehicle Prices Scraper](https://apify.com/parseforge/fipe-brazil-vehicle-prices-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to FIPE through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/fipe-brazil-vehicle-prices-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. If brandName or modelName is set, it must match a real brand or model in the FIPE table. Try leaving them blank to see all vehicles for the selected type.

**The run stops before collecting all vehicles.**

Increase maxItems. The actor stops after reaching that number, even if more matching vehicles exist.

**I get an error about vehicleType.**

Use one of the allowed values: carros, motos, or caminhoes. The input editor provides a dropdown with these options.

**The output has fewer fields than expected.**

The actor returns a fixed schema based on the FIPE data. If a field is missing for a particular vehicle, it may be empty in the source.

**Can I run this for a specific year?**

The actor does not have a year filter. It returns all years for the matching brand and model. You can filter the output dataset afterward.

### FAQ

| Question | Answer |
|---|---|
| What is the FIPE table? | The FIPE table is the official reference for vehicle prices in Brazil, published monthly by the Fundação Instituto de Pesquisas Econômicas. It covers cars, motorcycles, and trucks with prices by brand, model, and year. |
| Does this actor require an API key or login? | No. The actor reads the public FIPE data directly, so you do not need to register or authenticate. |
| Can I filter by brand or model? | Yes. Use the brandName and modelName inputs for case-insensitive substring matching. For example, brandName 'Fiat' returns all Fiat vehicles, and modelName 'Uno' narrows to that model. |
| What vehicle types are supported? | You can choose cars (carros), motorcycles (motos), or trucks (caminhoes) using the vehicleType input. |
| How many records can I collect in one run? | Set maxItems to any number from 1 to 1,000,000. The actor stops after collecting that many matching vehicle prices. |
| What output formats are available? | The dataset can be exported to CSV, JSON, Excel, or XML from the Apify platform. |
| Is the data current? | The actor reads the latest FIPE reference prices available at the time of the run. FIPE updates its table monthly. |
| Can I get historical FIPE prices? | The actor returns the current reference prices. For historical data, you would need to run it over time and store snapshots. |
| Does this work for all brands in Brazil? | Yes, it covers all brands listed in the FIPE table for the selected vehicle type. Use the brand filter to narrow results. |
| Is there a limit on concurrent runs? | Apify platform limits apply, but the actor itself can be scheduled or run on demand without additional restrictions. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Fundação Instituto de Pesquisas Econômicas. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Maximum number of vehicle prices to collect per run.

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

Type of vehicle to query.

## `brandName` (type: `string`):

Case-insensitive substring match against brand name (e.g. 'Fiat', 'Volks'). Leave blank for all brands.

## `modelName` (type: `string`):

Case-insensitive substring match against model name (e.g. 'Uno', 'Gol'). Leave blank for all models.

## Actor input object example

```json
{
  "maxItems": 10,
  "vehicleType": "carros"
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 10,
    "vehicleType": "carros"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fipe-brazil-vehicle-prices-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 = {
    "maxItems": 10,
    "vehicleType": "carros",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/fipe-brazil-vehicle-prices-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 '{
  "maxItems": 10,
  "vehicleType": "carros"
}' |
apify call parseforge/fipe-brazil-vehicle-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/fipe-brazil-vehicle-prices-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/mln25Y4OcMFqudwNg/builds/pzGAfVmz1jzKbcu5m/openapi.json