Paperless-ngx verwandelt Ihren VPS in ein durchsuchbares Dokumentenarchiv. Sie scannen oder laden Dokumente hoch, Paperless-ngx führt die OCR-Erkennung durch, macht sie volltextdurchsuchbar und ordnet sie mit automatischen Tags und Korrespondenten ein. Die Anwendung läuft als Docker-Compose-Stack mit PostgreSQL, Redis und Gotenberg für die Dokumentenkonvertierung.

Diese Anleitung deployt Paperless-ngx auf einem VPS, auf dem Docker und ein Reverse Proxy bereits laufen. Falls Sie diese Grundlage noch benötigen, beginnen Sie mit unserer Anleitung zur Docker-Stack-Einrichtung.

Welche Ressourcen braucht Paperless-ngx auf einem VPS?

Paperless-ngx benötigt mindestens 2 GB RAM, empfohlen sind 4 GB. Der Stack betreibt PostgreSQL, Redis, Gotenberg, Tika und den Webserver. Im Leerlauf liegt der gesamte Speicherverbrauch bei etwa 800 MB. Während der OCR-Verarbeitung gescannter PDFs steigt die CPU-Auslastung auf 100 % auf einem Kern und der RAM-Verbrauch auf 1,5-2 GB. Der Festplattenverbrauch liegt durchschnittlich bei 5-10 MB pro Dokument (Original + Archiv + Vorschaubild).

Komponente	RAM (Leerlauf)	RAM max (OCR)	Festplatte pro 1.000 Docs
Paperless-ngx Webserver	~300 MB	~900 MB	5-10 GB
PostgreSQL	~50 MB	~100 MB	~500 MB
Redis	~10 MB	~10 MB	vernachlässigbar
Gotenberg	~150 MB	~300 MB	—
Tika	~250 MB	~400 MB	—
Gesamt	~760 MB	~1.710 MB	5-10 GB

Planen Sie den Festplattenplatz anhand Ihres Dokumentenvolumens. Ein Haushalt, der 50 Dokumente pro Monat scannt, benötigt etwa 6 GB pro Jahr. Ein kleines Unternehmen mit 500 Dokumenten/Monat sollte 50-60 GB pro Jahr einplanen.

Wie deploye ich Paperless-ngx mit Docker Compose auf einem VPS?

Erstellen Sie ein Verzeichnis für den Stack, generieren Sie Secrets und schreiben Sie die Compose-Datei. Jeder Service hat einen Health Check, sodass Docker fehlerhafte Container automatisch neu startet.

Projektverzeichnis erstellen

mkdir -p /opt/paperless-ngx && cd /opt/paperless-ngx

Secrets generieren

Verwenden Sie niemals Standardpasswörter. Generieren Sie ein starkes Datenbankpasswort und einen Django-Secret-Key:

openssl rand -base64 32 > .db_password
openssl rand -base64 48 > .secret_key
chmod 600 .db_password .secret_key

Diese Dateien bleiben mit eingeschränkten Berechtigungen auf der Festplatte. Die Compose-Datei liest sie beim Containerstart.

Umgebungsdatei schreiben

cat > .env << 'EOF'
COMPOSE_PROJECT_NAME=paperless
EOF

Compose-Datei schreiben

# docker-compose.yml
services:
  broker:
    image: docker.io/library/redis:8
    restart: unless-stopped
    volumes:
      - redisdata:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3

  db:
    image: docker.io/library/postgres:18
    restart: unless-stopped
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U paperless"]
      interval: 30s
      timeout: 5s
      retries: 3

  gotenberg:
    image: docker.io/gotenberg/gotenberg:8
    restart: unless-stopped
    command:
      - "gotenberg"
      - "--chromium-disable-javascript=true"
      - "--chromium-allow-list=file:///tmp/.*"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 5s
      retries: 3

  tika:
    image: docker.io/apache/tika:latest
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9998/"]
      interval: 30s
      timeout: 5s
      retries: 3

  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
      broker:
        condition: service_healthy
      gotenberg:
        condition: service_healthy
      tika:
        condition: service_healthy
    ports:
      - "127.0.0.1:8000:8000"
    volumes:
      - data:/usr/src/paperless/data
      - media:/usr/src/paperless/media
      - ./export:/usr/src/paperless/export
      - ./consume:/usr/src/paperless/consume
    environment:
      PAPERLESS_REDIS: redis://broker:6379
      PAPERLESS_DBHOST: db
      PAPERLESS_DBUSER: paperless
      PAPERLESS_DBPASS_FILE: /run/secrets/db_password
      PAPERLESS_TIKA_ENABLED: 1
      PAPERLESS_TIKA_GOTENBERG_ENDPOINT: http://gotenberg:3000
      PAPERLESS_TIKA_ENDPOINT: http://tika:9998
      PAPERLESS_SECRET_KEY_FILE: /run/secrets/secret_key
      PAPERLESS_OCR_LANGUAGE: eng
      PAPERLESS_OCR_MODE: skip
      PAPERLESS_OCR_OUTPUT_TYPE: pdfa
      PAPERLESS_FILENAME_FORMAT: "{created_year}/{correspondent}/{title}"
      PAPERLESS_URL: https://paperless.example.com
      USERMAP_UID: 1000
      USERMAP_GID: 1000
    secrets:
      - db_password
      - secret_key
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

