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

Export Brazilian FIPE vehicle reference prices for cars, motorcycles, and trucks. Pull brand, model, year, fuel type, FIPE code, and current market price (R$). Filter by vehicle type, brand name, or model name. Covers all major Brazilian and international brands.

- **URL**: https://apify.com/parseforge/fipe-brazil-vehicle-prices-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🚗 FIPE Brazil Vehicle Prices Scraper

> 🚀 **Export the official Brazilian vehicle reference prices in seconds.** Pull **cars, motorcycles, and trucks** with brand, model, year, fuel type, FIPE code, current price in R$, and reference month. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per record · **🚗 3 vehicle types** · **🇧🇷 100+ brands** · **🛞 Cars, motos, trucks**

The **FIPE Brazil Vehicle Prices Scraper** exports the canonical FIPE (Fundação Instituto de Pesquisas Econômicas) vehicle reference catalog and returns **14 fields per record**, including vehicle type, brand, model, model year, fuel type, FIPE code, current market price as both R$-formatted string and clean numeric, plus the official reference month. FIPE is the legal benchmark used by Brazilian insurers, banks, dealerships, and tax authorities for valuing every passenger vehicle in the country.

The catalog covers **3 vehicle types (Carros, Motos, Caminhões), 100+ brands, and tens of thousands of model-year-fuel combinations**, from popular hatchbacks down to heavy commercial trucks. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes. All filters run server-side, so you skip the parser engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Brazilian auto marketplaces, insurance underwriters, dealerships, vehicle traders, fintech, fleet managers, journalists, used-car platforms | Insurance pricing, loan collateral valuation, used-car listings, vehicle history checks, fleet residual-value analysis, market-trend research |

---

### 📋 What the FIPE Brazil Vehicle Prices Scraper does

Three filtering workflows in a single run:

- 🚗 **Vehicle-type filter.** Cars (Carros), Motorcycles (Motos), or Trucks (Caminhões).
- 🏷️ **Brand-name filter.** Case-insensitive substring match (e.g. `Fiat`, `Volks`, `Honda`).
- 🔍 **Model-name filter.** Case-insensitive substring match (e.g. `Uno`, `Gol`, `Onix`).

Each record includes the FIPE-issued identifier, full brand/model/year naming, fuel type and short acronym, the canonical R$ price string (e.g. `"R$ 45.231,00"`) plus a clean numeric form for analytics, and the FIPE reference month (e.g. `"maio de 2026"`).

> 💡 **Why it matters:** FIPE is the legally recognized vehicle price index in Brazil. Insurance companies use it to set premiums, banks use it for loan-to-value calculations, and dealerships use it to negotiate trade-ins. Building your own pipeline means navigating a complex multi-step lookup tree. This Actor flattens all of that into a single dataset.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded FIPE dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>vehicleType</td><td>string</td><td>"carros"</td><td>One of carros, motos, caminhoes.</td></tr>
<tr><td>brandName</td><td>string</td><td>""</td><td>Case-insensitive substring match on brand. Empty = all brands.</td></tr>
<tr><td>modelName</td><td>string</td><td>""</td><td>Case-insensitive substring match on model. Empty = all models.</td></tr>
</tbody>
</table>

**Example: 50 Fiat Uno prices across all years and fuel types.**

```json
{
    "maxItems": 50,
    "vehicleType": "carros",
    "brandName": "Fiat",
    "modelName": "Uno"
}
````

**Example: every Honda motorcycle currently listed.**

```json
{
    "maxItems": 500,
    "vehicleType": "motos",
    "brandName": "Honda"
}
```

> ⚠️ **Good to Know:** FIPE prices are reference values updated monthly. The `referenceMonth` field tells you which month the price applies to. Use `priceNumeric` for analytics and `price` for display in BRL formatting.

***

### 📊 Output

Each vehicle record contains **14 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🚗 `vehicleType` | string | `"carros"` |
| 🏷️ `brand` | string | `"Fiat"` |
| 🔤 `model` | string | `"Uno Mille 1.0 EP/ EX 2p e 4p"` |
| 📅 `modelYear` | string | `"1997"` |
| ⛽ `fuel` | string | `"Gasolina"` |
| 🅖 `fuelAcronym` | string | `"G"` |
| 🆔 `fipeCode` | string | `"001004-9"` |
| 💵 `price` | string | `"R$ 8.927,00"` |
| 🔢 `priceNumeric` | number | `8927` |
| 📆 `referenceMonth` | string | `"maio de 2026"` |
| 🔖 `brandCode` | string | `"21"` |
| 🔖 `modelCode` | string | `"4828"` |
| 🔖 `yearCode` | string | `"1997-1"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🚗 Popular hatchback: Fiat Uno Mille 1.0</strong></summary>

