---
title: "Extrair dados de notas e faturas em JSON com LLM de visão"
description: "Pipeline de produção para faturas, recibos e formulários: preparo de imagens, prompt com esquema JSON, validação Pydantic, checagens de soma, retentativas e revisão."
url: https://broadrouter.com/pt/blog/extract-data-from-documents-with-vision-llm/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/extract-data-from-documents-with-vision-llm/) (atualizado em 2026-11-14).

# Extrair dados de faturas, recibos e formulários com LLM de visão

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em 2026-11-14

Converta cada página em imagem, envie a um modelo de visão com um prompt que nomeie cada campo e seu formato, e peça só JSON. Depois valide no código: faça o parsing, confira o esquema, verifique se os itens somam o total e repita uma vez com o erro. Falhas repetidas vão para uma pessoa.

## Pontos principais

-   O modelo lê; o seu código decide. Nunca grave dados extraídos na contabilidade sem checagens de esquema e de aritmética.
-   No prompt, nomeie cada campo, o tipo e o formato, e diga o que devolver quando um campo faltar (null, nunca um palpite).
-   Checagens aritméticas pegam a maioria das leituras erradas: os totais das linhas precisam somar o subtotal, e subtotal mais imposto precisa dar o total.
-   Repita uma vez com o erro de validação no prompt; falhas repetidas vão para uma fila de revisão humana.
-   No pagamento por uso, imagens são cobradas como tokens de entrada e imagens maiores usam mais, então redimensione antes de enviar.

**Nesta página**

1.  Como é o pipeline?
2.  Como preparar as imagens dos documentos?
3.  Como escrever o prompt de extração?
4.  Como obter saída estruturada e validá-la?
5.  Quais checagens pegam mais erros?
6.  Como medir a precisão antes de colocar em produção?
7.  Quais modelos de visão servem na BroadNet Inference?
8.  Onde a BroadNet Inference se encaixa

_[image: A paper invoice headed "فاتورة" (invoice) with tabs labelled Vendor, Date and Total, and the text "Turn documents into useful data."]_

Illustrative example.

