bentopdf

BentoPDF is a powerful, privacy-first, client-side PDF toolkit that is self-hostable and allows you to manipulate, edit, merge, and process PDF files directly in your browser. No server-side processing is required, ensuring your files remain secure and private.

---

Table of Contents

• Join Us on Discord
• Documentation
• Licensing
• Stargazers over time
• Why BentoPDF?
• Features / Tools Supported
  • Organize & Manage PDFs
  • Edit & Modify PDFs
  • Convert to PDF
  • Convert from PDF
  • Secure & Optimize PDFs
• Other Products
• Translations
• Getting Started
  • Prerequisites
  • Quick Start
  • Static Hosting
  • Self-Hosting Locally
  • Docker Compose / Podman Compose
  • Podman Quadlet
  • Self-Hosted Build (Simple Mode)
  • Commercial Build
  • Custom Branding
  • Disabling Specific Tools
  • Disabling the GitHub Star Counter
  • WASM Configuration
  • Air-Gapped / Offline Deployment
  • Security Features
  • Digital Signature CORS Proxy
  • Version Management
  • Development Setup
• Tech Stack & Background
• Roadmap
• Contributing
• Special Thanks

---

📢 Join Us on Discord

Have questions, feature requests, or want to chat with the community? Join our Discord server!

---

📚 Documentation

Visit our Documentation for:

• Getting Started guide
• Tools Reference (50+ tools)
• Self-Hosting guides (Docker, Vercel, Netlify, Cloudflare, AWS, Hostinger, Nginx, Apache)
• Contributing guide
• Commercial License details

---

📜 Licensing

BentoPDF is dual-licensed to fit your needs:

License	Best For	Price
AGPL-3.0	Open-source projects with public source code	Free
Commercial	Proprietary / closed-source applications	$79 (lifetime)

One-time purchase · One product, unlimited devices & users · Lifetime updates · No AGPL obligations

Building on BentoPDF? Hyper Compress is included. The commercial license covers Hyper Compress as a bundled component in eligible products: companies under US$1 million in revenue and funding, general PDF toolkits, and only through BentoPDF's own tools on the end user's device. Using the engine on its own, on a server, through an API or in other software needs a separate Hyper Compress license, and Kura is licensed separately. Both are annual subscriptions from $99/year, under the Hyper Compress and Kura commercial licenses. See the full license terms.

📖 For more details, see our Licensing Page

AGPL Components (Pre-configured via CDN)

BentoPDF does not bundle AGPL-licensed processing libraries in its source code, but pre-configures CDN URLs so all features work out of the box with zero setup:

Component	License	Features Enabled
PyMuPDF	AGPL-3.0	PDF to Text/Markdown/SVG/DOCX, Extract Images/Tables, EPUB/MOBI/XPS conversion, Compression, Deskew
Ghostscript	AGPL-3.0	PDF/A Conversion, Font to Outline
CoherentPDF (CPDF)	AGPL-3.0	Merge, Split by Bookmarks, Table of Contents, PDF to/from JSON, Attachments

[!TIP] Zero-config by default. WASM modules are loaded at runtime from jsDelivr CDN. No manual configuration is needed. For custom deployments (air-gapped, self-hosted), see WASM Configuration below.

⭐ Stargazers over time

---

✨ Why BentoPDF?

• Privacy First: All processing happens in your browser. Your files are never uploaded to a server, guaranteeing 100% privacy.
• No Limits: Manipulate as many files as you want, as often as you want. There are no restrictions or upload limits.
• High Performance: Built with modern web technologies, BentoPDF is fast and efficient, handling even large PDF files with ease.
• Completely Free: BentoPDF is a free and open-source tool for everyone.

---

🛠️ Features / Tools Supported

BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.

Organize & Manage PDFs

