자체 인프라에서 문서 처리 실행
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.
통합 REST API로 로컬 자동화와 데이터 보안을 구현하세요
자체 호스팅 Docker 이미지로 Documentize를 내 서버에서 운영하세요. PDF 변환, 병합, 분할, 압축, OCR, 텍스트와 양식 데이터 추출, 서명, 페이지 편집, PDF/A 검증은 물론 초록, 체크리스트, 목차, 콜라주, 기울기 보정, 워터마크 제거 같은 AI 문서 도구까지 하나의 REST API로 제공합니다. 약 30개의 처리 워커가 부하에 맞춰 확장되는 비동기 작업 큐 뒤에서 동작합니다.
파일이 인프라 밖으로 절대 나가지 않으므로 GDPR, 의료, 법률, 금융 등 규제가 엄격한 환경에 적합합니다. 서명된 라이선스 키는 외부 통신 없이 오프라인으로 검증되며, 결과는 로컬 디스크나 S3에 저장할 수 있습니다. 클라우드 PDF API를 대체하는 프라이빗 온프레미스 솔루션이며 Documentize 클라우드와 같은 API를 쓰기 때문에 한쪽용으로 작성한 코드가 다른 쪽에서도 그대로 동작합니다.
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
셀프 호스팅 Documentize 작동 방식
1. API 배포
Docker 또는 로컬 호스트를 사용하여 자체 환경에서 REST API와 워커 실행.
2. REST를 통해 문서 전송
변환, OCR, 검색 또는 AI 처리를 위해 파일과 파라미터를 API 엔드포인트로 업로드.
3. 백그라운드 처리
작업은 비동기적으로 처리되며 상태 추적과 예측 가능한 실행 제공.
4. 결과 가져오기
작업 완료 시 처리된 문서 또는 구조화된 결과 다운로드.
FAQs
자체 호스팅 문서 API
PDF 잠금
REST API를 사용하여 문서를 비밀번호로 잠금.
PDF 잠금 해제
REST API를 통해 비밀번호로 보호된 문서 잠금 해제.
문서 변환
지원되는 형식 간 문서를 변환.
문서 병합
여러 문서를 하나의 출력 파일로 병합.
PDF 분할
페이지 또는 정의된 규칙에 따라 문서를 분할.
OCR 처리
스캔 문서 및 이미지에서 텍스트 인식.
검색 가능한 PDF
스캔 파일에서 검색 가능한 PDF 생성.
PDF 검색
문서 내 텍스트 콘텐츠 검색.
페이지 제거
PDF 페이지 제거.
페이지 회전
문서 페이지 회전.
PDF 압축
문서 페이지 압축.
디지털 서명
API를 사용하여 문서를 디지털 서명.
PDF 서명 검증
문서의 디지털 서명을 검증.
목차
목차 자동 생성.
체크리스트 생성
AI를 사용하여 문서에서 구조화된 체크리스트 생성.
일러스트 생성
문서 내용을 기반으로 AI 생성 일러스트 생성.