---
title: "Revisión humana en IA documental: reglas y muestreo | BroadRouter"
description: "Diseñe el paso de revisión humana de un pipeline de IA documental: reglas de validación, qué enviar a una persona, muestras de auditoría, registro y tasa."
url: https://broadrouter.com/es/blog/document-review-queues/
lang: es
updated: 2026-11-15
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/document-review-queues/) (actualizado el 2026-11-16).

# Integre la revisión humana en su flujo de IA documental

Por el equipo de BroadNet Inference · 7 min de lectura · Publicado 2026-11-15 · Actualizado 2026-11-16

Trate cada documento extraído como no aprobado hasta que pase las reglas. Envíelo a una persona si falta un campo obligatorio, las sumas no cuadran, la fecha o el proveedor parecen incorrectos o el modelo no está seguro. Revise también una pequeña parte aleatoria de los documentos limpios, registre cada corrección en su propio sistema y siga la tasa de revisión y la tasa de error auditada.

## Puntos clave

-   Las reglas de validación deciden qué ve una persona. La confianza que declara el modelo es solo una señal más, y la investigación publicada encuentra que los LLM son demasiado confiados cuando la declaran.
-   Cada documento en cola debe llevar motivos legibles por máquina, como arithmetic o vendor:unknown, para que el revisor sepa dónde mirar y usted sepa qué regla corregir.
-   Audite una muestra aleatoria de los documentos aprobados automáticamente. Cero errores en 50 documentos auditados todavía admite una tasa de error real de hasta un 7 % aproximadamente (intervalo de Wilson al 95 %).
-   Guarde usted mismo el registro de auditoría: hash de la imagen, ID del modelo, versión del prompt, salida, reglas activadas y corrección del revisor. Una API sin retención de datos no conserva ninguna copia del contenido.
-   Siga tres números cada semana: tasa de revisión, principales motivos de revisión y tasa de error auditada de los documentos aprobados automáticamente.

**En esta página**

1.  ¿Qué debe decidir si una persona revisa un documento?
2.  ¿Debe confiar en la confianza del modelo?
3.  ¿Cómo enrutar los documentos a una cola?
4.  ¿Qué cambia con las facturas en árabe e inglés?
5.  ¿Qué debe ver el revisor?
6.  ¿Por qué muestrear documentos que pasaron todas las reglas?
7.  ¿Cómo mantener un registro de auditoría?
8.  ¿Cómo medir la tasa de revisión?
9.  Dónde encaja BroadNet Inference

Un modelo de visión puede leer una factura, pero también puede leer mal un dígito, saltarse una línea o inventar un campo que no existe. La solución no es solo un mejor prompt. Es un paso de revisión diseñado desde el primer día: reglas que deciden qué documentos ve una persona, una cola que le dice por qué y un registro que le permite demostrar la tasa de error.

