Автоматизуйте роботу з PDF із командного рядка за допомогою 39 готових до запуску CLI-плагінів Documentize. Конвертуйте HTML і зображення в PDF, а PDF — у зображення та інші формати, об'єднуйте, розділяйте, обертайте, змінюйте розмір, стискайте й «сплющуйте» PDF, запускайте OCR, щоб скани стали доступні для пошуку, видобувайте текст, зображення, метадані й дані форм, блокуйте, розблоковуйте, підписуйте електронним підписом і перевіряйте підписи, а також викликайте ШІ-плагіни для анотацій, чек-листів, змістів, ілюстрацій, колажів і вирівнювання сканів.
Кожен плагін — самостійне завантаження з виконуваними файлами для Windows, macOS і Linux (x64), документацією та прикладами: не треба встановлювати SDK і нічого компілювати. Використовуйте їх у batch-файлах, shell-конвеєрах і завданнях CI/CD, щоб обробляти тисячі документів без участі людини тим самим рушієм, на якому працюють вебзастосунки Documentize.
One Premium subscription licenses every developer tool — no separate license to buy.
Generates an AI abstract/summary of a PDF document.
Завантажити ZIPLicense to run: PDF Manager
GuideGenerates an AI abstract/summary of a PDF document.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Abstracts.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Abstracts.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Abstracts.dll --style value --length value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Abstracts --style value --length value # Linux/macOS
.\Documentize.Abstracts.exe --style value --length value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Abstracts.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Abstracts.dll --task-id job1 --style value --length value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--style | string | "informative" | Abstract style (default 'informative'). |
--length | string | "medium" | Abstract length: short |
--output-language | string | "en" | ISO language code for the output (default 'en'). |
--include-keywords | bool | false | Append extracted keywords. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Style | string | no | "informative" | Abstract style (default 'informative'). |
Length | string | no | "medium" | Abstract length: short|medium|long (default 'medium'). |
OutputLanguage | string | no | "en" | ISO language code for the output (default 'en'). |
IncludeKeywords | boolean | no | false | Append extracted keywords. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Style": "informative", "Length": "medium", "OutputLanguage": "en", "IncludeKeywords": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Style": "informative", "Length": "medium", "OutputLanguage": "en", "IncludeKeywords": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Abstracts.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Style\": \"informative\", \"Length\": \"medium\", \"OutputLanguage\": \"en\", \"IncludeKeywords\": false }'.encode()).decode())"
dotnet Documentize.Abstracts.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Answers a question from your PDFs with AI, citing the exact passages it used.
Завантажити ZIPLicense to run: PDF Manager
Answers a question from your PDFs with AI, citing the exact passages it used.
The PDFs are split into passages, the passages that best match the question are ranked locally (BM25), and only those are sent to the model, so long documents still fit and every claim in the answer cites its source passage ([P1], [P2] …). The result is a Markdown file with the answer and the quoted sources.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.AskPdf.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.AskPdf.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.AskPdf.dll --question "What is the notice period?"
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.AskPdf --question "What is the notice period?" # Linux/macOS
.\Documentize.AskPdf.exe --question "What is the notice period?" # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.AskPdf.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF(s) you want to ask about (*.pdf) in the input folder. All PDFs in the folder are searched together.
Output: <first-pdf-name>_answer.md.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item contract.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.AskPdf.dll --task-id job1 --question "What is the notice period?"
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--question | string | "" | The question to answer from the PDF(s). Required. |
--top-passages | int | 6 | How many of the best-matching passages the answer is grounded in. |
--max-tokens | int | 1024 | Maximum answer tokens. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Question | string | yes | "" | The question to answer from the PDF(s). Required. |
TopPassages | integer | no | 6 | How many of the best-matching passages the answer is grounded in. |
MaxTokens | integer | no | 1024 | Maximum answer tokens. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Question": "What is the notice period?", "TopPassages": 6, "MaxTokens": 1024 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Question": "What is the notice period?", "TopPassages": 6, "MaxTokens": 1024 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.AskPdf.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Question\": \"What is the notice period?\", \"TopPassages\": 6, \"MaxTokens\": 1024 }'.encode()).decode())"
dotnet Documentize.AskPdf.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Release builds send one anonymous report per run to api.documentize.app: the plugin name, the result (ok / failed / bad arguments), how long it took, the OS, the release date and whether a subscription key is set, plus a random install id stored in your local app-data folder. File names, options and document content are never sent. The first run prints a notice.
To turn it off, set DOCUMENTIZE_TELEMETRY_OPTOUT=1 (or DO_NOT_TRACK=1).
Answers a prompt about an uploaded PDF using an LLM chat endpoint.
Завантажити ZIPLicense to run: PDF Manager
GuideAnswers a prompt about an uploaded PDF using an LLM chat endpoint.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Chat.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Chat.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Chat.dll --query value --system-message value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Chat --query value --system-message value # Linux/macOS
.\Documentize.Chat.exe --query value --system-message value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Chat.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
This plugin does not require an input file -- it runs entirely from --query, so the input folder can stay empty.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
dotnet Documentize.Chat.dll --task-id job1 --query value --system-message value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--query | string | (required) | The user prompt to send to the model. |
--system-message / --system | string | "" | Optional system prompt. |
--max-tokens | int | 2048 | Maximum response tokens (default 2048). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Query | string | yes | -- | The user prompt to send to the model. |
SystemMessage | string | no | "" | Optional system prompt. |
MaxTokens | integer | no | 2048 | Maximum response tokens (default 2048). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "Summarize this document in three bullet points", "SystemMessage": "", "MaxTokens": 2048 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "Summarize this document in three bullet points", "SystemMessage": "", "MaxTokens": 2048 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Chat.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Query\": \"Summarize this document in three bullet points\", \"SystemMessage\": \"\", \"MaxTokens\": 2048 }'.encode()).decode())"
dotnet Documentize.Chat.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Turns a PDF (or just a topic) into a concise Markdown study cheat sheet with AI.
Завантажити ZIPLicense to run: PDF Manager
GuideTurns a PDF (or just a topic) into a concise Markdown study cheat sheet with AI.
Sections are chosen with --categories (definitions, formulas, key facts, dates, summary). Book-length PDFs are trimmed head-and-tail to fit the model's context window.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.CheatSheet.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.CheatSheet.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.CheatSheet.dll --categories definitions,formulas,summary
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.CheatSheet --categories definitions,formulas,summary # Linux/macOS
.\Documentize.CheatSheet.exe --categories definitions,formulas,summary # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.CheatSheet.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Optionally place one PDF (*.pdf) in the input folder. Without a PDF, --topic is required and the sheet is built from the model's own knowledge.
Output: <pdf-name-or-topic>_cheat_sheet.md.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item lecture-notes.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.CheatSheet.dll --task-id job1 --categories definitions,formulas,summary
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--topic | string | "" | Topic to build the sheet for; required when no PDF is given, otherwise it focuses the sheet. |
--categories | string | "definitions,formulas,keyfacts,dates,summary" | Comma-separated sections to include. |
--output-language | string | "en" | ISO language code for the output. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Topic | string | no | "" | Topic to build the sheet for; required when no PDF is given, otherwise it focuses the sheet. |
Categories | string | no | "definitions,formulas,keyfacts,dates,summary" | Comma-separated sections to include. |
OutputLanguage | string | no | "en" | ISO language code for the output. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Topic": "Thermodynamics", "Categories": "definitions,formulas,summary", "OutputLanguage": "en" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Topic": "Thermodynamics", "Categories": "definitions,formulas,summary", "OutputLanguage": "en" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.CheatSheet.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Topic\": \"Thermodynamics\", \"Categories\": \"definitions,formulas,summary\", \"OutputLanguage\": \"en\" }'.encode()).decode())"
dotnet Documentize.CheatSheet.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Release builds send one anonymous report per run to api.documentize.app: the plugin name, the result (ok / failed / bad arguments), how long it took, the OS, the release date and whether a subscription key is set, plus a random install id stored in your local app-data folder. File names, options and document content are never sent. The first run prints a notice.
To turn it off, set DOCUMENTIZE_TELEMETRY_OPTOUT=1 (or DO_NOT_TRACK=1).
Generates an AI checklist derived from a PDF's content.
Завантажити ZIPLicense to run: PDF Manager
GuideGenerates an AI checklist derived from a PDF's content.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.CheckList.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.CheckList.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.CheckList.dll --topic value --checklist-type value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.CheckList --topic value --checklist-type value # Linux/macOS
.\Documentize.CheckList.exe --topic value --checklist-type value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.CheckList.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.CheckList.dll --task-id job1 --topic value --checklist-type value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--topic | string | "" | Checklist topic. |
--checklist-type | string | "tasks" | Checklist type (default 'tasks'). |
--detail-level | string | "moderate" | Level of detail (default 'moderate'). |
--max-items | int | 20 | Maximum checklist items (default 20). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Topic | string | no | "" | Checklist topic. |
ChecklistType | string | no | "tasks" | Checklist type (default 'tasks'). |
DetailLevel | string | no | "moderate" | Level of detail (default 'moderate'). |
MaxItems | integer | no | 20 | Maximum checklist items (default 20). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Topic": "", "ChecklistType": "tasks", "DetailLevel": "moderate", "MaxItems": 20 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Topic": "", "ChecklistType": "tasks", "DetailLevel": "moderate", "MaxItems": 20 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.CheckList.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Topic\": \"\", \"ChecklistType\": \"tasks\", \"DetailLevel\": \"moderate\", \"MaxItems\": 20 }'.encode()).decode())"
dotnet Documentize.CheckList.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Analyzes a document and reports structural/content metrics.
Завантажити ZIPLicense to run: PDF Extractor
Analyzes a document and reports structural/content metrics.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.DocAnalyze.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.DocAnalyze.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.DocAnalyze.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.DocAnalyze # Linux/macOS
.\Documentize.DocAnalyze.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.DocAnalyze.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.DocAnalyze.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.DocAnalyze.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.DocAnalyze.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Generates AI illustrations for sections of a PDF.
Завантажити ZIPLicense to run: PDF Manager
Generates AI illustrations for sections of a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Illustrator.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Illustrator.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Illustrator.dll --count 1 --language value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Illustrator --count 1 --language value # Linux/macOS
.\Documentize.Illustrator.exe --count 1 --language value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Illustrator.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Illustrator.dll --task-id job1 --count 1 --language value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--count | int | 3 | Number of illustrations to generate (default 3). |
--language | string | "en" | ISO language code (default 'en'). |
--need-cover | bool | false | Also generate a cover image. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Count | integer | no | 3 | Number of illustrations to generate (default 3). |
Language | string | no | "en" | ISO language code (default 'en'). |
NeedCover | boolean | no | false | Also generate a cover image. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Count": 3, "Language": "en", "NeedCover": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Count": 3, "Language": "en", "NeedCover": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Illustrator.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Count\": 3, \"Language\": \"en\", \"NeedCover\": false }'.encode()).decode())"
dotnet Documentize.Illustrator.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Converts a folder of PDFs, TXT and Markdown files into a linked Markdown knowledge-base wiki with AI.
Завантажити ZIPLicense to run: PDF Manager
GuideConverts a folder of PDFs, TXT and Markdown files into a linked Markdown knowledge-base wiki with AI.
Each document gets its own page (summary, key points, concepts); concepts are merged across documents into a concepts.md glossary with back-links, and index.md ties it together, ready for Obsidian, a docs site or a RAG pipeline.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.PdfKb.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.PdfKb.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.PdfKb.dll --max-concepts 15
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.PdfKb --max-concepts 15 # Linux/macOS
.\Documentize.PdfKb.exe --max-concepts 15 # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.PdfKb.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the documents (*.pdf, *.txt, *.md) in the input folder; every one becomes a wiki page.
Output: index.md, concepts.md and one <document>.md per input file.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item *.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.PdfKb.dll --task-id job1 --max-concepts 15
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--max-concepts | int | 15 | Maximum concepts extracted per document (1-50). |
--output-language | string | "en" | ISO language code for the wiki pages. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
MaxConcepts | integer | no | 15 | Maximum concepts extracted per document (1-50). |
OutputLanguage | string | no | "en" | ISO language code for the wiki pages. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "MaxConcepts": 15, "OutputLanguage": "en" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "MaxConcepts": 15, "OutputLanguage": "en" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.PdfKb.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"MaxConcepts\": 15, \"OutputLanguage\": \"en\" }'.encode()).decode())"
dotnet Documentize.PdfKb.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Release builds send one anonymous report per run to api.documentize.app: the plugin name, the result (ok / failed / bad arguments), how long it took, the OS, the release date and whether a subscription key is set, plus a random install id stored in your local app-data folder. File names, options and document content are never sent. The first run prints a notice.
To turn it off, set DOCUMENTIZE_TELEMETRY_OPTOUT=1 (or DO_NOT_TRACK=1).
Extracts or tailors resume content using an LLM, optionally against a job description.
Завантажити ZIPLicense to run: PDF Manager
GuideExtracts or tailors resume content using an LLM, optionally against a job description.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Resume.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Resume.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Resume.dll --operation-type value --job-description-url value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Resume --operation-type value --job-description-url value # Linux/macOS
.\Documentize.Resume.exe --operation-type value --job-description-url value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Resume.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Resume.dll --task-id job1 --operation-type value --job-description-url value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--operation-type | string | "extract" | Operation to run (default 'extract'). |
--job-description-url | string | null | URL of a job description to tailor against. |
--job-description-text | string | null | Inline job description text. |
--target-industry | string | null | Target industry for tailoring. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
OperationType | string | no | "extract" | Operation to run (default 'extract'). |
JobDescriptionUrl | string | no | null | URL of a job description to tailor against. |
JobDescriptionText | string | no | null | Inline job description text. |
TargetIndustry | string | no | null | Target industry for tailoring. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OperationType": "extract", "JobDescriptionUrl": null, "JobDescriptionText": null, "TargetIndustry": null }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OperationType": "extract", "JobDescriptionUrl": null, "JobDescriptionText": null, "TargetIndustry": null }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Resume.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OperationType\": \"extract\", \"JobDescriptionUrl\": null, \"JobDescriptionText\": null, \"TargetIndustry\": null }'.encode()).decode())"
dotnet Documentize.Resume.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Builds an AI-segmented table of contents/outline for a PDF.
Завантажити ZIPLicense to run: PDF Manager
GuideBuilds an AI-segmented table of contents/outline for a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.TableOfContents.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.TableOfContents.dll (the plugin runs in evaluation mode if it is absent).EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.TableOfContents.dll --max-layers 1
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.TableOfContents --max-layers 1 # Linux/macOS
.\Documentize.TableOfContents.exe --max-layers 1 # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.TableOfContents.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.TableOfContents.dll --task-id job1 --max-layers 1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--max-layers | int | 3 | Maximum heading depth to include (default 3). |
--summarize-all-levels | bool | true | Summarize every level, not just the top (default true). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
MaxLayers | integer | no | 3 | Maximum heading depth to include (default 3). |
SummarizeAllLevels | boolean | no | true | Summarize every level, not just the top (default true). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "MaxLayers": 3, "SummarizeAllLevels": true }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "MaxLayers": 3, "SummarizeAllLevels": true }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.TableOfContents.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"MaxLayers\": 3, \"SummarizeAllLevels\": true }'.encode()).decode())"
dotnet Documentize.TableOfContents.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Removes hidden AI-text watermarks: invisible characters, Unicode tags, odd spaces and homoglyphs.
Завантажити ZIPLicense to run: PDF Manager
GuideRemoves hidden AI-text watermarks: invisible characters, Unicode tags, odd spaces and homoglyphs.
Fully local and deterministic, with no AI call and nothing uploaded. Zero-width and tag characters are dropped, exotic spaces become normal spaces, and Cyrillic/Greek look-alikes hidden inside Latin words are replaced. Real Cyrillic/Greek words, emoji sequences and Persian/Indic joiners are left intact. A report lists every character found by code point. --detect only reports.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Unwatermark.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Unwatermark.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Unwatermark.dll --normalize-punctuation
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Unwatermark --normalize-punctuation # Linux/macOS
.\Documentize.Unwatermark.exe --normalize-punctuation # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Unwatermark.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place one text file (*.txt, *.md) or PDF (*.pdf) in the input folder. A PDF comes back as its cleaned text (.txt).
Output: the cleaned file (same name; .txt for a PDF) and <name>_report.txt.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item essay.txt "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Unwatermark.dll --task-id job1 --normalize-punctuation
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--detect | bool | false | Only report the hidden characters found; write no cleaned file. |
--normalize-punctuation | bool | false | Also replace typographic quotes, dashes and ellipses with plain ASCII. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Detect | boolean | no | false | Only report the hidden characters found; write no cleaned file. |
NormalizePunctuation | boolean | no | false | Also replace typographic quotes, dashes and ellipses with plain ASCII. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Detect": false, "NormalizePunctuation": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Detect": false, "NormalizePunctuation": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Unwatermark.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Detect\": false, \"NormalizePunctuation\": false }'.encode()).decode())"
dotnet Documentize.Unwatermark.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Release builds send one anonymous report per run to api.documentize.app: the plugin name, the result (ok / failed / bad arguments), how long it took, the OS, the release date and whether a subscription key is set, plus a random install id stored in your local app-data folder. File names, options and document content are never sent. The first run prints a notice.
To turn it off, set DOCUMENTIZE_TELEMETRY_OPTOUT=1 (or DO_NOT_TRACK=1).
Converts an HTML file to PDF.
Завантажити ZIPLicense to run: PDF Converter
GuideConverts an HTML file to PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.HtmlToPdf.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.HtmlToPdf.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.HtmlToPdf.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.HtmlToPdf # Linux/macOS
.\Documentize.HtmlToPdf.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.HtmlToPdf.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place an HTML file in the input folder -- .html/.htm is preferred; if none is found, the first file in the folder is used instead.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item page.html "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.HtmlToPdf.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.HtmlToPdf.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.HtmlToPdf.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Combines one or more images into a single PDF.
Завантажити ZIPLicense to run: PDF Converter
GuideCombines one or more images into a single PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ImageToPdf.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ImageToPdf.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ImageToPdf.dll --output-name value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ImageToPdf --output-name value # Linux/macOS
.\Documentize.ImageToPdf.exe --output-name value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ImageToPdf.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place one or more image files in the input folder -- supported extensions: .jpg, .jpeg, .png, .bmp, .gif, .webp, .tif, .tiff, .svg. They become PDF pages in filename order.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item photo1.jpg "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item photo2.jpg "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ImageToPdf.dll --task-id job1 --output-name value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--output-name | string | "output" | Output PDF base name (default 'output'). |
--fit-to-page | bool | true | Scale each image to the page (default true). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
OutputName | string | no | "output" | Output PDF base name (default 'output'). |
FitToPage | boolean | no | true | Scale each image to the page (default true). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputName": "output", "FitToPage": true }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputName": "output", "FitToPage": true }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ImageToPdf.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputName\": \"output\", \"FitToPage\": true }'.encode()).decode())"
dotnet Documentize.ImageToPdf.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Converts a PDF into another document format (docx, xlsx, pptx, ...).
Завантажити ZIPLicense to run: PDF Converter
GuideConverts a PDF into another document format (docx, xlsx, pptx, ...).
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.PdfSaveAs.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.PdfSaveAs.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.PdfSaveAs.dll --output-format value --output-type value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.PdfSaveAs --output-format value --output-type value # Linux/macOS
.\Documentize.PdfSaveAs.exe --output-format value --output-type value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.PdfSaveAs.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.PdfSaveAs.dll --task-id job1 --output-format value --output-type value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--output-format | string | "docx" | Target format (default 'docx'). |
--output-type | string | null | Alternate format key; overrides output-format when it is the default. |
--extract-ocr-sublayer-only | bool | false | Export only the OCR text sublayer. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
OutputFormat | string | no | "docx" | Target format (default 'docx'). |
OutputType | string | no | null | Alternate format key; overrides output-format when it is the default. |
ExtractOcrSublayerOnly | boolean | no | false | Export only the OCR text sublayer. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "docx", "OutputType": null, "ExtractOcrSublayerOnly": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "docx", "OutputType": null, "ExtractOcrSublayerOnly": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.PdfSaveAs.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"docx\", \"OutputType\": null, \"ExtractOcrSublayerOnly\": false }'.encode()).decode())"
dotnet Documentize.PdfSaveAs.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Rasterizes PDF pages to image files (jpg, png, ...).
Завантажити ZIPLicense to run: PDF Converter
GuideRasterizes PDF pages to image files (jpg, png, ...).
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.PdfToImage.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.PdfToImage.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.PdfToImage.dll --output-format value --output-type value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.PdfToImage --output-format value --output-type value # Linux/macOS
.\Documentize.PdfToImage.exe --output-format value --output-type value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.PdfToImage.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.PdfToImage.dll --task-id job1 --output-format value --output-type value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--output-format | string | "jpg" | Target image format (default 'jpg'). |
--output-type | string | null | Alternate format key; overrides output-format when it is the default. |
--resolution | int | 150 | Render resolution in DPI (default 150). |
--first-page | int | 1 | First page to render (default 1). |
--last-page | int | 0 | Last page to render; 0 = last (default 0). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
OutputFormat | string | no | "jpg" | Target image format (default 'jpg'). |
OutputType | string | no | null | Alternate format key; overrides output-format when it is the default. |
Resolution | integer | no | 150 | Render resolution in DPI (default 150). |
FirstPage | integer | no | 1 | First page to render (default 1). |
LastPage | integer | no | 0 | Last page to render; 0 = last (default 0). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "jpg", "OutputType": null, "Resolution": 150, "FirstPage": 1, "LastPage": 0 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "jpg", "OutputType": null, "Resolution": 150, "FirstPage": 1, "LastPage": 0 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.PdfToImage.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"jpg\", \"OutputType\": null, \"Resolution\": 150, \"FirstPage\": 1, \"LastPage\": 0 }'.encode()).decode())"
dotnet Documentize.PdfToImage.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Inserts an Excel worksheet as a table into a PDF.
Завантажити ZIPLicense to run: PDF Manager
GuideInserts an Excel worksheet as a table into a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.AddTable.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.AddTable.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.AddTable.dll --insert-page-before 1 --sheet-name value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.AddTable --insert-page-before 1 --sheet-name value # Linux/macOS
.\Documentize.AddTable.exe --insert-page-before 1 --sheet-name value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.AddTable.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place a PDF (*.pdf, required) in the input folder and, if you want to import a table from a spreadsheet, an Excel file (*.xlsx, optional) alongside it -- pick the worksheet with --sheet-name.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item table.xlsx "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.AddTable.dll --task-id job1 --insert-page-before 1 --sheet-name value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--insert-page-before | int | null | Insert the table before this page number; null = append. |
--sheet-name | string | null | Worksheet name to import; null = first sheet. |
--first-row-is-header | bool | false | Treat the first row as a header row. |
--max-rows | int | 1000 | Maximum rows to import (default 1000). |
--max-columns | int | 50 | Maximum columns to import (default 50). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
InsertPageBefore | integer | no | null | Insert the table before this page number; null = append. |
SheetName | string | no | null | Worksheet name to import; null = first sheet. |
FirstRowIsHeader | boolean | no | false | Treat the first row as a header row. |
MaxRows | integer | no | 1000 | Maximum rows to import (default 1000). |
MaxColumns | integer | no | 50 | Maximum columns to import (default 50). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "InsertPageBefore": null, "SheetName": null, "FirstRowIsHeader": false, "MaxRows": 1000, "MaxColumns": 50 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "InsertPageBefore": null, "SheetName": null, "FirstRowIsHeader": false, "MaxRows": 1000, "MaxColumns": 50 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.AddTable.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"InsertPageBefore\": null, \"SheetName\": null, \"FirstRowIsHeader\": false, \"MaxRows\": 1000, \"MaxColumns\": 50 }'.encode()).decode())"
dotnet Documentize.AddTable.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Adds a table of contents page and bookmarks to a PDF.
Завантажити ZIPLicense to run: PDF Manager
GuideAdds a table of contents page and bookmarks to a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.AddToc.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.AddToc.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.AddToc.dll --title value --toc-structure value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.AddToc --title value --toc-structure value # Linux/macOS
.\Documentize.AddToc.exe --title value --toc-structure value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.AddToc.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.AddToc.dll --task-id job1 --title value --toc-structure value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--title | string | "Table of Contents" | Table-of-contents page title. |
--generate-bookmarks | bool | false | Also generate PDF bookmarks. |
--toc-structure | string | null | Optional JSON describing the TOC entries. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Title | string | no | "Table of Contents" | Table-of-contents page title. |
GenerateBookmarks | boolean | no | false | Also generate PDF bookmarks. |
TocStructure | string | no | null | Optional JSON describing the TOC entries. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Title": "Table of Contents", "GenerateBookmarks": false, "TocStructure": null }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Title": "Table of Contents", "GenerateBookmarks": false, "TocStructure": null }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.AddToc.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Title\": \"Table of Contents\", \"GenerateBookmarks\": false, \"TocStructure\": null }'.encode()).decode())"
dotnet Documentize.AddToc.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Arranges a set of images into a single collage PDF page.
Завантажити ZIPLicense to run: PDF Manager
Arranges a set of images into a single collage PDF page.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Collage.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Collage.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Collage.dll --page-size-name value --title value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Collage --page-size-name value --title value # Linux/macOS
.\Documentize.Collage.exe --page-size-name value --title value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Collage.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place one or more image files in the input folder -- supported extensions: .jpg, .jpeg, .png, .webp, .bmp.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item photo1.jpg "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item photo2.jpg "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Collage.dll --task-id job1 --page-size-name value --title value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--page-size-name | string | "A4" | Output page size (default 'A4'). |
--title | string | "" | Optional collage title. |
--max-images-per-page | int | 6 | Maximum images per page (default 6). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
PageSizeName | string | no | "A4" | Output page size (default 'A4'). |
Title | string | no | "" | Optional collage title. |
MaxImagesPerPage | integer | no | 6 | Maximum images per page (default 6). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "PageSizeName": "A4", "Title": "", "MaxImagesPerPage": 6 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "PageSizeName": "A4", "Title": "", "MaxImagesPerPage": 6 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Collage.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"PageSizeName\": \"A4\", \"Title\": \"\", \"MaxImagesPerPage\": 6 }'.encode()).decode())"
dotnet Documentize.Collage.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Compresses PDF files to reduce file size.
Завантажити ZIPLicense to run: PDF Form
Compresses PDF files to reduce file size.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Compress.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Compress.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Compress.dll --compress-type 1
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Compress --compress-type 1 # Linux/macOS
.\Documentize.Compress.exe --compress-type 1 # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Compress.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Compress.dll --task-id job1 --compress-type 1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--compress-type | int | 1 | Compression preset (default 1). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
CompressType | integer | no | 1 | Compression preset (default 1). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "CompressType": 1 }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "CompressType": 1 }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Compress.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"CompressType\": 1 }'.encode()).decode())"
dotnet Documentize.Compress.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Flattens PDF form fields into static page content.
Завантажити ZIPLicense to run: PDF Form
GuideFlattens PDF form fields into static page content.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Flatten.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Flatten.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Flatten.dll --skip-fields value --flatten-only-fields value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Flatten --skip-fields value --flatten-only-fields value # Linux/macOS
.\Documentize.Flatten.exe --skip-fields value --flatten-only-fields value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Flatten.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Flatten.dll --task-id job1 --skip-fields value --flatten-only-fields value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--skip-fields | csv list | (empty list) | Comma-separated field names to leave un-flattened. |
--flatten-only-fields | csv list | (empty list) | Comma-separated field names to flatten exclusively. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
SkipFields | array of string | no | [] | Comma-separated field names to leave un-flattened. |
FlattenOnlyFields | array of string | no | [] | Comma-separated field names to flatten exclusively. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SkipFields": [], "FlattenOnlyFields": [] }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SkipFields": [], "FlattenOnlyFields": [] }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Flatten.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"SkipFields\": [], \"FlattenOnlyFields\": [] }'.encode()).decode())"
dotnet Documentize.Flatten.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Merges multiple input documents into one output document.
Завантажити ZIPLicense to run: PDF Manager
GuideMerges multiple input documents into one output document.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Merge.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Merge.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Merge.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Merge # Linux/macOS
.\Documentize.Merge.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Merge.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place two or more PDF files (*.pdf) in the input folder -- they are merged in filename order.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item part1.pdf "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item part2.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Merge.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Merge.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.Merge.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Merges multiple PDF files into a single PDF.
Завантажити ZIPLicense to run: PDF Manager
GuideMerges multiple PDF files into a single PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.PdfMerge.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.PdfMerge.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.PdfMerge.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.PdfMerge # Linux/macOS
.\Documentize.PdfMerge.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.PdfMerge.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place two or more PDF files (*.pdf) in the input folder -- they are merged in filename order.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item part1.pdf "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item part2.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.PdfMerge.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.PdfMerge.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.PdfMerge.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Removes a page range from a PDF.
Завантажити ZIPLicense to run: PDF Manager
GuideRemoves a page range from a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.RemovePages.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.RemovePages.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.RemovePages.dll --remove-range value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.RemovePages --remove-range value # Linux/macOS
.\Documentize.RemovePages.exe --remove-range value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.RemovePages.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.RemovePages.dll --task-id job1 --remove-range value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--remove-range | string | (required) | Pages to remove, e.g. 1,3,5-7. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
RemoveRange | string | yes | -- | Pages to remove, e.g. 1,3,5-7. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "RemoveRange": "2,4,7-9" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "RemoveRange": "2,4,7-9" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.RemovePages.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"RemoveRange\": \"2,4,7-9\" }'.encode()).decode())"
dotnet Documentize.RemovePages.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Resizes PDF pages to a target page size.
Завантажити ZIPLicense to run: PDF Manager
GuideResizes PDF pages to a target page size.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Resize.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Resize.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Resize.dll --target-page-size value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Resize --target-page-size value # Linux/macOS
.\Documentize.Resize.exe --target-page-size value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Resize.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Resize.dll --task-id job1 --target-page-size value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--target-page-size | string | "A4" | Target page size, e.g. A4 (default 'A4'). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
TargetPageSize | string | no | "A4" | Target page size, e.g. A4 (default 'A4'). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "TargetPageSize": "A4" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "TargetPageSize": "A4" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Resize.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"TargetPageSize\": \"A4\" }'.encode()).decode())"
dotnet Documentize.Resize.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Rotates PDF pages by a fixed angle.
Завантажити ZIPLicense to run: PDF Manager
GuideRotates PDF pages by a fixed angle.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Rotate.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Rotate.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Rotate.dll --angle 1 --rotate-type value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Rotate --angle 1 --rotate-type value # Linux/macOS
.\Documentize.Rotate.exe --angle 1 --rotate-type value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Rotate.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF (or other file) you want rotated in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Rotate.dll --task-id job1 --angle 1 --rotate-type value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--angle | int | 90 | Rotation angle in degrees (default 90). |
--rotate-type | string | "a" | Rotation mode; 'a' = all pages (default). |
--page-num | string | null | Specific page(s) to rotate; null = all. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Angle | integer | no | 90 | Rotation angle in degrees (default 90). |
RotateType | string | no | "a" | Rotation mode; 'a' = all pages (default). |
PageNum | string | no | null | Specific page(s) to rotate; null = all. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Angle": 90, "RotateType": "a", "PageNum": null }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Angle": 90, "RotateType": "a", "PageNum": null }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Rotate.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Angle\": 90, \"RotateType\": \"a\", \"PageNum\": null }'.encode()).decode())"
dotnet Documentize.Rotate.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Splits a PDF into multiple files by page, range, or single page.
Завантажити ZIPLicense to run: PDF Manager
Splits a PDF into multiple files by page, range, or single page.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Split.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Split.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Split.dll --range value --page 1
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Split --range value --page 1 # Linux/macOS
.\Documentize.Split.exe --range value --page 1 # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Split.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Split.dll --task-id job1 --range value --page 1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--range | string | null | Pages to extract, e.g. 1,3,5-7 (default: every page). |
--page | int | 0 | Single page number to extract; 0 means unused. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Range | string | no | null | Pages to extract, e.g. 1,3,5-7 (default: every page). |
Page | integer | no | 0 | Single page number to extract; 0 means unused. |
SavePattern | string | no | "split_[N].pdf" | Output file name pattern; [N] is replaced by the page number. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Range": null, "Page": 0, "SavePattern": "split_[N].pdf" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Range": null, "Page": 0, "SavePattern": "split_[N].pdf" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Split.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Range\": null, \"Page\": 0, \"SavePattern\": \"split_[N].pdf\" }'.encode()).decode())"
dotnet Documentize.Split.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Splits a non-PDF document (Word/Excel/PowerPoint) using a strategy code.
Завантажити ZIPLicense to run: PDF Manager
Splits a non-PDF document (Word/Excel/PowerPoint) using a strategy code.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.SplitDoc.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.SplitDoc.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.SplitDoc.dll --split-type 1 --parameters value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.SplitDoc --split-type 1 --parameters value # Linux/macOS
.\Documentize.SplitDoc.exe --split-type 1 --parameters value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.SplitDoc.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.SplitDoc.dll --task-id job1 --split-type 1 --parameters value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--split-type | int | 1 | Split strategy code (default 1). |
--parameters | string | null | Strategy-specific parameters; null = none. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
SplitType | integer | no | 1 | Split strategy code (default 1). |
Parameters | string | no | null | Strategy-specific parameters; null = none. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SplitType": 1, "Parameters": null }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SplitType": 1, "Parameters": null }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.SplitDoc.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"SplitType\": 1, \"Parameters\": null }'.encode()).decode())"
dotnet Documentize.SplitDoc.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Extracts AcroForm/XFA field data from a PDF into structured output.
Завантажити ZIPLicense to run: PDF Extractor
GuideExtracts AcroForm/XFA field data from a PDF into structured output.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ExtractFormData.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ExtractFormData.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ExtractFormData.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ExtractFormData # Linux/macOS
.\Documentize.ExtractFormData.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ExtractFormData.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ExtractFormData.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ExtractFormData.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.ExtractFormData.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Extracts embedded images from a PDF.
Завантажити ZIPLicense to run: PDF Extractor
GuideExtracts embedded images from a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ExtractImage.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ExtractImage.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ExtractImage.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ExtractImage # Linux/macOS
.\Documentize.ExtractImage.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ExtractImage.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ExtractImage.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ExtractImage.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.ExtractImage.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Extracts document metadata (title, author, dates, custom properties) from a PDF.
Завантажити ZIPLicense to run: PDF Extractor
GuideExtracts document metadata (title, author, dates, custom properties) from a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ExtractMetadata.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ExtractMetadata.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ExtractMetadata.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ExtractMetadata # Linux/macOS
.\Documentize.ExtractMetadata.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ExtractMetadata.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the file you want to inspect in the input folder -- any file type is accepted.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ExtractMetadata.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ExtractMetadata.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.ExtractMetadata.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Extracts plain text content from a document.
Завантажити ZIPLicense to run: PDF Extractor
GuideExtracts plain text content from a document.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ExtractText.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ExtractText.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ExtractText.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ExtractText # Linux/macOS
.\Documentize.ExtractText.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ExtractText.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the document you want text extracted from in the input folder -- any file type is accepted.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ExtractText.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ExtractText.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.ExtractText.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Parses a document and extracts structured paragraph/layout data.
Завантажити ZIPLicense to run: PDF Extractor
GuideParses a document and extracts structured paragraph/layout data.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Parser.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Parser.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Parser.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Parser # Linux/macOS
.\Documentize.Parser.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Parser.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Parser.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Parser.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.Parser.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Searches PDF text content, with optional regular-expression matching.
Завантажити ZIPLicense to run: PDF Extractor
Searches PDF text content, with optional regular-expression matching.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.Search.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.Search.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.Search.dll --query value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.Search --query value # Linux/macOS
.\Documentize.Search.exe --query value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.Search.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.Search.dll --task-id job1 --query value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--query | string | "" | Text or pattern to search for. |
--use-as-regex | bool | false | Treat the query as a regular expression. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Query | string | no | "" | Text or pattern to search for. |
UseAsRegex | boolean | no | false | Treat the query as a regular expression. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "", "UseAsRegex": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "", "UseAsRegex": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.Search.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Query\": \"\", \"UseAsRegex\": false }'.encode()).decode())"
dotnet Documentize.Search.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Rasterizes a PDF and runs OCR to produce a searchable-text PDF layer.
Завантажити ZIPLicense to run: PDF Manager
Rasterizes a PDF and runs OCR to produce a searchable-text PDF layer.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.OcrSearchable.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.OcrSearchable.dll (the plugin runs in evaluation mode if it is absent).This plugin rasterizes PDF pages with the Documentize engine (see the base Linux font/GDI+ requirements below) and then runs the tesseract CLI on each page image, so it needs both dependency sets.
PATH: setx PATH "%PATH%;C:\Program Files\Tesseract-OCR"
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
sudo apt-get install -y tesseract-ocr tesseract-ocr-eng
# Add further language packs as needed, e.g. tesseract-ocr-deu tesseract-ocr-fra ...
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.OcrSearchable.dll --language value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.OcrSearchable --language value # Linux/macOS
.\Documentize.OcrSearchable.exe --language value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.OcrSearchable.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.OcrSearchable.dll --task-id job1 --language value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--language | string | "eng" | Tesseract language code (default 'eng'). |
--remove-scanned-images | bool | false | Drop the original scanned image layer. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Language | string | no | "eng" | Tesseract language code (default 'eng'). |
RemoveScannedImages | boolean | no | false | Drop the original scanned image layer. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Language": "eng", "RemoveScannedImages": false }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Language": "eng", "RemoveScannedImages": false }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.OcrSearchable.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Language\": \"eng\", \"RemoveScannedImages\": false }'.encode()).decode())"
dotnet Documentize.OcrSearchable.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Applies a digital signature to a PDF using a PFX certificate.
Завантажити ZIPLicense to run: PDF Security
GuideApplies a digital signature to a PDF using a PFX certificate.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.ESign.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.ESign.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.ESign.dll --password value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.ESign --password value # Linux/macOS
.\Documentize.ESign.exe --password value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.ESign.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place exactly one PDF (*.pdf) and one PFX signing certificate (*.pfx) in the input folder -- both are required.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
Copy-Item certificate.pfx "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.ESign.dll --task-id job1 --password value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--password | string | "" | Password for the PFX certificate. |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Password | string | no | "" | Password for the PFX certificate. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.ESign.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }'.encode()).decode())"
dotnet Documentize.ESign.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Encrypts/protects a PDF, including per-layer (OCG) protection modes.
Завантажити ZIPLicense to run: PDF Security
GuideEncrypts/protects a PDF, including per-layer (OCG) protection modes.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.LockPdf.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.LockPdf.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.LockPdf.dll --password value --lock-type FullDocument
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.LockPdf --password value --lock-type FullDocument # Linux/macOS
.\Documentize.LockPdf.exe --password value --lock-type FullDocument # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.LockPdf.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.LockPdf.dll --task-id job1 --password value --lock-type FullDocument
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--password | string | "" | Owner/user password to apply. |
--lock-type | LockType | FullDocument | Protection mode: FullDocument |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Password | string | no | "" | Owner/user password to apply. |
LockType | string (FullDocument | LayerLock | LayerUnlock | MergeLayers | ExtractLayers | FlattenLayers | LayerVisibility | SelectiveEncryption | ReadLayers) | no | "FullDocument" | Protection mode: FullDocument|LayerLock|... (default FullDocument). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "", "LockType": "FullDocument" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "", "LockType": "FullDocument" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.LockPdf.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\", \"LockType\": \"FullDocument\" }'.encode()).decode())"
dotnet Documentize.LockPdf.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Removes password protection from a PDF.
Завантажити ZIPLicense to run: PDF Security
GuideRemoves password protection from a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.UnlockPdf.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.UnlockPdf.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.UnlockPdf.dll --password value
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.UnlockPdf --password value # Linux/macOS
.\Documentize.UnlockPdf.exe --password value # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.UnlockPdf.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.UnlockPdf.dll --task-id job1 --password value
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
| Flag | Type | Default | Description |
|---|---|---|---|
--password | string | "" | Password protecting the PDF(s). |
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Password | string | no | "" | Password protecting the PDF(s). |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.UnlockPdf.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }'.encode()).decode())"
dotnet Documentize.UnlockPdf.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Verifies digital signatures present in a PDF.
Завантажити ZIPLicense to run: PDF Security
GuideVerifies digital signatures present in a PDF.
This is one of the Documentize CLI plugins: a small, self-contained command-line tool. What you download from the Documentize CLI Plugin Catalog is a pre-built, obfuscated .NET assembly (a .dll) -- not source code -- so you run it directly; no build step, SDK, or source checkout required.
Documentize.VerifyESign.dll -- not source -- so the .NET SDK is not required, only the runtime.documentize.lic, placed next to Documentize.VerifyESign.dll (the plugin runs in evaluation mode if it is absent).This plugin renders/edits documents through the Documentize engine. On Linux, .NET's System.Drawing/GDI+ compatibility layer (libgdiplus) and a font configuration (fontconfig + at least one font family) are required for correct text measurement and rendering.
No extra OS packages are normally required — GDI+ and fonts are part of Windows. If the document uses fonts not installed system-wide, install them normally (Settings > Fonts) so the engine can find them.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Recommended for documents authored with Microsoft-compatible fonts:
sudo apt-get install -y ttf-mscorefonts-installer
fc-cache -f
Run it:
# Any OS, with just the .NET 10 runtime installed
dotnet Documentize.VerifyESign.dll
# If the download includes a native executable for your OS, you can also run it directly:
./Documentize.VerifyESign # Linux/macOS
.\Documentize.VerifyESign.exe # Windows (cmd.exe or PowerShell)
Show all available options:
dotnet Documentize.VerifyESign.dll --help
The plugin does not take file paths as CLI flags. It reads input from, and writes output to, a per-task folder pair:
<PLUGIN_INPUT_DIR>/<task-id>/ -- env var PLUGIN_INPUT_DIR, defaults to %TEMP%\documentize\input on Windows and /tmp/documentize/input on Linux/macOS.<PLUGIN_OUTPUT_DIR>/<task-id>/ -- env var PLUGIN_OUTPUT_DIR, defaults to %TEMP%\documentize\output on Windows and /tmp/documentize/output on Linux/macOS.Always pass an explicit --task-id so you know which folder to use -- if you omit it, the plugin generates a random GUID internally that you won't know in advance.
Place the PDF you want processed (*.pdf) in the input folder.
Example (Windows PowerShell):
$env:PLUGIN_INPUT_DIR = "C:\documentize-work\input"
$env:PLUGIN_OUTPUT_DIR = "C:\documentize-work\output"
New-Item -ItemType Directory -Force "$env:PLUGIN_INPUT_DIR\job1" | Out-Null
Copy-Item report.pdf "$env:PLUGIN_INPUT_DIR\job1\"
dotnet Documentize.VerifyESign.dll --task-id job1
dir "$env:PLUGIN_OUTPUT_DIR\job1"
The output folder also gets a <task-id>.json handoff file alongside the result -- that's metadata for the Plugin Manager and can be ignored for standalone/manual use.
This plugin takes no parameters beyond the task id — it only needs the input file(s).
Every plugin also accepts --task-id <guid> (alias --id) to set the task id used for the input/output working directories; if omitted, a new GUID is generated.
As an alternative to --flags, the plugin also accepts a single base64-encoded JSON argument instead. JSON field names are PascalCase (matching the CLI options above), plus an "ID" field for the task id (same as --task-id/--id; a fresh GUID is generated if omitted). Full field spec:
| JSON field | Type | Required | Default | Description |
|---|---|---|---|---|
ID | string (GUID) | no | new GUID if omitted | Task id -- same as --task-id/--id. |
Full example:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
Encode it to base64 and pass that as the plugin's only argument:
# Windows PowerShell
$json = '{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }'
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($json))
dotnet Documentize.VerifyESign.dll $b64
# Linux/macOS
python3 -c "import base64; print(base64.b64encode('{ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }'.encode()).decode())"
dotnet Documentize.VerifyESign.dll <base64-string-from-above>
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | The task ran but failed (see stderr for the exception) |
| 2 | Usage/argument error (missing required option, invalid value, --help) |
Each guide shows the plugin run end to end, with the commands that were run and checked.
License: each plugin needs the license of the product it belongs to, saved as documentize.lic next to its binary — without it the plugin runs in evaluation mode. The license a plugin needs is shown on its card. Licenses on documentize.com: PDF Extractor, PDF Form, PDF Converter, PDF Security, PDF Manager.
Автоматизуйте роботу з PDF із командного рядка за допомогою 39 готових до запуску CLI-плагінів Documentize. Конвертуйте HTML і зображення в PDF, а PDF — у зображення та інші формати, об'єднуйте, розділяйте, обертайте, змінюйте розмір, стискайте й «сплющуйте» PDF, запускайте OCR, щоб скани стали доступні для пошуку, видобувайте текст, зображення, метадані й дані форм, блокуйте, розблоковуйте, підписуйте електронним підписом і перевіряйте підписи, а також викликайте ШІ-плагіни для анотацій, чек-листів, змістів, ілюстрацій, колажів і вирівнювання сканів.
Кожен плагін — самостійне завантаження з виконуваними файлами для Windows, macOS і Linux (x64), документацією та прикладами: не треба встановлювати SDK і нічого компілювати. Використовуйте їх у batch-файлах, shell-конвеєрах і завданнях CI/CD, щоб обробляти тисячі документів без участі людини тим самим рушієм, на якому працюють вебзастосунки Documentize.