Dokumentenscanner-API – Dokumente aus Fotos automatisch extrahieren

Kommen bei Ihnen Dokumente als Fotos in E-Mail-Anhängen an? In der Kanzlei unserer Gründer war das ein nicht unerhebliches Problem, das manuelle Arbeitszeit band. Mandanten fotografieren Rechnungen, Unfallberichte und Verträge auf dem Küchentisch und drücken auf Senden. Man erhält verzerrte JPGs, die vor der Ablage zugeschnitten, perspektivkorrigiert und in PDF konvertiert werden müssen.

Eine Dokumentenscanner-App-API, die die Dokumentgrenze erkennt, die Perspektive korrigiert und ein sauberes PDF ausgibt, würde Stunden einsparen. Das klingt einfach – aber selbst bauen ist es selten.

Warum eine eigene Dokumentenscanner-App Wochen dauert

Wer eine Dokumentextraktionslösung intern aufbauen möchte, greift schnell zu OpenCV für Kantenerkennung und Perspektivtransformationen, Tesseract oder einem Cloud-OCR für Texterkennung, PyMuPDF oder reportlab für PDF-Generierung und Pillow für die Bildverarbeitung. Vielleicht kommt noch ein Dokumenterkennungsmodell (z. B. Layout-Transformer oder SAM-basierte Segmentierer) für robuste Erkennung hinzu. Jedes Teil funktioniert isoliert; sie zu einer zuverlässigen Pipeline mit korrekter Fehlerbehandlung, Virenscan und Formatvalidierung zu verdrahten dauert Wochen. ML-Modelle erfordern GPU-Infrastruktur, Model-Hosting und Wartung. Die meisten Entwickler erkennen schnell, dass mehr als ein Wochenend-Hack nötig ist.

Wie die MaraDocs Dokumentenscanner-API das in Minuten löst

Die MaraDocs Dokumentenverarbeitungs-API wandelt diesen Workflow in wenige API-Aufrufe um. Gleiches Hochladen, Validierung und verkettete Verarbeitung – aber ohne den Integrationsaufwand. Ein Foto hochladen, es validieren (Virenscan und Formatprüfungen inklusive), Dokumente im Bild erkennen, jedes einzelne extrahieren und perspektivkorrigieren und in PDF konvertieren – alles über eine einzige REST-API. Keine ML-Infrastruktur, kein Python-Dependency-Chaos.

Dokumentenscanner-Workflow: Hochladen, Validieren, Extrahieren, Konvertieren

Jeder MaraDocs-Workflow folgt dem gleichen Muster: eine Datei hochladen, validieren (Virenscan + Formatvalidierung), dann Operationen verketten. Validierung ist obligatorisch und erfolgt vor jeder Verarbeitung. Wenn eine Datei infiziert oder beschädigt ist, erhält man eine klare Fehlermeldung – keine Verarbeitung nicht vertrauenswürdiger Daten.

Nach der Validierung werden Operationen durch die Übergabe von Handles verkettet. Für einen Dokumentenscanner-Flow: das Bild validieren, findDocuments aufrufen, um quadrilaterale Koordinaten zu erhalten, extractQuadrilateral für jedes erkannte Dokument aufrufen, dann mit toPdf oder ocrToPdf für durchsuchbaren Output in PDF konvertieren. Die gesamte Pipeline bleibt serverseitig; dieselbe Datei wird nie erneut hochgeladen.

Was MaraDocs unterscheidet: Workspaces, Webview und deutsches Datenschutzrecht

Die meisten Dokumenten-APIs zwingen zum Hochladen, Herunterladen und erneuten Hochladen für jeden Verarbeitungsschritt. Das bedeutet zusätzliche Roundtrips, mehr Code zum Verfolgen von Dateiidentitäten und höhere Latenz. MaraDocs nutzt stattdessen Workspaces: Der eigene Server erstellt einen Workspace mit einem geheimen Schlüssel und erhält ein workspace_secret. Der Client (Browser oder Backend) verwendet dieses Token für alle Operationen. Dateien bleiben serverseitig; Handles werden zwischen den Schritten übergeben. Man verkettet validieren → suchen → extrahieren → toPdf → herunterladen mit fließenden Handles – kein erneutes Hochladen, weniger Netzwerkaufrufe, einfacherer Code.

Manchmal stößt die Automatisierung an einen Sonderfall: ein schwieriger Winkel, mehrere Dokumente in einem Foto oder ein Format, das manuell angepasst werden muss. Mit MaraDocs kann app.maradocs.io geöffnet werden, um mit dem Workspace-Secret Dateien direkt anzuzeigen, umzuordnen und zu bearbeiten. Nutzer erhalten volle manuelle Kontrolle, wenn die Pipeline menschliches Eingreifen benötigt – ein seltener Vorteil gegenüber APIs, die nur programmatischen Zugriff bieten.

Die gesamte Verarbeitung erfolgt auf Servern in Deutschland unter der Kontrolle der Maramia GmbH. Daten sind im Ruhezustand (SSE-C) und während der Übertragung (TLS) verschlüsselt. Workspaces verfallen nach 7 Tagen. Keine Daten verlassen die EU. Auf Wunsch ist ein Auftragsverarbeitungsvertrag verfügbar. Für DSGVO- und BDSG-sensible Workloads ist das relevant.

