Ir al contenido principal
Español— Elegir un idioma
Menú

OCR y transcripción de texto en imágenes

Lección 8 de 12 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Lectura de texto en imágenes
  2. OCR simple: lectura de texto visible
  3. Extracción de texto de una factura
  4. Transcripción de capturas de pantalla
  5. Lectura de tickets de caja y recibos
  6. Procesamiento de documentos por lotes
  7. Mejora de la precisión del OCR
  8. API de Visión frente a Document AI
  9. Puntos clave

Lectura de texto en imágenes

El reconocimiento óptico de caracteres (OCR) es uno de los casos de uso más habituales de la API de Visión. Con los modelos multimodales de Mistral, puedes extraer texto de fotografías, capturas de pantalla, documentos escaneados, facturas o tickets sin necesidad de instalar una biblioteca de OCR dedicada: ni Tesseract, ni modelos de lenguaje específicos, ni tuberías de preprocesamiento.

La ventaja no se limita a reducir dependencias. El OCR clásico devuelve caracteres; un modelo multimodal entiende lo que lee y puede, en la misma llamada, distinguir un número de factura de un número de orden de compra. Esta lección aborda casos de uso comunes y técnicas que mejoran concretamente la precisión.

OCR simple: lectura de texto visible

El enfoque más directo se reduce a un único prompt, siempre que sea inequívoco:

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Transcribe exactamente todo el texto visible en esta imagen. No comentes, no resumas; devuelve solo el texto tal como aparece."},
                {"type": "image_url", "image_url": "https://exemple.com/document-scanne.jpg"}
            ]
        }
    ]
)

print(response.choices[0].message.content)

La palabra clave es «exactamente». Sin esta instrucción, el modelo tiende a parafrasear o resumir el contenido porque es lo que hace espontáneamente un asistente útil: aquí estás pidiendo lo contrario a un servicio, una restitución literal.

Extracción de texto de una factura

Las facturas contienen información estructurada —emisor, destinatario, importes, fechas— que el modelo puede identificar por su función, no solo por su posición. Esta es precisamente la ventaja frente al OCR de zonas fijas, que falla en cuanto el proveedor cambia el diseño:

prompt_facture = """Analiza esta factura y extrae la siguiente información:
- Emisor (nombre, dirección, SIRET si es visible)
- Destinatario (nombre, dirección)
- Número de factura
- Fecha de emisión
- Fecha de vencimiento
- Líneas de facturación (descripción, cantidad, precio unitario, total)
- Subtotal sin impuestos
- IVA (tipo e importe)
- Total con impuestos

Devuelve el resultado como JSON estructurado."""

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Eres un contable certificado. Extrae datos de facturación con precisión. Devuelve solo JSON válido."
        },
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_facture},
                {"type": "image_url", "image_url": data_uri_facture}
            ]
        }
    ]
)

Transcripción de capturas de pantalla

Otra necesidad frecuente es recuperar contenido de una interfaz o terminal compartido como captura de pantalla, habitualmente en un ticket de soporte. Aquí, el formato es parte de la información: un rastro de terminal sin sangría correcta queda inutilizable.

import base64

def encoder_image(chemin):
    with open(chemin, "rb") as f:
        b64 = base64.standard_b64encode(f.read()).decode("utf-8")
    return f"data:image/png;base64,{b64}"

# Transcribe una captura de pantalla de terminal
response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Transcribe la salida de terminal visible en esta captura de pantalla. Conserva el formato y la sangría."
                },
                {"type": "image_url", "image_url": encoder_image("captures/terminal.png")}
            ]
        }
    ]
)

Lectura de tickets de caja y recibos

Los tickets térmicos son el caso más difícil: impresión tenue, papel arrugado, tinta desvanecida. La técnica decisiva es permitir explícitamente que el modelo declare su incapacidad para leer un elemento; de lo contrario, rellenará los huecos con valores plausibles.

prompt_recu = """Lee este ticket de caja y extrae:
1. Nombre de la tienda
2. Fecha y hora
3. Lista de artículos (nombre, precio)
4. Subtotal
5. Método de pago
6. Importe total

Si un artículo es ilegible, indica [illegible].
Devuelve el resultado como JSON."""

