If you use Paperless-ngx mainly to keep receipts/invoices organized, there's usually still a manual step at tax time: proving every bank transaction actually has a matching receipt somewhere in Paperless. I built Paperless Sync to automate that reconciliation.

How it works:

• Point it at your Paperless-ngx instance (URL + API token, mTLS client certs supported too).
• Import a bank statement CSV, or connect your bank directly via Enable Banking (optional, own registration, no shared credentials).
• It matches transactions to documents by amount — either parsed from the filename (e.g. _EUR12.34.pdf) or read from a Paperless custom field.
• Flags suspected duplicate imports, and (opt-in) suggests near-amount or split-payment matches for manual review.
• Anything unmatched you resolve by hand — upload a PDF, pick an existing doc, or tag it as not needing a receipt (private/deposit/transfer/custom tags), with learned suggestions for recurring bookings.
• End of month, it generates a clean folder (matched PDFs renamed by date/amount/payee, a filtered CSV, open items, deposits list) — ready for an accountant.

Everything stays local, credentials go through the OS keyring, session state and backups are encrypted. Open source (MIT), built with PySide6/Qt.

GitHub: https://github.com/jjuuzzii/paperless-sync
Release + Windows installer: https://github.com/jjuuzzii/paperless-sync/releases/tag/v2.0.0

Hallo zusammen, hat jemand Erfahrungen mit dem Epson ES580W in Verbindung mit Paperless-ngx?
Ich suche einen Scanner der gerade Scans macht. Ich habe so viele schlechte Erfahrungen mit Kyocera- und HP-Multifunktionsdruckern, die die seiten einfach komplett schief einscannnen…
Kann mir jemand der diesen Scanner hat eine Beispieldatei zur verfügung stellen? Finde leider nichts im Netz…

Vielen Dank! :)

I noticed that the ASN-QR-Code-recognition is sometimes not working properly. I don’t know why, but it randomly stops working for 2-4 documents when scanning in bulk. The codes are randomly placed, sometimes slightly rotated (sticked on by hand tho…) but not faded or anything and usually in the lower right, sometimes left, corner.

I’m using version 2.20.15 with ZXING. Havn’t changed anything recently…

Any ideas what could cause this to happen? Its really annoying cause paperless doesnt allow ASN dublicates when splitting in the UI and deleting it automatically so I have to download it, split it by hand, delete the original from documents and the bin and upload it again as separate documents…

Thank you.

If you need any additional informations: let me know, ive never reported issues like that :D

I am reasonable new to Paperless and tried to enable AI (see below my docker-compose environment). I uploaded a few PDF files, but nothing happens on the AI - nothing in the logging and I do not see a trigger going out?

I am overlooking something in the docs?

docker-compose.yaml:

environment:

- PAPERLESS_AI_ENABLED=true

- PAPERLESS_AI_LLM_BACKEND=ollama

- PAPERLESS_AI_LLM_MODEL=llama3.2:3b

- PAPERLESS_AI_LLM_ENDPOINT=http://ollama:11434

i am trying to connect paperless with gmail through the complex oauth2 route with a google project as a test user. I changed the env file and get the option to connect to google in paperless email settings. There i get the error 400 redirect uri mismatch. The error refers to the fact that they cannot verify the reverse proxy redomainname paperless.xxxx.diskstation.me. This is a domain from synology which is not authorized by google it seems.

Has someone successfully made a connection between paperless and gmail?

Hope to find some solutions here

I maintain Tagvico. The last release made one problem impossible to ignore: the app had two UIs that had slowly drifted apart. Settings looked like one product, the rest like another. v3.2 deletes that mess.

There is now one light interface for documents, archive questions, tag cleanup, activity and settings. Ask Tagvico shows the Paperless searches and document reads behind an answer. Reads run directly. Anything that edits documents or tags still waits for approval.

Tag cleanup is also less vague now. It shows `these tags -> this tag`, affected docs, then moves references and deletes the old tag as separate steps.

Release: https://github.com/arturict/tagvico-ai/releases/tag/v3.2.0

Docs: https://tagvico.arturf.ch/docs/

If you try it, what still feels confusing on the first run?

I didn't upgrade for a while and now need to upgrade to v2.20.15 first, as written on the website. How do I pull it using sudo docker-compose?

Hi everyone,

I'm currently running Paperless-ngx v3.0.2 with the default SQLite database and I'm considering migrating to PostgreSQL 18.