secrets:
  db_password:
    file: .db_password
  secret_key:
    file: .secret_key

volumes:
  data:
  media:
  pgdata:
  redisdata:

Hinweise zu dieser Konfiguration:

Ports sind nur an 127.0.0.1 gebunden. Ihr Reverse Proxy übernimmt den öffentlichen Zugriff über HTTPS. Port 8000 auf 0.0.0.0 zu öffnen würde TLS und Ihre Firewall umgehen.
Secrets verwenden Docker Secrets (Variablen mit dem Suffix _FILE). Passwörter erscheinen weder in der Ausgabe von docker inspect noch in Prozesslisten.
USERMAP_UID/USERMAP_GID ordnen den Container-Benutzer der UID 1000 auf dem Host zu. Dateien in den Verzeichnissen consume und export gehören diesem Benutzer.
PAPERLESS_URL muss mit Ihrer öffentlichen Domain übereinstimmen. Paperless-ngx nutzt diesen Wert für Share-Links und E-Mail-URLs. Ersetzen Sie paperless.example.com durch Ihre tatsächliche Domain.

Stack starten

docker compose up -d

Warten Sie etwa 60 Sekunden, bis alle Services initialisiert sind. Prüfen Sie, ob jeder Container gesund ist:

docker compose ps

NAME                   SERVICE      STATUS                  PORTS
paperless-broker-1     broker       running (healthy)
paperless-db-1         db           running (healthy)
paperless-gotenberg-1  gotenberg    running (healthy)
paperless-tika-1       tika         running (healthy)
paperless-webserver-1  webserver    running (healthy)       127.0.0.1:8000->8000/tcp

Alle fünf Container sollten (healthy) anzeigen. Wenn einer (health: starting) zeigt, warten Sie weitere 30 Sekunden. Falls ein Container dauerhaft (unhealthy) bleibt, prüfen Sie seine Logs:

docker compose logs gotenberg --tail 20

Superuser erstellen

docker compose exec webserver createsuperuser

Folgen Sie den Eingabeaufforderungen für Benutzername, E-Mail und Passwort. Dies ist Ihr Administratorkonto für die Web-Oberfläche.

Auf die Web-Oberfläche zugreifen

Wenn Ihr Reverse Proxy konfiguriert ist, öffnen Sie https://paperless.example.com im Browser. Die Paperless-ngx-Anmeldeseite wird geladen. Falls Sie den Reverse Proxy noch einrichten, testen Sie lokal:

curl -s -o /dev/null -w "%{http_code}" http://127.0.0.1:8000

Welche OCR-Sprachen und -Modi sollte ich konfigurieren?

Paperless-ngx nutzt Tesseract für die OCR-Erkennung. Sprache und Verarbeitungsmodus konfigurieren Sie über Umgebungsvariablen. Die Standardwerte passen für englische Dokumente, aber die meisten Anwender müssen sie anpassen.

OCR-Sprache

Setzen Sie PAPERLESS_OCR_LANGUAGE auf den dreibuchstabigen Tesseract-Sprachcode für Ihre Dokumente. Für mehrere Sprachen verbinden Sie die Codes mit +:

# Einzelne Sprache
PAPERLESS_OCR_LANGUAGE: deu

# Mehrere Sprachen
PAPERLESS_OCR_LANGUAGE: deu+eng+fra

Gängige Sprachcodes: eng (Englisch), deu (Deutsch), fra (Französisch), spa (Spanisch), ita (Italienisch), nld (Niederländisch), por (Portugiesisch). Die vollständige Liste finden Sie in der Tesseract-Dokumentation.

