API de compression PDF – Réduire la taille des fichiers PDF

Les PDF volumineux – dossiers d'instruction, rapports d'expertise, documents scannés – posent des problèmes avec les limites d'e-mail, ralentissent le stockage et rendent la gestion documentaire laborieuse. Dans notre cabinet, un seul rapport d'expertise pouvait atteindre 30 Mo. Une API de compression PDF qui réduit la taille des fichiers tout en préservant la lisibilité faciliterait considérablement le partage et l'archivage.

Pourquoi développer sa propre solution de compression PDF prend des semaines

Ceux qui souhaitent développer cela eux-mêmes découvrent rapidement que Ghostscript, qpdf et pikepdf peuvent réduire la taille des PDF – mais il faut choisir les niveaux de compression, prendre en compte les différentes structures PDF et éviter les pertes de qualité. Le sous-échantillonnage d'images, l'incorporation de polices et la compression de flux ont chacun leurs propres compromis. Construire une API de compression PDF fiable avec des résultats cohérents nécessite de l'expérimentation.

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

L'API MaraDocs propose pdf.optimize pour une compression intelligente. Téléchargez un PDF, validez-le, puis optimisez-le. Le résultat est généralement nettement plus petit tout en préservant la qualité – l'API gère le sous-échantillonnage d'images, la compression de flux et l'incorporation de polices en interne. Pas besoin d'installer Ghostscript, d'ajuster des paramètres ou de deviner entre qualité et taille. Un seul appel et vous obtenez un handle optimisé, prêt pour l'e-mail, l'archivage ou l'étape de traitement suivante.

Workflow de compression PDF : Télécharger, Valider, Optimiser

Téléchargez le PDF, validez-le contre les virus et le format, puis appelez pdf.optimize. L'API applique une compression intelligente – sous-échantillonnage d'images, optimisation de flux – et renvoie un handle optimisé. Il peut être téléchargé ou transmis à la composition, au traitement de pièces jointes d'e-mail ou à l'archivage. L'optimisation s'intègre naturellement comme dernière étape avant la livraison dans n'importe quel pipeline. Les fichiers restent dans l'espace de travail ; pas besoin de retélécharger entre validation et optimisation.

Ce qui distingue MaraDocs : Espaces de travail, Webview et droit allemand de 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 MaraDocs, les fichiers restent dans l'espace de travail. Enchaînez avec l'OCR, la composition ou le traitement d'e-mails – le handle PDF optimisé passe directement à l'opération suivante. Pas de retéléchargement, moins d'allers-retours.

Si la qualité de compression doit être vérifiée manuellement – ou si vous souhaitez une comparaison avant-après – app.maradocs.io peut être ouvert pour un contrôle manuel. 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 en transit. Les espaces de travail expirent après 7 jours. Aucune donnée ne quitte l'UE. Pour les workflows documentaires sensibles en matière de protection des données, c'est pertinent.

Code TypeScript pour réduire la taille des PDF

Référence API : data/upload, pdf/validate, pdf/optimize, 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, valider, optimiser, télécharger
const uploaded = await client.data.upload(pdfFile);
const validated = await client.pdf.validate({
  unvalidated_file_handle: uploaded.unvalidated_file_handle,
});
const pdfHandle = okPdf(validated);

const optimized = await client.pdf.optimize({ pdf_handle: pdfHandle });

const blob = await client.data.downloadPdf({ pdf_handle: optimized.pdf_handle });

Code Python pour la compression PDF

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

# pip install python-decouple requests
"""Compress a 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, "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"]
    optimized = run_job("pdf/optimize", {"pdf_handle": pdf_handle}, auth)
    compressed_handle = optimized.get("response", optimized).get("pdf_handle")
    Path("compressed.pdf").write_bytes(download_pdf(compressed_handle, auth))
    print("compressed.pdf created")


if __name__ == "__main__":
    main()

Résumé et prochaines étapes

Une API de compression PDF qui réduit la taille des fichiers tout en préservant la qualité est disponible. MaraDocs gère l'optimisation dans le cadre d'un workflow documentaire plus complet. Autres cas d'usage associés : Traitement PDF, Traitement d'e-mails et Image sur page vierge.

---

Essayez maintenant : API MaraDocs | SDK TypeScript

---