Tool Name	Description
Merge PDFs	Combine multiple PDF files into one. Preserves Bookmarks.
Split PDFs	Extract specific pages or divide a document into smaller files.
Organize Pages	Reorder, duplicate, or delete pages with a simple drag-and-drop interface.
Extract Pages	Save a specific range of pages as a new PDF.
Delete Pages	Remove unwanted pages from your document.
Rotate PDF	Rotate individual or all pages in a document.
Rotate by Custom Degrees	Rotate pages by any custom angle.
N-Up PDF	Combine multiple pages onto a single page.
View PDF	A powerful, integrated PDF viewer.
Alternate & Mix Pages	Merge pages by alternating pages from each PDF. Preserves Bookmarks.
Posterize PDF	Split a PDF into multiple smaller pages for print.
PDF Multi Tool	Merge, Split, Organize, Delete, Rotate, Add Blank Pages, Extract and Duplicate in a unified interface.
PDF Booklet	Rearrange pages for double-sided booklet printing. Fold and staple to create a booklet.
Add Attachments	Embed one or more files into your PDF.
Extract Attachments	Extract all embedded files from PDF(s) as a ZIP.
Edit Attachments	View or remove attachments in your PDF.
Divide Pages	Divide pages horizontally or vertically.
Combine to Single Page	Stitch all pages into one continuous scroll.
Add Blank Page	Insert an empty page anywhere in your PDF.
Reverse Pages	Flip the order of all pages in your document.
View Metadata	Inspect the hidden properties of your PDF.
PDFs to ZIP	Package multiple PDF files into a ZIP archive.
Compare PDFs	Compare two PDFs side by side.

Edit & Modify PDFs

Tool Name	Description
PDF Editor	Annotate, highlight, redact, comment, add shapes/images, search, and view PDFs.
Edit PDF Text	Edit existing text directly in your PDF. Reuses the document's embedded fonts and keeps the rest of the page untouched.
Create Fillable Forms	Create professional fillable PDF forms with text fields, checkboxes, dropdowns, radio buttons, signatures, and more. Fully compliant with PDF standards for compatibility with all PDF viewers.
PDF Form Filler	Fill in forms directly in the browser. Also supports XFA forms.
Add Page Numbers	Easily add page numbers with customizable formatting.
Bates Numbering	Add sequential Bates numbers across one or more PDF files.
Add Watermark	Add text or image watermarks to protect your documents.
Header & Footer	Add customizable headers and footers.
Crop PDF	Crop specific pages or the entire document.
Deskew PDF	Automatically straighten tilted scanned pages using OpenCV.
Font to Outline	Convert all fonts to vector outlines for consistent rendering across all devices.
Invert Colors	Invert the colors of your PDF pages for better readability.
Change Background	Modify the background color of your PDF.
Change Text Color	Change the color of text content within the PDF.
Flatten PDF	Flatten form fields and annotations into static content.
Remove Annotations	Remove comments, highlights, and other annotations.
Remove Blank Pages	Auto detect and remove blank pages in a PDF.
Edit Bookmarks	Add, Edit, Create, Import and Export PDF Bookmarks.
Add Stamps	Add image stamps to your PDF using the annotation toolbar.
Table of Contents	Generate a table of contents page from PDF bookmarks.
Redact Content	Permanently remove sensitive content from your PDFs.
Scanner Effect	Make your PDF look like a scanned document.
Adjust Colors	Fine-tune brightness, contrast, saturation and more.

Automate

Tool Name	Description
PDF Workflow Builder	Build custom PDF processing pipelines with a visual node editor.

Convert to PDF

Tool Name	Description
Image to PDF	Convert JPG, PNG, BMP, GIF, TIFF, PNM, PGM, PBM, PPM, PAM, JXR, JPX, JP2, PSD, SVG, HEIC, WebP to PDF.
JPG to PDF	Convert JPG, JPEG, and JPEG2000 (JP2/JPX) images to PDF.
PNG to PDF	Convert PNG images to PDF.
WebP to PDF	Convert WebP images to PDF.
SVG to PDF	Convert SVG images to PDF.
BMP to PDF	Convert BMP images to PDF.
HEIC to PDF	Convert HEIC images to PDF.
TIFF to PDF	Convert TIFF images to PDF.
PSD to PDF	Convert Adobe Photoshop (PSD) files to PDF.
Word to PDF	Convert Word documents (DOCX, DOC, ODT, RTF) to PDF.
Excel to PDF	Convert Excel spreadsheets (XLSX, XLS, ODS, CSV) to PDF.
PowerPoint to PDF	Convert PowerPoint presentations (PPTX, PPT, ODP) to PDF.
ODT to PDF	Convert OpenDocument Text files to PDF.
ODS to PDF	Convert OpenDocument Spreadsheet (ODS) files to PDF.
ODP to PDF	Convert OpenDocument Presentation (ODP) files to PDF.
ODG to PDF	Convert OpenDocument Graphics (ODG) files to PDF.
RTF to PDF	Convert Rich Text Format documents to PDF.
CSV to PDF	Convert CSV spreadsheet files to PDF.
Markdown to PDF	Write or paste Markdown and export it as a beautifully formatted PDF.
Text to PDF	Convert plain text files into a PDF.
JSON to PDF	Convert JSON files to PDF.
XML to PDF	Convert XML documents to PDF.
EPUB to PDF	Convert EPUB e-books to PDF.
MOBI to PDF	Convert MOBI e-books to PDF.
FB2 to PDF	Convert FictionBook (FB2) e-books to PDF.
CBZ to PDF	Convert comic book archives (CBZ/CBR) to PDF.
XPS to PDF	Convert XPS/OXPS documents to PDF.
Email to PDF	Convert email files (EML, MSG) to PDF. Supports Outlook exports.
Pages to PDF	Convert Apple Pages documents to PDF.
WPD to PDF	Convert WordPerfect documents (WPD) to PDF.
WPS to PDF	Convert WPS Office documents to PDF.
PUB to PDF	Convert Microsoft Publisher (PUB) files to PDF.
VSD to PDF	Convert Microsoft Visio (VSD, VSDX) files to PDF.