TypeScript-Code zum Extrahieren von Dokumenten aus Fotos

Das MaraDocs TypeScript SDK übernimmt das Polling für asynchrone Jobs. Vollständiger Flow mit Hochladen, Validieren, Verarbeiten und Herunterladen.

API-Referenz: workspace, data/upload, img/validate, img/find/documents, img/extract/quadrilateral, img/ocr/to/pdf, data/download/pdf

import { MaraDocsServer, MaraDocsClient } from "@maramia/maradocs-sdk-ts";
import { okImg } from "@maramia/maradocs-sdk-ts/models/img";

// Server: Workspace erstellen
const server = new MaraDocsServer({ secretKey: process.env.MARADOCS_SECRET_KEY! });
const { workspace_secret } = await server.workspace.create({});

// Client: hochladen, validieren, Dokumente suchen, extrahieren, OCR, herunterladen
const client = new MaraDocsClient({ workspaceSecret: workspace_secret });
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 docs = await client.img.findDocuments({ img_handle: imgHandle });
if (docs.documents.length > 0) {
  const extracted = await client.img.extractQuadrilateral({
    img_handle: imgHandle,
    quadrilateral: docs.documents[0].quadrilateral,
  });
  const pdf = await client.img.ocrToPdf({
    img_handle: extracted.img_handle,
  });
  const blob = await client.data.downloadPdf({ pdf_handle: pdf.pdf_handle });
}

Oder flow.ocrImg für eine vollständige Pipeline (hochladen, validieren, suchen, extrahieren, ausrichten, OCR, optimieren) in einem Aufruf verwenden:

const pdfHandle = await client.flow.ocrImg(imageFile);
const blob = await client.data.downloadPdf({ pdf_handle: pdfHandle });

Python-Code zur Dokumentextraktion

API-Referenz: data/upload, img/validate, img/find/documents, img/extract/quadrilateral, img/ocr/to/pdf, data/download/pdf

import requests
import time

API_URL = "https://api.maradocs.io/v1"
WORKSPACE_SECRET = "..."  # vom eigenen Server
headers = {"Authorization": f"Bearer {WORKSPACE_SECRET}"}

def poll(job_url, job_id):
    while True:
        r = requests.get(f"{job_url}/{job_id}", headers=headers).json()
        if r["status"] == "complete":
            return r["response"]["response"]
        time.sleep(1)

# 1. Hochladen
with open("photo.jpg", "rb") as f:
    upload = requests.post(f"{API_URL}/data/upload", headers=headers,
        files={"file": ("photo.jpg", f, "image/jpeg")}).json()
handle = upload["unvalidated_file_handle"]

# 2. Validieren
val = requests.post(f"{API_URL}/img/validate", headers=headers,
    json={"unvalidated_file_handle": handle}).json()
img_handle = poll(f"{API_URL}/img/validate", val["job_id"])["img_handle"]

# 3. Dokumente suchen, 4. Extrahieren, 5. OCR zu PDF (vereinfacht; jeder Job wird gepollt)
find_res = requests.post(f"{API_URL}/img/find/documents", headers=headers,
    json={"img_handle": img_handle}).json()
find_data = poll(f"{API_URL}/img/find/documents", find_res["job_id"])
if find_data.get("documents"):
    quad = find_data["documents"][0]["quadrilateral"]
    ext_res = requests.post(f"{API_URL}/img/extract/quadrilateral", headers=headers,
        json={"img_handle": img_handle, "quadrilateral": quad}).json()
    extracted = poll(f"{API_URL}/img/extract/quadrilateral", ext_res["job_id"])
    ocr_res = requests.post(f"{API_URL}/img/ocr/to/pdf", headers=headers,
        json={"img_handle": extracted["img_handle"]}).json()
    ocr_data = poll(f"{API_URL}/img/ocr/to/pdf", ocr_res["job_id"])
    pdf_handle = ocr_data["pdf_handle"]

    # 6. Herunterladen
    pdf_resp = requests.get(f"{API_URL}/data/download/pdf", headers=headers,
        params={"pdf_handle": pdf_handle})
    with open("output.pdf", "wb") as out:
        out.write(pdf_resp.content)

Zusammenfassung: Dokumentenscanner-API ohne Integrationsaufwand

Eine Dokumentenscanner-App-API, die Dokumente aus Fotos extrahiert, Perspektive korrigiert und PDFs ausgibt, ist in Reichweite. Mit MaraDocs entfällt die wochenlange Integration von OpenCV, Tesseract und ML-Modellen. Validierung, Workspaces, Webview und deutschen Datenspeicherort gibt es direkt dazu.

Weitere Anwendungsfälle: PDF-Verarbeitung – Zusammenführen, Trennen, Automatisch Drehen, Automatisches Drehen und Ausrichtungserkennung, Texterkennung (OCR) und Bild oder PDF auf leere DIN A4-Seite platzieren.

---

Jetzt ausprobieren: MaraDocs API | TypeScript SDK

---