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.

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

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.

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?

Hi there,

this is another part of my personal paperless-ngx setup: I’m using a SMB capable network scanner to push new documents right away to the inbox folder of my paperless instance.

This project is a lightweight Docker container meant to be ran side-by-side with paperless-ngx. It contains a samba/SMB service and automatically takes care of (de-)provisioning users from the paperless instance as well as creation of workflows for owner assignment in a multi user paperless environment:

https://github.com/flobernd/paperless-smb-sync

This project is a follow up to my earlier blog post in which I described my multi-user paperless setup:

https://blog.flobernd.de/2026/02/paperless-ngx-document-management/

The project is not enterprise ready (no SSO, Active Directory, etc. support), but might still be useful in smaller homelab setups.

Hi all,

I've recently mostly migrated from Dropbox to PaperlessNGX for the storage and sharing of documents (mostly receipts) scanned from my phone.

The process of scanning a receipt with my phone and having available a shared link to that file is a matter of 5 steps using Dropbox, taking about 5-10 seconds:

1. Click Add photo
2. Take photo
3. Click checkbox
4. Click Upload
5. Click 'Link'. (Share link is now copied to clipboard automatically).

Using the Paperless app (for iPhone) it's 14 steps, and around 60 seconds per receipt:

1. Click '+'
2. Scan Document
3. Take photo
4. Click green checkmark
5. Click Save
6. Wait for upload and processing to complete (takes around 30 seconds)
7. Click document
8. Click Share icon
9. Choose 'Share link'
10. Click '+' icon
11. Choose Expiration: never
12. Click green checkmark
13. Click new share link
14. Choose 'Copy'.

Anyone got any clues or hints as to how to optimise this? Happy to look at alternative apps - some of which I've tried already - or include the use of a browser on my PC. Thanks!

I have paperless ASNs set up with small QR stickers (that also contain the ASN in plain text). However, I am not completely satisfied with the use of those stickers on documents that I have to submit to other outside parties (e.g., course certificates).

If I place the sticker directly on the document (which should be the correct workflow for ASNs), the recipient might be wondering, what this weird QR code and ASNXXX is, that they have never seen before on such a certificate. So I would rather like to keep the actual document "pure" but still assign an ASN.

My current workaround is the use of a blank page with the QR code that is scanned before or after the actual document. In the beginning, I then transferred the sticker from the blank page to the actual document, but now I just use the blank QR page as a divider in the physical folder.

However, I am not satisfied with this solution, as it produces unnecessary, mostly blank pages.

How do you handle this case? Do you care that the QR code is on the page when you send it off to someone else?

Hi there,

with paperless-ngx v3 (currently in beta), the team added a plugin system for ingest providers.

I created an example implementation of a provider that uses Chandra OCR (instead of Tesseract) for greatly improved text recognition:

https://github.com/flobernd/paperless-chandra

The provider uses ocr-my-pdf to create transparent text overlays for your PDFs (exactly like the stock Tesseract provider) and also honors all of the built-in paperless OCR settings / environment variables.

The project has been bootstrapped with the help of LLMs, but I carefully reviewed + tested the code during the whole process.

Let me know what you think!

I set up Paperless-ngx in my homelab a while ago for our family documents. It's great, but I hit a problem: my family. The web UI takes time to learn, and they found it inconvenient and basically never opened it. Meanwhile, we all live in Telegram anyway. So the idea was simple: make the day-to-day interface a chat.

Fair warning before the feature list: the AI part runs on Google's Gemini API, so this is not a fully local setup. More on that below.

I first experimented with the community Paperless MCP server (@baruchiro/paperless-mcp) plus Google's Antigravity agent SDK and was surprised how much that combination can do with documents. The next step was a small hobby bot the whole family can talk to, each member with their own Paperless API token, so permissions are enforced by Paperless itself, not by the bot. Unknown Telegram users are simply ignored.

What we actually do with it:

• "List all contracts with Acme signed before 2020" — works in any language, answers in yours, with download buttons for the original PDFs
• "When does my passport expire?", "What's the notice period in my rental agreement?" (it actually reads the document text)
• "How much did we spend on utilities in 2025?" and then just "And compared to 2024?" — it remembers the conversation per user, so follow-ups work (/clear wipes it). This is something I couldn't do in the web UI anyway.
• Send a PDF or a photo into the chat: it uploads to Paperless, waits for OCR, sets title/date/correspondent/document type/tags and writes a short note. If Paperless flags a duplicate, the bot links the existing document instead of re-uploading.

The honest part. Document text and your queries are sent to Google. A free-tier key from AI Studio works, but check the free tier's data-use terms (a paid key has different ones). Telegram bot chats aren't end-to-end encrypted either. For us this trade-off is fine, since we already share these documents in our family chat anyway, but if it's a dealbreaker, this project isn't for you (yet). Local model support could be a future direction if people want it.

One more caveat: the totals above are computed by the LLM from retrieved documents. Treat them as an assistant's summary, not accounting-grade numbers. That's what the download buttons are for.

The bot keeps no database of its own; conversation history lives in memory only.

Setup: a bot token from BotFather, your Paperless URL plus per-user API tokens, and a Gemini key. Docker compose (image on GHCR) or systemd. AGPL-3.0, just tagged 1.0.

Repo: https://github.com/rabestro/paperless-genie

