The Documentize CLI plugin catalog gathers every command-line tool in one place — from PDF conversion and OCR to data extraction, editing, and security. Each plugin ships as a self-contained, cross-platform zip with binaries, docs, and usage examples, so you can search, preview, and start automating document workflows in seconds. Why the CLI? Unlike a point-and-click app, the command line is scriptable, repeatable, and headless — ideal when you need to process thousands of documents the same way every time, without a UI in the loop. Because every plugin is a single precompiled binary with no runtime to install, it drops straight into your existing tooling and produces identical results on every machine. Key advantages: batch-process entire folders in one command; chain plugins together in shell pipelines; wire them into CI/CD, cron jobs, or serverless functions; run on Windows, macOS, and Linux from the same package; and get deterministic, auditable exit codes for reliable error handling. No compilation, no dependencies, no manual steps. Common use cases: automated PDF generation and conversion in build pipelines; bulk OCR of scanned archives; extracting text, images, form data, and metadata for search indexing or analytics; merging, splitting, compressing, and watermarking documents at scale; locking, unlocking, and e-signing files for compliance; and integrating document processing into any backend service or scheduled job.
Generates an AI abstract/summary of a PDF document.
Download ZIPGenerates an AI abstract/summary of a PDF document.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.Abstracts.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Abstracts.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Abstracts.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Abstracts.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Abstracts.csproj -- --style value --length value
Using a published build:
# Linux
./publish/linux/Documentize.Abstracts --style value --length value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Abstracts.exe --style value --length value
Show all available options:
./publish/linux/Documentize.Abstracts --help
| Flag | Type | Default | Description | |---|---|---|---| | --style | string | "informative" | Abstract style (default 'informative'). | | --length | string | "medium" | Abstract length: short|medium|long (default 'medium'). | | --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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Style": "", "Length": "", "OutputLanguage": "", "IncludeKeywords": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Style\": \"\", \"Length\": \"\", \"OutputLanguage\": \"\", \"IncludeKeywords\": false }).encode()).decode())"
./publish/linux/Documentize.Abstracts <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
Inspects a .NET assembly (local or from NuGet) and answers questions about its API surface.
Download ZIPInspects a .NET assembly (local or from NuGet) and answers questions about its API surface.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 shells out to the dotnet CLI itself (to load/inspect assemblies) and, when a NuGet package is requested, downloads it over HTTPS from api.nuget.org — so it needs the .NET SDK (not just the runtime) and outbound internet access, in addition to the standard Aspose font/GDI+ requirements used for any generated PDF/SVG output.
1. Install the .NET SDK (not just the runtime): https://dotnet.microsoft.com/download 2. No extra font/GDI+ setup needed.
sudo apt-get update
sudo apt-get install -y libgdiplus fontconfig fonts-liberation fonts-dejavu-core
# Install the .NET SDK (matching net10.0), e.g. via the official install script:
curl -LO https://dot.net/v1/dotnet-install.sh
chmod +x dotnet-install.sh
./dotnet-install.sh --channel 10.0
Outbound HTTPS access to api.nuget.org is required when --nuget-package is used.
dotnet build Documentize.AssemblyChat.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.AssemblyChat.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.AssemblyChat.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.AssemblyChat.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.AssemblyChat.csproj -- --command value --query value
Using a published build:
# Linux
./publish/linux/Documentize.AssemblyChat --command value --query value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.AssemblyChat.exe --command value --query value
Show all available options:
./publish/linux/Documentize.AssemblyChat --help
| Flag | Type | Default | Description | |---|---|---|---| | --command | string | "scan" | Operation to run (default 'scan'). | | --query | string | "" | User query/prompt. | | --nuget-package | string | null | NuGet package id to analyze; null = none. | | --nuget-version | string | null | NuGet package version; null = latest. | | --generate-svg | bool | false | Also render an SVG diagram. | | --alt | int | null | Optional alternative-rendering index. |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Command": "", "Query": "", "NugetPackage": "", "NugetVersion": "", "GenerateSvg": false, "Alt": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Command\": \"\", \"Query\": \"\", \"NugetPackage\": \"\", \"NugetVersion\": \"\", \"GenerateSvg\": false, \"Alt\": 1 }).encode()).decode())"
./publish/linux/Documentize.AssemblyChat <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 prompt about an uploaded PDF using an LLM chat endpoint.
Download ZIPAnswers a prompt about an uploaded PDF using an LLM chat endpoint.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.Chat.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Chat.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Chat.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Chat.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Chat.csproj -- --query value --system-message value
Using a published build:
# Linux
./publish/linux/Documentize.Chat --query value --system-message value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Chat.exe --query value --system-message value
Show all available options:
./publish/linux/Documentize.Chat --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "", "SystemMessage": "", "MaxTokens": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Query\": \"\", \"SystemMessage\": \"\", \"MaxTokens\": 1 }).encode()).decode())"
./publish/linux/Documentize.Chat <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 an AI checklist derived from a PDF's content.
Download ZIPGenerates an AI checklist derived from a PDF's content.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.CheckList.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.CheckList.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.CheckList.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.CheckList.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.CheckList.csproj -- --topic value --checklist-type value
Using a published build:
# Linux
./publish/linux/Documentize.CheckList --topic value --checklist-type value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.CheckList.exe --topic value --checklist-type value
Show all available options:
./publish/linux/Documentize.CheckList --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Topic": "", "ChecklistType": "", "DetailLevel": "", "MaxItems": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Topic\": \"\", \"ChecklistType\": \"\", \"DetailLevel\": \"\", \"MaxItems\": 1 }).encode()).decode())"
./publish/linux/Documentize.CheckList <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPAnalyzes a document and reports structural/content metrics.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.DocAnalyze.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.DocAnalyze.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.DocAnalyze.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.DocAnalyze.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.DocAnalyze.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.DocAnalyze
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.DocAnalyze.exe
Show all available options:
./publish/linux/Documentize.DocAnalyze --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.DocAnalyze <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPGenerates AI illustrations for sections of a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.Illustrator.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Illustrator.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Illustrator.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Illustrator.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Illustrator.csproj -- --count 1 --language value
Using a published build:
# Linux
./publish/linux/Documentize.Illustrator --count 1 --language value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Illustrator.exe --count 1 --language value
Show all available options:
./publish/linux/Documentize.Illustrator --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Count": 1, "Language": "", "NeedCover": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Count\": 1, \"Language\": \"\", \"NeedCover\": false }).encode()).decode())"
./publish/linux/Documentize.Illustrator <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 or tailors resume content using an LLM, optionally against a job description.
Download ZIPExtracts or tailors resume content using an LLM, optionally against a job description.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.Resume.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Resume.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Resume.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Resume.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Resume.csproj -- --operation-type value --job-description-url value
Using a published build:
# Linux
./publish/linux/Documentize.Resume --operation-type value --job-description-url value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Resume.exe --operation-type value --job-description-url value
Show all available options:
./publish/linux/Documentize.Resume --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OperationType": "", "JobDescriptionUrl": "", "JobDescriptionText": "", "TargetIndustry": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OperationType\": \"\", \"JobDescriptionUrl\": \"\", \"JobDescriptionText\": \"\", \"TargetIndustry\": \"\" }).encode()).decode())"
./publish/linux/Documentize.Resume <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 an SVG image from a text description using an LLM, with iterative refinement.
Download ZIPGenerates an SVG image from a text description using an LLM, with iterative refinement.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.SvgMaker.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.SvgMaker.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.SvgMaker.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.SvgMaker.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.SvgMaker.csproj -- --query value --max-iterations 1
Using a published build:
# Linux
./publish/linux/Documentize.SvgMaker --query value --max-iterations 1
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.SvgMaker.exe --query value --max-iterations 1
Show all available options:
./publish/linux/Documentize.SvgMaker --help
| Flag | Type | Default | Description | |---|---|---|---| | --query | string | "" | Description of the SVG to generate. | | --max-iterations | int | 3 | Refinement iterations, clamped to 1-5 (default 3). | | --previous-svg-context | string | null | Prior SVG to iterate on; null = start fresh. |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "", "MaxIterations": 1, "PreviousSvgContext": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Query\": \"\", \"MaxIterations\": 1, \"PreviousSvgContext\": \"\" }).encode()).decode())"
./publish/linux/Documentize.SvgMaker <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPBuilds an AI-segmented table of contents/outline for a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/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 Aspose. 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 Aspose 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
dotnet build Documentize.TableOfContents.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.TableOfContents.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.TableOfContents.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.TableOfContents.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.TableOfContents.csproj -- --max-layers 1
Using a published build:
# Linux
./publish/linux/Documentize.TableOfContents --max-layers 1
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.TableOfContents.exe --max-layers 1
Show all available options:
./publish/linux/Documentize.TableOfContents --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "MaxLayers": 1, "SummarizeAllLevels": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"MaxLayers\": 1, \"SummarizeAllLevels\": false }).encode()).decode())"
./publish/linux/Documentize.TableOfContents <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 an HTML file to PDF.
Download ZIPConverts an HTML file to PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.HtmlToPdf.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.HtmlToPdf.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.HtmlToPdf.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.HtmlToPdf.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.HtmlToPdf.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.HtmlToPdf
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.HtmlToPdf.exe
Show all available options:
./publish/linux/Documentize.HtmlToPdf --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.HtmlToPdf <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 images between raster formats (jpg, png, bmp, tiff, ...).
Download ZIPConverts images between raster formats (jpg, png, bmp, tiff, ...).
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ImageConvert.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ImageConvert.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ImageConvert.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ImageConvert.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ImageConvert.csproj -- --output-format value --output-type value
Using a published build:
# Linux
./publish/linux/Documentize.ImageConvert --output-format value --output-type value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ImageConvert.exe --output-format value --output-type value
Show all available options:
./publish/linux/Documentize.ImageConvert --help
| 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. | | --quality | int | 90 | Output quality 1-100 (default 90). |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "", "OutputType": "", "Quality": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"\", \"OutputType\": \"\", \"Quality\": 1 }).encode()).decode())"
./publish/linux/Documentize.ImageConvert <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPCombines one or more images into a single PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ImageToPdf.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ImageToPdf.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ImageToPdf.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ImageToPdf.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ImageToPdf.csproj -- --output-name value
Using a published build:
# Linux
./publish/linux/Documentize.ImageToPdf --output-name value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ImageToPdf.exe --output-name value
Show all available options:
./publish/linux/Documentize.ImageToPdf --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputName": "", "FitToPage": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputName\": \"\", \"FitToPage\": false }).encode()).decode())"
./publish/linux/Documentize.ImageToPdf <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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, ...).
Download ZIPConverts a PDF into another document format (docx, xlsx, pptx, ...).
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.PdfSaveAs.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.PdfSaveAs.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.PdfSaveAs.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.PdfSaveAs.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.PdfSaveAs.csproj -- --output-format value --output-type value
Using a published build:
# Linux
./publish/linux/Documentize.PdfSaveAs --output-format value --output-type value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.PdfSaveAs.exe --output-format value --output-type value
Show all available options:
./publish/linux/Documentize.PdfSaveAs --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "", "OutputType": "", "ExtractOcrSublayerOnly": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"\", \"OutputType\": \"\", \"ExtractOcrSublayerOnly\": false }).encode()).decode())"
./publish/linux/Documentize.PdfSaveAs <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 to HTML using the poppler pdftohtml tool.
Download ZIPConverts a PDF to HTML using the poppler pdftohtml tool.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin shells out to pdftohtml from the Poppler PDF toolkit.
1. Download a Windows build of Poppler, e.g. https://github.com/oschwartz10612/poppler-windows/releases 2. Extract it and add its bin folder (containing pdftohtml.exe) to PATH:
setx PATH "%PATH%;C:\poppler\bin"
sudo apt-get update
sudo apt-get install -y poppler-utils
dotnet build Documentize.PdfToHtml.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.PdfToHtml.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.PdfToHtml.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.PdfToHtml.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.PdfToHtml.csproj -- --first-page 1 --last-page 1
Using a published build:
# Linux
./publish/linux/Documentize.PdfToHtml --first-page 1 --last-page 1
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.PdfToHtml.exe --first-page 1 --last-page 1
Show all available options:
./publish/linux/Documentize.PdfToHtml --help
| Flag | Type | Default | Description | |---|---|---|---| | --complex | bool | false | Use complex/high-fidelity layout mode. | | --no-frames | bool | true | Emit a single frameless document (default true). | | --single-page | bool | false | Render the whole PDF onto one HTML page. | | --first-page | int | 1 | First page to convert (default 1). | | --last-page | int | 0 | Last page to convert; 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Complex": false, "NoFrames": false, "SinglePage": false, "FirstPage": 1, "LastPage": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Complex\": false, \"NoFrames\": false, \"SinglePage\": false, \"FirstPage\": 1, \"LastPage\": 1 }).encode()).decode())"
./publish/linux/Documentize.PdfToHtml <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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, ...).
Download ZIPRasterizes PDF pages to image files (jpg, png, ...).
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.PdfToImage.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.PdfToImage.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.PdfToImage.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.PdfToImage.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.PdfToImage.csproj -- --output-format value --output-type value
Using a published build:
# Linux
./publish/linux/Documentize.PdfToImage --output-format value --output-type value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.PdfToImage.exe --output-format value --output-type value
Show all available options:
./publish/linux/Documentize.PdfToImage --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "", "OutputType": "", "Resolution": 1, "FirstPage": 1, "LastPage": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"\", \"OutputType\": \"\", \"Resolution\": 1, \"FirstPage\": 1, \"LastPage\": 1 }).encode()).decode())"
./publish/linux/Documentize.PdfToImage <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 office documents using a headless LibreOffice instance.
Download ZIPConverts office documents using a headless LibreOffice instance.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin shells out to LibreOffice's soffice binary in headless mode.
1. Install LibreOffice: https://www.libreoffice.org/download/download/ 2. Add the LibreOffice program folder to PATH so soffice.exe is resolvable, e.g.:
setx PATH "%PATH%;C:\Program Files\LibreOffice\program"
3. Open a new terminal so the updated PATH takes effect.
sudo apt-get update
sudo apt-get install -y libreoffice
The plugin looks for soffice/loffice on PATH and at the standard /usr/lib/libreoffice/program/soffice location, so a normal package-manager install is sufficient — no extra PATH configuration needed.
dotnet build Documentize.SofficeConvert.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.SofficeConvert.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.SofficeConvert.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.SofficeConvert.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.SofficeConvert.csproj -- --output-format value --input-filter value
Using a published build:
# Linux
./publish/linux/Documentize.SofficeConvert --output-format value --input-filter value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.SofficeConvert.exe --output-format value --input-filter value
Show all available options:
./publish/linux/Documentize.SofficeConvert --help
| Flag | Type | Default | Description | |---|---|---|---| | --output-format | string | "pdf" | Target format (default 'pdf'). | | --input-filter | string | null | LibreOffice input filter override; null = auto. |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputFormat": "", "InputFilter": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputFormat\": \"\", \"InputFilter\": \"\" }).encode()).decode())"
./publish/linux/Documentize.SofficeConvert <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPInserts an Excel worksheet as a table into a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.AddTable.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.AddTable.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.AddTable.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.AddTable.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.AddTable.csproj -- --insert-page-before 1 --sheet-name value
Using a published build:
# Linux
./publish/linux/Documentize.AddTable --insert-page-before 1 --sheet-name value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.AddTable.exe --insert-page-before 1 --sheet-name value
Show all available options:
./publish/linux/Documentize.AddTable --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "InsertPageBefore": 1, "SheetName": "", "FirstRowIsHeader": false, "MaxRows": 1, "MaxColumns": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"InsertPageBefore\": 1, \"SheetName\": \"\", \"FirstRowIsHeader\": false, \"MaxRows\": 1, \"MaxColumns\": 1 }).encode()).decode())"
./publish/linux/Documentize.AddTable <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPAdds a table of contents page and bookmarks to a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.AddToc.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.AddToc.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.AddToc.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.AddToc.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.AddToc.csproj -- --title value --toc-structure value
Using a published build:
# Linux
./publish/linux/Documentize.AddToc --title value --toc-structure value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.AddToc.exe --title value --toc-structure value
Show all available options:
./publish/linux/Documentize.AddToc --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Title": "", "GenerateBookmarks": false, "TocStructure": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Title\": \"\", \"GenerateBookmarks\": false, \"TocStructure\": \"\" }).encode()).decode())"
./publish/linux/Documentize.AddToc <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPArranges a set of images into a single collage PDF page.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Collage.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Collage.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Collage.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Collage.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Collage.csproj -- --page-size-name value --title value
Using a published build:
# Linux
./publish/linux/Documentize.Collage --page-size-name value --title value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Collage.exe --page-size-name value --title value
Show all available options:
./publish/linux/Documentize.Collage --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "PageSizeName": "", "Title": "", "MaxImagesPerPage": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"PageSizeName\": \"\", \"Title\": \"\", \"MaxImagesPerPage\": 1 }).encode()).decode())"
./publish/linux/Documentize.Collage <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPCompresses PDF files to reduce file size.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Compress.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Compress.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Compress.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Compress.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Compress.csproj -- --compress-type 1
Using a published build:
# Linux
./publish/linux/Documentize.Compress --compress-type 1
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Compress.exe --compress-type 1
Show all available options:
./publish/linux/Documentize.Compress --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "CompressType": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"CompressType\": 1 }).encode()).decode())"
./publish/linux/Documentize.Compress <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPFlattens PDF form fields into static page content.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Flatten.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Flatten.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Flatten.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Flatten.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Flatten.csproj -- --skip-fields value --flatten-only-fields value
Using a published build:
# Linux
./publish/linux/Documentize.Flatten --skip-fields value --flatten-only-fields value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Flatten.exe --skip-fields value --flatten-only-fields value
Show all available options:
./publish/linux/Documentize.Flatten --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SkipFields": [], "FlattenOnlyFields": [] }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"SkipFields\": [], \"FlattenOnlyFields\": [] }).encode()).decode())"
./publish/linux/Documentize.Flatten <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPMerges multiple input documents into one output document.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Merge.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Merge.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Merge.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Merge.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Merge.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.Merge
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Merge.exe
Show all available options:
./publish/linux/Documentize.Merge --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.Merge <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPMerges multiple PDF files into a single PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.PdfMerge.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.PdfMerge.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.PdfMerge.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.PdfMerge.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.PdfMerge.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.PdfMerge
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.PdfMerge.exe
Show all available options:
./publish/linux/Documentize.PdfMerge --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.PdfMerge <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPRemoves a page range from a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.RemovePages.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.RemovePages.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.RemovePages.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.RemovePages.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.RemovePages.csproj -- --remove-range value
Using a published build:
# Linux
./publish/linux/Documentize.RemovePages --remove-range value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.RemovePages.exe --remove-range value
Show all available options:
./publish/linux/Documentize.RemovePages --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "RemoveRange": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"RemoveRange\": \"\" }).encode()).decode())"
./publish/linux/Documentize.RemovePages <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPResizes PDF pages to a target page size.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Resize.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Resize.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Resize.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Resize.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Resize.csproj -- --target-page-size value
Using a published build:
# Linux
./publish/linux/Documentize.Resize --target-page-size value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Resize.exe --target-page-size value
Show all available options:
./publish/linux/Documentize.Resize --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "TargetPageSize": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"TargetPageSize\": \"\" }).encode()).decode())"
./publish/linux/Documentize.Resize <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPRotates PDF pages by a fixed angle.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Rotate.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Rotate.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Rotate.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Rotate.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Rotate.csproj -- --angle 1 --rotate-type value
Using a published build:
# Linux
./publish/linux/Documentize.Rotate --angle 1 --rotate-type value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Rotate.exe --angle 1 --rotate-type value
Show all available options:
./publish/linux/Documentize.Rotate --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Angle": 1, "RotateType": "", "PageNum": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Angle\": 1, \"RotateType\": \"\", \"PageNum\": \"\" }).encode()).decode())"
./publish/linux/Documentize.Rotate <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPSplits a PDF into multiple files by page, range, or single page.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Split.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Split.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Split.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Split.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Split.csproj -- --range value --page 1
Using a published build:
# Linux
./publish/linux/Documentize.Split --range value --page 1
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Split.exe --range value --page 1
Show all available options:
./publish/linux/Documentize.Split --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Range": "", "Page": 1 }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Range\": \"\", \"Page\": 1 }).encode()).decode())"
./publish/linux/Documentize.Split <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPSplits a non-PDF document (Word/Excel/PowerPoint) using a strategy code.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.SplitDoc.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.SplitDoc.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.SplitDoc.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.SplitDoc.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.SplitDoc.csproj -- --split-type 1 --parameters value
Using a published build:
# Linux
./publish/linux/Documentize.SplitDoc --split-type 1 --parameters value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.SplitDoc.exe --split-type 1 --parameters value
Show all available options:
./publish/linux/Documentize.SplitDoc --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "SplitType": 1, "Parameters": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"SplitType\": 1, \"Parameters\": \"\" }).encode()).decode())"
./publish/linux/Documentize.SplitDoc <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPExtracts AcroForm/XFA field data from a PDF into structured output.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ExtractFormData.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ExtractFormData.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ExtractFormData.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ExtractFormData.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ExtractFormData.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.ExtractFormData
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ExtractFormData.exe
Show all available options:
./publish/linux/Documentize.ExtractFormData --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.ExtractFormData <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPExtracts embedded images from a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ExtractImage.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ExtractImage.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ExtractImage.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ExtractImage.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ExtractImage.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.ExtractImage
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ExtractImage.exe
Show all available options:
./publish/linux/Documentize.ExtractImage --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.ExtractImage <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPExtracts document metadata (title, author, dates, custom properties) from a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ExtractMetadata.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ExtractMetadata.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ExtractMetadata.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ExtractMetadata.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ExtractMetadata.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.ExtractMetadata
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ExtractMetadata.exe
Show all available options:
./publish/linux/Documentize.ExtractMetadata --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.ExtractMetadata <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPExtracts plain text content from a document.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ExtractText.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ExtractText.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ExtractText.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ExtractText.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ExtractText.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.ExtractText
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ExtractText.exe
Show all available options:
./publish/linux/Documentize.ExtractText --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.ExtractText <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPParses a document and extracts structured paragraph/layout data.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Parser.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Parser.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Parser.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Parser.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Parser.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.Parser
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Parser.exe
Show all available options:
./publish/linux/Documentize.Parser --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.Parser <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPSearches PDF text content, with optional regular-expression matching.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Search.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Search.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Search.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Search.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Search.csproj -- --query value
Using a published build:
# Linux
./publish/linux/Documentize.Search --query value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Search.exe --query value
Show all available options:
./publish/linux/Documentize.Search --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Query": "", "UseAsRegex": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Query\": \"\", \"UseAsRegex\": false }).encode()).decode())"
./publish/linux/Documentize.Search <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
Straightens (deskews) scanned page images inside a PDF.
Download ZIPStraightens (deskews) scanned page images inside a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.Deskew.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.Deskew.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.Deskew.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.Deskew.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.Deskew.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.Deskew
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.Deskew.exe
Show all available options:
./publish/linux/Documentize.Deskew --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.Deskew <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
Runs OCR (Tesseract) on image files and returns extracted text.
Download ZIPRuns OCR (Tesseract) on image files and returns extracted text.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin shells out to the tesseract CLI (Tesseract OCR engine) and needs language data for whichever --language code is requested.
1. Install Tesseract via the UB-Mannheim build: https://github.com/UB-Mannheim/tesseract/wiki 2. During setup, select the language packs you need (English is included by default). 3. Add the install folder (default C:\Program Files\Tesseract-OCR) to PATH:
setx PATH "%PATH%;C:\Program Files\Tesseract-OCR"
sudo apt-get update
sudo apt-get install -y tesseract-ocr
# Add language packs as needed, e.g.:
sudo apt-get install -y tesseract-ocr-eng tesseract-ocr-deu tesseract-ocr-fra tesseract-ocr-spa
# Or install every language the org ships in production:
sudo apt-get install -y tesseract-ocr-all
dotnet build Documentize.OcrImage.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.OcrImage.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.OcrImage.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.OcrImage.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.OcrImage.csproj -- --language value
Using a published build:
# Linux
./publish/linux/Documentize.OcrImage --language value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.OcrImage.exe --language value
Show all available options:
./publish/linux/Documentize.OcrImage --help
| Flag | Type | Default | Description | |---|---|---|---| | --language | string | "eng" | Tesseract language code (default 'eng'). | | --output-to-single | bool | false | Combine all results into one 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Language": "", "OutputToSingle": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Language\": \"\", \"OutputToSingle\": false }).encode()).decode())"
./publish/linux/Documentize.OcrImage <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPRasterizes a PDF and runs OCR to produce a searchable-text PDF layer.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin rasterizes PDF pages with Aspose (see the base Linux font/GDI+ requirements below) and then runs the tesseract CLI on each page image, so it needs both dependency sets.
1. Fonts/GDI+: nothing extra — built into Windows. 2. Install Tesseract via the UB-Mannheim build: https://github.com/UB-Mannheim/tesseract/wiki and add its install folder to 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
dotnet build Documentize.OcrSearchable.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.OcrSearchable.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.OcrSearchable.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.OcrSearchable.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.OcrSearchable.csproj -- --language value
Using a published build:
# Linux
./publish/linux/Documentize.OcrSearchable --language value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.OcrSearchable.exe --language value
Show all available options:
./publish/linux/Documentize.OcrSearchable --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Language": "", "RemoveScannedImages": false }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Language\": \"\", \"RemoveScannedImages\": false }).encode()).decode())"
./publish/linux/Documentize.OcrSearchable <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
Runs the Tesseract OCR engine directly on image files.
Download ZIPRuns the Tesseract OCR engine directly on image files.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin shells out to the tesseract CLI (Tesseract OCR engine) and needs language data for whichever --language code is requested.
1. Install Tesseract via the UB-Mannheim build: https://github.com/UB-Mannheim/tesseract/wiki 2. During setup, select the language packs you need (English is included by default). 3. Add the install folder (default C:\Program Files\Tesseract-OCR) to PATH:
setx PATH "%PATH%;C:\Program Files\Tesseract-OCR"
sudo apt-get update
sudo apt-get install -y tesseract-ocr
# Add language packs as needed, e.g.:
sudo apt-get install -y tesseract-ocr-eng tesseract-ocr-deu tesseract-ocr-fra tesseract-ocr-spa
# Or install every language the org ships in production:
sudo apt-get install -y tesseract-ocr-all
dotnet build Documentize.TesseractOcr.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.TesseractOcr.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.TesseractOcr.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.TesseractOcr.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.TesseractOcr.csproj -- --language value --output-mode value
Using a published build:
# Linux
./publish/linux/Documentize.TesseractOcr --language value --output-mode value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.TesseractOcr.exe --language value --output-mode value
Show all available options:
./publish/linux/Documentize.TesseractOcr --help
| Flag | Type | Default | Description | |---|---|---|---| | --language | string | "eng" | Tesseract language code (default 'eng'). | | --output-mode | string | "hocr" | Output format: hocr|text|... (default 'hocr'). |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Language": "", "OutputMode": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Language\": \"\", \"OutputMode\": \"\" }).encode()).decode())"
./publish/linux/Documentize.TesseractOcr <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPApplies a digital signature to a PDF using a PFX certificate.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.ESign.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ESign.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ESign.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ESign.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ESign.csproj -- --password value
Using a published build:
# Linux
./publish/linux/Documentize.ESign --password value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ESign.exe --password value
Show all available options:
./publish/linux/Documentize.ESign --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }).encode()).decode())"
./publish/linux/Documentize.ESign <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPEncrypts/protects a PDF, including per-layer (OCG) protection modes.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.LockPdf.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.LockPdf.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.LockPdf.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.LockPdf.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.LockPdf.csproj -- --password value --lock-type FullDocument
Using a published build:
# Linux
./publish/linux/Documentize.LockPdf --password value --lock-type FullDocument
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.LockPdf.exe --password value --lock-type FullDocument
Show all available options:
./publish/linux/Documentize.LockPdf --help
| Flag | Type | Default | Description | |---|---|---|---| | --password | string | "" | Owner/user password to apply. | | --lock-type | LockType | FullDocument | Protection mode: FullDocument|LayerLock|... (default 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "", "LockType": "FullDocument" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\", \"LockType\": \"FullDocument\" }).encode()).decode())"
./publish/linux/Documentize.LockPdf <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 Office (docx/xlsx/pptx) documents.
Download ZIPRemoves password protection from Office (docx/xlsx/pptx) documents.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin shells out to the msoffcrypto-tool Python package.
1. Install Python 3: https://www.python.org/downloads/windows/ (check "Add python.exe to PATH" during setup). 2. Install the tool:
pip install msoffcrypto-tool
3. Confirm the Scripts folder pip installed into (e.g. %APPDATA%\Python\Python3xx\Scripts) is on PATH so msoffcrypto-tool resolves as a command.
sudo apt-get update
sudo apt-get install -y python3 python3-pip
pip3 install msoffcrypto-tool
dotnet build Documentize.MsOffCryptoUnlock.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.MsOffCryptoUnlock.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.MsOffCryptoUnlock.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.MsOffCryptoUnlock.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.MsOffCryptoUnlock.csproj -- --password value
Using a published build:
# Linux
./publish/linux/Documentize.MsOffCryptoUnlock --password value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.MsOffCryptoUnlock.exe --password value
Show all available options:
./publish/linux/Documentize.MsOffCryptoUnlock --help
| Flag | Type | Default | Description | |---|---|---|---| | --password | string | "" | Password protecting the Office documents. |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }).encode()).decode())"
./publish/linux/Documentize.MsOffCryptoUnlock <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPRemoves password protection from a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.UnlockPdf.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.UnlockPdf.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.UnlockPdf.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.UnlockPdf.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.UnlockPdf.csproj -- --password value
Using a published build:
# Linux
./publish/linux/Documentize.UnlockPdf --password value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.UnlockPdf.exe --password value
Show all available options:
./publish/linux/Documentize.UnlockPdf --help
| 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }).encode()).decode())"
./publish/linux/Documentize.UnlockPdf <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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.
Download ZIPVerifies digital signatures present in a PDF.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).This plugin renders/edits documents through Aspose. 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 Aspose 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
dotnet build Documentize.VerifyESign.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.VerifyESign.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.VerifyESign.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.VerifyESign.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.VerifyESign.csproj --
Using a published build:
# Linux
./publish/linux/Documentize.VerifyESign
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.VerifyESign.exe
Show all available options:
./publish/linux/Documentize.VerifyESign --help
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\" }).encode()).decode())"
./publish/linux/Documentize.VerifyESign <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
Packs input files into a zip/archive.
Download ZIPPacks input files into a zip/archive.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin uses SharpCompress (pure managed code) for archive read/write. No extra OS packages or native libraries are required on either platform beyond the .NET runtime.
dotnet build Documentize.ArchiveCreate.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ArchiveCreate.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ArchiveCreate.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ArchiveCreate.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ArchiveCreate.csproj -- --output-name value --format value
Using a published build:
# Linux
./publish/linux/Documentize.ArchiveCreate --output-name value --format value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ArchiveCreate.exe --output-name value --format value
Show all available options:
./publish/linux/Documentize.ArchiveCreate --help
| Flag | Type | Default | Description | |---|---|---|---| | --output-name | string | "archive" | Archive base file name (default 'archive'). | | --format | string | "zip" | Archive format, e.g. zip (default 'zip'). |
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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "OutputName": "", "Format": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"OutputName\": \"\", \"Format\": \"\" }).encode()).decode())"
./publish/linux/Documentize.ArchiveCreate <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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 files from a zip/rar/7z/tar archive.
Download ZIPExtracts files from a zip/rar/7z/tar archive.
This project is one of the standalone-publishable plugins under Plugins/. It has no ProjectReference to other projects in the repo — every file it needs is linked directly into its .csproj — so it builds and publishes independently of the rest of the solution.
This plugin uses SharpCompress (pure managed code) for archive read/write. No extra OS packages or native libraries are required on either platform beyond the .NET runtime.
dotnet build Documentize.ArchiveExtract.csproj -c Release
# Linux (framework-dependent, needs the .NET 10 runtime installed on the target machine)
dotnet publish Documentize.ArchiveExtract.csproj -c Release -r linux-x64 --self-contained false -o ./publish/linux
# Windows
dotnet publish Documentize.ArchiveExtract.csproj -c Release -r win-x64 --self-contained false -o ./publish/win
# Fully self-contained (no .NET runtime required on the target machine, larger output)
dotnet publish Documentize.ArchiveExtract.csproj -c Release -r linux-x64 --self-contained true -o ./publish/linux-standalone
Using dotnet run from source:
dotnet run --project Documentize.ArchiveExtract.csproj -- --password value
Using a published build:
# Linux
./publish/linux/Documentize.ArchiveExtract --password value
# Windows (cmd.exe or PowerShell)
.\publish\win\Documentize.ArchiveExtract.exe --password value
Show all available options:
./publish/linux/Documentize.ArchiveExtract --help
| Flag | Type | Default | Description | |---|---|---|---| | --password | string | null | Password for encrypted archives; null if 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.
For compatibility with the Plugin Manager (and as a drop-in alternative to flags), the plugin also accepts a single base64-encoded JSON argument instead of --flags. The JSON uses the same PascalCase property names as the options above, plus an "ID" field for the task id:
{ "ID": "b1e6a4b0-0000-0000-0000-000000000000", "Password": "" }
python3 -c "import base64,json; print(base64.b64encode(json.dumps({ \"ID\": \"b1e6a4b0-0000-0000-0000-000000000000\", \"Password\": \"\" }).encode()).decode())"
./publish/linux/Documentize.ArchiveExtract <base64-string-from-above>
--pool puts the plugin into the Plugin Manager's stdin/stdout worker-pool protocol (READY / {taskId} {base64} per line / DONE:{taskId} or FAIL:{taskId}:{msg}). This mode is only used by Documentize.Plugin.Manager — not intended for direct/manual use.
| 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) |
doccli run md2pdf --input report.md --output report.pdf| Code | Meaning |
|---|---|
0 | Success — the plugin completed without errors. |