Execute o Processamento de Documentos na Sua Própria Infraestrutura
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.
Implante o Documentize AI na sua infraestrutura com API REST unificada, garantindo automação local de documentos e controle total dos dados.
Execute o Documentize nos seus próprios servidores com a imagem Docker auto-hospedada: uma única REST API para conversão, mesclagem, divisão e compressão de PDF, OCR, extração de texto e dados de formulários, assinatura, edição de páginas, validação PDF/A e ferramentas de documentos com IA, como resumos, checklists, sumários, colagens, correção de inclinação e remoção de marca d'água. Cerca de 30 workers de processamento rodam atrás de uma fila de tarefas assíncrona que escala com a sua carga.
Seus arquivos nunca saem da sua infraestrutura, o que o torna adequado para LGPD e GDPR, saúde, jurídico, finanças e outros ambientes regulados. A chave de licença assinada é verificada offline, sem nenhuma conexão externa, e os resultados podem ficar em disco local ou no S3. Uma alternativa privada e on-premise às APIs de PDF na nuvem, com a mesma API da nuvem do Documentize, então o código escrito para uma funciona com a outra.
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
Como Funciona o Documentize Auto-hospedado
1. Implantar a API
Execute a API REST e os workers no seu próprio ambiente usando Docker ou um host local.
2. Enviar Documentos via REST
Envie arquivos e parâmetros para os endpoints da API para conversão, OCR, pesquisa ou processamento por IA.
3. Processamento em Segundo Plano
As tarefas são processadas de forma assíncrona, com acompanhamento de status e execução previsível.
4. Obter Resultados
Faça o download dos documentos processados ou dos resultados estruturados quando a tarefa for concluída.
FAQs
API de documentos auto-hospedada
Bloquear PDF
Bloqueie documentos com senha usando a API REST.
Desbloquear PDF
Desbloqueie documentos protegidos por senha via API REST.
Conversão de Documentos
Converta documentos entre formatos suportados.
Mesclar Documentos
Mescle vários documentos em um único arquivo de saída.
Dividir PDF
Divida documentos por páginas ou regras definidas.
Processamento OCR
Reconheça texto de documentos digitalizados e imagens.
PDF Pesquisável
Gere PDFs pesquisáveis a partir de arquivos digitalizados.
Pesquisa em PDF
Pesquise conteúdo de texto dentro de documentos.
Remover Página
Remova páginas do PDF.
Girar Página
Gire páginas do documento.
Compactar PDF
Compacte páginas do documento.
Assinatura Digital
Assine documentos digitalmente usando a API.
Verificação de Assinatura PDF
Verifique assinaturas digitais em documentos.
Sumário
Gere sumários automaticamente.
Geração de Checklist
Gere checklists estruturados a partir de documentos usando IA.
Geração de Ilustrações
Gere ilustrações baseadas em IA para o conteúdo dos documentos.
Totalmente Gratuito
Plano Gratuito
- Crie até 5 histórias ilustradas por dia sem registro ou pagamento.
Plano Premium
- Acesso total a todas as aplicações Documentize AI
- Limites de processamento diário estendidos
- Processamento prioritário e suporte gratuito
Plano Premium
- Acesso total às aplicações Documentize
- Ferramentas e recursos mais avançados
- Limites de processamento de arquivos estendidos
- Suporte gratuito