Paperless-ngx Demo: Try the Public Instance, Then Test It on Your Own Documents
The official Paperless-ngx demo lives at demo.paperless-ngx.com. The project README gives the login as demo / demo and warns that the content is reset frequently and that confidential information should not be uploaded. That is enough to click through the interface, see how tags, correspondents, document types, and saved views relate to each other, and decide whether the layout suits you.
What the demo cannot show you is how Paperless-ngx handles your paperwork: your scanner’s output, your languages, your messy phone photos, and the correspondents you deal with every month. For that you need a private trial, and the official Docker Compose files make one quick to start and easy to throw away. This guide covers both steps and gives you a short test plan so the trial ends with a real decision.
What the public Paperless-ngx demo is good for
The demo is a shared, community-hosted instance. The README currently credits Fyra Stack for hosting it. Everyone logs in with the same account, so treat it as a showroom:
- Learning the vocabulary. Paperless organizes documents with correspondents, document types, tags, storage paths, and custom fields. Seeing them on sample documents makes the official docs much easier to read later.
- Trying search and filters. Full-text search, the filter bar, and saved views on the dashboard behave the same way they will on your server.
- Checking the document view. You can open a document, look at its metadata and extracted text, and see how the original and the archived PDF are presented.
Its limits follow from being shared and reset:
- Other visitors change the same data you are looking at, so a tag you created can vanish or be renamed.
- You learn nothing about OCR quality on your documents, and you should not upload them to find out. The project’s own README goes further about hosting in general: Paperless-ngx should never be run on an untrusted host, because information is stored without encryption.
- Performance there says little about your hardware. A Synology NAS or a small mini PC processes a 40-page scan at its own pace.
- It is a volunteer-hosted service. If it is slow or unreachable, skip ahead to the local trial, which takes about as long as waiting.
A throwaway local trial with Docker Compose
The installation docs offer an interactive install script and a set of Docker Compose templates. For a trial, the templates are easier to reason about and to remove afterwards. You need Docker with the Compose plugin on a Linux machine, a Mac, or Windows with Docker Desktop.
The project ships several compose files in its docker/compose folder: SQLite, PostgreSQL, and MariaDB variants, each with an optional -tika version for Office documents and email. For a trial, the SQLite file has the fewest moving parts. For the server you keep, the docs recommend PostgreSQL.
mkdir paperless-trial && cd paperless-trial
base=https://raw.githubusercontent.com/paperless-ngx/paperless-ngx/main/docker/compose
curl -fsSL -o docker-compose.yml "$base/docker-compose.sqlite.yml"
curl -fsSL -o docker-compose.env "$base/docker-compose.env"
curl -fsSL -o .env "$base/.env"
Open docker-compose.env before starting. Three lines matter for a trial:
# required: replace the placeholder with a random value
PAPERLESS_SECRET_KEY=paste-a-long-random-string-here
# your local time zone, so dates are not shown in UTC
PAPERLESS_TIME_ZONE=Europe/Bucharest
# the main language of your documents (Tesseract code)
PAPERLESS_OCR_LANGUAGE=eng
The comment in the file suggests generating the key with python3 -c "import secrets; print(secrets.token_urlsafe(64))". The container already includes English, German, Italian, Spanish, and French language data. If your documents use another language, add it with PAPERLESS_OCR_LANGUAGES as well; the Paperless-ngx OCR guide explains the difference between the two language settings, which trips up a lot of first installs.
Then start it:
docker compose pull
docker compose up -d
Open http://127.0.0.1:8000. On first access the web interface asks you to create a superuser. The compose file mounts ./consume and ./export next to it, so dropping a PDF into consume is the fastest way to feed documents in. You can also drag files onto the web interface.
If you want to try it on a NAS instead, the Paperless-ngx on Synology guide covers Container Manager. That is a reasonable trial too, as long as you test on the hardware you plan to keep.
A 30-minute test plan with real documents
A trial with three sample PDFs tells you very little. Pick 20 to 40 documents that represent your actual mix, and keep anything you would be uncomfortable losing out of the trial until you trust the setup:
- Five clean digital PDFs (invoices or statements downloaded from a portal). These should arrive with perfect text.
- Ten scanner output files at your usual settings, including at least one multipage document and one double-sided one.
- Five phone photos of receipts or letters, taken the way you would really take them.
- A few documents in each language you deal with.
- Several documents from the same three or four correspondents, so matching has something to learn from.
Then check these, in this order:
- Text quality. Open each document and read the extracted content against the page. Search for an invoice number, a surname with an accent, and a total. Words you can see but cannot find point to a language or OCR mode problem, covered in the Paperless-ngx OCR settings guide.
- Processing time. Note how long the multipage scan takes from drop to searchable. On weak hardware this is the number that decides whether people keep using it.
- Matching. Assign correspondents and document types by hand on the first few, then let the automatic matching suggest them for the rest. If it guesses poorly with this little data, that is normal; try an Exact or Any rule on a word that always appears, as described in our Paperless-ngx tips.
- An inbox tag and one saved view. Create a tag every new document gets, and a dashboard view that lists documents still carrying it. If that review loop feels natural, daily use will too.
- Getting files back out. Download an original and an archived version. Run an export to confirm you understand the backup format:
docker compose exec -T webserver document_exporter ../export
The exporter writes originals, archive files, and a manifest.json with your metadata into the export folder on the host. Seeing that folder is the best answer to the question of lock-in.
What a good trial result looks like
By the end you should be able to answer a few concrete questions. Did printed documents come out with text you can search reliably? Did the hardware keep up with a realistic batch? Could you set up one review loop without fighting the interface? And did the documents that went badly have something in common?
That last question is the useful one. Tesseract, the OCR engine Paperless uses through OCRmyPDF, does well on clean printed pages and poorly on handwriting, faded thermal receipts, dense tables, and photos taken at an angle. Tuning helps up to a point. If your weak results cluster on those document types, you have learned something the public demo could never have told you, and you can plan for it before migrating years of paper. Our article on why OCR is so bad on some documents goes through the causes.
Paperless has two ways to route those documents elsewhere. One is its built-in remote OCR option. The other is a workflow webhook to an external service, which is how OCRskill connects: Paperless keeps its local text layer for search, and OCRskill reads the page with a vision model and returns the document type, correspondent, date, and fields that Paperless stores as metadata. The Paperless-ngx archive tutorial walks through that setup. It is worth testing during the trial with the documents that failed, not the ones that already worked.
Removing the trial or keeping it
To remove everything, including the database and stored documents in Docker volumes:
docker compose down -v
cd .. && rm -rf paperless-trial
Without -v, Docker keeps the named volumes, which is what you want if you plan to come back to the trial.
If the trial goes well, resist the urge to promote it as-is. Build the permanent instance deliberately: PostgreSQL as the database, bind mounts for consume, media, and export on storage that is backed up, the languages you confirmed, and a storage path decided before the archive grows. The paperless archive guide covers retention and backup decisions that are easier to make now than after 5,000 documents. Then import or simply re-consume the trial documents. The demo showed you the interface; the trial showed you your documents. The permanent install is where you apply what both taught you.