Das Container-Image enthält die meisten Sprachpakete. Mehr Sprachen in PAPERLESS_OCR_LANGUAGE erhöhen die OCR-Verarbeitungszeit pro Seite.

OCR-Modi

Die Einstellung PAPERLESS_OCR_MODE steuert, wie Paperless-ngx Dokumente behandelt, die bereits eine Textebene enthalten (häufig bei digital erstellten PDFs).

Modus	Verhalten	Wann verwenden
`skip`	OCR nur für Seiten ohne Text. Erstellt immer eine Archivkopie.	Standard. Optimal für gemischte Eingaben: gescannte + digitale PDFs.
`skip_noarchive`	Wie `skip`, aber ohne Archivkopie für Dokumente mit vorhandenem Text.	Sie möchten Festplattenplatz bei digitalen PDFs sparen.
`redo`	Alle Seiten neu per OCR erfassen, vorhandene Textebenen ersetzen.	Sie erhalten Dokumente mit schlechter OCR-Qualität.
`force`	Dokument rasterisieren und OCR von Grund auf durchführen. Zerstört den Originaltext.	Letzter Ausweg. Erzeugt größere Dateien mit weniger scharfem Text.

Für die meisten Setups ist skip die richtige Wahl. Es verarbeitet sowohl gescannte als auch digitale Dokumente, ohne CPU für bereits durchsuchbare Dokumente zu verschwenden.

Wenn Sie Dokumente von einem Scanner erhalten, der eine eigene (schlechte) OCR durchführt, stellen Sie den Modus auf redo um. Beachten Sie, dass redo nicht mit PAPERLESS_OCR_CLEAN und PAPERLESS_OCR_DESKEW kompatibel ist.

OCR-Ausgabetyp

PAPERLESS_OCR_OUTPUT_TYPE: pdfa (Standard) erzeugt PDF/A-Dateien, den Archivierungsstandard. Diese sind eigenständig und enthalten eingebettete Schriftarten. Behalten Sie diese Einstellung bei, sofern kein besonderer Grund dagegen spricht.

Nach Änderungen an den OCR-Einstellungen starten Sie den Webserver-Container neu:

docker compose restart webserver

Bestehende Dokumente werden nicht erneut verarbeitet. Um die OCR für ein Dokument zu wiederholen, nutzen Sie die Aktion „Redo OCR" in der Web-Oberfläche.

Wie funktioniert das automatische Tagging in Paperless-ngx?

Paperless-ngx unterstützt sechs Matching-Algorithmen für Tags, Korrespondenten und Dokumententypen. Wenn ein Dokument eintrifft, prüft jeder Tag den Dokumenteninhalt gegen sein Muster. Bei einem Treffer wird der Tag automatisch zugewiesen.

Algorithmus	Funktionsweise	Wann verwenden	Beispiel
Any	Trifft zu, wenn ein Wort aus dem Match-Feld vorkommt.	Breite Kategorien.	`invoice receipt bill`
All	Trifft zu, wenn alle Wörter vorkommen (beliebige Reihenfolge).	Engeres Matching ohne Positionsabhängigkeit.	`electricity quarterly`
Exact	Trifft auf die exakte Phrase in Reihenfolge zu.	Firmennamen, Kontonummern.	`Acme Corp`
Regular Expression	Vollständiger Regex-Musterabgleich.	Strukturierte Daten: Daten, Referenznummern, Beträge.	`Invoice\s+#?\d{4,}`
Fuzzy	Ungefähre Übereinstimmung mit konfigurierbarem Schwellenwert.	Inkonsistente OCR-Ausgabe, leichte Tippfehler.	`Stadtwerke` (erkennt `Stadtwenke`)
Auto	ML-Klassifizierer, der aus Ihren manuellen Zuweisungen lernt.	Nachdem Sie ~50+ Dokumente manuell getaggt haben.	(lernt aus Ihren Korrekturen)

Tags mit Matching-Regeln erstellen

Gehen Sie in der Web-Oberfläche zu Manage > Tags und erstellen Sie einen Tag. Legen Sie den Matching-Algorithmus und das Match-Feld fest. Einige praktische Beispiele:

Tag: Invoice, Algorithmus: Any, Match: invoice rechnung facture (erkennt Rechnungen in mehreren Sprachen)
Tag: Bank, Algorithmus: Regular Expression, Match: IBAN\s*[A-Z]{2}\d{2} (erkennt jede IBAN-Nummer)
Tag: Medical, Algorithmus: All, Match: patient diagnosis (erfordert beide Wörter)
Korrespondent: Electric Company, Algorithmus: Exact, Match: Springfield Energy Inc

