Paperless NGX: The Self-Hosted Document Archive That Reads Your Paperwork So You Never Have To

"The most sensitive data you own isn't in the cloud — it's in the shoebox of receipts and the drawer of tax forms. Paperless NGX reads all of it and tells nobody."

There is a particular drawer in most homes that contains tax returns, insurance policies, medical correspondence, mortgage documents, and seven years of receipts nobody has looked at twice. Commercial document management systems will happily solve this for roughly $50 per user per month, on their servers, under their terms. Paperless NGX (GitHub: paperless-ngx/paperless-ngx) solves it for free, on your hardware. It ingests scanned and digital documents, runs OCR so the text becomes searchable, applies machine learning to tag and classify them, and gives you a searchable archive you control. As of August 2026 it carries roughly 45,000 stars, ships under GPL-3.0, released v3.1.0 on August 27, 2026, and has no paid tier, no enterprise upsell, and no vendor at all. For a blog about software you run on your own machine, it's one of the most immediately useful: it solves a real problem in an afternoon and keeps the most sensitive paperwork you own off someone else's disk. This is the honest breakdown — how the OCR and classification pipeline works, what v3.1.0 actually changed, what it really costs, and the two architectural realities (clear-text storage and a bus factor of 1) that you need to plan around rather than discover later.