Convert from PDF

Tool Name	Description
PDF to Image	Convert PDF pages to JPG, PNG, WebP, BMP, or TIFF formats.
PDF to JPG	Convert each PDF page into a JPG image.
PDF to PNG	Convert each PDF page into a PNG image.
PDF to WebP	Convert each PDF page into a WebP image.
PDF to BMP	Convert each PDF page into a BMP image.
PDF to TIFF	Convert each PDF page into a TIFF image.
PDF to CBZ	Convert a PDF into a CBZ (Comic Book Archive) for comic readers and Calibre.
PDF to SVG	Convert each page into a scalable vector graphic (SVG) for perfect quality.
PDF to Greyscale	Convert a color PDF into a black-and-white version.
PDF to Text	Extract text from PDF files and save as plain text (.txt).
PDF to JSON	Convert PDF files to JSON format.
PDF to CSV	Extract tables from PDF and convert to CSV format.
PDF to Excel	Extract tables from PDF and convert to Excel (XLSX) format.
Extract Tables	Extract tables from PDF files and export as CSV, JSON, or Markdown.
OCR PDF	Make scanned PDFs searchable and copyable using Optical Character Recognition.

Secure & Optimize PDFs

Tool Name	Description
Compress PDF	Reduce file size while maintaining quality.
Repair PDF	Attempt to repair and recover data from a corrupted PDF.
Encrypt PDF	Add a password to protect your PDF from unauthorized access.
Decrypt PDF	Remove password protection from a PDF (password required).
Change Permissions	Set or modify user permissions for printing, copying, and editing.
Sign PDF	Draw, type, or upload your signature.
Digital Signature	Add cryptographic digital signatures using X.509 certificates (PFX/PEM). Private key never leaves browser.
Validate Signature	Verify digital signatures, check certificate validity, and confirm document integrity.
Redact Content	Permanently remove sensitive content from your PDFs.
Edit Metadata	View and modify PDF metadata (author, title, keywords, etc.).
Remove Metadata	Strip all metadata from your PDF for privacy.
Linearize PDF	Optimize PDF for fast web viewing.
Sanitize PDF	Remove metadata, annotations, scripts, and more.
Fix Page Size	Standardize all pages to a uniform size.
Page Dimensions	Analyze page size, orientation, and units.
Remove Restrictions	Remove password protection and security restrictions associated with digitally signed PDF files.

---

🌍 Translations

BentoPDF is available in multiple languages:

Language	Status
English
Chinese
Traditional Chinese
French
German
Indonesian
Italian
Portuguese
Turkish
Vietnamese
Korean
Russian
Persian (Farsi)

Want to help translate BentoPDF into your language? Check out our Translation Guide!

---

🚀 Getting Started

You can run BentoPDF locally for development or personal use.

Prerequisites

• Node.js (v18 or higher recommended)
• npm (or yarn/pnpm)
• Docker & Docker Compose (for containerized setup)

🚀 Quick Start

Run BentoPDF instantly from GitHub Container Registry (Recommended):

docker run -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest

Open your browser at: http://localhost:3000

[!TIP] BentoPDF ships in two builds:

• Self-Hosted build — ghcr.io/alam00000/bentopdf-simple:latest. Every PDF tool the public site has, without the BentoPDF marketing (no hero, FAQ, testimonials, footer). Use this for internal/team/organization deployments. It is not a feature-reduced lite version.
• Commercial build — ghcr.io/alam00000/bentopdf:latest. The full marketing site, used by bentopdf.com itself and by commercial license holders running public-facing deployments. Includes hero, FAQ, testimonials, and footer.

If in doubt: pull the Self-Hosted build.

Docker Hub:

docker run -p 3000:8080 bentopdfteam/bentopdf-simple:latest

Podman (GHCR):

podman run -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest

Podman (Docker Hub):

podman run -p 3000:8080 docker.io/bentopdfteam/bentopdf-simple:latest

[!NOTE] All docker commands in this documentation work with Podman by replacing docker with podman.

Static Hosting using Netlify, Vercel, and GitHub Pages

It is very straightforward to host your own instance of BentoPDF using a static web page hosting service. Plus, services such as Netlify, Vercel, and GitHub Pages all offer a free tier for getting started. See Static Hosting for details.

🏠 Self-Hosting Locally

Since BentoPDF is fully client-side, all processing happens in the user's browser and no server-side processing is required. This means you can host BentoPDF as simple static files on any web server or hosting platform.

[!IMPORTANT] Office file conversion uses LibreOffice WASM, which requires SharedArrayBuffer. That means the app must be both cross-origin isolated and served from a secure context. http://localhost works for local testing, but http://192.168.x.x or other LAN IPs usually require HTTPS even if the server already sends the correct COOP/COEP headers.

Download from Releases (Recommended):

The easiest way to self-host is to download the pre-built distribution file from our GitHub releases. Each release includes a dist-{version}.zip file that contains all necessary files for self-hosting.

1. Go to BentoPDF Releases
2. Download the latest dist-{version}.zip file
3. Extract the zip file
4. Serve the extracted folder with your preferred web server

Serve the extracted folder (requires Node.js):

# Navigate to the extracted folder
cd dist-1.7.3  # Replace with your version

# Start a local server
npx http-server -c-1

The website will be accessible at: http://localhost:8080/

[!NOTE] The -c-1 flag disables caching for development.

Build from Source (Advanced):

If you prefer to build from source:

# Clone the repository
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf

# Install dependencies
npm install

# Build the project
npm run build

# Package the distribution for hosting (optional)
npm run package

# Preview the build locally
npm run preview

# The website will be accessible at: http://localhost:4173/

Compression Modes:

By default the build saves no compressed copies, and your server or host compresses files as it sends them. If your server can send precompressed files (nginx gzip_static or brotli_static, Apache, Caddy precompressed), set COMPRESSION_MODE to save .gz and/or .br copies next to each text and WASM file. The originals are always kept.

The prebuilt Docker images have no copies, and their nginx compresses with gzip on the fly. Build your own image with COMPRESSION_MODE=g to have it serve .gz copies instead. The image's nginx can't serve brotli, so for brotli put a proxy or CDN that compresses with brotli, such as Traefik or Cloudflare, in front of it.

# No copies (default)
npm run build:original
docker build --build-arg COMPRESSION_MODE=o -t bentopdf:original .

# Gzip copies
npm run build:gzip
docker build --build-arg COMPRESSION_MODE=g -t bentopdf:gzip .

# Brotli copies
npm run build:brotli
docker build --build-arg COMPRESSION_MODE=b -t bentopdf:brotli .

# Both
npm run build:all
docker build --build-arg COMPRESSION_MODE=all -t bentopdf:all .

Mode	Copies made	Use case
o	none	Default, server compresses on the fly
g	.gz	nginx with gzip_static
b	.br	Servers with brotli_static
all	.gz and .br	Servers that serve both

CDN Optimization:

BentoPDF can use jsDelivr CDN to serve large WASM files (LibreOffice, Ghostscript, PyMuPDF) for improved performance and reduced bandwidth costs:

# Production build with CDN (Recommended)
VITE_USE_CDN=true npm run build

# Standard build with local files only
npm run build

How it works:

• When VITE_USE_CDN=true: Browser loads WASM files from jsDelivr CDN (fast, global delivery)
• Local files are always included as automatic fallback
• If CDN fails then it falls back to local files

Advanced PDF features (PyMuPDF, Ghostscript, CoherentPDF) are pre-configured to load from jsDelivr CDN via environment variables. This means all features work out of the box — no manual setup needed.

The default URLs are set in .env.production:

VITE_WASM_PYMUPDF_URL=https://cdn.jsdelivr.net/npm/@bentopdf/[email protected]/
VITE_WASM_GS_URL=https://cdn.jsdelivr.net/npm/@bentopdf/[email protected]/assets/
VITE_WASM_CPDF_URL=https://cdn.jsdelivr.net/npm/[email protected]/dist/
VITE_TESSERACT_WORKER_URL=
VITE_TESSERACT_CORE_URL=
VITE_TESSERACT_LANG_URL=
VITE_TESSERACT_AVAILABLE_LANGUAGES=
VITE_OCR_FONT_BASE_URL=

