# Exemplos de código

Todos os exemplos leem a chave da variável de ambiente `PLACAEFIPE_API_KEY` e rodam **no servidor**.

## cURL

```bash
curl https://api.placaefipe.com.br/v1/placas/ABC1D23 \
  -H "Authorization: Bearer $PLACAEFIPE_API_KEY"
```

## Node.js (18+)

```js
export async function consultarPlaca(placa) {
  const r = await fetch(`https://api.placaefipe.com.br/v1/placas/${encodeURIComponent(placa)}`, {
    headers: { Authorization: `Bearer ${process.env.PLACAEFIPE_API_KEY}` },
  });
  const dados = await r.json();
  if (!r.ok) throw new Error(`${dados.erro.codigo}: ${dados.erro.mensagem}`);
  return dados;
}

const v = await consultarPlaca('ABC1D23');
console.log(v.marca, v.modelo, v.ano_modelo, v.fipe?.valor_texto);
```

## TypeScript (tipos da resposta)

```ts
export interface VeiculoPlacaEFipe {
  placa: string;
  placa_antiga: string | null;
  marca: string | null;
  modelo: string | null;
  versao: string | null;
  ano_fabricacao: number | null;
  ano_modelo: number | null;
  cor: string | null;
  combustivel: string | null;
  chassi_final: string | null;
  municipio: string | null;
  uf: string | null;
  situacao: string | null;
  origem: string | null;
  tecnico: {
    motor: string | null;
    tipo: string | null;
    especie: string | null;
    segmento: string | null;
    cilindradas: number | null;
    passageiros: number | null;
    eixos: number | null;
  };
  fipe: {
    codigo: string | null;
    marca: string | null;
    modelo: string | null;
    ano_modelo: number | null;
    combustivel: string | null;
    valor: number | null;
    valor_texto: string | null;
    referencia: string | null;
    versoes: { codigo: string; modelo: string; valor: number | null; valor_texto: string | null }[];
  } | null;
  consulta: { id: string; creditos_restantes: number; cobrada: boolean; cache: boolean };
}

export interface ErroPlacaEFipe {
  erro: { codigo: string; mensagem: string; docs: string };
}
```

## Next.js (App Router): rota de API

Crie `app/api/placa/[placa]/route.ts`. O front chama `/api/placa/ABC1D23` e a chave fica no servidor.

```ts
export async function GET(_req: Request, { params }: { params: Promise<{ placa: string }> }) {
  const { placa } = await params;
  const r = await fetch(`https://api.placaefipe.com.br/v1/placas/${encodeURIComponent(placa)}`, {
    headers: { Authorization: `Bearer ${process.env.PLACAEFIPE_API_KEY}` },
    cache: 'no-store',
  });
  return new Response(await r.text(), { status: r.status, headers: { 'Content-Type': 'application/json' } });
}
```

## Python

```python
import os
import requests

def consultar_placa(placa: str) -> dict:
    r = requests.get(
        f"https://api.placaefipe.com.br/v1/placas/{placa}",
        headers={"Authorization": f"Bearer {os.environ['PLACAEFIPE_API_KEY']}"},
        timeout=15,
    )
    dados = r.json()
    if not r.ok:
        raise RuntimeError(f"{dados['erro']['codigo']}: {dados['erro']['mensagem']}")
    return dados

v = consultar_placa("ABC1D23")
print(v["marca"], v["modelo"], v["ano_modelo"], (v["fipe"] or {}).get("valor_texto"))
```

## PHP

```php
<?php
function consultarPlaca(string $placa): array {
    $ch = curl_init("https://api.placaefipe.com.br/v1/placas/" . urlencode($placa));
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT => 15,
        CURLOPT_HTTPHEADER => ["Authorization: Bearer " . getenv("PLACAEFIPE_API_KEY")],
    ]);
    $corpo = curl_exec($ch);
    $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    $dados = json_decode($corpo, true);
    if ($status !== 200) {
        throw new RuntimeException($dados["erro"]["codigo"] . ": " . $dados["erro"]["mensagem"]);
    }
    return $dados;
}

$v = consultarPlaca("ABC1D23");
echo $v["marca"] . " " . $v["modelo"] . " " . ($v["fipe"]["valor_texto"] ?? "sem FIPE");
```

## Go

```go
package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.placaefipe.com.br/v1/placas/ABC1D23", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("PLACAEFIPE_API_KEY"))
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	var v map[string]any
	json.NewDecoder(res.Body).Decode(&v)
	fmt.Println(res.StatusCode, v["marca"], v["modelo"])
}
```

## Supabase Edge Function

```ts
// supabase/functions/placa/index.ts
Deno.serve(async (req) => {
  const { placa } = await req.json();
  const r = await fetch(`https://api.placaefipe.com.br/v1/placas/${encodeURIComponent(placa)}`, {
    headers: { Authorization: `Bearer ${Deno.env.get('PLACAEFIPE_API_KEY')}` },
  });
  return new Response(await r.text(), { status: r.status, headers: { 'Content-Type': 'application/json' } });
});
```

```bash
supabase secrets set PLACAEFIPE_API_KEY=pf_live_sua_chave
supabase functions deploy placa
```

## n8n

Use o nó **HTTP Request**:

| Campo | Valor |
|---|---|
| Method | GET |
| URL | `https://api.placaefipe.com.br/v1/placas/{{ $json.placa }}` |
| Authentication | Generic Credential Type → Header Auth |
| Header Name | `Authorization` |
| Header Value | `Bearer pf_live_sua_chave` |

Em **Settings**, ligue **Never Error** e trate `erro.codigo` num nó **IF** em seguida.