Paperless-ngx vs Documenso (2026)

Two Different Document Problems

"Document management" covers two distinct problems that are often confused:

1. Document archival: "Where did I put that invoice from 2023?" — organizing, searching, and retrieving documents you've received or created
2. Document signing: "I need this contract signed" — collecting legally binding electronic signatures on documents

Paperless-ngx solves the first. Documenso solves the second. You might need both, or just one.

Paperless-ngx — The Document Archive

Paperless-ngx (37K+ GitHub stars) is the most popular open source document management system. It's designed for personal and small business document archival — scan your paper documents, upload digital files, and get a searchable, organized archive.

What Makes It Stand Out

OCR everything: When you import a document (PDF, JPEG, PNG, TIFF), Paperless-ngx runs OCR on it automatically. Every word in every document becomes searchable. Find "dentist receipt 2023" and it surfaces the correct document instantly.

Machine learning auto-tagging: Paperless-ngx learns from your tagging patterns. After you've tagged enough documents, it starts suggesting and automatically applying correspondents (senders), document types, and tags to new documents.

Full-text search: Search by content, not just filename. "Find all invoices from Amazon in Q3 2024" is a real search.

Document inbox: New documents land in an inbox for review. The ML suggestions make processing quick — review, confirm or adjust tags, file.

Multiple input methods:

• Email import (monitor a mailbox, automatically import attachments)
• Scanner integration (SANE-compatible scanners)
• Manual upload via web UI
• API for programmatic document import
• iOS/Android sharing (share a PDF to Paperless-ngx)

Custom fields: Add metadata beyond built-in fields — invoice amounts, contract expiry dates, whatever your workflow needs.

Storage backends: Local filesystem, S3-compatible storage (AWS S3, MinIO), or any storage that mounts as a filesystem.

Self-Hosting

services:
  broker:
    image: redis:7
  db:
    image: postgres:16
    environment:
      POSTGRES_DB: paperless
      POSTGRES_USER: paperless
      POSTGRES_PASSWORD: paperless
    volumes:
      - pgdata:/var/lib/postgresql/data
  webserver:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    ports:
      - "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

Three containers: the application, PostgreSQL, and Redis. The "consume" directory is watched — drop files there and they're automatically processed.

Scanner setup: Configure your network scanner to email scans to a monitored inbox, or use SANE network scanning to send directly to the consume directory.

Resource requirements: 1GB RAM minimum, 2GB recommended. OCR processing is CPU-intensive but processes in the background.

Use Cases

• Replace filing cabinets of paper documents
• Archive bank statements, tax documents, insurance policies
• Organize receipts for expense tracking
• Small business: invoices, contracts, correspondence
• Medical records, warranty documents, property records

Best for: Individuals and small teams who want a searchable archive of their documents — physical or digital.

Documenso — The DocuSign Alternative

Documenso (12K+ GitHub stars) is the open source alternative to DocuSign. If you need legally binding electronic signatures on documents — contracts, agreements, NDAs, employment offers — Documenso handles this without per-signature fees.

What Makes It Stand Out

No per-signature fees: DocuSign charges $1-2+ per envelope (document package) after your plan's included envelopes. Documenso self-hosted eliminates this — sign unlimited documents for the cost of your server.

Self-hosted = full control: Your contracts and signatures live on your infrastructure. Sensitive employment agreements, client contracts, and legal documents don't pass through a third-party service.

Complete signing workflow:

• Upload a document (PDF)
• Add signature fields, initials fields, date fields, text fields
• Send signing requests via email
• Signatories complete signing through a web interface
• Completed documents are saved with audit trail

Audit trail: Every signing event is timestamped and logged. Provides evidence of who signed, when, and from what IP.

Multi-party signing: Contracts with multiple signers — set the order, all parties receive and sign.

Template library: Create reusable templates for common documents (NDAs, employment agreements, service contracts).