To override via Docker build args:

docker build \
  --build-arg VITE_WASM_PYMUPDF_URL=https://your-server.com/pymupdf/ \
  --build-arg VITE_WASM_GS_URL=https://your-server.com/gs/ \
  --build-arg VITE_WASM_CPDF_URL=https://your-server.com/cpdf/ \
  --build-arg VITE_TESSERACT_WORKER_URL=https://your-server.com/ocr/worker.min.js \
  --build-arg VITE_TESSERACT_CORE_URL=https://your-server.com/ocr/core \
  --build-arg VITE_TESSERACT_LANG_URL=https://your-server.com/ocr/lang-data \
  --build-arg VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu \
  --build-arg VITE_OCR_FONT_BASE_URL=https://your-server.com/ocr/fonts \
  -t bentopdf .

To disable a module (require manual user config via Advanced Settings), set its variable to an empty string.

For OCR, either leave all VITE_TESSERACT_* variables empty and use the default online assets, or set the worker/core/lang URLs together for self-hosted/offline OCR. If your self-hosted bundle only includes a subset such as eng,deu, also set VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu so the UI only shows bundled languages and OCR fails with a descriptive message for unsupported ones. For fully offline searchable-PDF output, also set VITE_OCR_FONT_BASE_URL to the internal directory that serves the bundled OCR text-layer fonts.

Users can also override these defaults per-browser via Advanced Settings in the UI — user overrides take priority over the environment defaults.

[!IMPORTANT] These URLs are baked into the JavaScript at build time. The WASM files themselves are downloaded by the user's browser at runtime — Docker does not download them during the build.

For networks with no internet access (government, healthcare, financial, etc.), you need to prepare everything on a machine with internet, then transfer the bundle into the isolated network.

Automated Script (Recommended)

The included prepare-airgap.sh script automates the entire process — downloading WASM packages, building the Docker image, exporting everything into a self-contained bundle with a setup script.

git clone https://github.com/alam00000/bentopdf.git
cd bentopdf

# Show supported OCR language codes (for --ocr-languages)
bash scripts/prepare-airgap.sh --list-ocr-languages

# Search OCR language codes by name or abbreviation
bash scripts/prepare-airgap.sh --search-ocr-language german

# Interactive mode — prompts for all options
bash scripts/prepare-airgap.sh

# Or fully automated
bash scripts/prepare-airgap.sh --wasm-base-url https://internal.example.com/wasm

This produces a bundle directory containing:

bentopdf-airgap-bundle/
  bentopdf.tar              # Docker image
  *.tgz                     # WASM packages (PyMuPDF, Ghostscript, CoherentPDF, Tesseract)
  tesseract-langdata/       # OCR traineddata files
  ocr-fonts/                # OCR text-layer font files
  setup.sh                  # Setup script for the air-gapped side
  README.md                 # Instructions

Transfer the bundle into the air-gapped network via USB, internal artifact repo, or approved method. Then run the included setup script:

cd bentopdf-airgap-bundle
bash setup.sh

The setup script loads the Docker image, extracts WASM files, and optionally starts the container.

Flag	Description	Default
--wasm-base-url <url>	Where WASMs will be hosted internally	(required, prompted if missing)
--image-name <name>	Docker image tag	bentopdf
--output-dir <path>	Output bundle directory	./bentopdf-airgap-bundle
--simple-mode	Enable Simple Mode	off
--base-url <path>	Subdirectory base URL (e.g. /pdf/)	/
--language <code>	Default UI language (e.g. fr, de)	(none)
--brand-name <name>	Custom brand name	(none)
--brand-logo <path>	Logo path relative to public/	(none)
--footer-text <text>	Custom footer text	(none)
--ocr-languages <list>	Comma-separated OCR languages to bundle	eng
--list-ocr-languages	Print supported OCR codes and names, then exit	off
--search-ocr-language <term>	Search OCR codes by name or abbreviation	off
--dockerfile <path>	Dockerfile to use	Dockerfile
--skip-docker	Skip Docker build and export	off
--skip-wasm	Skip WASM download (reuse existing .tgz files)	off

The interactive prompt also accepts list to print the full supported Tesseract code list and search <term> to find matches such as search german or search chi.

[!IMPORTANT] WASM files must be served from the same origin as the BentoPDF app. Web Workers use importScripts() which cannot load scripts cross-origin. For example, if BentoPDF runs at https://internal.example.com, the WASM base URL should also be https://internal.example.com/wasm.