1. What Paperless NGX Is (and Isn't)

Paperless NGX is a document management system. You feed it documents — scans from a scanner, PDFs from an email, photos of receipts — and it produces a searchable, tagged, permanently archived library. It is the actively maintained successor to the original Paperless project, deliberately restructured from a single-maintainer model into a distributed community effort to reduce abandonment risk. What it is not is a file sync tool, a note-taking app, or a general-purpose archive. It is opinionated about documents: it wants to know who sent it, what type it is, when it arrived, and what's inside it. That structure is what makes search actually work — you're not grepping filenames, you're querying full text plus metadata. The project's scope discipline shows in what it doesn't do: no paid tier, no feature gating, no vendor. Every capability is available to anyone who can run Docker. In a category where competitors meter per user and per document, that alone is remarkable.

2. The Pipeline: Scan → OCR → Classify → Search

Understanding the pipeline explains both the magic and the resource requirements. 1. Ingestion. A document appears in the watched "consume" folder, arrives via email, or is uploaded through the UI. 2. OCR. Tesseract extracts text, supporting 100+ languages. This is the step that turns a picture of a receipt into searchable content — and the step that costs real CPU. 3. Archival. The document is stored in PDF/A format (the ISO-standardized archival variant of PDF) alongside the original, so you keep both a long-term preservation copy and the untouched source. 4. Classification. Machine learning suggests a correspondent, document type, and tags based on what it has learned from documents you've already filed. This is why the system gets better the longer you use it. 5. Indexing. Full text plus metadata go into the search index, and the document becomes findable instantly. The classifier is the quiet hero. After you've manually tagged a few dozen invoices, Paperless starts recognizing the next one on its own. Combined with workflows — rules that fire on matching documents — you can reach a state where dropping a scan in a folder results in it being OCR'd, tagged, dated, and filed without you touching anything.

3. Why Local Matters More Here Than Almost Anywhere

Most self-hosting pitches argue about convenience or cost. Paperless NGX's argument is different, because of what the data is. Think about what goes into a document archive: tax returns with income figures, medical correspondence, insurance claims, contracts, identity documents, bank statements. This is arguably the highest-sensitivity, lowest-volatility data a household or small business possesses — the stuff you keep for seven years precisely because it matters. Handing a copy of all of it to a SaaS document service is a materially different decision from storing your photos in a cloud album. Running it locally means: no vendor has a copy, no breach of a third party exposes your archive, no subscription price change forces you to migrate seven years of records, and the archive keeps working when the internet doesn't. There's also a longevity argument — PDF/A plus plain files on your disk is a format that will still be readable in twenty years, which is more than most proprietary DMS exports can promise.

4. Getting Documents In

The ingestion paths are what make it livable day to day:

• Consume folder — point a network scanner (or a phone scanning app writing to a synced folder) at it and documents appear automatically. This is the classic setup.
• Email ingestion — give it an IMAP mailbox and rules; anything sent to that address gets filed. Excellent for digital bills and statements.
• Web UI / drag and drop — for everything else.
• Bulk upload — for the initial migration of an existing folder of PDFs.

The initial bulk import is the emotional payoff moment. Feeding years of accumulated PDFs into the consume folder and watching them come out OCR'd, dated, and searchable is the kind of before-and-after that converts people to self-hosting permanently.

5. The AI Features (and Keeping Them Local)

Recent releases have added genuine AI assistance, and v3.1.0 (August 2026) made them considerably more useful:

• Auto-apply AI suggestions as a workflow action — previously AI suggestions for tags, correspondents, and document types had to be clicked through one by one; now they can be applied automatically on consumption. This is the difference between "the AI made a guess" and "the document is filed."
• Local embeddings via Ollama — you can point the AI pipeline at your own local model instead of a third-party API, keeping the entire classification pipeline on your hardware.
• AI suggestions prefer existing metadata — the engine now favours your existing tags and correspondents rather than inventing near-duplicates, which cuts down on tag sprawl.
• Selective remote OCR — route only certain document types to a cloud OCR engine if you want higher accuracy on hard scans, while keeping everything else on local Tesseract.

That last point is worth pausing on: the project gives you the choice of where inference happens, and defaults to local. For a blog about AI you can run on your own machine, that's exactly the right design — AI assistance without surrendering the data to get it. Under the hood, the AI vector store moved from LanceDB to sqlite-vec during the v3.0 cycle, which simplified deployment (one fewer component to run) at the cost of a migration for early beta users.

6. The Cost, Honestly

Software: $0, GPL-3.0. No seat pricing, no document limits, no enterprise tier. Full feature set for everyone. Hardware: it runs on a Raspberry Pi for light personal use, though OCR is CPU-intensive — a Pi will chew through a large backlog slowly. A small mini-PC or spare server handles a household comfortably. If you already run a Docker host, the marginal cost is essentially storage plus electricity. Storage: plan for it. Scanned documents plus PDF/A archives plus thumbnails add up — a serious archive is comfortably in the tens of gigabytes, and grows every year. Use real disks and back them up. Your time: moderate upfront (Docker Compose setup, then the initial bulk import and cleanup), then genuinely low ongoing. Once workflows and the classifier are trained, the system mostly runs itself. This is one of the better time-to-value ratios in self-hosting. Against commercial document management at roughly $50/user/month, a household or small office saves a meaningful amount annually — but as always, the real reason is ownership, not the subscription.

7. Honest Limitations

These are the two that matter most, and they're largely absent from marketing copy:

• Documents are stored in clear text. This is an architectural decision, not a bug. Paperless NGX does not encrypt documents at rest at the application layer. If your disk isn't encrypted, your archive isn't either. For regulated data (GDPR, HIPAA, or simply "I don't want this readable if the server is stolen"), you must provide encryption at the infrastructure level: encrypted volumes, encrypted database storage, encrypted backups, and network segmentation. The compliance burden sits entirely with the operator.
• Bus factor of 1. Despite 450+ contributors, the commit distribution shows one dominant maintainer carrying the majority of recent work. The project is healthy, ships weekly, and was deliberately restructured to spread responsibility — but continuity ultimately rests on a small group of volunteers. There is no legal entity, no SLA, and no contractual support.

Other real constraints:

• No built-in SSO or encryption at rest. Multi-user RBAC exists; OIDC group-to-role sync arrived in v3.1.0, but there's no turnkey enterprise identity story.
• OCR quality depends on source quality. Faded thermal receipts and handwritten notes will disappoint. Tesseract is good, not magic.
• Backups are on you — and they need to be encrypted because of the clear-text storage point.
• Resource spikes during bulk OCR. Importing a decade of scans will peg your CPU for a while.
• The v3 UI overhaul changed a lot at once; long-time v2 users should expect a re-learning period.

8. Getting Started

``bash

the official install script is the fastest path

bash -c "$(curl -L https://raw.githubusercontent.com/paperless-ngx/paperless-ngx/main/install-paperless-ngx.sh)"

or use Docker Compose with the provided postgres-backed template

`` Then: (1) change the admin password immediately, (2) set up the consume folder, (3) import a small batch first to sanity-check OCR and language settings, (4) tag those documents manually so the classifier has something to learn from, (5) create workflows for recurring document types, (6) only then do the big backlog import. That order prevents the classic mistake of dumping 5,000 documents in at once and then having to re-tag all of them.

9. Paperless NGX vs the Alternatives

| | Paperless NGX | DocuWare (SaaS) | Nextcloud (files) | |---|---|---|---| | Cost | $0 | ~$50/user/mo | free self-hosted | | OCR | ✅ Tesseract, 100+ langs | ✅ bundled | via app | | ML classification | ✅ | ✅ | ❌ | | Data location | your disk | vendor cloud | your disk | | Encryption at rest | ❌ (infra-level only) | ✅ | ✅ optional | | Enterprise SSO | limited (OIDC in v3.1) | ✅ | ✅ | | Self-hostable | ✅ | ❌ | ✅ | The short version: for sovereignty-focused individuals and small teams who can handle infrastructure-level encryption, Paperless NGX is the most capable self-hosted document system available. Commercial platforms win on compliance certifications and support contracts. Nextcloud is a file sync platform — it can hold documents, but it won't OCR and classify them.

10. Who Should Run It

Run it if: you have a drawer or folder of paperwork you'd rather never dig through again, you want your most sensitive documents on hardware you control, you have recurring documents (bills, statements, receipts) that would benefit from automatic filing, or you simply want a searchable archive of your household's history. Skip it if: you need certified compliance with encryption at rest and audit trails out of the box, you require contractual vendor support, or your source documents are mostly handwritten and you expect OCR miracles. For this blog's readers — the ones already running Immich for photos, Vaultwarden for passwords, and a Docker host for everything else — Paperless NGX completes the picture. Photos, credentials, and paperwork: the three things you'd least like to lose or leak, all on hardware you own.

11. A Real Setup Walkthrough

Step 1 — pick PostgreSQL over SQLite if you expect more than a casual archive. The Compose template supports both; Postgres handles concurrent writes and larger libraries better. Step 2 — set the OCR language correctly before the first import. Re-OCRing a large archive because you forgot your documents aren't English is a tedious afternoon. Step 3 — train the classifier with a small batch. Import 20–30 documents, tag them properly, and let the model learn. Skipping this means the AI suggestions start from nothing. Step 4 — build workflows for the recurring stuff. "If the document contains 'Invoice' and the correspondent is the electricity company, tag it utilities and set the document type." A handful of these handles most of the ongoing flow. Step 5 — encrypted, off-box backups. Because the documents are clear text on disk, your backup encryption is the only encryption. This is not optional. Step 6 — then do the backlog. With the classifier trained and workflows in place, the big import mostly files itself.

12. Troubleshooting

• Documents sit in "processing" forever — usually a resource ceiling or a stuck consumer queue. Check container logs; OCR on a low-RAM host is the usual culprit.
• OCR output is garbage — wrong language pack, or a low-resolution source scan. Re-scan at 300 DPI or better.
• Search doesn't find text you can see — the document may have been indexed before OCR completed, or it's a scanned image without a text layer.
• Mail rules stop fetching — IMAP credential or folder config; v3.1.0 added jitter to polling, which helps if you're sharing a mailbox with other automation.
• Disk fills up — originals plus PDF/A plus thumbnails. Review retention and prune the thumbnail cache.
• AI suggestions create duplicate tags — v3.1.0 improved this by preferring existing metadata; make sure you're on a recent build.

13. What's Actually on Disk (and Why It Matters)

Understanding the storage layout explains both the disk growth and the exit plan. For each document, Paperless NGX keeps:

• The original file exactly as it arrived — untouched, so you always have the source of truth.
• An archived PDF/A copy — the long-term preservation format, with OCR'd text embedded as a text layer so the file is searchable even outside Paperless.
• A thumbnail for the grid view.
• Metadata — correspondent, tags, document type, dates — stored in the database.

That redundancy is deliberate and it's why imports roughly double your raw file size. Plan storage accordingly, and know that scanning at unnecessarily high DPI is the fastest way to waste it: 300 DPI is plenty for text documents, and going to 600 doubles the size for no OCR benefit. The more important consequence is the exit plan. Because the archive is plain files plus a database, you are never trapped. Even if you abandoned Paperless entirely tomorrow, you'd have a folder of PDF/A files with embedded text layers, searchable by any tool that understands PDF. That's a fundamentally different position from a proprietary document service, where leaving means an export in a format you now have to reverse-engineer, or worse, a pile of PDFs with no searchable text at all because the OCR lived in the vendor's index rather than in your files.

14. The Exit Plan, Made Concrete

The built-in document exporter writes your entire archive to disk in a structured, readable form — documents with sane filenames, plus a manifest of metadata. It's the feature that makes "no lock-in" a fact rather than a claim, and it's worth testing early rather than assuming. Run a test export in your first week. Confirm you can find a specific document in the export by filename, that the PDF opens with searchable text (try Ctrl+F on a phrase you know is in it), and that the metadata manifest makes sense to you. Ten minutes of verification now means you never have to wonder whether your seven-year archive is portable. Then back that export up — encrypted, off-box, alongside your database dump. Given that documents are stored in clear text, your backup encryption is the only encryption. That sentence deserves repeating, because it's the single most consequential operational fact about running this software.

Related

• Immich: The Self-Hosted Google Photos Alternative That Keeps Your Memories on Your Own Disk — photos sorted; Paperless does the same for paperwork.
• Supabase: The Open-Source Firebase Alternative That Hands You a Real Postgres Database — the database layer if you want to build on top of your archive.
• Home Assistant: The Open-Source Smart-Home Hub That Keeps Your Data on Your Own Hardware — because the scanner that feeds your consume folder probably lives in your smart home.