response = client.chat.complete(
    model="mistral-large-latest",  # Large para la mejor lectura
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": prompt_recu},
                {"type": "image_url", "image_url": encoder_image("recu-supermarche.jpg")}
            ]
        }
    ]
)

Un [illegible] en el resultado es infinitamente mejor que un importe inventado: el primero activa una verificación humana, el segundo pasa desapercibido hasta la conciliación contable. Para estos documentos degradados, usa Mistral Large 3; la diferencia de precisión con Small es significativa en texto borroso o parcialmente legible.

Procesamiento de documentos por lotes

Escalar sigue el patrón que ya hemos visto: una función unitaria parametrizada por el modelo y luego un bucle sobre la carpeta.

import json
from pathlib import Path

def ocr_document(chemin_image, modele="mistral-small-latest"):
    """Realiza OCR en un documento y devuelve el texto."""
    response = client.chat.complete(
        model=modele,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": "Transcribe todo el texto de este documento. Conserva el formato (encabezados, párrafos, listas)."
                    },
                    {"type": "image_url", "image_url": encoder_image(chemin_image)}
                ]
            }
        ]
    )
    return response.choices[0].message.content

# Procesa una carpeta
dossier = Path("documents_scannes/")
resultats = {}

for fichier in sorted(dossier.glob("*.jpg")):
    print(f"OCR de {fichier.name}...")
    resultats[fichier.name] = ocr_document(fichier)

# Guarda los resultados
with open("transcriptions.json", "w", encoding="utf-8") as f:
    json.dump(resultats, f, ensure_ascii=False, indent=2)

print(f"{len(resultats)} documentos transcritos.")

El parámetro modele en la firma no es cosmético: te permite volver a ejecutar solo los documentos dudosos con Large sin reescribir la función.

Mejora de la precisión del OCR

Dos palancas actúan antes del modelo. La primera es el preprocesamiento de la imagen: un escaneo gris y de bajo contraste se vuelve legible tras convertirlo a escala de grises, mejorar el contraste y aplicar enfoque.

from PIL import Image, ImageEnhance, ImageFilter

def pretraiter_pour_ocr(chemin):
    """Mejora una imagen para OCR: contraste, enfoque, escala de grises."""
    img = Image.open(chemin)

    # Convierte a escala de grises
    img = img.convert("L")

    # Aumenta el contraste
    enhancer = ImageEnhance.Contrast(img)
    img = enhancer.enhance(2.0)

    # Aumenta el enfoque
    img = img.filter(ImageFilter.SHARPEN)

    return img

El factor 2,0 funciona para un escaneo desvanecido; si se lleva demasiado lejos, crea artefactos que degradan la lectura. Prueba con tres documentos representativos antes de fijar el valor.

La segunda palanca es la especialización del prompt según el tipo de documento. Un formulario pide «Lee cada campo y su valor correspondiente», una carta «Transcribe el cuerpo de la carta conservando los párrafos», una tabla «Extrae los datos de la tabla en formato markdown». Tres formulaciones, tres estructuras de salida: clasifica tus documentos antes de transcribirlos y la calidad da un salto.

API de Visión frente a Document AI

Para OCR avanzado y análisis de documentos, Mistral ofrece también Document AI (OCR 4), un servicio especializado. La siguiente tabla delimita la frontera entre ambos.

CriterioAPI de VisiónDocument AI (OCR 4)
OCR simpleSuficienteSobredimensionado
Documentos complejosLimitadoOptimizado
Tablas anidadasAproximadoPreciso
PDF multipáginaNo soportadoSoportado
Diseño complejoBásicoAvanzado

La línea decisiva son los PDF multipágina: la API de Visión procesa imágenes, no documentos paginados. En cuanto tu origen es un PDF de varias decenas de páginas, la cuestión ni se plantea. Cubriremos Document AI en la Lección 12 (Próximos pasos).

Puntos clave

  • La API de Visión realiza un OCR adecuado para casos simples (facturas, capturas de pantalla, tickets)
  • Usa la palabra «exactamente» en tu prompt para evitar paráfrasis
  • Mistral Large 3 es significativamente mejor que Small para documentos de baja calidad
  • El preprocesamiento de imágenes (contraste, escala de grises) mejora los resultados
  • Para OCR avanzado y PDF multipágina, considera Document AI (OCR 4) de Mistral