Manual Steps

Step 1: Download the WASM and OCR packages (on a machine with internet)

npm pack @bentopdf/[email protected]
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack [email protected]
npm pack [email protected]
mkdir -p tesseract-langdata
curl -fsSL https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng/4.0.0_best_int/eng.traineddata.gz -o tesseract-langdata/eng.traineddata.gz
mkdir -p ocr-fonts
curl -fsSL https://raw.githack.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf -o ocr-fonts/NotoSans-Regular.ttf

Step 2: Build the Docker image with internal URLs

git clone https://github.com/alam00000/bentopdf.git
cd bentopdf

docker build \
  --build-arg VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/ \
  --build-arg VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/ \
  --build-arg VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/ \
  --build-arg VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js \
  --build-arg VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core \
  --build-arg VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data \
  --build-arg VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts \
  -t bentopdf .

Step 3: Export the Docker image

docker save bentopdf -o bentopdf.tar

Step 4: Transfer into the air-gapped network

Copy these files via USB drive, internal artifact repository, or approved transfer method:

• bentopdf.tar — the Docker image
• bentopdf-pymupdf-wasm-0.11.14.tgz — PyMuPDF WASM package
• bentopdf-gs-wasm-*.tgz — Ghostscript WASM package
• coherentpdf-*.tgz — CoherentPDF WASM package
• tesseract.js-7.0.0.tgz — Tesseract worker package
• tesseract.js-core-7.0.0.tgz — Tesseract core runtime package
• tesseract-langdata/ — OCR traineddata files
• ocr-fonts/ — OCR text-layer font files

Step 5: Set up inside the air-gapped network

# Load the Docker image
docker load -i bentopdf.tar