Den Auto-Klassifizierer trainieren

Der Auto-Algorithmus nutzt einen Machine-Learning-Klassifizierer, den Paperless-ngx automatisch nachtrainiert. So trainieren Sie ihn:

Taggen Sie mindestens 50 Dokumente manuell über Ihre Kategorien hinweg
Stellen Sie sicher, dass diese Dokumente nicht in Ihrem Posteingang sind (der Klassifizierer ignoriert Posteingangs-Dokumente)
Der Klassifizierer trainiert nach einem Zeitplan neu (Standard: stündlich über document_create_classifier)
Neue Dokumente erhalten ab dann automatische Zuweisungen

Sie können ein manuelles Nachtraining auslösen:

docker compose exec webserver document_create_classifier

Der Klassifizierer verbessert sich mit jeder Korrektur. Jede Korrektur fließt in den nächsten Trainingszyklus ein.

Wie richte ich die Dokumentenaufnahme in Paperless-ngx ein?

Paperless-ngx nimmt Dokumente über drei Kanäle auf: manueller Upload über die Web-Oberfläche, ein überwachtes Verzeichnis auf der Festplatte und E-Mail-Abruf über IMAP.

Upload über die Web-Oberfläche

Ziehen Sie Dateien per Drag-and-Drop in die Web-Oberfläche. Das funktioniert sofort nach der Einrichtung. Unterstützte Formate: PDF, PNG, JPEG, TIFF und (mit aktiviertem Tika) DOCX, XLSX, ODT sowie weitere Office-Formate.

Überwachtes Verzeichnis (consume-Verzeichnis)

Das Verzeichnis ./consume aus der Compose-Datei wird von einem inotify-Watcher überwacht. Legen Sie eine Datei hinein, und Paperless-ngx verarbeitet sie innerhalb von Sekunden.

cp /tmp/scan-001.pdf /opt/paperless-ngx/consume/

Die Datei verschwindet aus dem consume-Verzeichnis, sobald die Verarbeitung abgeschlossen ist. Um die Aufnahme nach Tags zu organisieren, aktivieren Sie Unterverzeichnis-Tagging:

PAPERLESS_CONSUMER_RECURSIVE: true
PAPERLESS_CONSUMER_SUBDIRS_AS_TAGS: true

Mit dieser Einstellung erhält eine Datei in consume/invoices/scan.pdf automatisch den Tag invoices.

E-Mail-Verarbeitung (IMAP)

Die E-Mail-Verarbeitung wird vollständig in der Web-Oberfläche unter Manage > Mail konfiguriert. Sie fügen Mailkonten und Mailregeln hinzu.

Mailkonto hinzufügen:

Gehen Sie zu Manage > Mail > Mail Accounts
Geben Sie IMAP-Server, Port (993 für TLS), Benutzername und Passwort ein
Legen Sie den zu überwachenden Ordner fest (z. B. INBOX)

Mailregel hinzufügen:

Gehen Sie zu Manage > Mail > Mail Rules
Wählen Sie das Mailkonto
Wählen Sie, was verarbeitet werden soll: nur Anhänge oder die gesamte E-Mail als PDF
Legen Sie eine Aktion für verarbeitete E-Mails fest: als gelesen markieren, in einen Ordner verschieben oder löschen
Optional können Sie einen Tag, Korrespondenten oder Dokumententyp zuweisen

Typisches Setup: Leiten Sie Dokumente an eine dedizierte E-Mail-Adresse weiter (z. B. scan@ihredomain.de), konfigurieren Sie Paperless-ngx zur Überwachung dieses Posteingangs und verarbeiten Sie die Anhänge. Die Originale werden nach der Verarbeitung in einen IMAP-Ordner „Archived" verschoben.

Wie organisiere ich Speicherpfade und Dateinamen?

Paperless-ngx speichert Dokumente an zwei Orten: Das media-Volume enthält die Dateien auf der Festplatte, während PostgreSQL die Metadaten verwaltet. Die Variable PAPERLESS_FILENAME_FORMAT steuert die Benennung der archivierten Dateien im media-Verzeichnis.

Die Compose-Datei oben verwendet:

PAPERLESS_FILENAME_FORMAT: "{created_year}/{correspondent}/{title}"

Das erzeugt eine Struktur wie:

