OCR-API – Tworzenie przeszukiwalnych plików PDF z obrazów i skanów

Zeskanowane dokumenty i zdjęcia zawierają tekst, który nie jest ani zaznaczalny, ani przeszukiwalny. Wiele API OCR zwraca tylko wyodrębniony tekst, a nie oryginalny dokument z niewidoczną warstwą tekstową. Potrzebny jest ten sam plik PDF – ten sam układ i wygląd – ale z zaznaczalną, przeszukiwalną zawartością. To właśnie powinno zapewniać porządne API OCR do tworzenia przeszukiwalnych plików PDF.

Dlaczego własne rozwiązanie OCR dla przeszukiwalnych PDF zajmuje tygodnie

Kto chce zbudować to samodzielnie, szybko stwierdza, że Tesseract, EasyOCR czy Cloud-OCR zwracają tylko czysty tekst i ramki ograniczające. Aby utworzyć przeszukiwalny PDF, tekst musi być niewidocznie nałożony na oryginalny obraz lub oryginalny plik PDF. Wymaga to koordynacji układów współrzędnych, czcionek, kodowań i struktury PDF. Różne języki, czcionki i układy zwiększają złożoność. Solidne API OCR, które pozostawia dokument w nienaruszonym stanie, wymaga znacznego nakładu pracy programistycznej.

Jak API OCR MaraDocs rozwiązuje to w minuty

API MaraDocs wykonuje OCR i zwraca plik PDF z niewidocznie nałożoną warstwą tekstową. Otrzymujesz oryginalny dokument – układ, obrazy, wygląd – z zaznaczalnym i przeszukiwalnym tekstem. Żadnego osobnego pliku tekstowego. Żadnej okrojonej wersji. Ten sam dokument, ulepszony.

Przepływ pracy OCR: Walidacja, OCR, Optymalizacja

Dla obrazów: walidacja, następnie img.ocrToPdf. Dla plików PDF: walidacja, następnie pdf.ocrToPdf (opcjonalnie po pdf.orientation w celu wcześniejszego skorygowania obróconych stron). Wysokopoziomowe flow.ocrImg i flow.ocrPdf łączą wyrównanie, OCR i optymalizację w jednym wywołaniu. Wynik to zawsze uchwyt PDF – ten sam dokument z niewidoczną warstwą tekstową – który można pobrać lub przekazać do przepływów pracy związanych z kompozycją, kompresją lub e-mailem. Pipeline pozostaje po stronie serwera; nie ma ponownego przesyłania między krokami.

Co wyróżnia MaraDocs: Workspaces, Webview i niemieckie prawo o ochronie danych

Większość API do dokumentów wymusza przesyłanie, przetwarzanie, pobieranie i ponowne przesyłanie dla następnego kroku. W MaraDocs OCR działa we własnym workspace. Łańcuchuj z ekstrakcją dokumentów, kompozycją lub kompresją – przekaż uchwyt PDF bezpośrednio do następnej operacji. Bez ponownego przesyłania, mniej podróży w obie strony.

Gdy wyniki OCR wymagają ręcznej korekty – błędnie rozpoznane znaki, skomplikowane układy lub skany niskiej jakości – można otworzyć app.maradocs.io w celu ręcznej kontroli i edycji. Użytkownicy otrzymują pełną ręczną kontrolę, gdy automatyzacja osiąga swoje granice.

Całe przetwarzanie odbywa się w Niemczech (Maramia GmbH), zaszyfrowane w spoczynku i podczas przesyłania. Workspaces wygasają po 7 dniach. Żadne dane nie opuszczają UE. Dla obciążeń OCR wrażliwych na ochronę danych jest to istotne.

Kod TypeScript do tworzenia przeszukiwalnych plików PDF z OCR

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

// Wysokopoziomowe: prześlij, waliduj, pełny pipeline, pobierz
const pdfHandle = await client.flow.ocrImg(imageFile);
const blob = await client.data.downloadPdf({ pdf_handle: pdfHandle });

// Niskopoziomowe: Obraz – prześlij, waliduj, OCR, pobierz
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: prześlij, waliduj, ocrToPdf, pobierz
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 });

Kod Python dla OCR do przeszukiwalnego PDF

Dokumentacja API: data/upload, img/validate, img/ocr/to/pdf, pdf/ocr/pdf, data/download/pdf

# pip install python-decouple requests
"""OCR obrazu do przeszukiwalnego PDF za pomocą MaraDocs. Ustaw ACCOUNT_SECRET w .env lub środowisku."""

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:
    """Utwórz workspace i zwróć nagłówki autoryzacji."""
    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:
    """Prześlij plik przez przepływ dwuetapowy (podpisany URL + S3 POST). Zwraca 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:
    """Uruchom zadanie i odpytuj do zakończenia. Zwraca wynik (rozpakowuje response jeśli obecny)."""
    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} przekroczył limit czasu")


def download_pdf(pdf_handle: str, auth: dict) -> bytes:
    """Zażądaj podpisanego URL i pobierz bajty 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 utworzony")


if __name__ == "__main__":
    main()

Podsumowanie i kolejne kroki

API OCR, które tworzy przeszukiwalne pliki PDF – oryginalny dokument z niewidoczną warstwą tekstową – jest dostępne. MaraDocs zachowuje oryginalny układ i dodaje zaznaczalny, przeszukiwalny tekst. Dalsze powiązane przepływy pracy: Skaner dokumentów, Obsługa PDF i Obraz na pustej stronie.

---

Wypróbuj teraz: API MaraDocs | TypeScript SDK

---