---
title: "Extraer datos de facturas a JSON con un LLM de visión"
description: "Flujo de producción para facturas, recibos y formularios: imágenes, prompt con esquema JSON, Pydantic, controles aritméticos, reintentos y revisión humana."
url: https://broadrouter.com/es/blog/extract-data-from-documents-with-vision-llm/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/extract-data-from-documents-with-vision-llm/) (actualizado el 2026-11-14).

# Extraer datos de facturas, recibos y formularios a JSON con visión

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado 2026-11-14

Convierta cada página en una imagen, envíela a un modelo de visión con un prompt que nombre cada campo y su formato, y pida solo JSON. Después valide en código: analícelo, compruebe su esquema, verifique que las líneas suman el total y reintente una vez con el error. Envíe los fallos repetidos a una persona.

## Puntos clave

-   El modelo lee; su código decide. Nunca escriba datos extraídos en la contabilidad sin controles de esquema y aritméticos.
-   Nombre en el prompt cada campo, su tipo y su formato, e indique qué devolver cuando falte un campo (null, nunca una suposición).
-   Los controles aritméticos detectan la mayoría de las malas lecturas: los totales de línea deben sumar el subtotal, y el subtotal más el impuesto debe ser igual al total.
-   Reintente una vez con el error de validación en el prompt; envíe los fallos repetidos a una cola de revisión humana.
-   Con pago por uso, las imágenes se facturan como tokens de entrada y las más grandes consumen más, así que redimensiónelas antes de enviarlas.

**En esta página**

1.  ¿Cómo es el flujo?
2.  ¿Cómo se preparan las imágenes de los documentos?
3.  ¿Cómo se escribe el prompt de extracción?
4.  ¿Cómo se obtiene y se valida la salida estructurada?
5.  ¿Qué controles detectan más errores?
6.  ¿Cómo se mide la precisión antes de salir a producción?
7.  ¿Qué modelos de visión ofrece BroadNet Inference?
8.  Dónde encaja BroadNet Inference

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

Illustrative example.