media/documents/archive/
  2026/
    Springfield Energy Inc/
      Electricity Bill January 2026.pdf
    Dr. Smith/
      Lab Results March 2026.pdf

Verfügbare Template-Variablen: {created_year}, {created_month}, {created_day}, {correspondent}, {document_type}, {title}, {tag_list} und {owner_username}. Wenn eine Variable leer ist (kein Korrespondent zugewiesen), ersetzt Paperless-ngx sie durch none.

Nach einer Änderung des Dateinamenformats wenden Sie es auf bestehende Dokumente an:

docker compose exec webserver document_renamer

Welche Backup-Strategie eignet sich für Paperless-ngx?

Ein funktionierendes Backup umfasst die PostgreSQL-Datenbank, die Dokumentdateien (Originale + Archive + Vorschaubilder) und die Paperless-ngx-Metadaten (Tags, Korrespondenten, Matching-Regeln). Der Dokumentenexporter erfasst all das in einem portablen Format. Kombinieren Sie ihn mit einem Datenbank-Dump für schnellere Datenbank-Restores.

Datenbank-Dump

docker compose exec db pg_dump -U paperless paperless | gzip > /opt/paperless-ngx/backups/db-$(date +%Y%m%d).sql.gz

Dokumentenexporter

Der Exporter erstellt einen vollständigen Snapshot: Dokumente, Metadaten und Manifest. Dies ist die kanonische Backup-Methode.

docker compose exec webserver document_exporter ../export -c -d

Das Flag -c vergleicht Prüfsummen (exportiert nur geänderte Dateien). Das Flag -d löscht Dateien aus dem Export, die in Paperless-ngx nicht mehr existieren. Zusammen halten sie das Export-Verzeichnis als Spiegel des aktuellen Zustands.

Mit cron automatisieren

Erstellen Sie ein Backup-Skript:

cat > /opt/paperless-ngx/backup.sh << 'SCRIPT'
#!/bin/bash
set -euo pipefail

BACKUP_DIR="/opt/paperless-ngx/backups"
EXPORT_DIR="/opt/paperless-ngx/export"

mkdir -p "$BACKUP_DIR"

# Database dump
docker compose -f /opt/paperless-ngx/docker-compose.yml exec -T db \
  pg_dump -U paperless paperless | gzip > "$BACKUP_DIR/db-$(date +%Y%m%d).sql.gz"

# Document exporter
docker compose -f /opt/paperless-ngx/docker-compose.yml exec -T webserver \
  document_exporter ../export -c -d

# Remove database dumps older than 30 days
find "$BACKUP_DIR" -name "db-*.sql.gz" -mtime +30 -delete

echo "[$(date -Is)] Backup completed" >> "$BACKUP_DIR/backup.log"
SCRIPT

chmod 700 /opt/paperless-ngx/backup.sh

Planen Sie das Skript mit cron (bestehende Crontab-Einträge bleiben erhalten):

(crontab -l 2>/dev/null; echo "0 3 * * * /opt/paperless-ngx/backup.sh") | crontab -

Das fügt einen nächtlichen Job um 03:00 Uhr hinzu.

Offsite-Synchronisation

Das Export-Verzeichnis und die Datenbank-Dumps müssen den Server verlassen. Nutzen Sie rsync oder rclone, um sie an einen zweiten Standort zu übertragen. Für ein S3-kompatibles Ziel:

rclone sync /opt/paperless-ngx/export remote:paperless-backup/export
rclone sync /opt/paperless-ngx/backups remote:paperless-backup/db-dumps

Für einen anderen Server via SSH:

rsync -az --delete /opt/paperless-ngx/export/ backup-server:/backups/paperless/export/
rsync -az /opt/paperless-ngx/backups/ backup-server:/backups/paperless/db-dumps/

Für einen tieferen Einblick in Docker-Volume-Backup-Strategien siehe unsere Anleitung zu Docker-Volume-Backup-Strategien.

Wie stelle ich ein Paperless-ngx-Backup wieder her?

Die Wiederherstellung erfordert eine frische Paperless-ngx-Installation. Starten Sie den Stack und importieren Sie dann.

Nur Datenbank wiederherstellen (schneller, bei Datenbankkorruption oder Migration):

gunzip < /opt/paperless-ngx/backups/db-20260320.sql.gz | \
  docker compose exec -T db psql -U paperless paperless

Vollständige Wiederherstellung aus dem Exporter (Dokumente, Tags, Korrespondenten, alles):

docker compose exec webserver document_importer ../export

