Find the Right CLI Plugin for Every Documentize Task

Find the Right CLI Plugin for Every Documentize Task

Browse plugins, read descriptions, view screenshots, and download pre-built zip bundles that work out of the box.

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.

Browse by category

Available Plugins

AI

Abstracts

Generates an AI abstract/summary of a PDF document.

Download ZIP
Documentation

Documentize.Abstracts

Generates 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Abstracts.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

AssemblyChat

Inspects a .NET assembly (local or from NuGet) and answers questions about its API surface.

Download ZIP
Documentation

Documentize.AssemblyChat

Inspects 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

1. Install the .NET SDK (not just the runtime): https://dotnet.microsoft.com/download 2. No extra font/GDI+ setup needed.

Linux (primary platform)
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.

Build

dotnet build Documentize.AssemblyChat.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

Chat

Answers a prompt about an uploaded PDF using an LLM chat endpoint.

Download ZIP
Documentation

Documentize.Chat

Answers 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Chat.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

CheckList

Generates an AI checklist derived from a PDF's content.

Download ZIP
Documentation

Documentize.CheckList

Generates 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.CheckList.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

DocAnalyze

Analyzes a document and reports structural/content metrics.

Download ZIP
Documentation

Documentize.DocAnalyze

Analyzes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.DocAnalyze.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

Illustrator

Generates AI illustrations for sections of a PDF.

Download ZIP
Documentation

Documentize.Illustrator

Generates 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Illustrator.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

Resume

Extracts or tailors resume content using an LLM, optionally against a job description.

Download ZIP
Documentation

Documentize.Resume

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Resume.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

SvgMaker

Generates an SVG image from a text description using an LLM, with iterative refinement.

Download ZIP
Documentation

Documentize.SvgMaker

Generates 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.SvgMaker.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

AI

TableOfContents

Builds an AI-segmented table of contents/outline for a PDF.

Download ZIP
Documentation

Documentize.TableOfContents

Builds 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
  • Outbound HTTPS access to the configured LLM endpoint (EP_API_URL/EP_TOKEN or DW_API_URL/DW_TOKEN environment variables — see Documentize.Entities.Llm.LlmOwnerResolver).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.TableOfContents.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

HtmlToPdf

Converts an HTML file to PDF.

Download ZIP
Documentation

Documentize.HtmlToPdf

Converts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.HtmlToPdf.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

ImageConvert

Converts images between raster formats (jpg, png, bmp, tiff, ...).

Download ZIP
Documentation

Documentize.ImageConvert

Converts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ImageConvert.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

ImageToPdf

Combines one or more images into a single PDF.

Download ZIP
Documentation

Documentize.ImageToPdf

Combines 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ImageToPdf.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

PdfSaveAs

Converts a PDF into another document format (docx, xlsx, pptx, ...).

Download ZIP
Documentation

Documentize.PdfSaveAs

Converts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.PdfSaveAs.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

PdfToHtml

Converts a PDF to HTML using the poppler pdftohtml tool.

Download ZIP
Documentation

Documentize.PdfToHtml

Converts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

This plugin shells out to pdftohtml from the Poppler PDF toolkit.

Windows

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"
Linux (primary platform)
sudo apt-get update
sudo apt-get install -y poppler-utils

Build

dotnet build Documentize.PdfToHtml.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

PdfToImage

Rasterizes PDF pages to image files (jpg, png, ...).

Download ZIP
Documentation

Documentize.PdfToImage

Rasterizes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.PdfToImage.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Convert

SofficeConvert

Converts office documents using a headless LibreOffice instance.

Download ZIP
Documentation

Documentize.SofficeConvert

Converts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

This plugin shells out to LibreOffice's soffice binary in headless mode.

Windows

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.

Linux (primary platform)
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.

Build

dotnet build Documentize.SofficeConvert.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

AddTable

Inserts an Excel worksheet as a table into a PDF.

Download ZIP
Documentation

Documentize.AddTable

Inserts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.AddTable.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

AddToc

Adds a table of contents page and bookmarks to a PDF.

Download ZIP
Documentation

Documentize.AddToc

Adds 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.AddToc.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Collage

Arranges a set of images into a single collage PDF page.

Download ZIP
Documentation

Documentize.Collage

Arranges 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Collage.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Compress

Compresses PDF files to reduce file size.

Download ZIP
Documentation

Documentize.Compress

Compresses 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Compress.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Flatten

Flattens PDF form fields into static page content.

Download ZIP
Documentation

Documentize.Flatten

Flattens 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Flatten.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Merge

Merges multiple input documents into one output document.

Download ZIP
Documentation

Documentize.Merge

Merges 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Merge.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

PdfMerge

Merges multiple PDF files into a single PDF.

Download ZIP
Documentation

Documentize.PdfMerge

Merges 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.PdfMerge.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

RemovePages

Removes a page range from a PDF.

Download ZIP
Documentation

Documentize.RemovePages

Removes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.RemovePages.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Resize

Resizes PDF pages to a target page size.

Download ZIP
Documentation

Documentize.Resize

Resizes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Resize.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Rotate

Rotates PDF pages by a fixed angle.

Download ZIP
Documentation

Documentize.Rotate

Rotates 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Rotate.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

Split

Splits a PDF into multiple files by page, range, or single page.

Download ZIP
Documentation

Documentize.Split

Splits 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Split.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Edit

SplitDoc

Splits a non-PDF document (Word/Excel/PowerPoint) using a strategy code.

Download ZIP
Documentation

Documentize.SplitDoc

Splits 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.SplitDoc.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

ExtractFormData

Extracts AcroForm/XFA field data from a PDF into structured output.