API: Programmatic document preparation and signing trigger via REST API. Integrate into your application workflow.

Self-Hosting

git clone https://github.com/documenso/documenso
cd documenso
cp .env.example .env
# Configure:
# - DATABASE_URL (PostgreSQL)
# - NEXTAUTH_SECRET
# - EMAIL settings (SMTP)
# - NEXT_PUBLIC_WEBAPP_URL
docker compose up -d

Documenso runs as a Next.js application + PostgreSQL. Requires email configuration for sending signing requests.

Community Edition vs Business Edition

Documenso's Community Edition (AGPL-3.0) includes full core functionality — document signing, templates, and API.

The Business Edition (paid license) adds:

• SSO/SAML
• Embedded signing (embed the signing experience in your application)
• White label (remove Documenso branding)
• 21 CFR Part 11 compliance
• Advanced audit logs

For most teams, Community Edition covers all needs.

Cost Comparison vs DocuSign

DocuSign pricing:

• Personal: $15/month (10 envelopes)
• Standard: $25/user/month (100 envelopes)
• Business Pro: $45/user/month (unlimited)
• Enterprise: Custom

Documenso self-hosted:

• Server cost (Hetzner CPX21): $6.50/month
• Envelopes: Unlimited
• Annual: $78

For a 5-person team on DocuSign Standard: $1,500/year. Self-hosted Documenso: $78/year. Savings: $1,422/year.

Using Both Together

Many organizations need both document archival and signing:

1. Documenso handles the active document lifecycle — send for signature, collect signed copies
2. Paperless-ngx receives completed signed documents (via email) and archives them in the searchable database

The workflow:

• Send contract via Documenso
• Recipient signs
• Completed PDF emailed to your Paperless-ngx monitored inbox
• Paperless-ngx OCRs and archives the signed document with appropriate tags
• Years later, search "Acme Corp service agreement 2024" and find it instantly

Both can run on the same server with minimal resource overlap.

Infrastructure Costs

Setup	Monthly	Annual
Paperless-ngx only (Hetzner CAX11)	$4	$48
Documenso only (Hetzner CPX21)	$6.50	$78
Both on Hetzner CPX31 (8GB)	$10	$120

Compare to commercial alternatives:

• DocuSign Business Pro (5 users): $225/month, $2,700/year
• Adobe Document Cloud: $12.99-22.99/month per user
• Combined savings: $2,580-3,240/year for a 5-person team

Paperless-ngx in Depth: OCR, Machine Learning, and Workflow Automation

The most underappreciated feature of Paperless-ngx is its machine learning pipeline. When you first install it, the ML system starts with no knowledge of your document patterns. But as you manually tag documents — assigning correspondents (who sent this), document types (invoice, contract, statement), and tags — Paperless-ngx trains a classifier on your decisions. After roughly 50-100 manually processed documents, it starts making accurate automatic suggestions. After a few hundred documents, it can auto-assign the correct correspondent and document type to most incoming documents without any manual review.

This transforms the daily workflow. Instead of manually filing every incoming document, you check an inbox of AI-suggested classifications and confirm or correct them. The learning loop means the system gets more accurate as you use it. For a small business processing 50-100 documents per month, this saves a meaningful amount of time compared to manual filing.

The consumption directory pattern is particularly powerful for automation. Paperless-ngx watches a directory for new files. You can feed it from multiple sources simultaneously: a network scanner writes scanned documents directly to the directory; email monitoring downloads attachments from a monitored mailbox; your phone shares PDFs via a Paperless-ngx mobile app that uploads to the consume directory over the API. Documents from all these sources enter the same ML-powered processing pipeline.

For the email integration specifically, Paperless-ngx monitors one or more IMAP mailboxes with configurable rules. "Monitor this mailbox, download all PDF attachments from senders matching *@amazon.com, tag them as online-purchase, and archive the original email." Once configured, Amazon purchase receipts appear in your Paperless archive automatically, tagged and searchable, without any manual action.