Führen Sie den Importer gegen eine leere Datenbank aus. Er erstellt alle Metadaten neu und verknüpft die Dateien aus dem Export-Verzeichnis.

Testen Sie Ihre Wiederherstellung regelmäßig. Ein Backup, das Sie nie wiederhergestellt haben, ist kein Backup.

Wie härte ich die Paperless-ngx-Container ab?

Die Compose-Datei oben deckt bereits die Grundlagen ab: Secret-Dateien statt Klartext-Passwörter, Port-Binding auf localhost und User-Mapping. Hier folgen zusätzliche Härtungsmaßnahmen.

Unnötige Capabilities entfernen

Fügen Sie dem Webserver-Service Sicherheitsoptionen hinzu:

webserver:
  # ... bestehende Konfiguration ...
  security_opt:
    - no-new-privileges:true

Das verhindert, dass der Container-Prozess über setuid-Binaries zusätzliche Privilegien erlangt.

Ressourcenlimits setzen

Verhindern Sie, dass ein außer Kontrolle geratener OCR-Prozess alle Server-Ressourcen verbraucht:

webserver:
  # ... bestehende Konfiguration ...
  deploy:
    resources:
      limits:
        memory: 2g
        cpus: "2.0"
      reservations:
        memory: 512m

Mehr zu Ressourcenlimits finden Sie in unserer Anleitung zu Docker-Compose-Ressourcenlimits.

Versionsinformationen verbergen

Konfigurieren Sie Ihren Reverse Proxy so, dass er den Server-Header entfernt. Mit Nginx:

server_tokens off;

Paperless-ngx selbst gibt seine Version nicht in HTTP-Headern preis, aber Ihr Reverse Proxy könnte es tun.

Wie aktualisiere ich Paperless-ngx?

Laden Sie die neuesten Images herunter und erstellen Sie die Container neu. Das Paperless-ngx-Image führt Datenbankmigrationen beim Start automatisch aus.

cd /opt/paperless-ngx
docker compose pull
docker compose up -d

Prüfen Sie nach dem Update die Logs auf Migrationsausgaben:

docker compose logs webserver --tail 30

Suchen Sie nach Zeilen wie Applying documents.XXXX_migration_name... OK. Wenn Migrationen fehlschlagen, stoppt der Container. Prüfen Sie die Release Notes vor größeren Versionssprüngen.

Führen Sie immer Ihr Backup-Skript vor dem Update aus.

Etwas funktioniert nicht?

Container bleibt unhealthy: Prüfen Sie die Logs mit docker compose logs <service> --tail 50. Häufige Ursachen: PostgreSQL-Passwort stimmt nicht (.db_password neu generieren und das Datenbank-Volume neu erstellen), Redis-Verbindung verweigert (Broker noch nicht gestartet).

OCR erzeugt unlesbaren Text: Falsche Sprache eingestellt. Prüfen Sie, ob PAPERLESS_OCR_LANGUAGE zu Ihren Dokumenten passt. Bei mehrsprachigen Dokumenten fügen Sie alle relevanten Sprachcodes getrennt durch + hinzu.

Dokumente erscheinen nach dem Upload nicht: Prüfen Sie das Consumer-Log:

docker compose logs webserver --tail 50 | grep -i consumer

Häufige Ursache: Berechtigungsproblem. Das consume-Verzeichnis muss für UID 1000 (oder den Wert von USERMAP_UID) beschreibbar sein:

chown -R 1000:1000 /opt/paperless-ngx/consume

Automatisches Tagging funktioniert nicht: Der Klassifizierer benötigt mindestens ~50 manuell getaggte Dokumente. Prüfen Sie, ob der Klassifizierer trainiert wurde:

docker compose exec webserver document_create_classifier

Festplattenplatz wächst schnell: Prüfen Sie, welche Dokumente am größten sind:

docker compose exec webserver document_sanity_checker

Überprüfen Sie auch Ihren OCR-Modus. Der force-Modus erzeugt deutlich größere Archivdateien als skip.

E-Mail-Verarbeitung holt keine Mails ab: Prüfen Sie die IMAP-Zugangsdaten in der Web-Oberfläche. Lösen Sie einen manuellen Abruf aus, um Fehler zu sehen:

docker compose exec webserver mail_fetcher

Für weitere Self-Hosting-Anleitungen siehe unsere Immich-Anleitung zur Fotoverwaltung auf dem gleichen Stack.

Paperless-ngx auf einem VPS mit Docker Compose selbst hosten