Download ZIP
Documentation

Documentize.ExtractFormData

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ExtractFormData.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

ExtractImage

Extracts embedded images from a PDF.

Download ZIP
Documentation

Documentize.ExtractImage

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ExtractImage.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

ExtractMetadata

Extracts document metadata (title, author, dates, custom properties) from a PDF.

Download ZIP
Documentation

Documentize.ExtractMetadata

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ExtractMetadata.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

ExtractText

Extracts plain text content from a document.

Download ZIP
Documentation

Documentize.ExtractText

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ExtractText.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

Parser

Parses a document and extracts structured paragraph/layout data.

Download ZIP
Documentation

Documentize.Parser

Parses 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Parser.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Extract

Search

Searches PDF text content, with optional regular-expression matching.

Download ZIP
Documentation

Documentize.Search

Searches 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Search.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

OCR

Deskew

Straightens (deskews) scanned page images inside a PDF.

Download ZIP
Documentation

Documentize.Deskew

Straightens (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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.Deskew.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

OCR

OcrImage

Runs OCR (Tesseract) on image files and returns extracted text.

Download ZIP
Documentation

Documentize.OcrImage

Runs 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

This plugin shells out to the tesseract CLI (Tesseract OCR engine) and needs language data for whichever --language code is requested.

Windows

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"
Linux (primary platform)
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

Build

dotnet build Documentize.OcrImage.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

OCR

OcrSearchable

Rasterizes a PDF and runs OCR to produce a searchable-text PDF layer.

Download ZIP
Documentation

Documentize.OcrSearchable

Rasterizes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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"
Linux (primary platform)
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

Build

dotnet build Documentize.OcrSearchable.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

OCR

TesseractOcr

Runs the Tesseract OCR engine directly on image files.

Download ZIP
Documentation

Documentize.TesseractOcr

Runs 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

This plugin shells out to the tesseract CLI (Tesseract OCR engine) and needs language data for whichever --language code is requested.

Windows

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"
Linux (primary platform)
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

Build

dotnet build Documentize.TesseractOcr.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Security

ESign

Applies a digital signature to a PDF using a PFX certificate.

Download ZIP
Documentation

Documentize.ESign

Applies 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.ESign.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Security

LockPdf

Encrypts/protects a PDF, including per-layer (OCG) protection modes.

Download ZIP
Documentation

Documentize.LockPdf

Encrypts/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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.LockPdf.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Security

MsOffCryptoUnlock

Removes password protection from Office (docx/xlsx/pptx) documents.

Download ZIP
Documentation

Documentize.MsOffCryptoUnlock

Removes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

This plugin shells out to the msoffcrypto-tool Python package.

Windows

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.

Linux (primary platform)
sudo apt-get update
sudo apt-get install -y python3 python3-pip
pip3 install msoffcrypto-tool

Build

dotnet build Documentize.MsOffCryptoUnlock.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Security

UnlockPdf

Removes password protection from a PDF.

Download ZIP
Documentation

Documentize.UnlockPdf

Removes 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.UnlockPdf.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Security

VerifyESign

Verifies digital signatures present in a PDF.

Download ZIP
Documentation

Documentize.VerifyESign

Verifies 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
  • An Aspose Documentize license file, documentize.lic, placed next to the published binary (the plugin runs unlicensed/evaluation mode if it is absent).
OS packages

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.

Windows

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.

Linux (primary platform)
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

Build

dotnet build Documentize.VerifyESign.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Archive

ArchiveCreate

Packs input files into a zip/archive.

Download ZIP
Documentation

Documentize.ArchiveCreate

Packs 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

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.

Build

dotnet build Documentize.ArchiveCreate.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

Archive

ArchiveExtract

Extracts files from a zip/rar/7z/tar archive.

Download ZIP
Documentation

Documentize.ArchiveExtract

Extracts 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.

Requirements

  • .NET 10 SDK to build; the .NET 10 runtime is enough to run a published build.
OS packages

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.

Build

dotnet build Documentize.ArchiveExtract.csproj -c Release

Publish a standalone build

# 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

Run

From the terminal (Linux) / cmd or PowerShell (Windows)

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
CLI options

| 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.

Alternative input: base64 task JSON

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>
Manager hot-process mode

--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.

Exit codes

| 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) |

How to Run a Plugin

doccli run md2pdf --input report.md --output report.pdf
./doccli run md2pdf --input report.md --output report.pdf
./doccli run md2pdf --input report.md --output report.pdf

Exit Codes

CodeMeaning
0Success — the plugin completed without errors.
1General error — an unexpected failure occurred during processing.
2Invalid arguments — a required option is missing or malformed.
3Input not found — the specified input file or path does not exist.
4License error — activation or authentication failed.

Requirements

  • Documentize CLI v2.0 or later installed and available on your PATH.
  • .NET 8 runtime (bundled in the self-contained plugin builds).
  • 64-bit Windows 10+, macOS 12+, or Linux with glibc 2.31 or newer.
  • At least 200 MB of free disk space per installed plugin.
  • Internet access for first-run license activation.

FAQs

Plugins are built for Documentize CLI v2.0 and later. Each plugin page lists the exact compatible versions.
All plugins are compiled for Windows, macOS, and Linux (x64). The zip includes binaries for each platform.
Yes. All plugins are open‑source, reviewed, and signed with our code‑signing certificate. You can also inspect the source on GitHub.
Each plugin page shows the latest version and a changelog. You can re‑download the zip or use the built‑in "doccli update" command.
Absolutely. Follow our SDK guide, package your binary and assets into a zip, and submit it via the "Submit Plugin" form.