Las facturas, los recibos y los formularios comparten el mismo problema: los datos están en una imagen y usted los necesita en una base de datos. El OCR basado en plantillas se rompe con cada nuevo diseño de proveedor. Un [modelo de visión y lenguaje](https://broadrouter.com/es/glossary/vision-language-model/) lee la página y devuelve los campos directamente. El inconveniente es que puede equivocarse con total seguridad, así que el trabajo está en el flujo que lo rodea. Este artículo cubre el flujo general para cualquier idioma. Para documentos en árabe, consulte [leer facturas en árabe con visión](https://broadrouter.com/es/guides/read-arabic-invoices-with-vision/) para la configuración y [OCR árabe frente a LLM de visión](https://broadrouter.com/es/blog/arabic-ocr-vision-llm/) para saber cuándo el OCR clásico es la mejor herramienta.

## ¿Cómo es el flujo?

1.  **Prepare** cada página: convierta los PDF en imágenes, corrija la rotación y redimensione.
2.  **Extraiga**: una solicitud por documento con un prompt campo por campo, solo JSON.
3.  **Valide**: analice, compruebe el esquema, compruebe la aritmética.
4.  **Reintente** una vez con el mensaje de error si la validación falla.
5.  **Revise**: lo que siga fallando pasa a una persona, con la imagen y el borrador.
6.  **Mida** la precisión por campo en una muestra etiquetada y repita la medición cada vez que cambie de modelo o de prompt.

## ¿Cómo se preparan las imágenes de los documentos?

Convierta los PDF en imágenes con PyMuPDF y mantenga nítido el texto más pequeño sin enviar más píxeles de los necesarios:

```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
```

En BroadNet Inference, las imágenes van en el mensaje como URL `data:` con un tipo MIME correcto, y con [pago por uso](https://broadrouter.com/es/glossary/pay-as-you-go/) se facturan como tokens de entrada; las imágenes más grandes consumen más. Mida una vez los tokens por página con el bloque `usage` y dimensione sus lotes a partir de ahí; [contar tokens antes de enviar](https://broadrouter.com/es/blog/count-tokens-before-sending/) explica cómo, y [costo por imagen de los LLM de visión](https://broadrouter.com/es/blog/cheapest-vision-llm-api/) convierte tokens en costo por página. Para estimar los tokens por página antes de enviar nada, cargue un escaneo de muestra en la [calculadora de tokens de imagen](https://broadrouter.com/tools/image-token-calculator/).

## ¿Cómo se escribe el prompt de extracción?

Sea exacto con las claves, los tipos, los formatos y los valores ausentes. Si además quiere un JSON Schema para validar o para proveedores que lo imponen, el [generador de esquemas JSON](https://broadrouter.com/tools/json-schema-generator/) gratuito lo crea a partir de una factura de ejemplo:

```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."""
```

Lo que más importa es “Never guess” (Traducción: nunca suponga) junto con un `null` explícito. Sin eso, los modelos rellenan los huecos con valores verosímiles, lo que es peor que un campo vacío porque supera un control ingenuo.

## ¿Cómo se obtiene y se valida la salida estructurada?

Hay dos niveles de [salida estructurada](https://broadrouter.com/es/glossary/structured-output/). El modo JSON garantiza un JSON válido. La salida restringida por esquema garantiza además la forma. La guía de OpenAI lo dice claramente: ambos producen JSON válido, pero solo Structured Outputs garantiza la adherencia al esquema. La compatibilidad con cada uno varía según el proveedor y el modelo, así que valide en código, prometa lo que prometa la API:

```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`, no `float`, para importes. Mantenga `max_tokens` generoso: Qwen3.8 27B razona antes de responder, y el razonamiento cuenta para el límite; un tope pequeño devuelve una cadena vacía. Consulte [por qué los modelos de razonamiento devuelven respuestas vacías](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/).

## ¿Qué controles detectan más errores?

| Control | Detecta | Costo |
| --- | --- | --- |
| El JSON se analiza | Texto alrededor del JSON, truncamiento | Gratis |
| El esquema valida | Claves ausentes, tipos incorrectos | Gratis |
| Las líneas suman el subtotal | Dígitos mal leídos, líneas omitidas | Gratis |
| Subtotal + impuesto = total | Total o impuesto mal leídos | Gratis |
| La fecha se analiza y no es futura | Día y mes invertidos, ruido de OCR | Gratis |
| El ID fiscal del proveedor coincide con su lista de proveedores | Proveedor equivocado, fraude | Una búsqueda |
| Número de factura duplicado por proveedor | Pago doble | Una consulta |

Los controles aritméticos son los más rentables: un solo dígito mal leído casi siempre rompe una suma. Los recibos a menudo carecen de detalle por línea, así que compruebe lo que haya y acepte menos controles en ellos.

## ¿Cómo se mide la precisión antes de salir a producción?

Etiquete a mano entre 50 y 100 documentos reales, ejecute el flujo y puntúe **por campo**, no por documento. Los totales y las fechas merecen un listón más alto que las descripciones. Haga seguimiento de tres cifras: la precisión por campo, la proporción de documentos que pasan la validación sin reintento y la proporción que va a revisión. Cómo diseñar ese paso de revisión, incluidas auditorías aleatorias de documentos que pasaron, se explica en [cómo integrar la revisión humana en su flujo de IA para documentos](https://broadrouter.com/es/blog/document-review-queues/). Cuando pruebe otro modelo, ejecute el mismo conjunto; [evaluar un LLM antes de cambiar](https://broadrouter.com/es/blog/evaluate-llm-before-switching/) cubre el método.

## ¿Qué modelos de visión ofrece BroadNet Inference?

| Modelo | Imágenes | Contexto | Notas |
| --- | --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) | Sí | 262,144 | Herramientas, salida estructurada y razonamiento listados; probado en árabe por BroadNet |
| [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/) | Sí | 32,768 | El precio más bajo de BroadNet; funciona con el crédito gratuito y la clave por hora |
| [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) | Sí | 1,048,576 | Imágenes incluidas en los planes ilimitados |

Los precios por 1M de tokens están en la [página de precios](https://broadrouter.com/es/pricing/); multiplique sus tokens medidos por página por el volumen mensual en la [calculadora de costo de API de LLM](https://broadrouter.com/tools/llm-api-cost-calculator/).

## Dónde encaja BroadNet Inference

BroadNet Inference acepta imágenes en tres modelos de chat mediante el formato de mensajes estándar de OpenAI, y no conserva prompts, imágenes ni respuestas después de la solicitud, lo que importa en facturas llenas de nombres, ID fiscales y datos bancarios ([cero retención de datos](https://broadrouter.com/es/privacy/)). Su documentación lista la salida estructurada para Qwen3.8 27B, pero no documenta parámetros de esquema, así que confíe en la capa de validación anterior y no en la API para imponer su esquema. BroadNet no publica un límite de tamaño de imagen ni un producto específico de IA para documentos, y su documentación describe la entrada de imágenes, no la subida de PDF, así que convierta primero las páginas en imágenes. Para ejecuciones de gran volumen con un presupuesto fijo, un [plan ilimitado de DeepSeek V4.1 Flash](https://broadrouter.com/es/guides/unlimited-llm-api-sessions/) incluye imágenes.

Herramientas gratuitas sobre este tema (en 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.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

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

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[Salida estructurada (structured output)](https://broadrouter.com/es/glossary/structured-output/)

La salida estructurada es una función de las APIs de LLM que restringe la respuesta del modelo a un formato que define el desarrollador, normalmente un JSON Schema, para que el código pueda procesarla de forma fiable. Es más estricta que JSON mode, que garantiza JSON válido pero no una forma concreta.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

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

El reconocimiento óptico de caracteres (OCR) es la tecnología que detecta el texto impreso o manuscrito de una imagen, un escaneo o un PDF y lo convierte en caracteres legibles por máquina. El OCR clásico devuelve el texto y su posición en la página; los modelos de visión y lenguaje pueden leer el texto y responder preguntas sobre él directamente.

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

El pago por uso es un modelo de precios en el que usted paga solo lo que usa, medido por unidades como tokens, solicitudes o minutos de audio, sin suscripción ni compromiso mínimo. La mayoría de las APIs de LLM cobran así, desde un saldo prepagado o con una factura periódica.

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

El modo JSON (JSON mode) es un ajuste de las APIs de LLM, response\_format {"type": "json\_object"} en las APIs al estilo de OpenAI, que hace que la respuesta del modelo sea JSON válido y procesable. A diferencia de la salida estructurada con un JSON Schema, no garantiza qué claves, tipos o valores contiene el objeto.

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

JSON Schema es un vocabulario, escrito en JSON, para describir y validar la estructura de datos JSON: tipos, campos obligatorios, valores permitidos y anidamiento. La versión actual es la 2020-12. Las APIs de LLM lo usan para definir los parámetros de las herramientas y la forma exacta que debe seguir una salida estructurada.

[Modelo de visión y lenguaje (VLM)](https://broadrouter.com/es/glossary/vision-language-model/)

Un modelo de visión y lenguaje (VLM) es un modelo que recibe imágenes y texto a la vez y produce texto, por lo que puede describir imágenes, responder preguntas sobre ellas y leer documentos, gráficos o capturas de pantalla. También se les llama modelos image-text-to-text o multimodales.

## Preguntas frecuentes

### ¿Puede un LLM de visión sustituir al OCR en las facturas?

En muchos diseños, sí. Un modelo de visión lee la imagen y asigna el texto a los campos en un solo paso, sin plantillas por proveedor. Aun así, a veces lee mal los dígitos, así que mantenga la validación y una cola de revisión.

### ¿Cómo obtengo JSON fiable de un modelo de visión?

Enumere en el prompt las claves, los tipos y los formatos exactos, pida solo JSON y analícelo en código. Si el modelo admite salida restringida por esquema, úsela. En cualquier caso, valide con una biblioteca de esquemas y reintente una vez con el error.

### ¿Cómo extraigo datos de una factura PDF de varias páginas?

Convierta cada página en una imagen y envíe todas las páginas de una factura en una sola solicitud si caben en el contexto del modelo, para que los totales de la última página puedan cotejarse con las líneas de la primera.

### ¿Qué resolución deben tener las imágenes de facturas?

La suficiente para que los dígitos más pequeños se vean nítidos, y no más. Las imágenes más grandes consumen más tokens de entrada. Un lado largo de unos 1,500 a 2,000 píxeles es un punto de partida razonable para una página A4; pruebe con sus propios documentos.

### ¿Cómo mido la precisión de la extracción?

Etiquete a mano entre 50 y 100 documentos reales y puntúe campo por campo. Haga seguimiento de los totales y las fechas por separado de los campos de texto libre, como los nombres de proveedor, porque el costo de sus errores es distinto.

## Siga leyendo

-   [OCR árabe frente a LLM de visión: leer documentos y facturas en árabe](https://broadrouter.com/es/blog/arabic-ocr-vision-llm/)
-   [Comparativa de OCR árabe: Google, Azure, Textract, Mistral y LLM](https://broadrouter.com/es/blog/arabic-ocr-api-comparison/)
-   [La API de LLM de visión más barata: costo por imagen y por página](https://broadrouter.com/es/blog/cheapest-vision-llm-api/)
-   [Modo JSON o json\_schema: salida estructurada que no falla](https://broadrouter.com/es/blog/structured-output-json-schema/)
-   [Cómo evaluar un LLM antes de cambiar de proveedor](https://broadrouter.com/es/blog/evaluate-llm-before-switching/)
-   [Cómo contar tokens antes de enviar una petición a un LLM](https://broadrouter.com/es/blog/count-tokens-before-sending/)
-   [Integre la revisión humana en su flujo de IA documental](https://broadrouter.com/es/blog/document-review-queues/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Lea facturas y recibos en árabe con un modelo de visión](https://broadrouter.com/es/guides/read-arabic-invoices-with-vision/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

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

**Fuentes**

-   [Referencia de la API de BroadNet Inference: chat con una imagen, tipos MIME, imágenes en los planes (consultado el 2026-11-14) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-extract-data-from-documents-with-vision-llm&utm_content=sources#requests)
-   [Precios de BroadNet Inference en formato legible por máquina, modelos y modalidades, pricing.json (consultado el 2026-11-14) (en inglés)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-extract-data-from-documents-with-vision-llm&utm_content=sources)
-   [Guía de Structured Outputs de OpenAI, modo JSON frente a adherencia al esquema (consultado el 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [Documentación de Pydantic, modelos y validación (consultado el 2026-11-14)](https://docs.pydantic.dev/latest/concepts/models/)
-   [Documentación de PyMuPDF, convertir páginas en imágenes (consultado el 2026-11-14)](https://pymupdf.readthedocs.io/en/latest/recipes-images.html)
