API OCR – Créer des PDF consultables à partir d'images et de scans

Les documents scannés et les photos contiennent du texte qui n'est ni sélectionnable ni consultable. De nombreuses API OCR ne renvoient que du texte extrait, pas le document original avec une couche de texte invisible. On souhaite le même PDF – même mise en page et même apparence – mais avec un contenu sélectionnable et consultable. C'est ce qu'une API OCR performante pour PDF consultables devrait offrir.

Pourquoi développer sa propre solution OCR pour PDF consultables prend des semaines

Ceux qui souhaitent créer cela eux-mêmes constatent rapidement que Tesseract, EasyOCR ou Cloud-OCR ne renvoient que du texte brut et des cadres de délimitation. Pour créer un PDF consultable, le texte doit être superposé de manière invisible sur l'image ou le PDF d'origine. Cela nécessite la coordination des systèmes de coordonnées, des polices, des encodages et de la structure PDF. Différentes langues, polices et mises en page augmentent la complexité. Une API OCR robuste qui préserve le document original nécessite un effort de développement considérable.

Comment l'API OCR de MaraDocs résout cela en quelques minutes

L'API MaraDocs effectue l'OCR et produit un PDF avec une couche de texte superposée de manière invisible. Vous obtenez le document original – mise en page, images, apparence – avec du texte sélectionnable et consultable. Pas de fichier texte séparé. Pas de version allégée. Le même document, amélioré.

Workflow OCR : Valider, OCR, Optimiser

Pour les images : valider, puis img.ocrToPdf. Pour les PDF : valider, puis pdf.ocrToPdf (éventuellement après pdf.orientation pour corriger préalablement les pages pivotées). Les fonctions de haut niveau flow.ocrImg et flow.ocrPdf combinent orientation, OCR et optimisation en un seul appel. Le résultat est toujours un handle PDF – le même document avec une couche de texte invisible – qui peut être téléchargé ou transmis à des workflows de composition, compression ou email. Le pipeline reste côté serveur ; pas de nouveau téléchargement entre les étapes.

Ce qui distingue MaraDocs : Workspaces, Webview et droit allemand de la protection des données

La plupart des API de documents obligent à télécharger, traiter, télécharger et re-télécharger pour l'étape suivante. Avec MaraDocs, l'OCR s'exécute dans votre propre workspace. Enchaînez avec l'extraction de documents, la composition ou la compression – transmettez directement le handle PDF à l'opération suivante. Pas de nouveau téléchargement, moins d'allers-retours.

Lorsque les résultats OCR nécessitent une correction manuelle – caractères mal reconnus, mises en page complexes ou scans de mauvaise qualité – app.maradocs.io peut être ouvert pour vérification et édition manuelles. Les utilisateurs obtiennent un contrôle manuel complet lorsque l'automatisation atteint ses limites.

Tout le traitement s'effectue en Allemagne (Maramia GmbH), chiffré au repos et pendant le transfert. Les workspaces expirent après 7 jours. Aucune donnée ne quitte l'UE. Pour les charges de travail OCR sensibles en matière de protection des données, c'est pertinent.

Code TypeScript pour créer des PDF consultables avec OCR

Référence 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 });

// Haut niveau : télécharger, valider, pipeline complet, télécharger
const pdfHandle = await client.flow.ocrImg(imageFile);
const blob = await client.data.downloadPdf({ pdf_handle: pdfHandle });

// Bas niveau : Image – télécharger, valider, OCR, télécharger
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 : télécharger, valider, ocrToPdf, télécharger
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 });

Code Python pour OCR vers PDF consultable

Référence API : data/upload, img/validate, img/ocr/to/pdf, pdf/ocr/pdf, data/download/pdf

# pip install python-decouple requests
"""OCR d'une image vers un PDF consultable avec MaraDocs. Définissez ACCOUNT_SECRET dans .env ou l'environnement."""

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:
    """Créer un workspace et retourner les en-têtes d'authentification."""
    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:
    """Télécharger un fichier via un flux en deux étapes (URL signée + S3 POST). Retourne 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:
    """Exécuter une tâche et interroger jusqu'à la fin. Retourne le résultat (décompresse la réponse si présente)."""
    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:
    """Demander l'URL signée et récupérer les octets 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 created")


if __name__ == "__main__":
    main()

Résumé et prochaines étapes

Une API OCR qui crée des PDF consultables – le document original avec une couche de texte invisible – est disponible. MaraDocs préserve la mise en page d'origine et ajoute du texte sélectionnable et consultable. Autres workflows associés : Scanner de documents, Traitement PDF et Image sur page vierge.

---

Essayez maintenant : API MaraDocs | SDK TypeScript

---