API de traitement PDF – Fusionner, séparer et faire pivoter automatiquement les PDF

Vous devez fusionner plusieurs PDF, sélectionner certaines pages ou corriger des scans mal orientés ? Dans notre cabinet, les dossiers arrivaient souvent sous forme de PDF séparés – expertises, courriers de clients, documents judiciaires – qui devaient être fusionnés et réorganisés. Une API pour fusionner et séparer des PDF, qui corrige également l'orientation, simplifierait considérablement ce flux de travail.

Cela semble simple – jusqu'à ce que vous essayiez d'intégrer PyMuPDF, pikepdf ou des bibliothèques similaires dans une pipeline robuste avec antivirus et validation.

Pourquoi développer sa propre solution de fusion et séparation PDF prend des semaines

PyMuPDF, pikepdf, PyPDF2 et reportlab couvrent chacun une partie de la manipulation PDF. La fusion fonctionne – jusqu'à ce que vous tombiez sur des fichiers chiffrés, des flux corrompus ou des encodages inhabituels. Ceux qui veulent construire cela eux-mêmes constatent rapidement que la détection d'orientation nécessite généralement de l'OCR ou une analyse de mise en page – des dépendances supplémentaires, plus d'infrastructure. Générer des aperçus signifie convertir des pages en images, les redimensionner et les encoder. Construire une API de manipulation PDF fiable et validée prend du temps et cache une complexité dans les cas particuliers.

Comment l'API MaraDocs de fusion et séparation PDF résout cela en quelques minutes

L'API MaraDocs offre le traitement PDF en tant que service. Téléchargez, validez (virus et format), puis composez (fusionnez/séparez par page), détectez et corrigez l'orientation, générez des aperçus, optimisez et appliquez l'OCR – tout via une seule API. Pas de téléchargements entre les étapes ; les fichiers restent dans l'espace de travail. Vous spécifiez quelles pages de quels PDF combiner, et l'API renvoie un seul handle composé. La correction d'orientation utilise une analyse textuelle, de sorte que les scans pivotés sont automatiquement corrigés.

Flux de traitement de documents : télécharger, valider, composer, orienter

