alam00000/bentopdf

_{Supported by}

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.

• Join Us on Discord
• Documentation
• Licensing
• Stargazers over time
• Thank You to Our Sponsors
• 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

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

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

BentoPDF is dual-licensed to fit your needs:

One-time purchase · Unlimited devices & users · Lifetime updates · No AGPL obligations

📖 For more details, see our Licensing Page

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:

We're incredibly grateful to all our sponsors and supporters who help keep BentoPDF free and open source!

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

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

BentoPDF is available in multiple languages:

Language	Status
English
Chinese
Traditional Chinese
French
German
Indonesian
Italian
Portuguese
Turkish
Vietnamese
Korean
Russian

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

You can run BentoPDF locally for development or personal use.

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

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

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

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

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

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.

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.

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/

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:

BentoPDF supports different compression modes for optimized builds:

# Gzip only (smallest Docker image size)
npm run build:gzip
docker build --build-arg COMPRESSION_MODE=g -t bentopdf:gzip .

# Brotli only (best compression ratio)
npm run build:brotli
docker build --build-arg COMPRESSION_MODE=b -t bentopdf:brotli .

# No compression (fastest build time)
npm run build:original
docker build --build-arg COMPRESSION_MODE=o -t bentopdf:original .

# All formats (default, maximum browser compatibility)
npm run build:all
docker build --build-arg COMPRESSION_MODE=all -t bentopdf:all .

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/pymupdf-wasm@0.11.16/
VITE_WASM_GS_URL=https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/
VITE_WASM_CPDF_URL=https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/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.

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.

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.

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.

npm pack @bentopdf/pymupdf-wasm@0.11.16
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack tesseract.js@7.0.0
npm pack tesseract.js-core@7.0.0
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

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 .

docker save bentopdf -o bentopdf.tar

# 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

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

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

1. Start the application:

# Docker Compose
docker-compose up -d

# Podman Compose
podman-compose up -d

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

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.

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.

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.

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

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.

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.

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

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

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

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

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

For detailed security configuration, see SECURITY.md.

The Digital Signature tool uses a signing library that may need to fetch certificate chain data from certificate authority providers. Since many certificate servers don't include CORS headers (and often serve over HTTP, which is blocked by browsers on HTTPS sites), a proxy is required for this feature to work.

When is the proxy needed?

• Only when using the Digital Signature tool
• Only if your certificate requires fetching issuer certificates from external URLs
• Self-signed certificates typically don't need this

Deploying the CORS Proxy (Cloudflare Workers):

1. Navigate to the cloudflare directory:

   cd cloudflare

2. Login to Cloudflare (if not already):

   npx wrangler login

3. Update allowed origins — open cors-proxy-worker.js and change ALLOWED_ORIGINS to your domain:

   const ALLOWED_ORIGINS = [
     'https://your-domain.com',
     'https://www.your-domain.com',
   ];

   [!IMPORTANT] Without this step, the proxy will reject all requests from your site with a 403 error. The default only allows bentopdf.com.

4. Deploy the worker:

   npx wrangler deploy