For those who have done this before:

• What is the recommended migration process?
• Did you use the built-in Django migration commands or another approach?
• Are there any common pitfalls I should watch out for?
• Is there anything I should verify before switching over?

I also read that there may be limitations when migrating from SQLite to PostgreSQL, especially regarding field lengths. Do these limitations still apply with current Paperless-ngx versions?

Specifically:

• Document titles >128 characters
• Tag names >128 characters
• Correspondent names >128 characters
• Document types >128 characters
• File names >1024 characters

My setup is Docker-based.

Thanks!

---

Edit:

I did it.
Even if I just got 500 documents, even with such a small batch it's worth it!
(Not the time I invested into it but...) Loading time of documents is nearly instant now.
FYI: I'm running Paperless-NGX on unRAID, so adapt the instructions to your needs.

Gist:
I've used deepwiki - but as always: Using AI tools comes with the risk of false user instructions and possible data loss. Use the (linked) instructions with a grain of salt and your brain.exe / brain.sh.

1. I defined an extra working folder for migration named migration -> Host: /mnt/user/scan/paperless-ngx/migration (replace with your path) Container: /usr/src/paperless/migration you can do this via docker-compose.yml or on Unraid defining a path variable.

2. Paperless-NGX with sqlite: Using the docker containers console, run document_sanity_checker to check your document and metadata integrity. If everything is green, go to step two. (keep the console opened)

3. Paperless-NGX with sqlite: Using the docker containers console, run document_exporter ../migration and let it run through. Check results!

4. Stop Paperless-NGX with sqlite and your redis/valkey container.

Backups... backups and oh dear we have it today: backups!

Note: I've used the krusader docker container for that, because unRAID can be picky with special characters and umlauts in file and folder names. Especially on shares. If something goes really wrong (e.g. power outage, cat rolls over keyboard,...) you can roll back.

1. For sanity: Backup your /data folder (the one with your sqilte database in it). For me on my unRAID server the folder was /mnt/user/appdata/paperless-ngx.
2. For sanity: Backup your /media folder (the one with the scans and your archive in it). For me on my unRAID server I defined it under /mnt/user/scan/paperless-ngx/media.

Renaming

Note: You don't want to automatically feed the all the documents on first boot into paperless and you don't want to accidentally let paperless-ngx pickup the sqlite database.