Chaque flux de travail MaraDocs commence par le téléchargement et la validation. Téléchargez un PDF (ou récupérez-en un d'une étape précédente), validez les virus et le format, puis enchaînez les opérations. Le point de terminaison Compose permet de fusionner plusieurs PDF et de sélectionner des pages spécifiques : par exemple { pdf_handle: p1, pages: [{ page_number: 0 }, { page_number: 2 }] } pour les pages 1 et 3 du premier document, plus { pdf_handle: p2 } pour l'intégralité du deuxième document. La détection d'orientation utilise une analyse textuelle pour corriger automatiquement les pages pivotées. Pour les aperçus : convertir une page en image, puis créer une miniature, puis convertir en JPEG – tout avec des handles côté serveur, sans nouveau téléchargement.

Ce qui distingue MaraDocs : espaces de travail, vue web et droit allemand de la protection des données

La plupart des API de documents obligent à télécharger, traiter, télécharger et retélécharger pour l'étape suivante. Avec les espaces de travail MaraDocs, les fichiers restent côté serveur. Les handles sont transmis entre les opérations : valider → composer → orienter → optimiser. Moins d'allers-retours, code plus simple, pas besoin de suivre l'identité des fichiers entre les étapes.

Lorsque l'automatisation rencontre un cas particulier – mauvais ordre des pages, flux corrompu ou encodage inhabituel – app.maradocs.io peut être ouvert avec le secret de l'espace de travail pour une vérification et une édition manuelles. Les utilisateurs obtiennent un contrôle manuel complet lorsque la pipeline nécessite une intervention humaine.

Tout le traitement se fait en Allemagne (Maramia GmbH), avec chiffrement au repos (SSE-C) et en transit (TLS). Les espaces de travail expirent après 7 jours. Aucune donnée ne quitte l'UE. Pour les charges de travail sensibles au RGPD et au BDSG, c'est pertinent.

Code TypeScript pour fusionner et pivoter automatiquement des PDF

Référence API : data/upload, pdf/validate, pdf/compose, pdf/orientation, pdf/to/img, img/thumbnail, 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 les deux PDF
const up1 = await client.data.upload(pdf1File);
const up2 = await client.data.upload(pdf2File);
const val1 = await client.pdf.validate({ unvalidated_file_handle: up1.unvalidated_file_handle });
const val2 = await client.pdf.validate({ unvalidated_file_handle: up2.unvalidated_file_handle });
const pdf1 = okPdf(val1);
const pdf2 = okPdf(val2);

// Fusionner les PDF, sélectionner des pages spécifiques
const composed = await client.pdf.compose({
  pdfs: [
    { pdf_handle: pdf1, pages: [{ page_number: 0 }, { page_number: 2 }] },
    { pdf_handle: pdf2 },
  ],
});

// Détecter et corriger automatiquement l'orientation
const oriented = await client.pdf.orientation({
  pdf_handle: composed.pdf_handle,
});

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

// Optionnel : aperçu (convertir la page en image, puis créer une miniature)
const imgResult = await client.pdf.toImg({
  pdf_handle: oriented.rotated_pdf_handle,
  pages: [0],
});
const thumb = await client.img.thumbnail({
  img_handle: imgResult.img_handles[0],
});

Code Python pour fusionner et orienter des PDF

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

# pip install python-decouple requests
"""Fusionner des PDF (avec sélection de pages optionnelle) en utilisant MaraDocs. Définir 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 espace de travail 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 le flux en deux étapes (URL signée + POST S3). 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, "application/pdf")},
    )
    return resp["unvalidated_file_handle"]


def run_job(path: str, payload: dict, auth: dict, timeout: int = 60) -> dict:
    """Exécuter un job et interroger jusqu'à la fin. Retourne le résultat (déballe 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} a expiré")


def download_pdf(pdf_handle: str, auth: dict) -> bytes:
    """Demander l'URL signée et récupérer les octets du 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:
    paths = (
        [Path(p) for p in sys.argv[1:]]
        if len(sys.argv) > 1
        else [Path("doc1.pdf"), Path("doc2.pdf")]
    )
    auth = create_workspace()
    handles = [upload_file(p, auth) for p in paths]
    pdf_handles = [
        run_job("pdf/validate", {"unvalidated_file_handle": h}, auth)["response"][
            "pdf_handle"
        ]
        for h in handles
    ]
    if len(pdf_handles) == 2:
        compose_payload = {
            "pdfs": [
                {"pdf_handle": pdf_handles[0]},
                {
                    "pdf_handle": pdf_handles[1],
                    "pages": [{"page_number": 0}, {"page_number": 2}],
                },
            ]
        }
    else:
        compose_payload = {"pdfs": [{"pdf_handle": h} for h in pdf_handles]}
    composed = run_job("pdf/compose", compose_payload, auth)
    pdf_handle = composed.get("pdf_handle") or composed.get("response", {}).get(
        "pdf_handle"
    )
    oriented = run_job("pdf/orientation", {"pdf_handle": pdf_handle}, auth)
    rotated_handle = oriented["rotated_pdf_handle"]
    Path("merged.pdf").write_bytes(download_pdf(rotated_handle, auth))
    print("merged.pdf créé")


if __name__ == "__main__":
    main()

Résumé et prochaines étapes

Une API pour fusionner et séparer des PDF avec correction d'orientation et aperçus est prête à l'emploi. MaraDocs prend en charge la validation, la composition, l'orientation et l'optimisation dans un seul flux de travail. Plus d'informations : Scanner de documents, Rotation automatique, Compression PDF et Image sur page vierge.

---

Essayez maintenant : API MaraDocs | SDK TypeScript

---