5. Note your worker URL (e.g., https://bentopdf-cors-proxy.your-subdomain.workers.dev)

6. Set the environment variable when building:

   VITE_CORS_PROXY_URL=https://your-worker-url.workers.dev npm run build

   Or with Docker:

   export VITE_CORS_PROXY_URL="https://your-worker-url.workers.dev"
   DOCKER_BUILDKIT=1 docker build \
    --secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
    -t your-bentopdf .

The CORS proxy includes several security measures:

Rate limiting requires Cloudflare KV storage:

cd cloudflare

# Create KV namespace
npx wrangler kv namespace create "RATE_LIMIT_KV"

# Copy the returned ID and add to wrangler.toml:
# [[kv_namespaces]]
# binding = "RATE_LIMIT_KV"
# id = "YOUR_ID_HERE"

# Redeploy
npx wrangler deploy

Free tier limits: 100,000 reads/day, 1,000 writes/day (~300-500 signatures/day)

BentoPDF uses client-side HMAC as a deterrent against casual abuse, but accepts this tradeoff due to its fully client-side architecture. To enable:

# Generate a secret
openssl rand -hex 32

# Set on Cloudflare Worker
npx wrangler secret put PROXY_SECRET

# Set in build environment
VITE_CORS_PROXY_SECRET=your-secret npm run build

# Or with Docker (optional; URL secret also shown for completeness)
export VITE_CORS_PROXY_URL="https://your-worker-url.workers.dev"
export VITE_CORS_PROXY_SECRET="your-secret"
DOCKER_BUILDKIT=1 docker build \
  --secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
  --secret id=VITE_CORS_PROXY_SECRET,env=VITE_CORS_PROXY_SECRET \
  -t your-bentopdf .

BentoPDF publishes two image variants. Both ship the same PDF tools. The difference is purely whether the bentopdf.com marketing is included.

Self-Hosted build — recommended for internal/team/organization deployments:

• Latest: ghcr.io/alam00000/bentopdf-simple:latest
• Specific Version: ghcr.io/alam00000/bentopdf-simple:1.0.0
• Docker Hub: bentopdfteam/bentopdf-simple:latest

Commercial build — used by bentopdf.com itself and by commercial license holders running public-facing deployments:

• Latest: ghcr.io/alam00000/bentopdf:latest
• Specific Version: ghcr.io/alam00000/bentopdf:1.0.0
• Docker Hub: bentopdfteam/bentopdf:latest

# Release a patch version (0.0.1 → 0.0.2)
npm run release

# Release a minor version (0.0.1 → 0.1.0)
npm run release:minor

# Release a major version (0.0.1 → 1.0.0)
npm run release:major

For detailed release instructions, see RELEASE.md.

1. Clone the Repository:

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

2. Install Dependencies:

   npm install

3. Run the Development Server:

   npm run dev

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

   The dev server binds to localhost only by default. To expose it on your LAN (e.g. for mobile device testing), set VITE_DEV_HOST=0.0.0.0 npm run dev. The built-in CORS proxy at /cors-proxy?url= restricts targets to a known host allowlist; to permit additional hosts in development, set VITE_DEV_CORS_PROXY_EXTRA_HOSTS="host1.example.com,host2.example.com".

1. Clone the Repository:

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

2. Run with Docker Compose:

   docker-compose -f docker-compose.dev.yml up -d

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

   [!NOTE] After making any local changes to the code, rebuild the Docker image using:

   docker-compose -f docker-compose.dev.yml up --build -d

   This ensures your latest changes are applied inside the container.

BentoPDF was originally built using HTML, CSS, and vanilla JavaScript. As the project grew, it was migrated to a modern stack for better maintainability and scalability:

• Vite: A fast build tool for modern web development.
• TypeScript: For type safety and an improved developer experience.
• Tailwind CSS: For rapid and consistent UI development.

• HTML to PDF: Convert HTML files or web pages into PDF documents.

Contributions and discussions on the roadmap are welcome! Join the conversation via Discord.

We welcome contributions from the community! Here's how you can get started:

1. Fork the repository and create your branch from main.
2. Follow the Getting Started steps to set up your local environment.
3. Make your changes and commit them with a clear message.
4. Open a Pull Request and describe the changes you've made.

Have an idea for a new tool or an improvement? Open an issue to discuss it first.

Our documentation is built with VitePress. Here's how to contribute:

# Install dependencies
npm install

# Start docs dev server
npm run docs:dev

# Build docs for production
npm run docs:build

# Preview the built docs
npm run docs:preview

Documentation files are in the docs/ folder:

• docs/index.md - Home page
• docs/getting-started.md - Getting started guide
• docs/tools/ - Tools reference
• docs/self-hosting/ - Self-hosting guides (Docker, Vercel, Netlify, Hostinger, etc.)
• docs/contributing.md - Contributing guide
• docs/licensing.md - Commercial license info

BentoPDF wouldn't be possible without the amazing open-source tools and libraries that power it. We'd like to extend our heartfelt thanks to the creators and maintainers of:

Bundled Libraries:

• PDFLib.js – For enabling powerful client-side PDF manipulation.
• PDF.js – For the robust PDF rendering engine in the browser.
• PDFKit – For creating and editing PDFs with ease.
• EmbedPDF – For seamless PDF editing in pure JS.
• Cropper.js – For intuitive image cropping functionality.
• Vite – For lightning-fast development and build tooling.
• Tailwind CSS – For rapid, flexible, and beautiful UI styling.
• qpdf and qpdf-wasm – For inspecting, repairing, and transforming PDF files.
• LibreOffice – For powerful document conversion capabilities.
• wasm-vips – For advanced TIFF encoding with compression (LZW, Deflate, CCITT Group 4).
• pixelmatch – For fast, accurate image comparison and diff detection.
• diff – For computing text differences.
• microdiff – For lightweight, fast object diffing.

AGPL Libraries (Pre-configured via CDN):

• CoherentPDF (cpdf) – For content-preserving PDF operations. (AGPL-3.0)
• PyMuPDF – For high-performance PDF manipulation and data extraction. (AGPL-3.0)
• Ghostscript (GhostPDL) – For PDF/A conversion and font outlining. (AGPL-3.0)

Your work inspires and empowers developers everywhere. Thank you for making open-source amazing!