A tabela FIPE (Fundação Instituto de Pesquisas Econômicas) é uma referência essencial no mercado automotivo brasileiro, utilizada para definir os preços médios de veículos no país. Neste artigo, vamos explorar como utilizar a API FIPE para acessar esses dados de forma programática, permitindo que você integre essas informações em seus projetos e aplicações.

O que é a Tabela FIPE e API?

A Tabela FIPE é uma referência de preços de veículos elaborada pela Fundação Instituto de Pesquisas Econômicas, que serve como base para negociações de compra e venda, avaliações para seguros, financiamentos e para fins tributários no Brasil.

A API FIPE é uma interface que permite acessar esses dados de forma programática, oferecendo:

Consulta aos preços médios de mercado para carros, motos e caminhões
Dados atualizados mensalmente
Informações organizadas por marca, modelo e ano
Histórico de preços para análise de valorização/desvalorização

O melhor de tudo: a API está disponível gratuitamente desde 2015!

Benefícios de utilizar a API FIPE

Existem várias vantagens em utilizar a API FIPE em vez de acessar diretamente o site da FIPE:

Integração direta: Incorpore dados da tabela FIPE em seus sistemas
Automatização: Atualize preços e informações automaticamente
Eficiência: A API utiliza um banco de dados próprio, evitando sobrecarregar o serviço da FIPE
Confiabilidade: Acesso contínuo sem bloqueios por múltiplos acessos
Dados estruturados: Respostas em formato JSON facilmente manipuláveis

Estrutura da API FIPE

A API FIPE organiza os dados hierarquicamente:

Referências (meses disponíveis)
Tipos de veículos (carros, motos, caminhões)
Marcas (fabricantes)
Modelos (veículos específicos)
Anos (versões de cada modelo)
Preços (valor médio de mercado)

Além disso, é possível consultar diretamente pelo código FIPE de um veículo.

Como começar a utilizar a API FIPE

Requisitos