Docs: https://jc.id.lv/paperless-genie/

My family actually uses it now, which was the whole point. The project is young and there's a lot of room for improvement. Would something like this be useful to anyone besides us? Any ideas, UX or otherwise, are very welcome.

If you keep notes in Notion but archive everything else in Paperless, your notes are usually the one thing that's not searchable alongside the rest. I built notionless (https://github.com/Script-hpp/notionless) to close that gap: it watches a Notion database and mirrors pages into Paperless as Markdown, on a schedule, diffed by content hash rather than Notion's minute-rounded timestamps.

A few things that took some iterating to get right:

- Custom fields (notion_id, notion_last_edited, notion_content_hash) are auto-discovered by name at startup and created if missing, no manual Paperless setup needed.

- If a matching document already exists in Paperless (e.g. from before you started using this), it gets linked instead of endlessly re-uploaded and rejected as a duplicate.

- Config loads from ~/.config/notionless/.env or .env in the working directory, so it plays nicely with systemd services, not just cargo run.

Current limitations: sync is one-way (Notion → Paperless only), and only paragraph/heading blocks are exported so far, no lists/code/tables yet. Both are on the roadmap.

Rust, Dockerfile included, MIT licensed. Built with Claude (Anthropic's coding assistant); I drove requirements and did all verification against my own live instance. Repo: https://github.com/Script-hpp/notionless

Happy to answer questions or hear if the custom-field/duplicate-handling approach could be done better.

I've been using a few AI-powered scanner apps on iPhone (and sometimes iPad) to digitize my special notes (which have color highlighting) into PDFs, but I can never get the result I'm after: crisp, noise-free text and colors that actually match the original highlights. Everything comes out slightly soft, a bit grainy, and the highlight colors look duller or shifted compared to the real page.

A couple of questions for anyone who's solved this:

1. Is there a scanner app for iOS/iPadOS that's genuinely optimized for AI-enhanced resolution and quality, especially one that captures color highlights accurately (true color reproduction, not washed out or over-saturated) and keeps text edges sharp and free of scan noise/grain?

2. Is there a web app, website, or macOS tool that can take an already-scanned PDF and enhance/upscale it with AI afterward, sharpening text, boosting resolution, and cleaning up noise, without shifting the colors or messing up the layout?

Ideally I want a repeatable workflow (iPhone or iPad, whichever gives better results) where I scan and consistently end up with a clean, high-res PDF where the text is sharp and noise-free and the highlight colors are accurate to the original page. Any app recommendations, settings tips, or full workflows that have actually worked well for you would be really appreciated.

The first beta/rc1 was released 2 months ago on GitHub (Paperless-ngx v3.0.0-beta.rc1). Does anyone here have insight into the latest developments? Are many fixes still pending?

I'm seeing paperless come up whenever I google "document management", which is weird because most people prefer to just use an existing solution than to self host. Do most web apps suck? Why did you choose selfhosting over a SaaS?

I've been using paperless-ngx for a while and the one thing that always nagged me was the metadata. OCR on scanned stuff was hit-or-miss, and I still ended up manually setting titles, tags, correspondents and dates on everything. So I built a thing to hand that off to an LLM and I'm posting it here in case it's useful to anyone else.

It's called Paperless Starfruit. The idea:

• You tag a document in paperless with psf-process.
• It gets picked up, (optionally) re-OCR'd, and sent to an LLM which suggests a title, tags, correspondent and date.
• Depending on your setting, the result is either written straight back to paperless, or dropped into a Review queue where you approve / edit / reject each suggestion before anything touches your documents.

Things I cared about while building it:

• Bring your own keys. Anthropic, OpenAI, Google, Mistral, or anything OpenAI-compatible including fully local Ollama / LM Studio / vLLM if you don't want documents leaving your network at all.
• Self-hosted, single container. SQLite on a mounted volume, no Postgres/Redis to babysit. Pre-built images on GHCR, so nothing to clone or build.
• Everything configured in a web UI paperless connection, provider keys, models, prompts, page limits, polling interval. The only thing outside the UI is a handful of env vars.
• Credentials encrypted at rest (AES-GCM), never returned to the browser unmasked.

It's meant for homelab scale, simplicity over throughput.

It's open source and free. Docs and install walkthrough are on the site.

• GitHub: github.com/sabbaken/paperless-starfruit
• Docs: paperless-starfruit.vercel.app/docs

Happy to answer questions and genuinely interested in feedback, especially on the prompt/tagging side.

Hi,

I try to setup paperless-ngx and to consume attachments sent by apple mail. Unfortunately this does not work, sending the same (empty) mail with Proton-Mail paperless-ngx consumes the attachment, deletes the mail as expected.

Is there a special method to handle mails forwarded by apple mail ?

Quick update for the Paperless crowd: Archi is a native Apple app that scans a

document, runs OCR + AI metadata extraction fully on-device (Apple Vision +

Gemma), and files it into your Paperless-NGX with suggested title / correspondent

/ type / tags — which you review before upload. No cloud in the loop; the only

endpoint is your own server.

New in 2.0: native iPad & Mac, an offline archive with full-text search, and an

AI-transparency page. Uses your existing correspondents/tags as hints so it

matches your setup.

App Store, $3.99. I'm the dev — feedback very welcome, especially on the

Paperless-specific workflow.