The custom fields feature added in recent versions enables structured data extraction beyond the built-in fields. For invoices, you can add fields for invoice number, invoice amount, due date, and vendor account number. Filling these fields as you process documents creates a lightweight invoice database within Paperless-ngx — queryable by custom field values, not just document text. This bridges the gap between a document archive and a simple expense tracking system.

Documenso: The Developer-Focused Signing Platform

Documenso's standout technical feature compared to other open source e-signature tools is the embedded signing component. The @documenso/embed-react package allows you to render the entire Documenso signing experience inside your own web application as a React component. From the signer's perspective, they never leave your application — the signing UI appears inline, styled with your branding.

This matters for product-led applications where the signing experience is part of the core product flow. An employment platform that needs candidates to sign offer letters can integrate signing directly into the application rather than redirecting to an external signing service. A legal tech product can offer contract signing as a native feature. The embedding approach maintains brand consistency, reduces drop-off from context switching, and allows the parent application to handle the post-signing workflow directly.

The Documenso REST API is well-designed for programmatic workflows. The common pattern is: your application generates or selects a document, calls the API to create a signing request with pre-positioned fields, receives back a document ID and signer tokens, and then either triggers email-based signing or uses the embedded component with the signer token. The webhook system notifies your application when each signing event occurs — signer viewed the document, signer completed signing, all signers completed, document sent for archival.

For organizations that need to process many contracts regularly — hiring, vendor agreements, client onboarding — the template system is the key productivity feature. Create a template for your standard NDA once, with signature fields, date fields, and any custom text fields pre-positioned. Creating a new signing request from the template is a few clicks or a single API call with recipient details. Templates are the difference between Documenso as a useful tool and Documenso as a fully automated contract workflow system.

Compliance, Retention, and Long-Term Document Strategy

Both tools benefit from explicit planning around document retention and compliance. "Store documents forever" sounds safe but creates its own problems — GDPR's right to erasure, storage costs at scale, and the difficulty of finding relevant documents in a growing archive.

For Paperless-ngx, a retention policy means periodically reviewing and deleting document types with defined expiry — utility bills older than 7 years, promotional materials, documents superseded by updated versions. Paperless-ngx doesn't have a built-in retention policy engine, so this is a manual process (or a cron job that calls the Paperless API to delete documents matching certain criteria). For regulated industries with specific retention requirements, document the policy and automate its enforcement.

For Documenso, completed signed documents should be treated as legal records with retention obligations. The signed PDFs with embedded certificates are the primary legal artifact — they should be backed up separately and retained according to your jurisdiction's requirements for the relevant document type (employment contracts, service agreements, financial documents). Many organizations route completed Documenso documents to a dedicated legal archive separate from Paperless-ngx's general archive, maintaining clear separation between routine correspondence and legally significant documents.

For the signing workflow specifically, it's worth reading the how to migrate from DocuSign to Documenso guide if you're transitioning from a paid service. It covers how to migrate existing templates, handle in-flight documents during the transition period, and communicate the change to counterparties. The broader context of open source DocuSign alternatives is also useful for evaluating whether Documenso or OpenSign better fits your specific signing volume and field type requirements.

Both Paperless-ngx and Documenso can coexist on the same server with minimal resource conflict. A Hetzner CPX31 with 8 GB RAM handles both comfortably, with the document archive and signing platform each using 1-2 GB under typical load. The Docker Compose configurations for each tool use separate networks by default, so they operate independently while sharing underlying infrastructure. For the Paperless-ngx deployment specifically, the Paperless-ngx self-hosting guide covers document scanner setup, email consumption configuration, and backup strategy in detail.

Find Your Document Tools

Browse all document management tools on OSSAlt — compare Paperless-ngx, Documenso, OpenSign, and every other open source document platform with deployment guides and use case comparisons.

See open source alternatives to Documenso on OSSAlt.