# Extract the WASM packages
mkdir -p ./wasm/pymupdf ./wasm/gs ./wasm/cpdf ./wasm/ocr/core ./wasm/ocr/lang-data ./wasm/ocr/fonts
tar xzf bentopdf-pymupdf-wasm-0.11.14.tgz -C ./wasm/pymupdf --strip-components=1
tar xzf bentopdf-gs-wasm-*.tgz -C ./wasm/gs --strip-components=1
tar xzf coherentpdf-*.tgz -C ./wasm/cpdf --strip-components=1
TEMP_TESS=$(mktemp -d)
tar xzf tesseract.js-7.0.0.tgz -C "$TEMP_TESS"
cp "$TEMP_TESS/package/dist/worker.min.js" ./wasm/ocr/worker.min.js
rm -rf "$TEMP_TESS"
tar xzf tesseract.js-core-7.0.0.tgz -C ./wasm/ocr/core --strip-components=1
cp ./tesseract-langdata/*.traineddata.gz ./wasm/ocr/lang-data/
cp ./ocr-fonts/* ./wasm/ocr/fonts/

# Run BentoPDF
docker run -d -p 3000:8080 --restart unless-stopped bentopdf

Make sure the files are accessible at the URLs you configured in Step 2, including .../ocr/worker.min.js, .../ocr/core, .../ocr/lang-data, and .../ocr/fonts.

[!NOTE] If you're building from source instead of Docker, set the variables in .env.production before running npm run build:

VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/
VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/
VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/
VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js
VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core
VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data
VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts

Subdirectory Hosting:

BentoPDF can also be hosted from a subdirectory (e.g., example.com/tools/bentopdf/):

# Example:
# 1. Build the app with the specific BASE_URL. BASE_URL must have a trailing and leading slash. The BASE_URL can be any URL of your choice. Here we are using /tools/bentopdf/ as an example.

BASE_URL=/tools/bentopdf/ npm run build

# 2. Create the nested directory structure inside serve-test (or any folder of your choice for local testing. In case of production, create the nested directory structure inside the root directory)
mkdir -p serve-test/tools/bentopdf

# 3. Copy all files from the 'dist' folder into that nested directory
cp -r dist/* serve-test/tools/bentopdf/

# 4. Serve the 'serve-test' folder
npx serve serve-test

The website can be accessible at: http://localhost:3000/tools/bentopdf/

The npm run package command creates a dist-{version}.zip file that you can use for self-hosting.

Docker Subdirectory Deployment:

BentoPDF's Docker image also supports the BASE_URL build argument for subdirectory deployments:

# Build for subdirectory deployment
docker build --build-arg BASE_URL=/bentopdf/ -t bentopdf .

# Run the container
docker run -p 3000:8080 bentopdf

# The app will be accessible at http://localhost:3000/bentopdf/

Default Language:

Set the default UI language at build time. Users can still switch languages — this only changes the initial default. Supported: en, ar, be, fr, de, es, zh, zh-TW, vi, tr, id, it, pt, nl, da.

docker build --build-arg VITE_DEFAULT_LANGUAGE=fr -t bentopdf .

Combined with Simple Mode:

# Build with both BASE_URL and SIMPLE_MODE
docker build \
  --build-arg BASE_URL=/tools/pdf/ \
  --build-arg SIMPLE_MODE=true \
  -t bentopdf-simple .

docker run -p 3000:8080 bentopdf-simple

[!IMPORTANT]

• Always include trailing slashes in BASE_URL (e.g., /bentopdf/ not /bentopdf)
• The default value is / for root deployment

🚀 Run with Docker Compose / Podman Compose (Recommended)

For a more robust setup with auto-restart capabilities:

1. Download the repo and create a docker-compose.yml file or use the one given in repo:

services:
  bentopdf:
    image: ghcr.io/alam00000/bentopdf-simple:latest # Self-Hosted build (recommended)
    # image: bentopdfteam/bentopdf-simple:latest     # Self-Hosted build (Docker Hub)
    # image: ghcr.io/alam00000/bentopdf:latest       # Commercial build (bentopdf.com / commercial license holders)
    container_name: bentopdf
    ports:
      - '3000:8080'
    restart: unless-stopped

2. Start the application:

# Docker Compose
docker-compose up -d

# Podman Compose
podman-compose up -d

The application will be available at http://localhost:3000.

🐧 Podman Quadlet (Systemd Integration)

For Linux production deployments, you can run BentoPDF as a systemd service using Podman Quadlet.

Create ~/.config/containers/systemd/bentopdf.container:

[Unit]
Description=BentoPDF - Privacy-first PDF toolkit
After=network-online.target

[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry

[Service]
Restart=always

[Install]
WantedBy=default.target

Then enable and start:

systemctl --user daemon-reload
systemctl --user enable --now bentopdf

For detailed Quadlet configuration, see Self-Hosting Docker Guide.

🏢 Self-Hosted build (Simple Mode)

The Self-Hosted build (the bentopdf-simple image, also called Simple Mode) is functionally identical to the Commercial build. Every PDF tool is present and behaves the same. It just hides the marketing that only makes sense on bentopdf.com itself or on a commercial public-facing deployment. It is not a feature-reduced or "lite" version.

What the Self-Hosted build hides (cosmetic only, no PDF features are removed):

• Navigation bar, hero section, features section, FAQ, testimonials, footer
• Updates page title to "PDF Tools"

What the Self-Hosted build keeps (everything that actually does PDF work):

• All PDF tools (merge, split, edit, sign, OCR, Office conversion, every other tool)
• Custom branding support, all build-time and runtime config

The Commercial build (ghcr.io/alam00000/bentopdf:latest) is what powers bentopdf.com itself and is used by commercial license holders running public-facing deployments. It adds the hero, FAQ, testimonials, and footer that wouldn't make sense on an internal tool.

If you're self-hosting BentoPDF for your team, organization, or as an internal tool, pull ghcr.io/alam00000/bentopdf-simple:latest. For more details, see SIMPLE_MODE.md.

🏬 Commercial Build

The Commercial build (the bentopdf image. Note: no -simple suffix) is what powers bentopdf.com itself. It includes the full marketing site (hero, features, FAQ, testimonials, footer) on top of every PDF tool. Use this build when you're running BentoPDF as a public-facing PDF service under your own brand. For example:

• You're deploying BentoPDF as a hosted SaaS for end-users (with your own domain and branding)
• You want the landing-page experience (marketing sections + tools), not just the tool surface
• You're a commercial license holder embedding BentoPDF into a commercial product or workflow

Run it as-is (carries BentoPDF branding by default. Useful to evaluate what the build looks like):

docker run -p 3000:8080 ghcr.io/alam00000/bentopdf:latest

Build with your own brand (the typical commercial path — replace the BentoPDF logo, name, and footer):

docker build \
  --build-arg VITE_BRAND_NAME="AcmePDF" \
  --build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
  --build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. All rights reserved." \
  -t acmepdf .

docker run -p 3000:8080 acmepdf

Or set the same variables when building from source — see Custom Branding below for the full list of options.

Combine with other build-time flags (BASE_URL, VITE_DEFAULT_LANGUAGE, DISABLE_TOOLS, VITE_USE_CDN, WASM URL overrides for air-gapped use, etc.) — every option that works on the Self-Hosted build also works here.

[!IMPORTANT] Licensing: Running the Commercial build is allowed under both license options BentoPDF ships under:

• AGPL-3.0 (free): allowed if your deployment publishes its full source code under AGPL — this includes any branding modifications, custom configuration, and any code you build on top of it.
• Commercial license ($79 lifetime): required for closed-source / proprietary deployments — e.g., a private SaaS where you don't open-source your branding fork or surrounding business logic.

See the Licensing page for the full comparison.

🎨 Custom Branding

Replace the default BentoPDF logo, name, and footer text with your own. Branding is configured via environment variables at build time and works across all deployment methods (Docker, static hosting, air-gapped VMs).

Variable	Description	Default
VITE_BRAND_NAME	Brand name shown in header and footer	BentoPDF
VITE_BRAND_LOGO	Path to logo file relative to public/	images/favicon-no-bg.svg
VITE_FOOTER_TEXT	Custom footer/copyright text	© 2026 BentoPDF. All rights reserved.

Docker:

docker build \
  --build-arg VITE_BRAND_NAME="AcmePDF" \
  --build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
  --build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
  -t acmepdf .

Building from source:

Place your logo in the public/ folder, then build:

VITE_BRAND_NAME="AcmePDF" \
VITE_BRAND_LOGO="images/acme-logo.svg" \
VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
npm run build

Or set the values in .env.production before building.

[!TIP] Branding works in both full mode and Simple Mode. You can combine it with other build-time options like SIMPLE_MODE, BASE_URL, and VITE_DEFAULT_LANGUAGE.

🚫 Disabling Specific Tools

Hide tools from the UI for compliance or security requirements. Disabled tools are removed from the homepage, search, keyboard shortcuts, workflow builder, and direct URL access.

Tool IDs are the page URL without .html — open any tool and look at the URL (e.g., edit-pdf, sign-pdf, encrypt-pdf).

Build-time (baked into the bundle):

docker build --build-arg DISABLE_TOOLS="edit-pdf,sign-pdf,encrypt-pdf" -t bentopdf .

Runtime (no rebuild — mount a config.json):

{
  "disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}

docker run -d -p 3000:8080 \
  -v ./config.json:/usr/share/nginx/html/config.json:ro \
  ghcr.io/alam00000/bentopdf-simple:latest

Both methods can be combined — the lists are merged. For the full list of tool IDs, see the self-hosting docs.

You can also disable specific features inside the PDF Editor (e.g., redaction, forms) without disabling the entire editor. Add editorDisabledCategories to your config.json:

{
  "editorDisabledCategories": ["redaction"]
}

For the full list of editor categories, see the self-hosting docs.

🔕 Disabling the GitHub Star Counter

The navbar shows a live GitHub star count, fetched from api.github.com on page load. The only external request that isn't serving a PDF feature. Self-hosters who want zero non-essential network calls can disable it at build time. This removes the fetch code from the bundle entirely and drops api.github.com from the Content-Security-Policy.

Simple Mode builds (bentopdf-simple) always skip the star counter — this flag is only needed on the Commercial build or custom full builds.

Docker:

docker build --build-arg DISABLE_GITHUB_STARS=true -t bentopdf .

Building from source:

DISABLE_GITHUB_STARS=true npm run build

🔒 Security Features

BentoPDF runs as a non-root user using nginx-unprivileged for enhanced security:

• Non-Root Execution: Container runs with minimal privileges using nginx-unprivileged
• Port 8080: Uses high port number to avoid requiring root privileges (configurable via PORT env var)
• Security Best Practices: Follows Principle of Least Privilege

Basic Usage

docker build -t bentopdf .
docker run -p 8080:8080 bentopdf

Custom Port

By default, BentoPDF listens on port 8080 inside the container. To change this, set the PORT environment variable:

docker run -p 3000:9090 -e PORT=9090 ghcr.io/alam00000/bentopdf-simple:latest

Variable	Description	Default
PORT	Nginx listen port in container	8080

Custom User ID (PUID/PGID)

For environments that require running as a specific non-root user (e.g., NAS devices, Kubernetes with security contexts), use the non-root Dockerfile:

# Build the non-root image
docker build -f Dockerfile.nonroot -t bentopdf-nonroot .

# Run with custom UID/GID
docker run -d -p 3000:8080 -e PUID=1000 -e PGID=1000 bentopdf-nonroot

Variable	Description	Default
PUID	User ID to run as	1000
PGID	Group ID to run as	1000

[!NOTE] The standard Dockerfile uses `nginx-unprivil