API kompresji PDF – redukcja rozmiaru pliku PDF

Duże pliki PDF – akta śledztwa, opinie biegłych, zeskanowane dokumenty – powodują problemy z limitami e-mail, spowalniają przechowywanie i sprawiają, że zarządzanie dokumentami staje się uciążliwe. W naszej kancelarii pojedyncza opinia biegłego mogła mieć 30 MB. API kompresji PDF, które redukuje rozmiar pliku przy zachowanej czytelności, znacznie ułatwiłoby udostępnianie i archiwizację.

Dlaczego własne rozwiązanie kompresji PDF zajmuje tygodnie

Kto chce zbudować to samodzielnie, szybko odkrywa, że Ghostscript, qpdf i pikepdf mogą zmniejszać pliki PDF – ale trzeba wybierać poziomy kompresji, uwzględniać różne struktury PDF i unikać utraty jakości. Downsampling obrazów, osadzanie czcionek i kompresja strumieni mają własne kompromisy. Zbudowanie niezawodnego API kompresji PDF z konsekwentnymi wynikami wymaga eksperymentów.

Jak API kompresji PDF MaraDocs rozwiązuje to w minuty

API MaraDocs oferuje pdf.optimize do inteligentnej kompresji. Wystarczy przesłać PDF, zwalidować, a następnie zoptymalizować. Wynik jest zazwyczaj znacznie mniejszy przy zachowanej jakości – API obsługuje wewnętrznie downsampling obrazów, kompresję strumieni i osadzanie czcionek. Nie trzeba instalować Ghostscript, dostosowywać parametrów ani zgadywać w kwestii jakości a rozmiaru. Jedno wywołanie i otrzymujesz zoptymalizowany uchwyt gotowy do wysłania e-mailem, archiwizacji lub kolejnego kroku przetwarzania.

Przepływ pracy kompresji PDF: Przesyłanie, walidacja, optymalizacja

Prześlij PDF, zwaliduj pod kątem wirusów i formatu, a następnie wywołaj pdf.optimize. API stosuje inteligentną kompresję – downsampling obrazów, optymalizację strumieni – i zwraca zoptymalizowany uchwyt. Można go pobrać lub przekazać do kompozycji, przetwarzania załączników e-mail lub archiwizacji. Optymalizacja naturalnie pasuje jako ostatni krok przed dostarczeniem w każdym pipeline. Pliki pozostają w przestrzeni roboczej; nie ma potrzeby ponownego przesyłania między walidacją a optymalizacją.

Co wyróżnia MaraDocs: Przestrzenie robocze, Webview i niemieckie prawo ochrony danych

Większość API dokumentów wymusza przesyłanie, przetwarzanie, pobieranie i ponowne przesyłanie dla kolejnego kroku. W MaraDocs pliki pozostają w przestrzeni roboczej. Można łączyć z OCR, kompozycją lub przetwarzaniem e-mail – zoptymalizowany uchwyt PDF płynie bezpośrednio do kolejnej operacji. Bez ponownego przesyłania, mniej cykli komunikacji.

Jeśli jakość kompresji musi zostać ręcznie sprawdzona – lub potrzebne jest porównanie przed-po – można otworzyć app.maradocs.io do ręcznej kontroli. Użytkownicy otrzymują pełną kontrolę manualną, gdy automatyzacja osiąga swoje granice.

Całe przetwarzanie odbywa się w Niemczech (Maramia GmbH), zaszyfrowane w spoczynku i podczas transmisji. Przestrzenie robocze wygasają po 7 dniach. Żadne dane nie opuszczają UE. Dla przepływów pracy z dokumentami wrażliwymi pod kątem ochrony danych jest to istotne.

Kod TypeScript do redukcji rozmiaru PDF

Dokumentacja 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 });

// Przesyłanie, walidacja, optymalizacja, pobieranie
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 });

Kod Python do kompresji PDF

Dokumentacja 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()

Podsumowanie i kolejne kroki

Dostępne jest API kompresji PDF, które redukuje rozmiar pliku przy zachowanej jakości. MaraDocs obsługuje optymalizację jako część szerszego przepływu pracy z dokumentami. Inne powiązane przypadki użycia: przetwarzanie PDF, przetwarzanie e-mail i obraz na pustej stronie.

---

Wypróbuj teraz: API MaraDocs | TypeScript SDK

---