```json
{
    "vehicleType": "carros",
    "brand": "Fiat",
    "model": "Uno Mille 1.0 EP/ EX 2p e 4p",
    "modelYear": "1997",
    "fuel": "Gasolina",
    "fuelAcronym": "G",
    "fipeCode": "001004-9",
    "price": "R$ 8.927,00",
    "priceNumeric": 8927,
    "referenceMonth": "maio de 2026",
    "brandCode": "21",
    "modelCode": "4828",
    "yearCode": "1997-1",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏍️ Motorcycle: Honda CG 160</strong></summary>

```json
{
    "vehicleType": "motos",
    "brand": "Honda",
    "model": "CG 160 TITAN",
    "modelYear": "2023",
    "fuel": "Gasolina",
    "fuelAcronym": "G",
    "fipeCode": "811026-3",
    "price": "R$ 14.732,00",
    "priceNumeric": 14732,
    "referenceMonth": "maio de 2026",
    "brandCode": "80",
    "modelCode": "10544",
    "yearCode": "2023-1",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🚛 Heavy truck: Volvo FH 540</strong></summary>

```json
{
    "vehicleType": "caminhoes",
    "brand": "Volvo",
    "model": "FH 540 6x4 2p (diesel) (E5)",
    "modelYear": "2022",
    "fuel": "Diesel",
    "fuelAcronym": "D",
    "fipeCode": "513032-7",
    "price": "R$ 658.412,00",
    "priceNumeric": 658412,
    "referenceMonth": "maio de 2026",
    "brandCode": "111",
    "modelCode": "9881",
    "yearCode": "2022-3",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🇧🇷 | **Official FIPE data.** Legally recognized vehicle price benchmark used by Brazilian insurers, banks, and tax authorities. |
| 🚗 | **All three vehicle types.** Cars, motorcycles, and trucks in one Actor. |
| 💵 | **Dual price format.** R$ string for display, numeric for analytics. |
| 📆 | **Reference month included.** Know exactly which monthly snapshot a price corresponds to. |
| ⚡ | **Fast.** 10 records in under 5 seconds. |
| 🔍 | **Brand and model filters.** Case-insensitive substring match, no need to learn FIPE codes upfront. |
| 🚫 | **No authentication.** Works with public reference data. No login or sign-up needed. |

> 📊 FIPE prices are the foundation of every used-car listing, vehicle loan, and auto insurance policy in Brazil.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ FIPE Brazil Vehicle Prices Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **All cars, motos, trucks** | **Monthly (live per run)** | type, brand, model | ⚡ 2 min |
| Commercial vehicle-data feeds | R$ 1,000+/month | Brazil-specific, often resold FIPE | Vendor-controlled | Limited | 🐢 Days |
| Manual FIPE portal queries | Free | One lookup at a time | Live | None | 🐌 Hours of clicking |
| Scraping the FIPE portal yourself | Free | Full | Monthly | Build your own | 🕒 Days of engineering |

Pick this Actor when you want the full FIPE catalog flattened into a clean dataset with zero parser maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the FIPE Brazil Vehicle Prices Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a vehicle type, optionally filter by brand or model substring, set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ Auto Insurance & Underwriting

- Premium pricing tied to current FIPE values
- Total-loss settlements benchmarked to FIPE
- Annual policy renewal price adjustments
- Risk modeling against vehicle depreciation curves

</td>
<td width="50%" valign="top">

#### 🏦 Banking & Auto Loans

- Loan-to-value calculations for vehicle financing
- Collateral revaluation across monthly cycles
- Used-vehicle loan approval workflows
- Refinancing offers with current market values

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🚙 Dealerships & Marketplaces

- Trade-in valuation tools for sales teams
- Listing-price suggestions on classifieds platforms
- Inventory aging analyses against monthly drift
- Negotiation backup with the legal benchmark

</td>
<td width="50%" valign="top">

#### 🚚 Fleet & Asset Management

- Residual-value forecasting for company fleets
- Vehicle disposal timing optimized to market peaks
- Asset depreciation accounting for accountants
- Fleet-mix optimization across cars, motos, trucks

</td>
</tr>
</table>

***

### 🔌 Automating FIPE Brazil Vehicle Prices Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. A monthly schedule is ideal since FIPE refreshes its reference values on a monthly cycle.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Economic studies on Brazilian vehicle market depreciation
- Inflation analyses against transport-good prices
- Reproducible studies with cited monthly snapshots
- Cross-country comparisons of auto-asset values

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, indie car-valuation tools, hobby calculators
- Personal trade-in research before buying or selling
- Used-car content for YouTube and blogs
- Hobbyist databases for vintage car collectors

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Investigative journalism on vehicle market trends
- Consumer-protection research on used-car pricing
- Open data publication for Brazilian transparency portals
- Educational material for personal-finance NGOs

</td>
<td width="50%">

#### 🧪 Experimentation

- Train price-prediction or depreciation ML models
- Validate vehicle-marketplace product hypotheses
- Prototype LLM agents that answer pricing questions
- Test dashboard concepts with live monthly data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20FIPE%20Brazil%20Vehicle%20Prices%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20FIPE%20Brazil%20Vehicle%20Prices%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20FIPE%20Brazil%20Vehicle%20Prices%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20FIPE%20Brazil%20Vehicle%20Prices%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a vehicle type and optional brand/model filters in the input form, click Start, and the Actor walks the FIPE catalog server-side and emits a clean structured record per vehicle/year/fuel combination. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

FIPE is the legally recognized vehicle price index in Brazil. Prices reflect the official monthly snapshot. The `referenceMonth` field on every record tells you exactly which month the price corresponds to.

#### 🔁 How often is the dataset refreshed?

FIPE publishes a new reference month every calendar month. Every run of this Actor pulls the latest available month, so your dataset reflects current FIPE values as of run time.

#### 🛞 Does it include heavy trucks and motorcycles?

Yes. Pass `"caminhoes"` for trucks (incluindo cavalos mecânicos, semi-reboques, caminhões pesados) or `"motos"` for motorcycles. The data shape is identical across all three vehicle types.

#### 💵 What is the difference between `price` and `priceNumeric`?

`price` is the human-readable Brazilian formatted string (e.g. `"R$ 45.231,00"`). `priceNumeric` is the same value as a clean integer or float (e.g. `45231`), ready for spreadsheets, databases, and analytics.

#### ⏰ Can I schedule regular runs?

Yes. A monthly Apify Schedule aligns perfectly with FIPE's monthly reference cycle. Set it for the first business day of each month to always have the latest values.

#### ⚖️ Is this data legal to use?

FIPE publishes vehicle reference prices as public information used by the entire Brazilian auto economy. Review the downstream terms of your specific use case, but reference pricing is generally considered public.

#### 💼 Can I use this data commercially?

Yes. FIPE reference values are widely used by insurance companies, banks, and auto marketplaces across Brazil. You are responsible for complying with any regulatory requirements in your own product.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

FIPE Brazil Vehicle Prices Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe vehicle prices into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh FIPE prices into your insurance backend, or alert your team in Slack when a new monthly reference is released.

***

### 🔗 Recommended Actors

- [**🚙 Cars For Sale Scraper**](https://apify.com/parseforge/cars-for-sale-scraper) - U.S. used-car classifieds
- [**🚗 Kelley Blue Book Scraper**](https://apify.com/parseforge/kelley-blue-book-scraper) - U.S. vehicle valuations
- [**🛵 Autotrader Scraper**](https://apify.com/parseforge/autotrader-scraper) - UK used vehicles
- [**🚛 Commercial Truck Trader Scraper**](https://apify.com/parseforge/commercialtrucktrader-scraper) - Heavy-duty commercial trucks
- [**🌎 Spain Empresia Scraper**](https://apify.com/parseforge/spain-empresia-scraper) - Spanish company directory

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by FIPE (Fundação Instituto de Pesquisas Econômicas) or any Brazilian government agency. All trademarks mentioned are the property of their respective owners. Only publicly available reference price data is collected.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `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("💾 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 '{
  "maxItems": 10,
  "vehicleType": "carros"
}' |
apify call parseforge/fipe-brazil-vehicle-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FIPE Brazil Vehicle Prices Scraper",
        "description": "Export Brazilian FIPE vehicle reference prices for cars, motorcycles, and trucks. Pull brand, model, year, fuel type, FIPE code, and current market price (R$). Filter by vehicle type, brand name, or model name. Covers all major Brazilian and international brands.",
        "version": "1.0",
        "x-build-id": "bd9WBdOes1hjG5UaZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~fipe-brazil-vehicle-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-fipe-brazil-vehicle-prices-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/parseforge~fipe-brazil-vehicle-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-fipe-brazil-vehicle-prices-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/parseforge~fipe-brazil-vehicle-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-fipe-brazil-vehicle-prices-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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "vehicleType": {
                        "title": "Vehicle Type",
                        "enum": [
                            "carros",
                            "motos",
                            "caminhoes"
                        ],
                        "type": "string",
                        "description": "Type of vehicle to query."
                    },
                    "brandName": {
                        "title": "Brand Name Filter",
                        "type": "string",
                        "description": "Case-insensitive substring match against brand name (e.g. 'Fiat', 'Volks'). Leave blank for all brands."
                    },
                    "modelName": {
                        "title": "Model Name Filter",
                        "type": "string",
                        "description": "Case-insensitive substring match against model name (e.g. 'Uno', 'Gol'). Leave blank for all models."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
