Exécutez le traitement de documents sur votre propre infrastructure
Run it locally or on your own infrastructure
A lightweight self-host version designed for developers. No complex setup, no external dependencies — just download, run, and start using Documentize in under a minute.
One Premium subscription licenses every developer tool — no separate license to buy.
- MCP server
- CLI
- Self-Host
- Desktop
⚡ Quick Start
Choose the setup that fits your workflow. Both options take only a few steps.
.NET 9 (fastest way)
If you already have .NET installed, this is the quickest way to get started.
- Download the self-host package
- Extract the archive
- Run:
dotnet Documentize.SelfHost.dllThen open http://localhost in your browser.
Docker
Prefer containers? Use the included Dockerfile to run Documentize anywhere.
- Download the Docker package
- Build the image:
docker build -t documentize .Run the container:
docker run -p 80:80 documentizeThen open http://localhost.
🧩 Requirements
Minimal requirements depending on your setup:
- .NET 9 Runtime for direct execution
- Docker for containerized setup
⚙️ More Details
The self-host version is built as a standard ASP.NET Core application, so it behaves exactly like any modern .NET web API.
- Runs locally or on any server
- Default Docker port: 80
- No external services required
- Suitable for internal tools or production use
🔑 Licensing & Subscription
Without a Documentize license the API runs on the free tier: PDF results are limited to 4 pages and carry a Documentize mark. A Documentize subscription or license lifts the limit and removes the mark, and it is the only thing you need to buy — SelfHost does not require, and does not ask you for, any third-party PDF license.
Why SelfHost is built on Aspose.Pdf FOSS
The PDF engine inside SelfHost is Aspose.Pdf FOSS, the open-source edition of Aspose.Pdf. We chose it because it fits a self-hosted product better than a licensed engine:
- No engine license to manage. There is no key to buy, rotate or hide inside your container. Install, run, and the engine just works.
- No evaluation mode. The engine itself never adds watermarks or cuts pages. The only limits you see are Documentize's own, and they are the ones shown in the table below.
- Light to deploy. It is a normal NuGet package that ships inside the SelfHost build. There is no separate engine to install, activate or keep in step with your container image.
- Open and auditable. You can read the code that touches your documents. That matters when your files must not leave your own infrastructure.
- Documentize adds the rest. Documentize brings the workers, the REST API, the AI tools, quotas and support on top, so you get a complete product, not just a library.
In short: the open engine does the PDF work, and a Documentize license is what unlocks the full SelfHost product for your team.
Free vs. paid tier
Every request — with a key or without one — runs under one of two allowances. A paid subscription is what lifts both the daily quota and, if the key is an active paid subscription, the free-tier watermark and page limit.
| Free / no key | Paid subscription | |
|---|---|---|
| Operations per day | 5 | Unlimited |
| Max file size | 10 MB | Unlimited |
| Concurrent operations | 2 | 8 |
| Watermark and 4-page limit on PDFs | Applied | Removed |
A paid subscription is proven to the instance by a signed key — either fetched automatically for you (Option 2) or issued manually (Option 3) — never by an environment variable you set yourself: those numbers are compiled into the binary and cannot be raised any other way.
Option 1 — Upload a license file via API
POST your Documentize .lic file to your running instance at any time.
curl -X POST http://localhost/webapi/license \
-F "license=@documentize.lic"Check the current license status at any time:
GET http://localhost/webapi/license
# { "licensed": true }Option 2 — Activate with your Documentize account (recommended)
If you already have a Documentize account with an active subscription, you don't need a license file at all. Create a SelfHost activation key below (requires signing in), then set it as an environment variable on your instance. The instance uses the key to call the Documentize API roughly every 6 hours and fetch a short-lived signed entitlement — whatever plan is active on your account is reflected automatically, with no further action from you when you upgrade, downgrade, or renew.
# Linux / macOS / Docker
export DOCUMENTIZE_API_TOKEN=dmk_your_activation_keyThis API token is not the same as the "Copy API token" button in the sidebar — that one is a short-lived login token for the hosted Documentize web app. The activation key created below is a separate, long-lived, single-purpose credential: it can only be used to refresh a SelfHost instance's entitlement, and it can be revoked here at any time, which stops the next refresh from renewing that instance — the instance simply keeps running on its last-known entitlement until that grant's own short expiry, then falls back to the free tier.
Independent of Options 1, 2 and 4 — use whichever fits your deployment; an instance is free to run more than one method side by side (a per-request key always wins if you send one — see below).
Option 3 — Manually issue a subscription key (advanced)
Options 1–3 are for the plans sold through the Documentize website. If you are distributing your own long-lived (monthly, yearly, or perpetual) subscription keys — for example as a vendor bundling SelfHost for your own customers — the Documentize.SelfHost binary can mint them itself, offline, from the command line. Neither command touches the network or starts the web server.
First, generate a signing key pair once (keep the private half secret):
dotnet Documentize.SelfHost.dll --new-signing-key
# PUBLIC (ship this — DOCUMENTIZE_SUBSCRIPTION_PUBLIC_KEY):
# MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
#
# PRIVATE (keep secret — needed only to issue keys):
# MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEA...Set the public half as DOCUMENTIZE_SUBSCRIPTION_PUBLIC_KEY on every instance that should trust keys you issue (a Release build can also have it baked in at compile time). Then issue a key for a customer:
dotnet Documentize.SelfHost.dll --issue-key "<privateKeyBase64>" \
'{"sub":"customer-123","email":"buyer@example.com","plan":"Pro Yearly","tier":"paid","period":"year","exp":1798761600}'
# DMZ1.eyJzdWIiOiJjdXN0b21lci0xMjMiLCJ0aWVyIjoicGFpZCIsLi4ufQ.MEUCIQD...Give the printed DMZ1.… value to the customer to set as:
# Linux / macOS / Docker
export DOCUMENTIZE_KEY=DMZ1.eyJzdWIiOiJjdXN0b21lci0xMjMiLC4uLn0.MEUCIQD...
# or, for a docker secret / k8s mount:
export DOCUMENTIZE_KEY_FILE=/run/secrets/documentize_keyPayload fields: sub/email/plan are freeform, shown back on /webapi/usage. tier is "free" or "paid". period is "month", "year", or "perpetual". exp is a Unix timestamp (seconds) the key stops working at — omit it (or set 0) for a perpetual key that never expires. You can optionally cap dailyOps, maxFileMb, or maxConcurrent per key for a bespoke plan; leave them out to use the standard paid-tier numbers above.
This key never expires from your side and never phones home — the instance verifies it completely offline, forever, unless you also set DOCUMENTIZE_KEY_REFRESH_URL to let it check for revocation periodically. This is the right tool for a key you are selling or handing out yourself; Option 2 above is the right tool for a customer with a Documentize account who just wants their own subscription reflected automatically.
🔑 Your SelfHost activation keys
No account needed to try this out — Create key below issues a free trial key on the spot. Sign in (top of the page) to list or revoke keys later, or to upgrade to a paid plan for full limits.
Copy this key now — it is stored only as a hash and cannot be shown again.
Set it as an environment variable on your instance:
This is a free trial key — it works at the same limits as a free account. Sign in to keep it listed for later, or upgrade to a paid plan for full limits.
Existing keys
| Label | Key | Created | Last used |
|---|
Presenting a key on a single request
Whichever option you use, a DOCUMENTIZE_KEY/DOCUMENTIZE_API_TOKEN set on the instance is the default for every request. You can also override it per request, e.g. to test a different key without restarting the instance — any one of these three works, and a per-request key always wins over whatever the instance is configured with:
# Dedicated header
curl http://localhost/webapi/usage -H "X-Documentize-Key: DMZ1...."
# Standard bearer auth (what Swagger UI's Authorize button sends)
curl http://localhost/webapi/usage -H "Authorization: Bearer DMZ1...."
# Query string, for clients that can't set headers
curl "http://localhost/webapi/usage?key=DMZ1...."Checking your current status
Free, no key required:
GET http://localhost/limits # human-readable
GET http://localhost/limits.json # machine-readable
GET http://localhost/webapi/usage # your own tier, plan, usage today, and licensing status/webapi/usage reports the same tier/plan a browser sees on the Documentize account page (email, plan name, days left in a term key), plus licensed/licensing fields explaining exactly why the free-tier watermark and page limit are or aren't applied right now — the first place to check if paid processing doesn't look the way you expect.
🖥️ Using the desktop & terminal clients with your local instance
The Windows, Linux, and TUI clients normally talk to the hosted Documentize API. You can point them at this self-host instance instead, so files are processed on your own machine and never leave your network.
Let the Windows client run the engine for you
The Windows client has a built-in copy of this engine — you don't need .NET or Docker installed separately.
- Open Settings → Run Documentize on this computer.
- Click Install — the client downloads
Documentize.SelfHostto%APPDATA%\PDFCON\self-hostand starts it on a local loopback port. - Click Use locally to route all operations to it.
When you are signed in with a paid subscription, the client fetches a signed entitlement for the local engine automatically (the same mechanism as Option 2 above), so full limits and watermark-free output work with no extra setup.
Point any client at an instance you started yourself
If you run this engine directly (dotnet Documentize.SelfHost.dll or the Docker image), connect any client to it with a provider profile:
- Start the instance and note its URL —
http://localhostfor the defaultdotnetrun, or the port you mapped for Docker. - In the client, open Settings and add/edit a provider profile:
- Kind: Documentize REST
- Base URL:
http://localhost/webapi/(keep the trailing/webapi/) - API Key (optional): empty for the free tier, or a SelfHost activation key /
DMZ1.…key to send per request.
- Select that profile as the active one and save.
Licensing the instance itself is done with any of Options 1–4 above; the client's API Key field is only for presenting a key on a single client's requests.
Déployez Documentize AI sur votre propre infrastructure grâce à une API REST unifiée, pour l’automatisation locale des documents et le contrôle total des données.
Exécutez Documentize sur vos propres serveurs avec l'image Docker auto-hébergée : une seule REST API pour la conversion, la fusion, la division et la compression de PDF, l'OCR, l'extraction de texte et de données de formulaires, la signature, l'édition de pages, la validation PDF/A et des outils documentaires IA comme les résumés, check-lists, tables des matières, collages, le redressement et la suppression de filigranes. Une trentaine de workers de traitement tournent derrière une file de tâches asynchrone qui s'adapte à votre charge.
Vos fichiers ne quittent jamais votre infrastructure, ce qui convient au RGPD, à la santé, au juridique, à la finance et aux autres environnements réglementés. La clé de licence signée est vérifiée hors ligne, sans aucun appel externe, et les résultats peuvent être stockés sur disque local ou dans S3. Une alternative privée et sur site aux API PDF cloud, avec la même API que le cloud Documentize : le code écrit pour l'un fonctionne avec l'autre.
How-to guides for every app
The same operations, step by step, in the web app, on the command line and over MCP.
- Add Table of Contents to PDF: web app and CLI
- Add tables to PDF files: web app and CLI
- Advisor: web app
- Ask questions from PDF files: web app and MCP
- Assembly Chat: web app and CLI
- Booklet: web app
- Chat with AI to generate PDF: web app and CLI
- Code Graph: web app
- Collage: web app and CLI
- Compress PDF files: web app and MCP
- Convert PDF files: web app, CLI and MCP
- Convert PDFs to a Markdown knowledge‑base wiki: web app and CLI
The Documentize book
What every app does, how the apps relate to each other, and how to chain them to reach a goal.
- The Map: how apps relate
- Goal-to-app finder
- How to read a recipe
- I.5 Product portfolio at a glance
- Diagnosis flowchart: find the symptom, find the page
Comment fonctionne Documentize Self-Hosted
1. Déployer l’API
Exécutez l’API REST et les workers dans votre propre environnement à l’aide de Docker ou sur un hôte local.
2. Envoyer des documents via REST
Téléversez des fichiers et des paramètres vers les endpoints de l’API pour la conversion, l’OCR, la recherche ou le traitement IA.
3. Traitement en arrière-plan
Les tâches sont traitées de manière asynchrone avec un suivi d’état et une exécution prévisible.
4. Récupérer les résultats
Téléchargez les documents traités ou les résultats structurés une fois la tâche terminée.
FAQs
API documentaire auto-hébergée
Verrouillage PDF
Protégez les documents par mot de passe via l’API REST.
Déverrouillage PDF
Déverrouillez des documents protégés par mot de passe via l’API REST.
Conversion de documents
Convertissez des documents entre les formats pris en charge.
Fusion de documents
Fusionnez plusieurs documents en un seul fichier de sortie.
Division de PDF
Divisez les documents par pages ou selon des règles définies.
Traitement OCR
Reconnaissez le texte à partir de documents numérisés et d’images.
PDF consultable
Générez des PDF consultables à partir de fichiers numérisés.
Recherche PDF
Recherchez du contenu textuel dans les documents.
Suppression de pages
Supprimez des pages PDF.
Rotation des pages
Faites pivoter les pages du document.
Compression PDF
Compressez les pages du document.
Signature numérique
Signez les documents numériquement via l’API.
Vérification de signature PDF
Vérifiez les signatures numériques dans les documents.
Table des matières
Générez automatiquement des tables des matières.
Génération de listes de contrôle
Générez des listes de contrôle structurées à partir de documents à l’aide de l’IA.
Génération d’illustrations
Générez des illustrations basées sur l’IA pour le contenu des documents.
Entièrement gratuit
Plan gratuit
- Créer jusquà 5 histoires illustrées par jour sans inscription ni paiement.
Plan Premium
- Accès complet à toutes les applications Documentize IA
- Limites de traitement quotidiennes étendues
- Traitement prioritaire et assistance gratuite
Plan Premium
- Accès complet aux applications Documentize
- Des outils et fonctionnalités plus avancés
- Limites étendues du traitement des fichiers
- Assistance gratuite