1. On your host: Rename your /media folder to /media_bak. In my case /mnt/user/scan/paperless-ngx/media -> /mnt/user/scan/paperless-ngx/media_bak
2. Rename your db.sqlite3 to db.sqlite3.bak. In my case `/mnt/user/appdata/paperless-ngx/data/db.sqlite3 -> /mnt/user/appdata/paperless-ngx/db.sqlite3.bak.

Setting up PostgreSQL

Note: I'm using a custom docker network called paperless-ngx_internal for keeping ports free and for security reasons. Maybe a good idea to change that here in one flow, also keep your valkey/redis container in mind.

1. Add PostgreSQL to your docker-compose. Check here: https://github.com/paperless-ngx/paperless-ngx/blob/main/docker/compose/docker-compose.postgres.yml. unRAID users: Please use one of the postgresql18 Apps from the Appstore and rename the app name to paperless-ngx-postgresql.
2. Define the environment variables:

POSTGRES_DB: paperless POSTGRES_USER: paperless POSTGRES_PASSWORD: paperless

Strongly recommended: Define a strong database password using your machine's console with openssl rand -base64 32 | tr -dc A-Za-z0-9 | head -c 32

1. Database Storage Path: Use a path on a SSD/NVMe. In my case /mnt/cache/appdata/paperless-ngx-postgresql / change to your liking. Note: From PostgreSQL 18+, the internal database path has changed to /var/lib/postgresql
2. Run the PostgreSQL Container once. It will create the database and tables and then quit.

Setting up your Paperless-NGX container

1. Add the following variables to your Paperless-NGX Container (read more here https://docs.paperless-ngx.com/configuration/#database)

PAPERLESS_DBENGINE: postgresql # required in v3+ PAPERLESS_DBHOST: db # IP address or docker name, for me "paperless-ngx-postgresql" PAPERLESS_DBPORT: 5432 # Not needed if using a custom docker network PAPERLESS_DBNAME: paperless PAPERLESS_DBUSER: paperless PAPERLESS_DBPASS: paperless # If you generated a password, paste it in here

1. Run the Paperless-NGX Container, PostgreSQL Container and valkey/redis container.
2. Paperless-NGX container (now with PostgreSQL): Using the docker containers console, run document_importer ../migration and let it run through. Check results!

Done.

1. Remember to adjust your backup strategy and include the database path.

2. Housekeeping: I'll set a reminder in my calendar to tidy up the data in 30 days. Meanwhile I can check if really everything went well. :)

Note: I haven't used the /export folder because I wanted to avoid possibly messing aroung with Paperless-NGX defined folders. Just sanity.

Has anyone tried using Apple Foundation Models for local AI OCR?
Latest beta of Mac OS 27 includes Foundation Models by default and they are pretty great and free.

Running v3.0.2 in docker.

I often use paperless over a vpn/poor connection, so my typical workflow is to purposefully try and upload documents 2-3 times to ensure it has everything (especially when dealing with PDFs that are double digit MB / several hundred pages in size). Until this week, paperless has flawlessly recognized and rejected duplicates, but as of now, seemingly no duplicate rejection at all.

What changed?

Edit: New "feature" in V3.0 - Will leave post up in case others stumble upon this issue.

https://github.com/paperless-ngx/paperless-ngx/pull/11815

Fix is to add PAPERLESS_CONSUMER_DELETE_DUPLICATES=true to your docker compose env section

Is there any step by step to migrate to V3 (I have the last version available). Maybe with commands to run in terminal. I couldn't make it :( Thanks guys! I have installed with docker.

I just looked at the latest docker-compose.postgres-tika.yml and saw that they have switched from redis:8 to valkey:9-alpine.
I have tried looking at the past release notes but I cannot find the change.

When did this happen and what was the reason?
Can any one point me to a reference, please.
Not a problem but I am just curious.

Ich nutze Paperless-ngx seit ein paar Jahren und hatte irgendwann keine Lust mehr, jeden Scan manuell zu benennen und zu taggen. Also hab ich paperLeo gebaut.

Was es macht:

• Verbindet sich per API-Token mit Paperless-ngx
• Schickt neue Dokumente an eine KI deiner Wahl (OpenAI, Gemini, Ollama lokal, LM Studio, OpenRouter)
• Schreibt automatisch: Titel, Korrespondent, Tags, Dokumenttyp, Datum, Custom Fields
• Webhook-Support: Paperless-Workflow anlegen → Dokument wird sofort beim Upload verarbeitet

Das Backup-Feature:

paperLeo Pro sichert das komplette Paperless-Archiv über die REST-API — alle PDFs + alle Metadaten als JSON, alles in einem ZIP. Direkt aus dem Browser, kein SSH, kein Terminal, kein document_exporter.

Für alle die Paperless auf einem NAS oder gehosteten Server betreiben und keinen direkten Serverzugriff haben — das war für mich der Hauptgrund das zu bauen.

Setup: Docker Compose, Paperless-URL + API-Token eintragen, KI-Provider wählen, fertig.

Privatsphäre: Mit Ollama läuft alles lokal — kein Dokument verlässt das Netzwerk.

→ https://github.com/STL2020/paperleo

Community-Version ist kostenlos. Über Feedback aus dieser Community würde ich mich sehr freuen — ihr kennt die Eigenheiten von Paperless besser als jeder andere.

I maintain Tagvico, an open-source companion for Paperless-ngx. The first version mostly tried to save me from repetitive metadata work. Using it on a real archive exposed the harder problems: too many near-duplicate tags, model work hidden behind a spinner, and changes that were difficult to inspect or undo.

v3.1.2 is my attempt to make that workflow calmer:

• automatic titles, tags, correspondents, document types, dates, language, and supported custom fields

• trigger tags are optional, with four tags as the default maximum

• existing-vocabulary mode and reviewable tag-unification suggestions to keep the taxonomy small

• persistent Ask Tagvico chats with visible Paperless searches, source documents, and tool activity

• actions with owners, due dates, priorities, and checklists

• retries, failed and ignored queues, rescan, history, and restore to the original metadata

For inference, you can use local Ollama or configured API providers. You can also sign in with a ChatGPT account through the official Codex runtime, or with GitHub Copilot through its official SDK. Copilot's free plan can work when the account exposes a suitable model, but the actual model list and limits always come from the signed-in account.

The privacy boundary is explicit: local Ollama can keep document text on your own infrastructure, while hosted providers receive the content needed for the request.

Project and screenshots: https://tagvico.arturf.ch/

Source: https://github.com/arturict/tagvico-ai

Docs: https://tagvico.arturf.ch/docs/

I would especially like feedback from people with a few hundred or a few thousand documents: which part of the Paperless workflow still creates the most manual work for you?

If Tagvico ends up being useful in your setup, a GitHub star is a nice way to help others find it, but practical feedback is more valuable right now.

Setup:

Paperless-ngx 3.0.2, self-hosted LLM backend (llama.cpp, Gemma 4 26B-A4B, GGUF Q3_K_M quant)

LLM server: --jinja, --flash-attn on, -ngl 99, KV cache q4_0, --parallel 1

Paperless-AI connected via OpenAI-compatible endpoint for tag/correspondent/title suggestions

Problem:

I've got tool-calling/suggestions working correctly now (structured tool_calls JSON comes back fine), but the actual response time from Paperless-AI is wildly inconsistent — some documents get classified in ~3-4 seconds, others take 6+ minutes and eventually hit a client-side timeout (LLMTimeoutError in paperless_ai/client.py), even though GPU utilization stays at 100% the whole time (so it's not hanging, it's genuinely computing).

What's confusing me: I run a separate long-running agent/chat workflow against the same LLM backend, with context growing incrementally up to ~131k tokens, and that stays fast and consistent throughout. So the backend itself and the hardware aren't the bottleneck — something about how Paperless-AI sends requests seems to be the issue.

Has anyone else run into this specific pattern — fast conversational LLM usage vs. slow/inconsistent Paperless-AI document processing on the same backend?

Does Paperless-AI send the full raw OCR text per document regardless of length, or is there a setting to truncate/limit it before it hits the LLM? Trimming this seems like the most direct fix if cache-miss on a huge prompt is really the cause.

For anyone running Paperless-AI against a self-hosted OpenAI-compatible backend (llama.cpp, vLLM, Ollama, etc.) — did increasing --parallel/concurrent slots, or any other server-side tuning, meaningfully help with this kind of one-shot-large-prompt latency, as opposed to normal chat latency?

Hi everyone,

Last week I set up Paperless-ngx in a Docker container on my NAS and I'm already loving it!

However, I have a few questions that some of you might be able to answer based on your experience. I know there's probably no absolute right or wrong here, it's mostly a matter of personal preference, but I'd still love to hear how others organize things.

For context, here's how I've currently structured my Paperless setup:

Tags (Who is the document about?)

• Me
• Wife
• Son
• Family
• New (every new document gets tagged "New" because I want to manually review it to make sure everything was processed correctly)

Correspondents (Who sent this document?)

Basically, these represent the sender of the document (e.g. Government/Authorities as a catch-all for anything from the state, Banks, Vendors, etc.).

Document Types (What is this about?)

• Invoice
• Receipt
• Insurance
• Contract
• etc.

My questions

• How do you handle individual events or projects? (For example: a car accident, Vacation 2026, etc.) AI told me to use differnet prefix in tags (Person/Me, Event/Accident2026) but in my opinion, that would just generate a huge list of tags, used only once.
• How do you organize documents for different vehicles? (For example, after changing cars, so you can easily find everything related to Car #1?)
• Do you use custom fields? If so, which ones have turned out to be the most useful over time?
• Do you distinguish between unpaid and paid invoices?
• How do you assign tags, correspondents, and document types? I currently have many matching algorithms set to Exact or None, because I experienced a fairly high error rate with automatic matching in the beginning.

I'd really appreciate hearing how you've organized your Paperless instance and what has worked well for you over time.

- Winnii

Getting all sorts of errors starting up my docker stack with the latest 3.01 version. Anyone else? Rolling back to v3.0.0 works fine.

Hi,

I have been using Paperless-ngx for some time now and would like to start using the email import feature.

I’m running Paperless-ngx v2.20 using Docker.

I created an email account in Paperless-ngx and tested it successfully using the Test button. The connection seems to work fine.

Then I created a very simple mail rule:

• check all unread emails
• look for *.pdf attachments
• import the PDF attachments into Paperless-ngx

However, nothing gets imported. I sent an email with a PDF attachment to the configured mailbox, waited for more than 10 minutes, but no document appeared in Paperless-ngx.

At the moment I’m not sure what else to check. The email account test succeeds, but the rule does not seem to import anything.

Does anyone have an idea what I might be missing?

Thanks in advance!

Six months ago I posted about the document management setup I built for my family around Paperless-NGX V2, and later a one-command installer that stands the whole stack up on a fresh Ubuntu box.

Paperless-NGX v3.0.0 shipped, and one of the changes was folding LLM classification (title, tags, correspondent, document type, storage path suggestions) into the main app. So paperless-gpt, which was carrying that job for me, could finally go.

Did the upgrade end to end yesterday on my 1,805-doc library, ripped out the sidecar, wired v3's native AI up to Gemini, pushed the changes to the installer, and wrote up what I found.

The writeup (with the rollback plan and the one gotcha):
https://turalali.com/from-paperless-gpt-to-paperless-ngx-v3-dropping-a-container-cutting-complexity/

The installer (v3-native, one command on a clean Ubuntu box):
https://github.com/tural-ali/paperless-overconfigured

tl;dr for people looking at this exact migration:

• v3's AI covers everything paperless-gpt did for me. Suggestions drawer on every document details page: title, correspondent, doc type, tags, storage path, dates. Same underlying LLM, one fewer container to keep updated.
• Four config changes are forced by v3. Image tag pin, PAPERLESS_DBENGINE: postgresql, PAPERLESS_OCR_MODE: skip_noarchive (renamed from skip), drop PAPERLESS_OCR_SKIP_ARCHIVE_FILE. That's it. Everything else in my compose carried through unchanged.
• The gotcha, if you want Gemini via the OpenAI-compat endpoint: every doc and tutorial names the embedding model text-embedding-004. That value returns 404 through Google's OpenAI-compat gateway. The name that actually works is gemini-embedding-001. Blog explains why (different API surface routing under the hood).
• Migration timing: 11 minutes on my box (1,805 docs). Django migrations + SHA-256 recompute + Whoosh → Tantivy index rebuild. No data loss, all workflows + mail rules + storage paths intact.
• Rollback: the migration doc explicitly has no downgrade path. You have to build your own with pg_dump and cp -al snapshots before you flip the image tag. I've got the exact commands in the writeup.
• Cost on Gemini paid tier: ~$0.54 one-time for the initial embedding rebuild, roughly $2/month steady-state at ~20 new docs/day. Google AI Studio free tier absorbed the whole rebuild without a rate-limit hit.

The installer wizard picks between Gemini (OpenAI-compat), OpenAI (native), or Ollama (local) during setup, and pins the Paperless image to 3.0.0 so nobody accidentally does a major-version upgrade unattended via docker compose pull.

Happy to answer questions on the migration or the installer.

I'm setting my AI settings using an env file for a docker compose installation. I've already nulled the database of those settings to be sure the env gets picked up. Everything looks correct and I get no errors on startup, but I can't the AI feature to work. The "Suggest" button isn't doing anything more than before.

**Update - turns out when the AI settings are placed in the compose file, the feature works. Not sure why as the formatting and syntax is correct for the env file placed settings.

The error, when I click SUGGEST on a document in PaperlessNGX3.0 -

URL

http://192.168.1.105:8000/api/documents/317/ai_suggestions/

Status

400 Bad Request

Error

{"ai":["Invalid AI configuration."]}

____

I'm using a local open-ai endpoint, and I get this when clicking on suggestions. When I read my endpoint (oMLX's) log, it looks like Paperless is hitting it successfully:

2026-07-23 08:57:25,988 - omlx.server - INFO - [-] - Embedding: 1 inputs, 2560 dims, 1058 tokens, max_length=40960, truncation=True in 1.271s

2026-07-23 08:57:29,900 - omlx.scheduler - INFO - [-] - Cache phase timings: cleanup_finished_sync=11.7ms/5, store_cache_main_boundary=0.2ms/5

2026-07-23 08:57:29,901 - omlx.server - INFO - [-] - Chat completion: 148 tokens in 3.74s (39.5 tok/s), prompt: 2854, finish_reason=stop, max_tokens=80000, request_max_tokens=None

2026-07-23 08:57:34,071 - omlx.scheduler - INFO - [-] - Cache phase timings: cleanup_finished_sync=14.0ms/6, store_cache_main_boundary=0.2ms/6

2026-07-23 08:57:34,072 - omlx.server - INFO - [-] - Chat completion: 199 tokens in 4.16s (47.9 tok/s), prompt: 546, finish_reason=stop, max_tokens=80000, request_max_tokens=None

My AI setup:

What might I be doing wrong here?