A API FIPE é gratuita e não requer autenticação para uso básico. No entanto, para uso mais intensivo, existe a possibilidade de obter um token de assinatura (disponível em https://fipe.online).

URL Base

A URL base para todas as requisições é:

https://fipe.parallelum.com.br/api/v2

Endpoints Principais

/references: Lista de meses de referência disponíveis
/{vehicleType}/brands: Lista de marcas (onde vehicleType pode ser cars, motorcycles ou trucks)
/{vehicleType}/brands/{brandId}/models: Lista de modelos de uma marca específica
/{vehicleType}/brands/{brandId}/models/{modelId}/years: Anos disponíveis para um modelo
/{vehicleType}/brands/{brandId}/models/{modelId}/years/{yearId}: Preço e detalhes de um veículo específico

Formato de Resposta

Todas as respostas são retornadas em formato JSON.

Exemplos práticos em JavaScript

Vamos ver como implementar as principais funcionalidades da API FIPE utilizando JavaScript.

1. Consultando referências (meses disponíveis)

async function obterReferencias() {  
  try {  
    const response = await fetch('https://fipe.parallelum.com.br/api/v2/references');  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao obter referências:', error);  
  }  
}

// Exemplo de uso  
obterReferencias().then(referencias => {  
  console.log('Mês de referência atual:', referencias[0].month);  
  console.log('Código da referência:', referencias[0].code);  
});

2. Consultando marcas de veículos

async function obterMarcas(tipoVeiculo, referencia = '') {  
  try {  
    let url = `https://fipe.parallelum.com.br/api/v2/${tipoVeiculo}/brands`;  
    if (referencia) {  
      url += `?reference=${referencia}`;  
    }  
    const response = await fetch(url);  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao obter marcas:', error);  
  }  
}

// Exemplo de uso  
obterMarcas('cars').then(marcas => {  
  console.log(`Encontradas ${marcas.length} marcas de carros`);  
  // Exibir as 5 primeiras marcas  
  marcas.slice(0, 5).forEach(marca => {  
    console.log(`${marca.code}: ${marca.name}`);  
  });  
});

3. Consultando modelos de uma marca

async function obterModelos(tipoVeiculo, marcaId, referencia = '') {  
  try {  
    let url = `https://fipe.parallelum.com.br/api/v2/${tipoVeiculo}/brands/${marcaId}/models`;  
    if (referencia) {  
      url += `?reference=${referencia}`;  
    }  
    const response = await fetch(url);  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao obter modelos:', error);  
  }  
}

// Exemplo de uso (consultando modelos da VW - código 59)  
obterModelos('cars', 59).then(modelos => {  
  console.log(`Encontrados ${modelos.length} modelos da marca`);  
  modelos.slice(0, 5).forEach(modelo => {  
    console.log(`${modelo.code}: ${modelo.name}`);  
  });  
});

4. Consultando anos disponíveis para um modelo

async function obterAnos(tipoVeiculo, marcaId, modeloId, referencia = '') {  
  try {  
    let url = `https://fipe.parallelum.com.br/api/v2/${tipoVeiculo}/brands/${marcaId}/models/${modeloId}/years`;  
    if (referencia) {  
      url += `?reference=${referencia}`;  
    }  
    const response = await fetch(url);  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao obter anos:', error);  
  }  
}

// Exemplo de uso (consultando anos do Gol - código varia)  
obterAnos('cars', 59, 5523).then(anos => {  
  console.log(`Encontrados ${anos.length} anos para este modelo`);  
  anos.forEach(ano => {  
    console.log(`${ano.code}: ${ano.name}`);  
  });  
});

5. Consultando o preço de um veículo específico

async function obterPreco(tipoVeiculo, marcaId, modeloId, anoId, referencia = '') {  
  try {  
    let url = `https://fipe.parallelum.com.br/api/v2/${tipoVeiculo}/brands/${marcaId}/models/${modeloId}/years/${anoId}`;  
    if (referencia) {  
      url += `?reference=${referencia}`;  
    }  
    const response = await fetch(url);  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao obter preço:', error);  
  }  
}

// Exemplo de uso  
obterPreco('cars', 59, 5523, '2020-1').then(preco => {  
  console.log('Informações do veículo:');  
  console.log(`Marca: ${preco.brand}`);  
  console.log(`Modelo: ${preco.model}`);  
  console.log(`Ano: ${preco.modelYear}`);  
  console.log(`Combustível: ${preco.fuel}`);  
  console.log(`Preço: ${preco.price}`);  
  console.log(`Mês de referência: ${preco.referenceMonth}`);  
  console.log(`Código FIPE: ${preco.codeFipe}`);  
});

6. Buscando diretamente pelo código FIPE

async function buscarPorCodigoFipe(tipoVeiculo, codigoFipe, anoId, referencia = '') {  
  try {  
    let url = `https://fipe.parallelum.com.br/api/v2/${tipoVeiculo}/${codigoFipe}/years/${anoId}`;  
    if (referencia) {  
      url += `?reference=${referencia}`;  
    }  
    const response = await fetch(url);  
    const data = await response.json();  
    return data;  
  } catch (error) {  
    console.error('Erro ao buscar por código FIPE:', error);  
  }  
}

// Exemplo de uso (com um código FIPE fictício)  
buscarPorCodigoFipe('cars', '004278-1', '2020-1').then(info => {  
  console.log(`Veículo: ${info.brand} ${info.model} ${info.modelYear}`);  
  console.log(`Valor atual: ${info.price}`);  
});

Exemplo completo: Consultando preço de um veículo específico

Vamos criar um exemplo prático que encadeia várias chamadas à API FIPE para encontrar o preço de um veículo específico:

// Exemplo completo: consultar preço de um VW Gol 2020  
async function consultarPrecoVeiculo() {  
  try {  
    // 1. Obter a referência mais recente  
    const referencias = await obterReferencias();  
    const referenciaAtual = referencias[0].code;  
      
    // 2. Obter lista de marcas de carros  
    const marcas = await obterMarcas('cars', referenciaAtual);  
      
    // 3. Encontrar a marca VW  
    const marcaVW = marcas.find(marca => marca.name.includes('VW'));  
      
    if (!marcaVW) {  
      console.error('Marca VW não encontrada');  
      return;  
    }  
      
    // 4. Obter modelos da VW  
    const modelos = await obterModelos('cars', marcaVW.code, referenciaAtual);  
      
    // 5. Encontrar o modelo Gol  
    const modeloGol = modelos.find(modelo => modelo.name.includes('Gol'));  
      
    if (!modeloGol) {  
      console.error('Modelo Gol não encontrado');  
      return;  
    }  
      
    // 6. Obter anos disponíveis para o Gol  
    const anos = await obterAnos('cars', marcaVW.code, modeloGol.code, referenciaAtual);  
      
    // 7. Encontrar o ano 2020  
    const ano2020 = anos.find(ano => ano.name.includes('2020'));  
      
    if (!ano2020) {  
      console.error('Ano 2020 não encontrado');  
      return;  
    }  
      
    // 8. Obter preço do Gol 2020  
    const preco = await obterPreco('cars', marcaVW.code, modeloGol.code, ano2020.code, referenciaAtual);  
      
    console.log('Informações do veículo:');  
    console.log(`Marca: ${preco.brand}`);  
    console.log(`Modelo: ${preco.model}`);  
    console.log(`Ano: ${preco.modelYear}`);  
    console.log(`Combustível: ${preco.fuel}`);  
    console.log(`Preço: ${preco.price}`);  
    console.log(`Mês de referência: ${preco.referenceMonth}`);  
    console.log(`Código FIPE: ${preco.codeFipe}`);  
      
    return preco;  
  } catch (error) {  
    console.error('Erro durante a consulta:', error);  
  }  
}

// Chamar a função  
consultarPrecoVeiculo();

Utilizando Token de Assinatura (Opcional)

Para usuários que precisam de acesso mais intensivo à API, é possível utilizar um token de assinatura. Aqui está um exemplo de como estruturar as requisições com token:

// Configuração para uso com token de assinatura (opcional)  
const API_CONFIG = {  
  baseURL: 'https://fipe.parallelum.com.br/api/v2',  
  token: 'seu-token-aqui' // Token opcional para assinantes  
};

// Função utilitária para fazer requisições à API  
async function fipeRequest(endpoint, params = {}) {  
  const url = new URL(`${API_CONFIG.baseURL}${endpoint}`);  
    
  // Adicionar parâmetros de query, se houver  
  Object.keys(params).forEach(key => {  
    if (params[key]) {  
      url.searchParams.append(key, params[key]);  
    }  
  });  
    
  const headers = {};  
    
  // Adicionar token de assinatura, se disponível  
  if (API_CONFIG.token) {  
    headers['X-Subscription-Token'] = API_CONFIG.token;  
  }  
    
  try {  
    const response = await fetch(url, { headers });  
      
    if (!response.ok) {  
      throw new Error(`Erro na API: ${response.status} ${response.statusText}`);  
    }  
      
    return await response.json();  
  } catch (error) {  
    console.error(`Falha na requisição para ${endpoint}:`, error);  
    throw error;  
  }  
}  
// Exemplo de uso da função utilitária  
async function obterMarcasComToken(tipoVeiculo, referencia) {  
  return await fipeRequest(`/${tipoVeiculo}/brands`, { reference: referencia });  
}

Casos de uso práticos

1. Sistema de avaliação de veículos

Integre a API FIPE em sistemas de avaliação de veículos para compra/venda ou seguros, obtendo valores de referência atualizados automaticamente.

2. Comparativo de preços

Desenvolva uma ferramenta que compare preços de anúncios com os valores de referência da FIPE, identificando oportunidades de negócio.

3. Análise histórica de desvalorização

Utilize o histórico de preços para analisar a curva de desvalorização de diferentes modelos de veículos, auxiliando em decisões de compra ou venda.

4. Cálculo de financiamento

Incorpore os valores FIPE em calculadoras de financiamento para determinar percentuais de entrada e parcelas com base em valores reais de mercado.

Conclusão

A API FIPE oferece uma maneira simples e eficiente de acessar dados de preços de veículos no mercado brasileiro. Com os exemplos mostrados neste artigo, você já pode começar a integrar esses dados em seus projetos, seja para aplicações web, mobile ou sistemas internos.

Lembre-se de que, embora a API seja gratuita, é importante respeitar limites de uso para garantir que o serviço continue disponível para todos. Para projetos que demandam maior volume de consultas, considere a opção de assinatura.

E se você encontrar valor na API, que tal seguir a sugestão dos mantenedores e pagar uma cerveja para eles? 🍺

Guia Completo da API FIPE: Como Consultar Preços de Veículos no Brasil