Este artículo trata ese paso. La extracción en sí (preparación de imágenes, el prompt JSON, validación del esquema y reintentos) está en [extraer datos de documentos con un LLM de visión](https://broadrouter.com/es/blog/extract-data-from-documents-with-vision-llm/), y la lectura específica del árabe en [leer facturas en árabe con visión](https://broadrouter.com/es/guides/read-arabic-invoices-with-vision/). Aquí suponemos que ya recibe JSON y necesita decidir en qué confiar.

## ¿Qué debe decidir si una persona revisa un documento?

Reglas que pueda probar en código, no una impresión sobre el modelo. Empiece por estas, ordenadas por su valor:

| Regla | Ejemplo de código de motivo | Por qué importa |
| --- | --- | --- |
| Falta un campo obligatorio | `missing:total` | Un null es honesto; un valor adivinado es peor |
| Las sumas no cuadran | `arithmetic:subtotal+tax!=total` | Un solo dígito mal leído casi siempre rompe una suma |
| Las partidas no suman el subtotal | `arithmetic:lines!=subtotal` | Detecta líneas omitidas o duplicadas |
| La fecha no se interpreta o está fuera de rango | `date:unparsed` | Detecta inversiones de día y mes y ruido de OCR |
| ID fiscal del proveedor desconocido | `vendor:unknown` | Los proveedores nuevos y el fraude empiezan aquí |
| Moneda inesperada | `currency:unexpected` | Un símbolo mal leído cambia el importe |
| El modelo dice que no está seguro | `model:not_confident` | Una pista, nunca el único filtro |

Dos decisiones de diseño hacen que la cola sea útil. Primera: cada regla produce un código de motivo corto y estable, de modo que el revisor abre el documento sabiendo qué comprobar y usted puede contar qué regla salta más. Segunda: un documento o pasa todas las reglas o va a una persona. Evite puntuaciones ponderadas que nadie sepa explicar a un auditor.

## ¿Debe confiar en la confianza del modelo?

Trátela como una señal débil. Puede pedirle al modelo que califique cada campo con confianza alta, media o baja, y lo hará. Pero Xiong et al. (ICLR 2024) compararon formas de hacer que los LLM declaren su confianza y encontraron que los modelos “tend to be overconfident” (Traducción: tienden a ser demasiado confiados) cuando dicen cuán seguros están; mejores prompts y el muestreo ayudaron, y ningún método superó de forma constante a los demás. Las log-probabilidades de los tokens son otra opción en algunas API. La referencia de la API de BroadNet no documenta `logprobs`, así que no base su diseño en ellas allí.

La regla práctica: cualquier calificación del modelo inferior a «high», o la ausencia de calificación, envía el documento a revisión, pero un «high» nunca se salta las comprobaciones en código. Tras unos cientos de documentos revisados, compruebe si los campos «high» de verdad necesitaron menos correcciones. Si no fue así, descarte la señal.

## ¿Cómo enrutar los documentos a una cola?

Este enrutador se ejecuta después de la extracción y la validación. Normaliza los dígitos arábigo-índicos, aplica las reglas anteriores y elige una de tres colas: `review`, `audit_sample` o `auto`. Es Python simple, sin llamadas a ninguna API, así que puede escribirle pruebas unitarias.

```python
import hashlib, json, random, re, time
from datetime import date, datetime
from decimal import Decimal, InvalidOperation

REQUIRED = ["vendor_name", "invoice_number", "invoice_date", "currency", "subtotal", "tax", "total"]
CURRENCIES = {"SAR", "AED", "USD", "EUR"}
KNOWN_VENDORS = {"300000000000003": "Example Trading Co"}   # your supplier master: tax ID -> name
AUTO_SAMPLE_RATE = 0.05          # share of clean documents a person still checks
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹٫٬", "01234567890123456789.,")

def money(v):
    """'١٬٢٥٠٫٥٠' or '1,250.50' -> Decimal('1250.50'); None if it is not a number."""
    if v is None:
        return None
    s = str(v).translate(DIGITS).replace(",", "").strip()
    try:
        return Decimal(s)
    except InvalidOperation:
        return None

def check(doc: dict, today: date) -> list[str]:
    """Return the reasons this document needs a person. Empty list = may auto-approve."""
    reasons = [f"missing:{f}" for f in REQUIRED if doc.get(f) in (None, "")]
    sub, tax, tot = (money(doc.get(k)) for k in ("subtotal", "tax", "total"))
    if None not in (sub, tax, tot) and abs(sub + tax - tot) > Decimal("0.01"):
        reasons.append("arithmetic:subtotal+tax!=total")
    lines = [money(l.get("amount")) for l in doc.get("lines", [])]
    if lines and None not in lines and sub is not None and abs(sum(lines) - sub) > Decimal("0.01"):
        reasons.append("arithmetic:lines!=subtotal")
    try:
        d = datetime.strptime(str(doc.get("invoice_date", "")).translate(DIGITS), "%Y-%m-%d").date()
        if d > today or (today - d).days > 400:
            reasons.append("date:out_of_range")
    except ValueError:
        reasons.append("date:unparsed")
    if doc.get("currency") and doc["currency"] not in CURRENCIES:
        reasons.append("currency:unexpected")
    if doc.get("vendor_tax_id") not in KNOWN_VENDORS:
        reasons.append("vendor:unknown")
    if doc.get("model_confidence", "low") != "high":   # a hint from the prompt, never the only gate
        reasons.append("model:not_confident")
    return reasons

def route(doc_id: str, doc: dict, today: date, rng=random.random) -> dict:
    reasons = check(doc, today)
    if reasons:
        queue = "review"
    elif rng() < AUTO_SAMPLE_RATE:
        queue, reasons = "audit_sample", ["sample:random"]
    else:
        queue = "auto"
    return {"doc": hashlib.sha256(doc_id.encode()).hexdigest()[:16], "queue": queue,
            "reasons": reasons, "ts": int(time.time())}
```

Lo probamos con tres facturas saudíes inventadas (el proveedor y el ID fiscal son ficticios). Una limpia, con la fecha y el subtotal escritos en dígitos arábigo-índicos (٢٠٢٦-١١-٠٢ y ١٬٠٠٠٫٠٠), fue a `auto`. La misma factura con el total mal leído como 1,105.00 fue a `review` con `arithmetic:subtotal+tax!=total`. Una con un ID fiscal desconocido, un mes 13 y confianza «medium» fue a `review` con tres motivos: `date:unparsed`, `vendor:unknown` y `model:not_confident`. Forzar el sorteo aleatorio por debajo de 0.05 envió la factura limpia a `audit_sample`.

Dos límites que conviene conocer. La función auxiliar `money()` supone un punto o el separador decimal árabe como separador decimal; un “1.150,00” europeo necesita su propio analizador, elegido según el país del proveedor. Y la regla de fechas supone que el modelo devolvió fechas ISO. Las fechas hégira necesitan conversión previa, como en [extracción de entidades nombradas en árabe](https://broadrouter.com/es/blog/arabic-named-entity-extraction-llm/).

## ¿Qué cambia con las facturas en árabe e inglés?

Las facturas bilingües son habituales en el Golfo: etiquetas en árabe e inglés lado a lado, importes en dígitos occidentales o arábigo-índicos y el nombre del proveedor en dos alfabetos. Algunas reglas ayudan:

-   **Normalice los dígitos antes de cualquier comprobación.** Convierta ٠–٩ y los persas ۰–۹ a 0–9, y los separadores árabes decimal y de miles (٫ y ٬) a sus formas ASCII. Después compare.
-   **Identifique a los proveedores por su ID fiscal, no por el nombre.** Los nombres en árabe e inglés rara vez coinciden carácter por carácter con su registro maestro. El número de registro sí.
-   **Muestre ambos nombres al revisor.** Presente los nombres del proveedor extraídos en árabe e inglés junto al registro maestro, con el árabe en un bloque aislado de derecha a izquierda. El artículo sobre [diseño de productos multilingües](https://broadrouter.com/es/blog/multilingual-product-design/) trata la visualización bidireccional.
-   **Compruebe si existe una factura estructurada.** La ZATCA de Arabia Saudita aplica la facturación electrónica (Fatoorah) en dos fases, desde el 4 de diciembre de 2021 y el 1 de enero de 2023, basada en facturas en un formato electrónico estructurado. Si un proveedor puede enviárselo, procéselo en lugar de leer una imagen suya, y reserve la visión para el papel, las fotos y los casos minoritarios.

[OCR en árabe con un LLM de visión](https://broadrouter.com/es/blog/arabic-ocr-vision-llm/) cubre la parte de lectura: diacríticos, alfabetos mezclados y maquetación.

## ¿Qué debe ver el revisor?

Una buena pantalla de revisión responde una pregunta por cada código de motivo. Para `arithmetic`, muestre las partidas, el subtotal, el impuesto y el total lado a lado con la suma calculada. Para `vendor:unknown`, muestre el ID fiscal extraído y los registros maestros más parecidos. Para `date:unparsed`, muestre el texto original de la fecha y el recorte de la imagen de donde salió.

Muestre la imagen junto a los campos, no en otra pestaña. Permita al revisor corregir un campo, aprobar o rechazar el documento por ilegible. Registre qué acción tomó. «Ilegible» es un dato útil: si el 10 % de los documentos de un proveedor son ilegibles, pídale a ese proveedor archivos PDF, no un milagro a su modelo.

## ¿Por qué muestrear documentos que pasaron todas las reglas?

Porque las reglas solo detectan los errores que usted previó. Si un modelo lee mal una partida, el subtotal y el total en la misma cantidad (un 7 borroso leído como 1 en los tres sitios), todas las sumas siguen cuadrando y ninguna regla salta. La única forma de encontrar esos errores es mirar documentos que nadie marcó.

Muestree al azar, no a elección, y lleve la cuenta de cuántos necesitaron una corrección. Una muestra pequeña da un rango amplio. Con el intervalo de Wilson al 95 %, que el manual del NIST describe para proporciones (citando recomendaciones de Agresti y Coull, y de Brown, Cai y DasGupta), nuestro código de métricas de más abajo da:

| Documentos auditados sin ningún error encontrado | La tasa de error real todavía podría llegar a |
| --- | --- |
| 50 | un 7.1 % aproximadamente |
| 300 | un 1.3 % aproximadamente |

Así que «auditamos 50 y no encontramos nada» no significa que la tasa de error esté por debajo del 1 %. Aumente la muestra tras cualquier cambio en el prompt, el modelo o el tipo de documentos, y redúzcala despacio.

## ¿Cómo mantener un registro de auditoría?

Registre las correcciones en su propio sistema. Cada documento necesita una fila con:

-   un hash SHA-256 del archivo original (y dónde se guarda el archivo, según sus reglas de retención);
-   el ID del modelo, la versión del prompt y el JSON en bruto que devolvió el modelo;
-   el ID de solicitud del proveedor (BroadNet lo devuelve en la cabecera `X-Request-ID`) para consultas de soporte;
-   los resultados de las reglas y la cola;
-   el revisor, la hora, la acción y el valor anterior y posterior de cada campo corregido.

Esto importa más con una API sin retención de datos. La declaración de privacidad de BroadNet dice que su gateway no conserva prompts, imágenes, respuestas ni transcripciones, y que solo guarda registros de cuenta, facturación, tráfico y seguridad sin contenido. Eso es bueno para facturas sensibles, pero significa que nadie en el proveedor podrá mostrarle lo que el modelo vio o dijo el mes pasado. Su registro es el único que existe. Manténgalo libre de lo que no necesite; [registro del uso de la API de LLM](https://broadrouter.com/es/blog/llm-api-usage-logging/) explica qué registrar y qué ocultar.

## ¿Cómo medir la tasa de revisión?

Ejecute esto cada semana sobre el registro de enrutamiento, con las correcciones unidas:

```python
import math
from collections import Counter

def wilson(errors: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """95% Wilson score interval for an error rate seen in a sample."""
    if n == 0:
        return (0.0, 1.0)
    p = errors / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return (max(0.0, centre - half), min(1.0, centre + half))

def report(log: list[dict]) -> dict:
    queues = Counter(r["queue"] for r in log)
    reasons = Counter(x.split(":")[0] for r in log if r["queue"] == "review" for x in r["reasons"])
    audited = [r for r in log if r["queue"] == "audit_sample"]
    wrong = sum(1 for r in audited if r.get("corrected_fields"))
    lo, hi = wilson(wrong, len(audited))
    return {"documents": len(log),
            "review_rate": round(queues["review"] / len(log), 3),
            "top_reasons": reasons.most_common(3),
            "audited": len(audited), "audited_with_errors": wrong,
            "auto_error_rate_95ci": (round(lo, 4), round(hi, 4))}
```

En una semana sintética de 1,000 documentos (760 automáticos, 190 en revisión, 50 auditados de los cuales 2 necesitaron corrección), informó una tasa de revisión de 0.19, `vendor` como principal motivo con 120 y una tasa de error auditada entre el 1.1 % y el 13.5 %. Ese último rango es la respuesta honesta a «¿qué tan precisa es la automatización?» con este tamaño de muestra.

Lea los tres números juntos:

-   **La tasa de revisión baja y los errores auditados se mantienen:** una regla era demasiado estricta o el modelo mejoró. Bien.
-   **La tasa de revisión baja y los errores auditados suben:** una regla es demasiado laxa. Ajústela antes de que los errores lleguen a su contabilidad.
-   **Un motivo domina:** corrija la causa. Si encabeza `vendor:unknown`, actualice el maestro de proveedores; si encabeza `arithmetic`, revise la calidad de las imágenes o pruebe otro modelo con los mismos documentos usando el método de [evaluar un LLM antes de cambiar](https://broadrouter.com/es/blog/evaluate-llm-before-switching/).

## Dónde encaja BroadNet Inference

BroadRouter es el sitio web de BroadNet. BroadNet Inference ofrece tres modelos de chat que aceptan imágenes, según su [feed de precios](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-document-review-queues&utm_content=body): [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) ($0.175 de entrada / $2.17 de salida por 1M de tokens, con salida estructurada documentada), [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/) ($0.10 / $0.22, utilizable con el crédito inicial de $5) y [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) ($0.175 / $0.52). En pago por uso, las imágenes cuentan como tokens de entrada; la [calculadora de tokens de imagen](https://broadrouter.com/tools/image-token-calculator/) ayuda a estimarlos. El contenido de inferencia no se retiene; los metadatos necesarios de cuenta, facturación y seguridad se conservan como se describe en la [declaración de privacidad](https://www.broadnet.ai/inference-privacy) de BroadNet. BroadNet no ofrece una cola de revisión ni un registro de auditoría, así que el enrutamiento y los registros descritos aquí los construye y conserva usted.

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.

[Logprobs (log-probabilidades de tokens)](https://broadrouter.com/es/glossary/logprobs/)

Los logprobs son las probabilidades logarítmicas que un modelo de lenguaje asignó a los tokens que generó. Una API que los devuelve muestra, para cada token de salida, qué tan probable lo consideró el modelo y, de forma opcional, los tokens alternativos más probables en esa posición.

[Reconocimiento de entidades nombradas (NER)](https://broadrouter.com/es/glossary/named-entity-recognition/)

El reconocimiento de entidades nombradas (NER) es la tarea de encontrar nombres en un texto y etiquetar cada uno con un tipo, como persona, organización o lugar. Los sistemas clásicos etiquetan cada token; a los LLMs, en cambio, se les suele pedir una lista de entidades en JSON, que luego se contrasta con el texto original.

[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.

[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.

[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.

[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.

[Retención cero de datos (zero data retention, ZDR)](https://broadrouter.com/es/glossary/zero-data-retention/)

La retención cero de datos (ZDR) es una política de manejo de datos en la que un proveedor de IA procesa los prompts y las salidas solo para atender una solicitud y después no guarda ese contenido en logs, cachés ni datos de entrenamiento. Los registros sin contenido, como conteos de tokens y tiempos, normalmente se conservan.

## Preguntas frecuentes

### ¿Qué debe pasar a revisión humana en la extracción de facturas?

Todo lo que incumpla una regla: un campo obligatorio ausente, partidas o impuestos que no suman el total, una fecha imposible de interpretar o fuera de rango, un proveedor desconocido, una moneda inesperada o una confianza del modelo inferior a «high». Añada una pequeña muestra aleatoria de documentos que pasaron todas las reglas.

### ¿Puedo usar la puntuación de confianza del modelo para saltarme la revisión?

No por sí sola. La investigación sobre la confianza declarada (Xiong et al., ICLR 2024) encontró que los LLM tienden a ser demasiado confiados. Úsela como una señal junto a las comprobaciones en código y verifique con sus datos etiquetados si «high» de verdad significa menos errores.

### ¿Cuántos documentos aprobados automáticamente debo auditar?

Los suficientes para acotar la tasa de error que le importa. Sin errores encontrados, 50 documentos auditados acotan la tasa real en un 7 % aproximadamente (límite superior de Wilson al 95 %) y 300 la acotan en un 1.3 % aproximadamente. Aumente la muestra cuando cambie una regla, un prompt o el modelo.

### ¿Cuál es una buena tasa de revisión?

No hay una cifra universal. Empiece alta y redúzcala solo mientras la tasa de error auditada de los documentos aprobados automáticamente se mantenga dentro de su tolerancia. Si la tasa de revisión baja y la tasa de error auditada sube, alguna regla es demasiado laxa.

### ¿Dónde debe guardarse el registro de auditoría?

En su propia base de datos. Guarde un hash del archivo original, el ID del modelo, la versión del prompt, la salida en bruto, los resultados de las reglas, el revisor y los valores corregidos. Si su proveedor no retiene el contenido de las solicitudes, como afirma BroadNet de su API de inferencia, nadie más podrá reconstruirlo después.

## Siga leyendo

-   [Extraer datos de facturas, recibos y formularios a JSON con visión](https://broadrouter.com/es/blog/extract-data-from-documents-with-vision-llm/)
-   [OCR árabe frente a LLM de visión: leer documentos y facturas en árabe](https://broadrouter.com/es/blog/arabic-ocr-vision-llm/)
-   [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/)
-   [Registro de uso de API de LLM: costo por usuario y función, sin PII](https://broadrouter.com/es/blog/llm-api-usage-logging/)
-   [Cómo corregir JSON inválido de un LLM: causas, reparación y reintento](https://broadrouter.com/es/blog/fix-invalid-json-from-llm/)
-   [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: 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-document-review-queues&utm_content=page-cta) ·

**Fuentes**

-   [Xiong et al., Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs, ICLR 2024 (consultado el 2026-11-15)](https://arxiv.org/abs/2306.13063)
-   [NIST/SEMATECH e-Handbook of Statistical Methods, 7.2.4: intervalos de confianza para una proporción, método de Wilson (consultado el 2026-11-15)](https://www.itl.nist.gov/div898/handbook/prc/section2/prc241.htm)
-   [ZATCA, facturación electrónica (Fatoorah): fase 1 desde el 4 de diciembre de 2021, fase 2 desde el 1 de enero de 2023 (consultado el 2026-11-15)](https://zatca.gov.sa/en/E-Invoicing/Pages/default.aspx)
-   [Referencia de la API de BroadNet Inference: chat con imagen, salida estructurada, X-Request-ID, tratamiento de datos (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-document-review-queues&utm_content=sources)
-   [pricing.json de BroadNet Inference: modalidades y precios de los modelos (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-document-review-queues&utm_content=sources)
-   [Declaración de privacidad y retención de datos de BroadNet Inference (consultado el 2026-11-15)](https://www.broadnet.ai/es/inference-privacy)
