Rotation PDF automatique – API pour aligner les pages PDF et images

Les documents numérisés ou photographiés arrivent fréquemment à l'envers ou tournés latéralement. La rotation manuelle ne passe pas à l'échelle quand vous devez traiter des centaines de documents. Une API de rotation PDF automatique qui détecte l'orientation à partir du contenu réel – et pas seulement des données EXIF – et la corrige, éliminerait une étape laborieuse de votre pipeline de traitement.

Ceux qui traitent des dossiers, scans ou photos en grande quantité le savent : une mauvaise orientation fait perdre du temps.

Pourquoi développer sa propre solution d'orientation automatique de pages PDF et images prend des semaines

Ceux qui veulent construire cela eux-mêmes réalisent rapidement que la détection d'orientation signifie généralement : exécuter l'OCR, analyser la direction du texte, déduire la rotation. Tesseract, EasyOCR ou les services OCR cloud peuvent aider – mais il faut les intégrer, prendre en compte différentes langues et mapper les résultats sur des rotations de 0°/90°/180°/270°. Les PDF nécessitent un traitement page par page. Construire une API fiable de détection d'orientation de documents demande du temps d'intégration et de calibrage.

Comment l'API MaraDocs de rotation PDF automatique résout cela en quelques minutes

L'API MaraDocs propose pdf.orientation et img.orientation. Les deux utilisent une analyse basée sur le texte pour déterminer l'orientation correcte – plus fiable que l'EXIF, qui est souvent incorrect ou absent. Pour les PDF, chaque page est analysée ; pour les images, l'image entière. L'API renvoie le résultat pivoté ainsi que les angles page par page avec des valeurs de confiance. Pas de pipeline OCR à maintenir, pas d'hébergement de modèle, pas de configuration linguistique. Un appel API et vous obtenez un identifiant corrigé pour l'étape suivante.

Workflow d'orientation de documents : Valider, Aligner, Enchaîner

Téléchargez le PDF ou l'image, validez le format et recherchez les virus, puis appelez orientation. L'API analyse chaque page (ou l'image entière pour les entrées mono-page) et renvoie un identifiant pivoté. Cet identifiant peut être directement transmis à l'OCR, la composition ou l'optimisation – l'orientation s'intègre comme une étape dans n'importe quel pipeline. Le fichier n'a pas besoin d'être retéléchargé entre les étapes ; le résultat pivoté reste dans l'espace de travail.

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

La plupart des API de documents vous obligent à télécharger, traiter, télécharger et retélécharger pour l'étape suivante. Avec MaraDocs, les fichiers restent dans l'espace de travail. Après la détection d'orientation, l'identifiant pivoté est directement transmis à l'OCR, la composition ou l'optimisation – pas de nouveau téléchargement. Les identifiants circulent ; les données restent côté serveur.

Lorsque la détection d'orientation est incertaine – scans à faible contraste, notes manuscrites ou langues mixtes – app.maradocs.io peut être ouvert pour vérification et correction 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 espaces de travail expirent après 7 jours. Aucune donnée ne quitte l'UE. Pour le traitement de documents sensibles en matière de protection des données, c'est pertinent.

Code TypeScript pour la rotation PDF automatique

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

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

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

// Télécharger et valider
const uploaded = await client.data.upload(pdfOrImageFile);
const pdfVal = await client.pdf.validate({ unvalidated_file_handle: uploaded.unvalidated_file_handle });
const pdfHandle = okPdf(pdfVal);

// Orientation PDF
const oriented = await client.pdf.orientation({ pdf_handle: pdfHandle });

// Télécharger le résultat
const blob = await client.data.downloadPdf({ pdf_handle: oriented.rotated_pdf_handle });

// Pour les images : utilisez client.img.validate + client.img.orientation

Code Python pour la détection d'orientation de documents

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

# pip install python-decouple requests
"""Fix PDF page orientation 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, "application/pdf")},
    )
    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:
    pdf_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path("input.pdf")
    auth = create_workspace()
    handle = upload_file(pdf_path, auth)
    validate = run_job("pdf/validate", {"unvalidated_file_handle": handle}, auth)
    pdf_handle = validate["response"]["pdf_handle"]
    oriented = run_job("pdf/orientation", {"pdf_handle": pdf_handle}, auth)
    rotated_handle = oriented["response"]["rotated_pdf_handle"]
    Path("rotated.pdf").write_bytes(download_pdf(rotated_handle, auth))
    print("rotated.pdf created")


if __name__ == "__main__":
    main()

Résumé et prochaines étapes

Une API de rotation PDF automatique et de détection d'orientation de documents est disponible. MaraDocs traite les images et PDF avec une analyse basée sur le texte. Autres workflows connexes : Scanner de documents, Traitement PDF et Reconnaissance de texte.

---

Essayez maintenant : API MaraDocs | SDK TypeScript

---