API OCR – Crear PDFs buscables a partir de imágenes y escaneos

Los documentos escaneados y las fotografías contienen texto que no es seleccionable ni buscable. Muchas APIs OCR solo devuelven texto extraído, no el documento original con una capa de texto invisible. Se desea el mismo PDF – mismo diseño y misma presentación – pero con contenido seleccionable y buscable. Eso es lo que debe lograr una API OCR adecuada para PDFs buscables.

Por qué desarrollar una solución OCR propia para PDFs buscables lleva semanas

Quien quiera construirlo por sí mismo descubre rápidamente que Tesseract, EasyOCR o Cloud-OCR solo devuelven texto plano y cuadros delimitadores. Para crear un PDF buscable, el texto debe insertarse de forma invisible sobre la imagen original o el PDF original. Esto requiere coordinar sistemas de coordenadas, fuentes, codificaciones y estructura PDF. Diferentes idiomas, fuentes y diseños aumentan la complejidad. Una API OCR robusta que mantenga intacto el documento propio requiere un esfuerzo de desarrollo considerable.

Cómo la API OCR de MaraDocs lo resuelve en minutos

La API de MaraDocs realiza OCR y genera un PDF con capa de texto insertada de forma invisible. Se obtiene el documento original – diseño, imágenes, presentación – con texto seleccionable y buscable. Sin archivo de texto separado. Sin versión reducida. El mismo documento, mejorado.

Flujo de trabajo OCR: Validar, OCR, Optimizar

Para imágenes: validar, luego img.ocrToPdf. Para PDFs: validar, luego pdf.ocrToPdf (opcionalmente después de pdf.orientation para corregir previamente páginas rotadas). Los comandos de alto nivel flow.ocrImg y flow.ocrPdf combinan orientación, OCR y optimización en una sola llamada. El resultado es siempre un identificador de PDF – el mismo documento con una capa de texto invisible –, que puede descargarse o pasarse a flujos de trabajo de composición, compresión o correo electrónico. La canalización permanece en el servidor; no es necesario volver a cargar entre pasos.

Lo que distingue a MaraDocs: Workspaces, vista web y legislación alemana de protección de datos

La mayoría de las APIs de documentos obligan a cargar, procesar, descargar y volver a cargar para el siguiente paso. En MaraDocs, OCR se ejecuta en el workspace propio. Se puede encadenar con extracción de documentos, composición o compresión – pasar el identificador de PDF directamente a la siguiente operación. Sin volver a cargar, menos viajes de ida y vuelta.

Cuando los resultados OCR necesitan corrección manual – caracteres mal reconocidos, diseños complejos o escaneos de baja calidad – se puede abrir app.maradocs.io para revisión y edición manual. Los usuarios obtienen control manual completo cuando la automatización llega a sus límites.

Todo el procesamiento se realiza en Alemania (Maramia GmbH), cifrado en reposo y durante la transmisión. Los workspaces expiran después de 7 días. Ningún dato sale de la UE. Para cargas de trabajo OCR sensibles a la protección de datos, esto es relevante.

Código TypeScript para crear PDFs buscables con OCR

Referencia de la API: data/upload, img/validate, pdf/validate, img/ocr/to/pdf, pdf/ocr/pdf, data/download/pdf

import { MaraDocsClient } from "@maramia/maradocs-sdk-ts";
import { okImg } from "@maramia/maradocs-sdk-ts/models/img";
import { okPdf } from "@maramia/maradocs-sdk-ts/models/pdf";

const client = new MaraDocsClient({ workspaceSecret: workspace_secret });

// Alto nivel: cargar, validar, pipeline completo, descargar
const pdfHandle = await client.flow.ocrImg(imageFile);
const blob = await client.data.downloadPdf({ pdf_handle: pdfHandle });

// Bajo nivel: Imagen – cargar, validar, OCR, descargar
const uploaded = await client.data.upload(imageFile);
const validated = await client.img.validate({ unvalidated_file_handle: uploaded.unvalidated_file_handle });
const imgHandle = okImg(validated);
const ocrPdf = await client.img.ocrToPdf({
  img_handle: imgHandle,
  options: { embed_in_blank_page: { size: { width: 210, height: 297 }, position: "center" } },
});
const blob2 = await client.data.downloadPdf({ pdf_handle: ocrPdf.pdf_handle });

