API OCR – Creare PDF ricercabili da immagini e scansioni

I documenti scansionati e le fotografie contengono testo che non è né selezionabile né ricercabile. Molte API OCR restituiscono solo testo estratto, non il documento originale con un livello di testo invisibile. Si desidera lo stesso PDF – stesso layout e stessa visualizzazione – ma con contenuto selezionabile e ricercabile. Questo è ciò che un'API OCR appropriata per PDF ricercabili dovrebbe fare.

Perché una soluzione OCR PDF ricercabile personalizzata richiede settimane

Chi desidera costruirla autonomamente scopre rapidamente che Tesseract, EasyOCR o Cloud-OCR restituiscono solo testo in chiaro e bounding box. Per creare un PDF ricercabile, il testo deve essere sovrapposto in modo invisibile all'immagine originale o al PDF originale. Questo richiede il coordinamento di sistemi di coordinate, font, codifiche e struttura PDF. Diverse lingue, font e layout aumentano la complessità. Un'API OCR robusta che lasci intatto il proprio documento richiede un considerevole sforzo di sviluppo.

Come l'API OCR di MaraDocs lo risolve in minuti

L'API MaraDocs esegue l'OCR e restituisce un PDF con livello di testo sovrapposto in modo invisibile. Si ottiene il documento originale – layout, immagini, visualizzazione – con testo selezionabile e ricercabile. Nessun file di testo separato. Nessuna versione ridotta. Lo stesso documento, migliorato.

Workflow OCR: Validare, OCR, Ottimizzare

Per le immagini: validare, poi img.ocrToPdf. Per i PDF: validare, poi pdf.ocrToPdf (opzionalmente dopo pdf.orientation per correggere preventivamente le pagine ruotate). Le operazioni di alto livello flow.ocrImg e flow.ocrPdf combinano orientamento, OCR e ottimizzazione in una singola chiamata. L'output è sempre un handle PDF – lo stesso documento con un livello di testo invisibile – che può essere scaricato o passato a workflow di composizione, compressione o email. La pipeline rimane lato server; nessun nuovo caricamento tra i passaggi.

Cosa distingue MaraDocs: Workspace, Webview e normativa tedesca sulla privacy

La maggior parte delle API per documenti obbliga a caricare, elaborare, scaricare e ricaricare per il passaggio successivo. Con MaraDocs l'OCR viene eseguito nel proprio workspace. Si può concatenare con estrazione documenti, composizione o compressione – passando l'handle PDF direttamente all'operazione successiva. Nessun nuovo caricamento, meno roundtrip.

Quando i risultati OCR necessitano di correzione manuale – caratteri riconosciuti erroneamente, layout complessi o scansioni di bassa qualità – si può aprire app.maradocs.io per verifica e modifica manuale. Gli utenti ottengono il pieno controllo manuale quando l'automazione raggiunge i suoi limiti.

Tutta l'elaborazione avviene in Germania (Maramia GmbH), crittografata a riposo e in transito. I workspace scadono dopo 7 giorni. Nessun dato lascia l'UE. Per carichi di lavoro OCR sensibili alla privacy questo è rilevante.

Codice TypeScript per creare PDF ricercabili con OCR

Riferimento 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 livello: caricare, validare, pipeline completa, scaricare
const pdfHandle = await client.flow.ocrImg(imageFile);
const blob = await client.data.downloadPdf({ pdf_handle: pdfHandle });

// Basso livello: Immagine – caricare, validare, OCR, scaricare
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: caricare, validare, ocrToPdf, scaricare
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 });

Codice Python per OCR a PDF ricercabile

Riferimento API: data/upload, img/validate, img/ocr/to/pdf, pdf/ocr/pdf, data/download/pdf

# pip install python-decouple requests
"""OCR an image to a searchable PDF using MaraDocs. Set ACCOUNT_SECRET in .env or environment."""

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:
    """Create a workspace and return auth headers."""
    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:
    """Upload a file via two-step flow (signed URL + S3 POST). Returns 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:
    """Run a job and poll until complete. Returns the result (unwraps response if present)."""
    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} timed out")


def download_pdf(pdf_handle: str, auth: dict) -> bytes:
    """Request signed URL and fetch PDF bytes."""
    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 created")


if __name__ == "__main__":
    main()

Riepilogo e prossimi passi

È disponibile un'API OCR che crea PDF ricercabili – il documento originale con livello di testo invisibile. MaraDocs preserva il layout originale e aggiunge testo selezionabile e ricercabile. Altri workflow correlati: Scanner documenti, Elaborazione PDF e Immagine su pagina vuota.

---

Prova ora: API MaraDocs | SDK TypeScript

---