Faturas, recibos e formulários têm o mesmo problema: os dados estão numa imagem, e você precisa deles num banco de dados. OCR baseado em templates quebra a cada novo layout de fornecedor. Um [modelo de visão e linguagem](https://broadrouter.com/pt/glossary/vision-language-model/) lê a página e devolve os campos diretamente. O porém é que ele pode errar com toda a confiança, então o trabalho está no pipeline em volta dele. Este post cobre o pipeline geral, para qualquer idioma. Para documentos em árabe, veja [ler faturas em árabe com visão](https://broadrouter.com/pt/guides/read-arabic-invoices-with-vision/) para a configuração e [OCR em árabe versus LLMs de visão](https://broadrouter.com/pt/blog/arabic-ocr-vision-llm/) para saber quando o OCR clássico é a melhor ferramenta.

## Como é o pipeline?

1.  **Prepare** cada página: converta PDFs em imagens, corrija a rotação, redimensione.
2.  **Extraia**: uma requisição por documento, com um prompt campo a campo, só JSON.
3.  **Valide**: parsing, checagem de esquema, checagem aritmética.
4.  **Repita** uma vez com a mensagem de erro se a validação falhar.
5.  **Revise**: o que continuar falhando vai para uma pessoa, com a imagem e o rascunho.
6.  **Meça** a precisão por campo em uma amostra rotulada e rode de novo sempre que trocar de modelo ou de prompt.

## Como preparar as imagens dos documentos?

Converta PDFs em imagens com o PyMuPDF e mantenha o menor texto nítido sem enviar mais pixels do que o necessário:

```python
# pip install pymupdf pillow
import base64, io
import pymupdf  # older code imports it as fitz
from PIL import Image

def pdf_pages_as_data_urls(path, long_edge=1800):
    urls = []
    for page in pymupdf.open(path):
        pix = page.get_pixmap(dpi=200)
        img = Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB")
        img.thumbnail((long_edge, long_edge))
        buf = io.BytesIO()
        img.save(buf, format="JPEG", quality=90)
        urls.append("data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode())
    return urls
```

Na BroadNet Inference, as imagens vão na mensagem como URLs `data:` com o tipo MIME correto e, no [pagamento por uso](https://broadrouter.com/pt/glossary/pay-as-you-go/), são cobradas como tokens de entrada; imagens maiores usam mais. Meça uma vez os tokens por página com o bloco `usage` e dimensione os lotes a partir disso; [contar tokens antes de enviar](https://broadrouter.com/pt/blog/count-tokens-before-sending/) mostra como, e [custo por imagem em LLMs de visão](https://broadrouter.com/pt/blog/cheapest-vision-llm-api/) transforma tokens em custo por página. Para estimar os tokens por página antes de enviar qualquer coisa, jogue uma digitalização de exemplo na [calculadora de tokens de imagem](https://broadrouter.com/tools/image-token-calculator/).

## Como escrever o prompt de extração?

Seja exato sobre chaves, tipos, formatos e valores ausentes. Se você também quiser um JSON Schema para validação ou para provedores que o exigem, o [gerador gratuito de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) monta um a partir de uma fatura de exemplo:

```python
PROMPT = """Extract this invoice. Reply with one JSON object only, no prose.
Keys:
- vendor_name: string, as printed
- vendor_tax_id: string or null
- invoice_number: string
- invoice_date: string, YYYY-MM-DD
- currency: ISO 4217 code, e.g. USD, EUR, SAR
- line_items: list of {description: string, quantity: number, unit_price: number, line_total: number}
- subtotal: number
- tax: number or null
- total: number
Rules: numbers without currency symbols or thousands separators. If a field is not on the page, use null. Never guess."""
```

“Never guess” (nunca chute) junto com um `null` explícito é o que mais importa. Sem isso, os modelos preenchem lacunas com valores plausíveis, o que é pior do que um campo vazio, porque passa numa checagem ingênua.

## Como obter saída estruturada e validá-la?

A [saída estruturada](https://broadrouter.com/pt/glossary/structured-output/) tem dois níveis. O modo JSON garante um JSON válido. A saída restrita a um esquema garante também o formato. O guia da OpenAI diz isso com clareza: os dois produzem JSON válido, mas só os Structured Outputs garantem a aderência ao esquema. O suporte a cada um varia por provedor e modelo, então valide no código, não importa o que a API prometa:

```python
import json, os
from decimal import Decimal
from pydantic import BaseModel, ValidationError, model_validator
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

class Line(BaseModel):
    description: str
    quantity: Decimal
    unit_price: Decimal
    line_total: Decimal

class Invoice(BaseModel):
    vendor_name: str
    vendor_tax_id: str | None = None
    invoice_number: str
    invoice_date: str
    currency: str
    line_items: list[Line]
    subtotal: Decimal
    tax: Decimal | None = None
    total: Decimal

    @model_validator(mode="after")
    def sums(self):
        tol = Decimal("0.02")
        if abs(sum(l.line_total for l in self.line_items) - self.subtotal) > tol:
            raise ValueError("line_totals do not sum to subtotal")
        if abs(self.subtotal + (self.tax or 0) - self.total) > tol:
            raise ValueError("subtotal + tax != total")
        return self

def extract(image_urls, model="broadnet/qwen3.8-27b"):
    content = [{"type": "text", "text": PROMPT}] + [
        {"type": "image_url", "image_url": {"url": u}} for u in image_urls]
    messages = [{"role": "user", "content": content}]
    for attempt in range(2):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=4000, temperature=0)
        raw = (r.choices[0].message.content or "").strip().removeprefix("```json").removesuffix("```")
        try:
            return Invoice.model_validate(json.loads(raw)), r.usage
        except (json.JSONDecodeError, ValidationError, ValueError) as e:
            messages += [{"role": "assistant", "content": raw},
                         {"role": "user", "content": f"That failed validation: {e}. Re-read the image and reply with corrected JSON only."}]
    return None, r.usage  # send to human review
```

Use `Decimal`, não `float`, para valores monetários. Mantenha `max_tokens` generoso: o Qwen3.8 27B raciocina antes de responder, e o raciocínio conta no limite; um teto baixo devolve uma string vazia. Veja [por que modelos de raciocínio devolvem respostas vazias](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).

## Quais checagens pegam mais erros?

| Checagem | O que pega | Custo |
| --- | --- | --- |
| O JSON faz parsing | Texto em volta do JSON, truncamento | Grátis |
| O esquema valida | Chaves ausentes, tipos errados | Grátis |
| As linhas somam o subtotal | Dígitos lidos errado, linhas puladas | Grátis |
| Subtotal + imposto = total | Total ou imposto lidos errado | Grátis |
| A data faz parsing e não está no futuro | Dia e mês trocados, ruído de OCR | Grátis |
| O CNPJ do fornecedor bate com o seu cadastro | Fornecedor errado, fraude | Uma consulta |
| Número de fatura duplicado por fornecedor | Pagamento em dobro | Uma query |

As checagens aritméticas são as que mais compensam: um único dígito lido errado quase sempre quebra uma soma. Recibos muitas vezes não têm detalhe por linha, então confira o que existe e aceite menos checagens para eles.

## Como medir a precisão antes de colocar em produção?

Rotule à mão de 50 a 100 documentos reais, rode o pipeline e avalie **por campo**, não por documento. Totais e datas merecem um critério mais rígido do que descrições. Acompanhe três números: a precisão por campo, a fração de documentos que passam na validação sem retentativa e a fração enviada para revisão. Como desenhar essa etapa de revisão, incluindo auditorias aleatórias de documentos que passaram, está em [tornar a revisão humana parte do seu fluxo de IA para documentos](https://broadrouter.com/pt/blog/document-review-queues/). Quando testar outro modelo, use o mesmo conjunto; [avaliar um LLM antes de trocar](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/) explica o método.

## Quais modelos de visão servem na BroadNet Inference?

| Modelo | Imagens | Contexto | Observações |
| --- | --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) | Sim | 262.144 | Ferramentas, saída estruturada e raciocínio listados; testado em árabe pela BroadNet |
| [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) | Sim | 32.768 | Menor preço da BroadNet; funciona com o crédito gratuito e com a chave por hora |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | Sim | 1.048.576 | Imagens incluídas nos planos ilimitados |

Os preços por 1M de tokens estão na [página de preços](https://broadrouter.com/pt/pricing/); multiplique os tokens por página que você mediu pelo volume mensal na [calculadora de custo de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).

## Onde a BroadNet Inference se encaixa

A BroadNet Inference aceita imagens em três modelos de chat pelo formato padrão de mensagens da OpenAI e não retém prompts, imagens nem respostas após a requisição, o que importa em faturas cheias de nomes, números de identificação fiscal e dados bancários ([retenção zero de dados](https://broadrouter.com/pt/privacy/)). A documentação lista saída estruturada para o Qwen3.8 27B, mas não documenta parâmetros de esquema, então confie na camada de validação acima, e não na API, para impor o seu esquema. A BroadNet não publica um limite de tamanho de imagem nem um produto dedicado de IA para documentos, e a documentação descreve entrada de imagens, não upload de PDF, então converta as páginas em imagens antes. Para execuções de alto volume com orçamento fixo, um [plano ilimitado do DeepSeek V4.1 Flash](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/) inclui imagens.

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Saída estruturada (structured output)](https://broadrouter.com/pt/glossary/structured-output/)

Saída estruturada é um recurso de APIs de LLM que restringe a resposta de um modelo a um formato definido pelo desenvolvedor, normalmente um JSON Schema, para que o código consiga interpretá-la de forma confiável. É mais rigorosa que o JSON mode, que garante um JSON válido, mas não uma estrutura específica.

[Reconhecimento óptico de caracteres (OCR)](https://broadrouter.com/pt/glossary/ocr/)

OCR (reconhecimento óptico de caracteres) é a tecnologia que detecta texto impresso ou manuscrito em uma imagem, digitalização ou PDF e o converte em caracteres legíveis por máquina. O OCR clássico devolve o texto e a posição dele na página; modelos de visão e linguagem conseguem ler o texto e responder perguntas sobre ele diretamente.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[JSON Schema](https://broadrouter.com/pt/glossary/json-schema/)

JSON Schema é um vocabulário, escrito em JSON, para descrever e validar a estrutura de dados JSON: tipos, campos obrigatórios, valores permitidos e aninhamento. A versão atual é a 2020-12. APIs de LLM o usam para definir parâmetros de tools e o formato exato que uma saída estruturada deve seguir.

[JSON mode (modo JSON)](https://broadrouter.com/pt/glossary/json-mode/)

JSON mode é uma configuração de APIs de LLM, response\_format {"type": "json\_object"} em APIs no estilo da OpenAI, que faz a resposta do modelo ser JSON válido e parseável. Ao contrário de structured outputs com JSON Schema, ele não garante quais chaves, tipos ou valores o objeto contém.

[Modelo de visão e linguagem (VLM)](https://broadrouter.com/pt/glossary/vision-language-model/)

Um modelo de visão e linguagem (VLM, vision-language model) é um modelo que recebe imagens e texto juntos como entrada e produz texto, então consegue descrever fotos, responder perguntas sobre elas e ler documentos, gráficos ou capturas de tela. VLMs também são chamados de modelos image-text-to-text ou multimodais.

## Perguntas frequentes

### Um LLM de visão pode substituir o OCR em faturas?

Em muitos layouts, sim. Um modelo de visão lê a imagem e associa o texto aos campos em uma só etapa, sem templates por fornecedor. Mas às vezes ele ainda lê dígitos errado, então mantenha a validação e uma fila de revisão.

### Como obter um JSON confiável de um modelo de visão?

Liste no prompt as chaves, os tipos e os formatos exatos, peça só JSON e faça o parsing no código. Se o modelo suporta saída restrita a um esquema, use. De qualquer forma, valide com uma biblioteca de esquemas e repita uma vez com o erro.

### Como extrair dados de uma fatura em PDF com várias páginas?

Converta cada página em imagem e envie todas as páginas de uma mesma fatura em uma única requisição, se couberem no contexto do modelo, para que os totais da última página possam ser conferidos com as linhas da primeira.

### Qual resolução as imagens das faturas devem ter?

Alta o suficiente para que os menores dígitos fiquem nítidos, e não mais que isso. Imagens maiores usam mais tokens de entrada. Um lado maior de cerca de 1.500 a 2.000 pixels é um bom ponto de partida para uma página A4; teste com os seus documentos.

### Como medir a precisão da extração?

Rotule à mão de 50 a 100 documentos reais e avalie campo a campo. Acompanhe totais e datas separados de campos de texto livre, como nomes de fornecedores, porque o custo dos erros é diferente.

## Continue lendo

-   [OCR em árabe ou LLM de visão: lendo documentos e notas fiscais](https://broadrouter.com/pt/blog/arabic-ocr-vision-llm/)
-   [OCR para árabe por API: Google, Azure, Textract, Mistral e LLMs](https://broadrouter.com/pt/blog/arabic-ocr-api-comparison/)
-   [API de LLM com visão mais barata: custo por imagem e por página](https://broadrouter.com/pt/blog/cheapest-vision-llm-api/)
-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [Como avaliar um LLM antes de trocar de provedor](https://broadrouter.com/pt/blog/evaluate-llm-before-switching/)
-   [Como contar tokens antes de enviar uma requisição a um LLM](https://broadrouter.com/pt/blog/count-tokens-before-sending/)
-   [Revisão humana no seu fluxo de IA para documentos](https://broadrouter.com/pt/blog/document-review-queues/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Ler notas fiscais e recibos em árabe com um modelo de visão](https://broadrouter.com/pt/guides/read-arabic-invoices-with-vision/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-extract-data-from-documents-with-vision-llm&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: chat com imagem, tipos MIME, imagens nos planos (consultada em 2026-11-14) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-extract-data-from-documents-with-vision-llm&utm_content=sources#requests)
-   [Preços, modelos e modalidades da BroadNet Inference em formato legível por máquina, pricing.json (consultado em 2026-11-14) (em inglês)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-extract-data-from-documents-with-vision-llm&utm_content=sources)
-   [Guia de Structured Outputs da OpenAI, modo JSON versus aderência ao esquema (consultado em 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [Documentação do Pydantic, modelos e validação (consultada em 2026-11-14)](https://docs.pydantic.dev/latest/concepts/models/)
-   [Documentação do PyMuPDF, renderização de páginas em imagens (consultada em 2026-11-14)](https://pymupdf.readthedocs.io/en/latest/recipes-images.html)