// PDF: cargar, validar, ocrToPdf, descargar
const pdfUploaded = await client.data.upload(pdfFile);
const pdfValidated = await client.pdf.validate({ unvalidated_file_handle: pdfUploaded.unvalidated_file_handle });
const pdfOcr = await client.pdf.ocrToPdf({ pdf_handle: okPdf(pdfValidated) });
const blob3 = await client.data.downloadPdf({ pdf_handle: pdfOcr.pdf_handle });

Código Python para OCR a PDF buscable

Referencia de la API: data/upload, img/validate, img/ocr/to/pdf, pdf/ocr/pdf, data/download/pdf

# pip install python-decouple requests
"""OCR de una imagen a PDF buscable usando MaraDocs. Configure ACCOUNT_SECRET en .env o en el entorno."""

import sys
import time
from pathlib import Path

import requests
from decouple import config

API_URL = "https://api.maradocs.io/v1"


def create_workspace() -> dict:
    """Crear un workspace y devolver encabezados de autenticación."""
    r = requests.post(
        f"{API_URL}/workspace",
        headers={"Authorization": f"Bearer {config('ACCOUNT_SECRET')}"},
        json={"subaccount": None},
    )
    ws = r.json()
    return {"Authorization": f"Bearer {ws['workspace_secret']}"}


def upload_file(path: Path, auth: dict) -> dict:
    """Cargar un archivo mediante flujo de dos pasos (URL firmada + S3 POST). Devuelve unvalidated_file_handle."""
    data = path.read_bytes()
    resp = requests.post(
        f"{API_URL}/data/upload",
        headers={**auth, "Content-Type": "application/json"},
        json={"name": path.name, "size": len(data)},
    ).json()
    requests.post(
        resp["post_url"],
        data=resp.get("post_header", {}),
        files={"file": (path.name, data, "image/png")},
    )
    return resp["unvalidated_file_handle"]


def run_job(path: str, payload: dict, auth: dict, timeout: int = 60) -> dict:
    """Ejecutar un trabajo y consultar hasta completar. Devuelve el resultado (desenvuelve la respuesta si está presente)."""
    url = f"{API_URL}/{path}"
    r = requests.post(url, headers=auth, json=payload).json()
    job_id = r["job_id"]
    start = time.time()
    while time.time() - start < timeout:
        poll_r = requests.get(f"{url}/{job_id}", headers=auth)
        if poll_r.status_code == 200:
            return poll_r.json()
    raise TimeoutError(f"Job {path} agotó el tiempo de espera")


def download_pdf(pdf_handle: str, auth: dict) -> bytes:
    """Solicitar URL firmada y obtener bytes del PDF."""
    r = requests.post(
        f"{API_URL}/data/download/pdf",
        headers=auth,
        json={"pdf_handle": pdf_handle},
    )
    info = r.json()
    dl = requests.get(info["url"], headers=info.get("headers", {}))
    return dl.content


def main() -> None:
    img_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("photo.png")
    auth = create_workspace()
    handle = upload_file(img_path, auth)
    validate = run_job("img/validate", {"unvalidated_file_handle": handle}, auth)
    img_handle = validate["response"]["img_handle"]
    ocr_result = run_job("img/ocr/to/pdf", {"img_handle": img_handle}, auth)
    pdf_handle = ocr_result.get("pdf_handle") or ocr_result.get("response", {}).get("pdf_handle")
    Path("searchable.pdf").write_bytes(download_pdf(pdf_handle, auth))
    print("searchable.pdf creado")


if __name__ == "__main__":
    main()

Resumen y próximos pasos

Está disponible una API OCR que crea PDFs buscables – el documento original con capa de texto invisible. MaraDocs conserva el diseño original y añade texto seleccionable y buscable. Otros flujos de trabajo relacionados: Escáner de documentos, Procesamiento de PDF e Imagen en página en blanco.

---

Pruébelo ahora: API de MaraDocs | SDK TypeScript

---