fix(split): wrong output paths when converting to PDF/A & PDF/UA

feat(split): add splitUnify form field
chore(deps): update Go depencies
2026-08-08 08:32:16 +01:00 · 2024-12-23 10:04:24 +01:00 · 2024-12-21 12:45:20 +01:00 · 2024-12-20 16:16:32 +01:00 · 2024-12-20 16:16:32 +01:00 · 2024-11-25 09:28:42 +01:00
74 changed files with 5909 additions and 1501 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: [gulien]
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -1,7 +1,7 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 15
+daysUntilStale: 7
 # Number of days of inactivity before a stale issue is closed
-daysUntilClose: 7
+daysUntilClose: 3
 # Issues with these labels will never be considered stale
 exemptLabels:
  - bug
--- a/.github/workflows/continuous_delivery.yml
+++ b/.github/workflows/continuous_delivery.yml
@@ -23,4 +23,4 @@ jobs:
      - name: Build and push Docker image for release
        run: |
          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }}
-          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REPOSITORY=thecodingmachine
+          make release GOTENBERG_VERSION=${{ github.event.release.tag_name }} DOCKER_REGISTRY=thecodingmachine
--- a/.github/workflows/continuous_integration.yml
+++ b/.github/workflows/continuous_integration.yml
@@ -17,18 +17,18 @@ jobs:
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
-          go-version: '1.22'
+          go-version: '1.23'
          cache: false
      - name: Checkout source code
        uses: actions/checkout@v4
      - name: Run linters
        uses: golangci/golangci-lint-action@v6
        with:
-          version: v1.59.0
+          version: v1.61.0

  tests:
    needs:
-      - Lint
+      - lint
    name: Tests
    # TODO: once arm64 actions are available, also run the tests on this architecture.
    # See: https://github.com/actions/virtual-environments/issues/2552#issuecomment-771478000.
@@ -50,11 +50,32 @@ jobs:
          token: ${{ secrets.CODECOV_TOKEN }}
          verbose: true

-  multiarch_build:
+  snapshot_release:
+    if: github.event_name == 'pull_request'
+    needs:
+      - tests
+    name: Snapshot release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: Log in to Docker Hub Container Registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push snapshot Docker image (linux/amd64)
+        run: make release GOTENBERG_VERSION=${{ github.head_ref }} DOCKER_REPOSITORY=snapshot LINUX_AMD64_RELEASE=true
+
+  edge_release:
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    needs:
-      - Tests
-    name: Multi-arch build
+      - tests
+    name: Edge release
    runs-on: ubuntu-latest
    steps:
      - name: Set up QEMU
@@ -71,4 +92,4 @@ jobs:
      - name: Build and push Docker image for main branch
        run: |
          make release GOTENBERG_VERSION=edge
-          make release GOTENBERG_VERSION=edge DOCKER_REPOSITORY=thecodingmachine
+          make release GOTENBERG_VERSION=edge DOCKER_REGISTRY=thecodingmachine
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -6,6 +6,10 @@ linters-settings:
      - prefix(github.com/gotenberg/gotenberg/v8)
    skip-generated: true
    custom-order: true
+  # Until https://github.com/securego/gosec/issues/1187 is resolved.
+  gosec:
+    excludes:
+      - G115

 linters:
  disable-all: true
@@ -19,10 +23,10 @@ linters:
    - dupl
    - dupword
    - durationcheck
+    - copyloopvar
    - errcheck
    - errname
    - exhaustive
-    - exportloopref
    - gci
    - gofmt
    - goimports
--- a/52
+++ b/52
@@ -5,14 +5,16 @@ help: ## Show the help
 .PHONY: it
 it: build build-tests ## Initialize the development environment

-GOLANG_VERSION=1.22
+GOLANG_VERSION=1.23
+DOCKER_REGISTRY=gotenberg
 DOCKER_REPOSITORY=gotenberg
 GOTENBERG_VERSION=snapshot
 GOTENBERG_USER_GID=1001
 GOTENBERG_USER_UID=1001
-NOTO_COLOR_EMOJI_VERSION=v2.042 # See https://github.com/googlefonts/noto-emoji/releases.
+NOTO_COLOR_EMOJI_VERSION=v2.047 # See https://github.com/googlefonts/noto-emoji/releases.
 PDFTK_VERSION=v3.3.3 # See https://gitlab.com/pdftk-java/pdftk/-/releases - Binary package.
-GOLANGCI_LINT_VERSION=v1.59.0 # See https://github.com/golangci/golangci-lint/releases.
+PDFCPU_VERSION=v0.8.1 # See https://github.com/pdfcpu/pdfcpu/releases.
+GOLANGCI_LINT_VERSION=v1.61.0 # See https://github.com/golangci/golangci-lint/releases.

 .PHONY: build
 build: ## Build the Gotenberg's Docker image
@@ -23,19 +25,26 @@ build: ## Build the Gotenberg's Docker image
 	--build-arg GOTENBERG_USER_UID=$(GOTENBERG_USER_UID) \
 	--build-arg NOTO_COLOR_EMOJI_VERSION=$(NOTO_COLOR_EMOJI_VERSION) \
 	--build-arg PDFTK_VERSION=$(PDFTK_VERSION) \
-	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	--build-arg PDFCPU_VERSION=$(PDFCPU_VERSION) \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
 	-f build/Dockerfile .

 GOTENBERG_GRACEFUL_SHUTDOWN_DURATION=30s
 API_PORT=3000
 API_PORT_FROM_ENV=
+API_BIND_IP=
 API_START_TIMEOUT=30s
 API_TIMEOUT=30s
+API_BODY_LIMIT=
 API_ROOT_PATH=/
 API_TRACE_HEADER=Gotenberg-Trace
 API_ENABLE_BASIC_AUTH=false
 GOTENBERG_API_BASIC_AUTH_USERNAME=
 GOTENBERG_API_BASIC_AUTH_PASSWORD=
+API-DOWNLOAD-FROM-ALLOW-LIST=
+API-DOWNLOAD-FROM-DENY-LIST=
+API-DOWNLOAD-FROM-FROM-MAX-RETRY=4
+API-DISABLE-DOWNLOAD-FROM=false
 API_DISABLE_HEALTH_CHECK_LOGGING=false
 CHROMIUM_RESTART_AFTER=0
 CHROMIUM_MAX_QUEUE_SIZE=0
@@ -63,6 +72,11 @@ LOG_LEVEL=info
 LOG_FORMAT=auto
 LOG_FIELDS_PREFIX=
 PDFENGINES_ENGINES=
+PDFENGINES_MERGE_ENGINES=qpdf,pdfcpu,pdftk
+PDFENGINES_SPLIT_ENGINES=pdfcpu,qpdf,pdftk
+PDFENGINES_CONVERT_ENGINES=libreoffice-pdfengine
+PDFENGINES_READ_METADATA_ENGINES=exiftool
+PDFENGINES_WRITE_METADATA_ENGINES=exiftool
 PDFENGINES_DISABLE_ROUTES=false
 PROMETHEUS_NAMESPACE=gotenberg
 PROMETHEUS_COLLECT_INTERVAL=1s
@@ -84,16 +98,22 @@ run: ## Start a Gotenberg container
 	-p $(API_PORT):$(API_PORT) \
 	-e GOTENBERG_API_BASIC_AUTH_USERNAME=$(GOTENBERG_API_BASIC_AUTH_USERNAME) \
 	-e GOTENBERG_API_BASIC_AUTH_PASSWORD=$(GOTENBERG_API_BASIC_AUTH_PASSWORD) \
-	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION) \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION) \
 	gotenberg \
 	--gotenberg-graceful-shutdown-duration=$(GOTENBERG_GRACEFUL_SHUTDOWN_DURATION) \
 	--api-port=$(API_PORT) \
 	--api-port-from-env=$(API_PORT_FROM_ENV) \
+	--api-bind-ip=$(API_BIND_IP) \
 	--api-start-timeout=$(API_START_TIMEOUT) \
 	--api-timeout=$(API_TIMEOUT) \
+	--api-body-limit="$(API_BODY_LIMIT)" \
 	--api-root-path=$(API_ROOT_PATH) \
 	--api-trace-header=$(API_TRACE_HEADER) \
 	--api-enable-basic-auth=$(API_ENABLE_BASIC_AUTH) \
+	--api-download-from-allow-list=$(API-DOWNLOAD-FROM-ALLOW-LIST) \
+	--api-download-from-deny-list=$(API-DOWNLOAD-FROM-DENY-LIST) \
+	--api-download-from-max-retry=$(API-DOWNLOAD-FROM-FROM-MAX-RETRY) \
+	--api-disable-download-from=$(API-DISABLE-DOWNLOAD-FROM) \
 	--api-disable-health-check-logging=$(API_DISABLE_HEALTH_CHECK_LOGGING) \
 	--chromium-restart-after=$(CHROMIUM_RESTART_AFTER) \
 	--chromium-auto-start=$(CHROMIUM_AUTO_START) \
@@ -121,6 +141,11 @@ run: ## Start a Gotenberg container
 	--log-format=$(LOG_FORMAT) \
 	--log-fields-prefix=$(LOG_FIELDS_PREFIX) \
 	--pdfengines-engines=$(PDFENGINES_ENGINES) \
+	--pdfengines-merge-engines=$(PDFENGINES_MERGE_ENGINES) \
+	--pdfengines-split-engines=$(PDFENGINES_SPLIT_ENGINES) \
+	--pdfengines-convert-engines=$(PDFENGINES_CONVERT_ENGINES) \
+	--pdfengines-read-metadata-engines=$(PDFENGINES_READ_METADATA_ENGINES) \
+	--pdfengines-write-metadata-engines=$(PDFENGINES_WRITE_METADATA_ENGINES) \
 	--pdfengines-disable-routes=$(PDFENGINES_DISABLE_ROUTES) \
 	--prometheus-namespace=$(PROMETHEUS_NAMESPACE) \
 	--prometheus-collect-interval=$(PROMETHEUS_COLLECT_INTERVAL) \
@@ -140,24 +165,25 @@ run: ## Start a Gotenberg container
 build-tests: ## Build the tests' Docker image
 	docker build \
 	--build-arg GOLANG_VERSION=$(GOLANG_VERSION) \
+	--build-arg DOCKER_REGISTRY=$(DOCKER_REGISTRY) \
 	--build-arg DOCKER_REPOSITORY=$(DOCKER_REPOSITORY) \
 	--build-arg GOTENBERG_VERSION=$(GOTENBERG_VERSION) \
 	--build-arg GOLANGCI_LINT_VERSION=$(GOLANGCI_LINT_VERSION) \
-	-t $(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	-t $(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
 	-f test/Dockerfile .

 .PHONY: tests
 tests: ## Start the testing environment
 	docker run --rm -it \
 	-v $(PWD):/tests \
-	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
 	bash

 .PHONY: tests-once
 tests-once: ## Run the tests once (prefer the "tests" command while developing)
 	docker run --rm  \
 	-v $(PWD):/tests \
-	$(DOCKER_REPOSITORY)/gotenberg:$(GOTENBERG_VERSION)-tests \
+	$(DOCKER_REGISTRY)/$(DOCKER_REPOSITORY):$(GOTENBERG_VERSION)-tests \
 	gotest

 # go install mvdan.cc/gofumpt@latest
@@ -174,8 +200,10 @@ godoc: ## Run a webserver with Gotenberg godoc
 	$(info http://localhost:6060/pkg/github.com/gotenberg/gotenberg/v8)
 	godoc -http=:6060

+LINUX_AMD64_RELEASE=false
+
 .PHONY: release
-release: ## Build the Gotenberg's Docker image for many platforms, then push it to a Docker repository
+release: ## Build the Gotenberg's Docker image and push it to a Docker repository
 	./scripts/release.sh \
 	$(GOLANG_VERSION) \
 	$(GOTENBERG_VERSION) \
@@ -183,4 +211,8 @@ release: ## Build the Gotenberg's Docker image for many platforms, then push it
 	$(GOTENBERG_USER_UID) \
 	$(NOTO_COLOR_EMOJI_VERSION) \
 	$(PDFTK_VERSION) \
-	$(DOCKER_REPOSITORY)
+	$(PDFCPU_VERSION) \
+	$(DOCKER_REGISTRY) \
+	$(DOCKER_REPOSITORY) \
+	$(LINUX_AMD64_RELEASE)
+
--- a/README.md
+++ b/README.md
@@ -2,12 +2,20 @@
    <img src="https://user-images.githubusercontent.com/8983173/130322857-185831e2-f041-46eb-a17f-0a69d066c4e5.png" alt="Gotenberg Logo" width="150" height="150" />
    <h3 align="center">Gotenberg</h3>
    <p align="center">A Docker-powered stateless API for PDF files</p>
+    <p align="center">
+        <a href="https://hub.docker.com/r/gotenberg/gotenberg"><img alt="Total downloads (gotenberg/gotenberg)" src="https://img.shields.io/docker/pulls/gotenberg/gotenberg"></a>
+        <a href="https://hub.docker.com/r/thecodingmachine/gotenberg"><img alt="Total downloads (thecodingmachine/gotenberg)" src="https://img.shields.io/docker/pulls/thecodingmachine/gotenberg"></a>
+        <br>
+        <a href="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml"><img alt="Continuous Integration" src="https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg"></a>
+        <a href="https://pkg.go.dev/github.com/gotenberg/gotenberg/v8"><img alt="Go Reference" src="https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg"></a>
+        <a href="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"><img alt="Code coverage" src="https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg"></a>
+    </p>
    <p align="center"><a href="https://gotenberg.dev/docs/getting-started/introduction">Documentation</a> &#183; <a href="https://gotenberg.dev/docs/getting-started/installation#live-demo-">Live Demo</a> 🔥</p>
 </p>

 ---

-Gotenberg provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice for converting 
+**Gotenberg** provides a developer-friendly API to interact with powerful tools like Chromium and LibreOffice for converting 
 numerous document formats (HTML, Markdown, Word, Excel, etc.) into PDF files, and more!

 ## Quick Start
@@ -32,14 +40,11 @@ Head to the [documentation](https://gotenberg.dev/docs/getting-started/introduct

 <p align="center">
    <a href="https://thecodingmachine.com">
-        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="429" height="210" />
+        <img src="https://user-images.githubusercontent.com/8983173/130324668-9d6e7b35-53a3-49c7-a574-38190d2bd6b0.png" alt="TheCodingMachine Logo" width="333" height="163" />
+    </a>
+    <a href="https://zolsec.com?utm_source=gotenberg_github&utm_medium=website" target="_blank">
+        <img src="https://github.com/gotenberg/gotenberg/assets/8983173/707ccc97-a79b-4dcb-8fc8-6827366e5be3" alt="Zolsec Logo" width="333" height="163" />
    </a>
 </p>

-## Badges
-
-[![Docker pulls](https://img.shields.io/docker/pulls/gotenberg/gotenberg)](https://hub.docker.com/r/gotenberg/gotenberg)
-[![Docker pulls](https://img.shields.io/docker/pulls/thecodingmachine/gotenberg)](https://hub.docker.com/r/thecodingmachine/gotenberg)
-[![Continuous Integration](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/gotenberg/gotenberg/actions/workflows/continuous_integration.yml)
-[![Go Reference](https://pkg.go.dev/badge/github.com/gotenberg/gotenberg.svg)](https://pkg.go.dev/github.com/gotenberg/gotenberg/v8)
-[![Codecov](https://codecov.io/gh/gotenberg/gotenberg/branch/main/graph/badge.svg)](https://codecov.io/gh/gotenberg/gotenberg)
+Sponsorships help maintaining and improving Gotenberg - [become a sponsor](https://github.com/sponsors/gulien) ❤️
--- a/build/Dockerfile
+++ b/build/Dockerfile
@@ -3,13 +3,38 @@
 # stage that uses them.
 ARG GOLANG_VERSION

+# ----------------------------------------------
+# pdfcpu binary build stage
+# ----------------------------------------------
+# Note: this stage is required as pdfcpu does not release an armhf variant by
+# default.
+
+FROM golang:$GOLANG_VERSION AS pdfcpu-binary-stage
+
+ARG PDFCPU_VERSION
+ENV CGO_ENABLED=0
+
+# Define the working directory outside of $GOPATH (we're using go modules).
+WORKDIR /home
+
+RUN curl -Ls "https://github.com/pdfcpu/pdfcpu/archive/refs/tags/$PDFCPU_VERSION.tar.gz" -o pdfcpu.tar.gz &&\
+    tar --strip-components=1 -xvzf pdfcpu.tar.gz
+
+# Install module dependencies.
+RUN go mod download &&\
+    go mod verify
+
+RUN go build -o pdfcpu -ldflags "-s -w -X 'main.version=$PDFCPU_VERSION' -X 'github.com/pdfcpu/pdfcpu/pkg/pdfcpu.VersionStr=$PDFCPU_VERSION' -X main.builtBy=gotenberg" ./cmd/pdfcpu &&\
+    # Verify installation.
+    ./pdfcpu version
+
 # ----------------------------------------------
 # Gotenberg binary build stage
 # ----------------------------------------------
-FROM golang:$GOLANG_VERSION AS binary-stage
+FROM golang:$GOLANG_VERSION AS gotenberg-binary-stage

 ARG GOTENBERG_VERSION
-ENV CGO_ENABLED 0
+ENV CGO_ENABLED=0

 # Define the working directory outside of $GOPATH (we're using go modules).
 WORKDIR /home
@@ -187,16 +212,20 @@ RUN \
 # https://github.com/arachnys/athenapdf/commit/ba25a8d80a25d08d58865519c4cd8756dc9a336d.
 COPY build/fonts.conf /etc/fonts/conf.d/100-gotenberg.conf

-# Copy the Gotenberg binary from the binary stage.
-COPY --from=binary-stage /home/gotenberg /usr/bin/
+# Copy the pdfcpu binary from the pdfcpu-binary-stage.
+COPY --from=pdfcpu-binary-stage /home/pdfcpu /usr/bin/
+
+# Copy the Gotenberg binary from the gotenberg-binary-stage.
+COPY --from=gotenberg-binary-stage /home/gotenberg /usr/bin/

 # Environment variables required by modules or else.
-ENV CHROMIUM_BIN_PATH /usr/bin/chromium
-ENV LIBREOFFICE_BIN_PATH /usr/lib/libreoffice/program/soffice.bin
-ENV UNOCONVERTER_BIN_PATH /usr/bin/unoconverter
-ENV PDFTK_BIN_PATH /usr/bin/pdftk
-ENV QPDF_BIN_PATH /usr/bin/qpdf
-ENV EXIFTOOL_BIN_PATH /usr/bin/exiftool
+ENV CHROMIUM_BIN_PATH=/usr/bin/chromium
+ENV LIBREOFFICE_BIN_PATH=/usr/lib/libreoffice/program/soffice.bin
+ENV UNOCONVERTER_BIN_PATH=/usr/bin/unoconverter
+ENV PDFTK_BIN_PATH=/usr/bin/pdftk
+ENV QPDF_BIN_PATH=/usr/bin/qpdf
+ENV EXIFTOOL_BIN_PATH=/usr/bin/exiftool
+ENV PDFCPU_BIN_PATH=/usr/bin/pdfcpu

 USER gotenberg
 WORKDIR /home/gotenberg
--- a/build/Dockerfile.cloudrun
+++ b/build/Dockerfile.cloudrun
@@ -1,7 +1,8 @@
+ARG DOCKER_REGISTRY
 ARG DOCKER_REPOSITORY
 ARG GOTENBERG_VERSION

-FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION
+FROM $DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION

 USER root

--- a/go.mod
+++ b/go.mod
@@ -1,70 +1,62 @@
 module github.com/gotenberg/gotenberg/v8

-go 1.21
+go 1.23.0

 require (
 	github.com/alexliesenfeld/health v0.8.0
-	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
 	github.com/barasher/go-exiftool v1.10.0
-	github.com/chromedp/cdproto v0.0.0-20240602235142-49d0e97b7881
-	github.com/chromedp/chromedp v0.9.5
+	github.com/chromedp/cdproto v0.0.0-20241208230723-d1c7de7e5dd2
+	github.com/chromedp/chromedp v0.11.2
 	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/uuid v1.6.0
 	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/hashicorp/go-retryablehttp v0.7.7
-	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/klauspost/pgzip v1.2.6 // indirect
-	github.com/labstack/echo/v4 v4.12.0
+	github.com/labstack/echo/v4 v4.13.3
 	github.com/labstack/gommon v0.4.2
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mholt/archiver/v3 v3.5.1
-	github.com/microcosm-cc/bluemonday v1.0.26
+	github.com/microcosm-cc/bluemonday v1.0.27
 	github.com/nwaples/rardecode v1.1.3 // indirect
-	github.com/pdfcpu/pdfcpu v0.8.0
-	github.com/pierrec/lz4/v4 v4.1.21 // indirect
-	github.com/prometheus/client_golang v1.19.1
+	github.com/pierrec/lz4/v4 v4.1.22 // indirect
+	github.com/prometheus/client_golang v1.20.5
 	github.com/russross/blackfriday/v2 v2.1.0
 	github.com/spf13/pflag v1.0.5
 	github.com/ulikunitz/xz v0.5.12 // indirect
 	go.uber.org/multierr v1.11.0
 	go.uber.org/zap v1.27.0
-	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/image v0.17.0 // indirect
-	golang.org/x/net v0.26.0
-	golang.org/x/sync v0.7.0
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/term v0.21.0
-	golang.org/x/text v0.16.0
+	golang.org/x/crypto v0.31.0 // indirect
+	golang.org/x/net v0.33.0
+	golang.org/x/sync v0.10.0
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/term v0.27.0
+	golang.org/x/text v0.21.0
 )

-require github.com/dlclark/regexp2 v1.11.0
+require github.com/dlclark/regexp2 v1.11.4

 require (
 	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/chromedp/sysutil v1.1.0 // indirect
 	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
 	github.com/gobwas/httphead v0.1.0 // indirect
 	github.com/gobwas/pool v0.2.1 // indirect
 	github.com/gobwas/ws v1.4.0 // indirect
-	github.com/golang-jwt/jwt v3.2.2+incompatible // indirect
 	github.com/gorilla/css v1.0.1 // indirect
-	github.com/hhrutter/lzw v1.0.0 // indirect
-	github.com/hhrutter/tiff v1.0.1 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mailru/easyjson v0.9.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.54.0 // indirect
+	github.com/prometheus/common v0.61.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fasttemplate v1.2.2 // indirect
 	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
-	golang.org/x/time v0.5.0 // indirect
-	google.golang.org/protobuf v1.34.2 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
+	golang.org/x/time v0.8.0 // indirect
+	google.golang.org/protobuf v1.36.0 // indirect
 )
--- a/go.sum
+++ b/go.sum
@@ -1,8 +1,8 @@
 github.com/alexliesenfeld/health v0.8.0 h1:lCV0i+ZJPTbqP7LfKG7p3qZBl5VhelwUFCIVWl77fgk=
 github.com/alexliesenfeld/health v0.8.0/go.mod h1:TfNP0f+9WQVWMQRzvMUjlws4ceXKEL3WR+6Hp95HUFc=
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
-github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
-github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/barasher/go-exiftool v1.10.0 h1:f5JY5jc42M7tzR6tbL9508S2IXdIcG9QyieEXNMpIhs=
@@ -11,18 +11,17 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/chromedp/cdproto v0.0.0-20240202021202-6d0b6a386732/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/cdproto v0.0.0-20240602235142-49d0e97b7881 h1:RAUqkPvbEDGPgCYVc4GefBqAorWJAjKpVHgsRZyJmGE=
-github.com/chromedp/cdproto v0.0.0-20240602235142-49d0e97b7881/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs=
-github.com/chromedp/chromedp v0.9.5 h1:viASzruPJOiThk7c5bueOUY91jGLJVximoEMGoH93rg=
-github.com/chromedp/chromedp v0.9.5/go.mod h1:D4I2qONslauw/C7INoCir1BJkSwBYMyZgx8X276z3+Y=
-github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
-github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
+github.com/chromedp/cdproto v0.0.0-20241208230723-d1c7de7e5dd2 h1:fJob5N/Eprtd427U84kFpQhAHIEqJYuDzveaL6T4Xsk=
+github.com/chromedp/cdproto v0.0.0-20241208230723-d1c7de7e5dd2/go.mod h1:4XqMl3iIW08jtieURWL6Tt5924w21pxirC6th662XUM=
+github.com/chromedp/chromedp v0.11.2 h1:ZRHTh7DjbNTlfIv3NFTbB7eVeu5XCNkgrpcGSpn2oX0=
+github.com/chromedp/chromedp v0.11.2/go.mod h1:lr8dFRLKsdTTWb75C/Ttol2vnBKOSnt0BW8R9Xaupi8=
+github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
+github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
-github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 h1:iFaUwBSo5Svw6L7HYpRu/0lE3e0BaElwnNO1qkNQxBY=
 github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5/go.mod h1:qssHWj60/X5sZFNxpG4HBPDHVqxNm4DfnCKgrbZOT+s=
 github.com/dsnet/golib v0.0.0-20171103203638-1ea166775780/go.mod h1:Lj+Z9rebOhdfkVLjJ8T6VcRQv3SXugXy999NBtR9aFY=
@@ -32,11 +31,8 @@ github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.3.2/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY=
 github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
 github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
-github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
-github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -53,70 +49,55 @@ github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB1
 github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M=
 github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU=
 github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk=
-github.com/hhrutter/lzw v1.0.0 h1:laL89Llp86W3rRs83LvKbwYRx6INE8gDn0XNb1oXtm0=
-github.com/hhrutter/lzw v1.0.0/go.mod h1:2HC6DJSn/n6iAZfgM3Pg+cP1KxeWc3ezG8bBqW5+WEo=
-github.com/hhrutter/tiff v1.0.1 h1:MIus8caHU5U6823gx7C6jrfoEvfSTGtEFRiM8/LOzC0=
-github.com/hhrutter/tiff v1.0.1/go.mod h1:zU/dNgDm0cMIa8y8YwcYBeuEEveI4B0owqHyiPpJPHc=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
 github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU=
 github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/labstack/echo/v4 v4.12.0 h1:IKpw49IMryVB2p1a4dzwlhP1O2Tf2E0Ir/450lH+kI0=
-github.com/labstack/echo/v4 v4.12.0/go.mod h1:UP9Cr2DJXbOK3Kr9ONYzNowSh7HP0aG0ShAyycHSJvM=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/labstack/echo/v4 v4.13.3 h1:pwhpCPrTl5qry5HRdM5FwdXnhXSLSY+WE+YQSeCaafY=
+github.com/labstack/echo/v4 v4.13.3/go.mod h1:o90YNEeQWjDozo584l7AwhJMHN0bOC4tAfg+Xox9q5g=
 github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0=
 github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU=
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
-github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
-github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4=
+github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
 github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
-github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
-github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
+github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
+github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
 github.com/nwaples/rardecode v1.1.3 h1:cWCaZwfM5H7nAD6PyEdcVnczzV8i/JtotnyW/dD9lEc=
 github.com/nwaples/rardecode v1.1.3/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
 github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
 github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
-github.com/pdfcpu/pdfcpu v0.8.0 h1:SuEB4uVsPFz1nb802r38YpFpj9TtZh/oB0bGG34IRZw=
-github.com/pdfcpu/pdfcpu v0.8.0/go.mod h1:jj03y/KKrwigt5xCi8t7px2mATcKuOzkIOoCX62yMho=
 github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pierrec/lz4/v4 v4.1.21 h1:yOVMLb6qSIDP67pl/5F7RepeKYu/VmTyEXvuMI5d9mQ=
-github.com/pierrec/lz4/v4 v4.1.21/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pierrec/lz4/v4 v4.1.22 h1:cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU=
+github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
+github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
+github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.54.0 h1:ZlZy0BgJhTwVZUn7dLOkwCZHUkrAqd3WYtcFCWnM1D8=
-github.com/prometheus/common v0.54.0/go.mod h1:/TQgMJP5CuVYveyT7n/0Ix8yLNNXy9yRSkhnLTHPDIQ=
+github.com/prometheus/common v0.61.0 h1:3gv/GThfX0cV2lpO7gkTUwZru38mxevy90Bj8YFSRQQ=
+github.com/prometheus/common v0.61.0/go.mod h1:zr29OCN/2BsJRaFwG8QOBr41D6kkchKbpeNH7pAjb/s=
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@@ -125,8 +106,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
@@ -137,38 +118,32 @@ github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQ
 github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
 go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco=
-golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
+golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+google.golang.org/protobuf v1.36.0 h1:mjIs9gYtt56AzC4ZaffQuh88TZurBGhIJMBZGSxNerQ=
+google.golang.org/protobuf v1.36.0/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/pkg/gotenberg/cmd.go
+++ b/pkg/gotenberg/cmd.go
@@ -156,7 +156,7 @@ func (cmd *Cmd) pipeOutput() error {
 		r := bufio.NewReader(reader)
 		defer func(reader io.ReadCloser) {
 			err := reader.Close()
-			if err != nil {
+			if err != nil && !strings.Contains(err.Error(), "file already closed") {
 				logger.Error(fmt.Sprintf("close reader: %s", err))
 			}
 		}(reader)
--- a/pkg/gotenberg/cmd_test.go
+++ b/pkg/gotenberg/cmd_test.go
@@ -104,19 +104,8 @@ func TestCmd_Wait(t *testing.T) {
 			expectWaitError: false,
 		},
 		{
-			scenario: "wait error",
-			cmd: func() *Cmd {
-				cmd := Command(zap.NewNop(), "echo", "Hello", "World")
-				err := cmd.Start()
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-				err = cmd.Kill()
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-				return cmd
-			}(),
+			scenario:        "wait error",
+			cmd:             Command(zap.NewNop(), "echo", "Hello", "World"),
 			expectWaitError: true,
 		},
 	}
--- a/pkg/gotenberg/flags.go
+++ b/pkg/gotenberg/flags.go
@@ -168,33 +168,37 @@ func (f *ParsedFlags) MustDeprecatedDuration(deprecated string, newName string)
 	return f.MustDuration(newName)
 }

-// MustHumanReadableBytesString returns the human-readable bytes string of a
-// flag given by name.
+// MustHumanReadableBytes returns the human-readable bytes string of a flag
+// given by name.
 // It panics if an error occurs.
-func (f *ParsedFlags) MustHumanReadableBytesString(name string) string {
+func (f *ParsedFlags) MustHumanReadableBytes(name string) int64 {
 	val, err := f.GetString(name)
 	if err != nil {
 		panic(err)
 	}

-	_, err = bytes.Parse(val)
+	if val == "" {
+		return 0
+	}
+
+	b, err := bytes.Parse(val)
 	if err != nil {
 		panic(err)
 	}

-	return val
+	return b
 }

-// MustDeprecatedHumanReadableBytesString returns the human-readable bytes
-// string of a deprecated flag if it was explicitly set or the human-readable
-// bytes string of the new flag.
+// MustDeprecatedHumanReadableBytes returns the human-readable bytes of a
+// deprecated flag if it was explicitly set or the human-readable bytes string
+// of the new flag.
 // It panics if an error occurs.
-func (f *ParsedFlags) MustDeprecatedHumanReadableBytesString(deprecated string, newName string) string {
+func (f *ParsedFlags) MustDeprecatedHumanReadableBytes(deprecated string, newName string) int64 {
 	if f.Changed(deprecated) {
-		return f.MustHumanReadableBytesString(deprecated)
+		return f.MustHumanReadableBytes(deprecated)
 	}

-	return f.MustHumanReadableBytesString(newName)
+	return f.MustHumanReadableBytes(newName)
 }

 // MustRegexp returns the regular expression of a flag given by name.
--- a/pkg/gotenberg/flags_test.go
+++ b/pkg/gotenberg/flags_test.go
@@ -644,10 +644,11 @@ func TestParsedFlags_MustDeprecatedDuration(t *testing.T) {
 	}
 }

-func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
+func TestParsedFlags_MustHumanReadableBytes(t *testing.T) {
 	fs := flag.NewFlagSet("tests", flag.ContinueOnError)
 	fs.String("foo", "1MB", "")
 	fs.String("bar", "1MB", "")
+	fs.String("qux", "", "")

 	err := fs.Parse([]string{"--foo=1GB", "--bar=foo"})
 	if err != nil {
@@ -671,6 +672,11 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 			name:        "bar",
 			expectPanic: true,
 		},
+		{
+			scenario:    "success: empty value",
+			name:        "qux",
+			expectPanic: false,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			if tc.expectPanic {
@@ -689,31 +695,31 @@ func TestParsedFlags_MustHumanReadableBytesString(t *testing.T) {
 				}()
 			}

-			parsedFlags.MustHumanReadableBytesString(tc.name)
+			parsedFlags.MustHumanReadableBytes(tc.name)
 		})
 	}
 }

-func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
+func TestParsedFlags_MustDeprecatedHumanReadableBytes(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		rawFlags    []string
-		expectValue string
+		expectValue int64
 	}{
 		{
 			scenario:    "deprecated flag value",
 			rawFlags:    []string{"--foo=1MB"},
-			expectValue: "1MB",
+			expectValue: 1000000,
 		},
 		{
 			scenario:    "non-deprecated flag value",
 			rawFlags:    []string{"--bar=2MB"},
-			expectValue: "2MB",
+			expectValue: 2000000,
 		},
 		{
 			scenario:    "deprecated flag value > non-deprecated flag value",
 			rawFlags:    []string{"--foo=1MB", "--bar=2MB"},
-			expectValue: "1MB",
+			expectValue: 1000000,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -728,9 +734,9 @@ func TestParsedFlags_MustDeprecatedHumanReadableBytesString(t *testing.T) {
 				t.Fatalf("expected no error but got: %v", err)
 			}

-			actual := parsedFlags.MustDeprecatedHumanReadableBytesString("foo", "bar")
+			actual := parsedFlags.MustDeprecatedHumanReadableBytes("foo", "bar")
 			if actual != tc.expectValue {
-				t.Errorf("expected '%s' but got '%s'", tc.expectValue, actual)
+				t.Errorf("expected %d but got %d", tc.expectValue, actual)
 			}
 		})
 	}
--- a/pkg/gotenberg/fs.go
+++ b/pkg/gotenberg/fs.go
@@ -3,22 +3,56 @@ package gotenberg
 import (
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"

 	"github.com/google/uuid"
 )

+// MkdirAll defines the method signature for create a directory. Implement this
+// interface if you don't want to rely on [os.MkdirAll], notably for testing
+// purpose.
+type MkdirAll interface {
+	// MkdirAll uses the same signature as [os.MkdirAll].
+	MkdirAll(path string, perm os.FileMode) error
+}
+
+// OsMkdirAll implements the [MkdirAll] interface with [os.MkdirAll].
+type OsMkdirAll struct{}
+
+// MkdirAll is a wrapper around [os.MkdirAll].
+func (o *OsMkdirAll) MkdirAll(path string, perm os.FileMode) error { return os.MkdirAll(path, perm) }
+
+// PathRename defines the method signature for renaming files. Implement this
+// interface if you don't want to rely on [os.Rename], notably for testing
+// purpose.
+type PathRename interface {
+	// Rename uses the same signature as [os.Rename].
+	Rename(oldpath, newpath string) error
+}
+
+// OsPathRename implements the [PathRename] interface with [os.Rename].
+type OsPathRename struct{}
+
+// Rename is a wrapper around [os.Rename].
+func (o *OsPathRename) Rename(oldpath, newpath string) error {
+	return os.Rename(oldpath, newpath)
+}
+
 // FileSystem provides utilities for managing temporary directories. It creates
 // unique directory names based on UUIDs to ensure isolation of temporary files
 // for different modules.
 type FileSystem struct {
 	workingDir string
+	mkdirAll   MkdirAll
 }

 // NewFileSystem initializes a new [FileSystem] instance with a unique working
 // directory.
-func NewFileSystem() *FileSystem {
+func NewFileSystem(mkdirAll MkdirAll) *FileSystem {
 	return &FileSystem{
 		workingDir: uuid.NewString(),
+		mkdirAll:   mkdirAll,
 	}
 }

@@ -44,7 +78,7 @@ func (fs *FileSystem) NewDirPath() string {
 func (fs *FileSystem) MkdirAll() (string, error) {
 	path := fs.NewDirPath()

-	err := os.MkdirAll(path, 0o755)
+	err := fs.mkdirAll.MkdirAll(path, 0o755)
 	if err != nil {
 		return "", fmt.Errorf("create directory %s: %w", path, err)
 	}
@@ -52,10 +86,27 @@ func (fs *FileSystem) MkdirAll() (string, error) {
 	return path, nil
 }

-// PathRename defines the method signature for renaming files. Implement this
-// interface if you don't want to rely on [os.Rename], notably for testing
-// purpose.
-type PathRename interface {
-	// Rename uses the same signature as [os.Rename].
-	Rename(oldpath, newpath string) error
+// WalkDir walks through the root level of a directory and returns a list of
+// files paths that match the specified file extension.
+func WalkDir(dir, ext string) ([]string, error) {
+	var files []string
+	err := filepath.Walk(dir, func(path string, info os.FileInfo, pathErr error) error {
+		if pathErr != nil {
+			return pathErr
+		}
+		if info.IsDir() {
+			return nil
+		}
+		if strings.EqualFold(filepath.Ext(info.Name()), ext) {
+			files = append(files, path)
+		}
+		return nil
+	})
+	return files, err
 }
+
+// Interface guards.
+var (
+	_ MkdirAll   = (*OsMkdirAll)(nil)
+	_ PathRename = (*OsPathRename)(nil)
+)
--- a/pkg/gotenberg/fs_test.go
+++ b/pkg/gotenberg/fs_test.go
@@ -1,14 +1,84 @@
 package gotenberg

 import (
+	"errors"
 	"fmt"
+	"io"
 	"os"
+	"path/filepath"
+	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/google/uuid"
 )

+func TestOsMkdirAll_MkdirAll(t *testing.T) {
+	dirPath, err := NewFileSystem(new(OsMkdirAll)).MkdirAll()
+	if err != nil {
+		t.Fatalf("create working directory: %v", err)
+	}
+
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("remove working directory: %v", err)
+	}
+}
+
+func TestOsPathRename_Rename(t *testing.T) {
+	dirPath, err := NewFileSystem(new(OsMkdirAll)).MkdirAll()
+	if err != nil {
+		t.Fatalf("create working directory: %v", err)
+	}
+
+	path := "/tests/test/testdata/api/sample1.txt"
+	copyPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	in, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open file: %v", err)
+	}
+
+	defer func() {
+		err := in.Close()
+		if err != nil {
+			t.Fatalf("close file: %v", err)
+		}
+	}()
+
+	out, err := os.Create(copyPath)
+	if err != nil {
+		t.Fatalf("create new file: %v", err)
+	}
+
+	defer func() {
+		err := out.Close()
+		if err != nil {
+			t.Fatalf("close new file: %v", err)
+		}
+	}()
+
+	_, err = io.Copy(out, in)
+	if err != nil {
+		t.Fatalf("copy file to new file: %v", err)
+	}
+
+	rename := new(OsPathRename)
+	newPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
+
+	err = rename.Rename(copyPath, newPath)
+	if err != nil {
+		t.Errorf("expected no error but got: %v", err)
+	}
+
+	err = os.RemoveAll(dirPath)
+	if err != nil {
+		t.Fatalf("remove working directory: %v", err)
+	}
+}
+
 func TestFileSystem_WorkingDir(t *testing.T) {
-	fs := NewFileSystem()
+	fs := NewFileSystem(new(MkdirAllMock))
 	dirName := fs.WorkingDir()

 	if dirName == "" {
@@ -17,7 +87,7 @@ func TestFileSystem_WorkingDir(t *testing.T) {
 }

 func TestFileSystem_WorkingDirPath(t *testing.T) {
-	fs := NewFileSystem()
+	fs := NewFileSystem(new(MkdirAllMock))
 	expectedPath := fmt.Sprintf("%s/%s", os.TempDir(), fs.WorkingDir())

 	if fs.WorkingDirPath() != expectedPath {
@@ -26,7 +96,7 @@ func TestFileSystem_WorkingDirPath(t *testing.T) {
 }

 func TestFileSystem_NewDirPath(t *testing.T) {
-	fs := NewFileSystem()
+	fs := NewFileSystem(new(MkdirAllMock))
 	newDir := fs.NewDirPath()
 	expectedPrefix := fs.WorkingDirPath()

@@ -36,20 +106,117 @@ func TestFileSystem_NewDirPath(t *testing.T) {
 }

 func TestFileSystem_MkdirAll(t *testing.T) {
-	fs := NewFileSystem()
+	for _, tc := range []struct {
+		scenario    string
+		mkdirAll    MkdirAll
+		expectError bool
+	}{
+		{
+			scenario: "error",
+			mkdirAll: &MkdirAllMock{
+				MkdirAllMock: func(path string, perm os.FileMode) error {
+					return errors.New("foo")
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			mkdirAll: &MkdirAllMock{
+				MkdirAllMock: func(path string, perm os.FileMode) error {
+					return nil
+				},
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			fs := NewFileSystem(tc.mkdirAll)

-	newPath, err := fs.MkdirAll()
-	if err != nil {
-		t.Fatalf("expected no error but got: %v", err)
-	}
+			_, err := fs.MkdirAll()

-	_, err = os.Stat(newPath)
-	if os.IsNotExist(err) {
-		t.Errorf("expected directory '%s' to exist but it doesn't", newPath)
-	}
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}

-	err = os.RemoveAll(fs.WorkingDirPath())
-	if err != nil {
-		t.Fatalf("expected no error while cleaning up but got: %v", err)
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
+func TestWalkDir(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		dir         string
+		ext         string
+		expectError bool
+		expectFiles []string
+	}{
+		{
+			scenario:    "directory does not exist",
+			dir:         uuid.NewString(),
+			ext:         ".pdf",
+			expectError: true,
+		},
+		{
+			scenario: "find PDF files",
+			dir: func() string {
+				path := fmt.Sprintf("%s/a_directory", os.TempDir())
+
+				err := os.MkdirAll(path, 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_foo_file.pdf", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_bar_file.PDF", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/a_baz_file.txt", path), []byte{1}, 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return path
+			}(),
+			ext:         ".pdf",
+			expectError: false,
+			expectFiles: []string{"/tmp/a_directory/a_bar_file.PDF", "/tmp/a_directory/a_foo_file.pdf"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			defer func() {
+				err := os.RemoveAll(tc.dir)
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			files, err := WalkDir(tc.dir, tc.ext)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectError && err != nil {
+				return
+			}
+
+			if !reflect.DeepEqual(files, tc.expectFiles) {
+				t.Errorf("expected files %+v, but got %+v", tc.expectFiles, files)
+			}
+		})
 	}
 }
--- a/pkg/gotenberg/logging.go
+++ b/pkg/gotenberg/logging.go
@@ -1,6 +1,11 @@
 package gotenberg

-import "go.uber.org/zap"
+import (
+	"fmt"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"go.uber.org/zap"
+)

 // LoggerProvider is an interface for a module that supplies a method for
 // creating a [zap.Logger] instance for use by other modules.
@@ -12,3 +17,41 @@ import "go.uber.org/zap"
 type LoggerProvider interface {
 	Logger(mod Module) (*zap.Logger, error)
 }
+
+// LeveledLogger is wrapper around a [zap.Logger] so that it may be used by a
+// [retryablehttp.Client].
+type LeveledLogger struct {
+	logger *zap.Logger
+}
+
+// NewLeveledLogger instantiates a [LeveledLogger].
+func NewLeveledLogger(logger *zap.Logger) *LeveledLogger {
+	return &LeveledLogger{
+		logger: logger,
+	}
+}
+
+// Error logs a message at error level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Error(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Warn logs a message at warning level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Warn(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Info logs a message at info level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Info(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Debug logs a message at debug level using the wrapped zap.Logger.
+func (leveled LeveledLogger) Debug(msg string, keysAndValues ...interface{}) {
+	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
+}
+
+// Interface guards.
+var (
+	_ retryablehttp.LeveledLogger = (*LeveledLogger)(nil)
+)
--- a/pkg/modules/webhook/client_test.go
+++ b/pkg/modules/webhook/client_test.go
@@ -1,4 +1,4 @@
-package webhook
+package gotenberg

 import (
 	"testing"
@@ -7,17 +7,17 @@ import (
 )

 func TestLeveledLogger_Error(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Error("foo")
+	NewLeveledLogger(zap.NewNop()).Error("foo")
 }

 func TestLeveledLogger_Warn(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Warn("foo")
+	NewLeveledLogger(zap.NewNop()).Warn("foo")
 }

 func TestLeveledLogger_Info(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Info("foo")
+	NewLeveledLogger(zap.NewNop()).Info("foo")
 }

 func TestLeveledLogger_Debug(t *testing.T) {
-	leveledLogger{logger: zap.NewNop()}.Debug("foo")
+	NewLeveledLogger(zap.NewNop()).Debug("foo")
 }
--- a/pkg/gotenberg/mocks.go
+++ b/pkg/gotenberg/mocks.go
@@ -2,6 +2,7 @@ package gotenberg

 import (
 	"context"
+	"os"

 	"go.uber.org/zap"
 )
@@ -36,6 +37,7 @@ func (mod *ValidatorMock) Validate() error {
 // PdfEngineMock is a mock for the [PdfEngine] interface.
 type PdfEngineMock struct {
 	MergeMock         func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error
+	SplitMock         func(ctx context.Context, logger *zap.Logger, mode SplitMode, inputPath, outputDirPath string) ([]string, error)
 	ConvertMock       func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
 	ReadMetadataMock  func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error)
 	WriteMetadataMock func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error
@@ -45,6 +47,10 @@ func (engine *PdfEngineMock) Merge(ctx context.Context, logger *zap.Logger, inpu
 	return engine.MergeMock(ctx, logger, inputPaths, outputPath)
 }

+func (engine *PdfEngineMock) Split(ctx context.Context, logger *zap.Logger, mode SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	return engine.SplitMock(ctx, logger, mode, inputPath, outputDirPath)
+}
+
 func (engine *PdfEngineMock) Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
 	return engine.ConvertMock(ctx, logger, formats, inputPath, outputPath)
 }
@@ -137,6 +143,15 @@ func (provider *MetricsProviderMock) Metrics() ([]Metric, error) {
 	return provider.MetricsMock()
 }

+// MkdirAllMock is a mock for the [MkdirAll] interface.
+type MkdirAllMock struct {
+	MkdirAllMock func(path string, perm os.FileMode) error
+}
+
+func (mkdirAll *MkdirAllMock) MkdirAll(path string, perm os.FileMode) error {
+	return mkdirAll.MkdirAllMock(path, perm)
+}
+
 // PathRenameMock is a mock for the [PathRename] interface.
 type PathRenameMock struct {
 	RenameMock func(oldpath, newpath string) error
@@ -156,4 +171,6 @@ var (
 	_ ProcessSupervisor = (*ProcessSupervisorMock)(nil)
 	_ LoggerProvider    = (*LoggerProviderMock)(nil)
 	_ MetricsProvider   = (*MetricsProviderMock)(nil)
+	_ MkdirAll          = (*MkdirAllMock)(nil)
+	_ PathRename        = (*PathRenameMock)(nil)
 )
--- a/pkg/gotenberg/mocks_test.go
+++ b/pkg/gotenberg/mocks_test.go
@@ -2,6 +2,7 @@ package gotenberg

 import (
 	"context"
+	"os"
 	"testing"

 	"go.uber.org/zap"
@@ -52,6 +53,9 @@ func TestPDFEngineMock(t *testing.T) {
 		MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 			return nil
 		},
+		SplitMock: func(ctx context.Context, logger *zap.Logger, mode SplitMode, inputPath, outputDirPath string) ([]string, error) {
+			return nil, nil
+		},
 		ConvertMock: func(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error {
 			return nil
 		},
@@ -68,6 +72,11 @@ func TestPDFEngineMock(t *testing.T) {
 		t.Errorf("expected no error from PdfEngineMock.Merge, but got: %v", err)
 	}

+	_, err = mock.Split(context.Background(), zap.NewNop(), SplitMode{}, "", "")
+	if err != nil {
+		t.Errorf("expected no error from PdfEngineMock.Split, but got: %v", err)
+	}
+
 	err = mock.Convert(context.Background(), zap.NewNop(), PdfFormats{}, "", "")
 	if err != nil {
 		t.Errorf("expected no error from PdfEngineMock.Convert, but got: %v", err)
@@ -205,6 +214,19 @@ func TestMetricsProviderMock(t *testing.T) {
 	}
 }

+func TestMkdirAllMock(t *testing.T) {
+	mock := &MkdirAllMock{
+		MkdirAllMock: func(dir string, perm os.FileMode) error {
+			return nil
+		},
+	}
+
+	err := mock.MkdirAll("/foo", 0o755)
+	if err != nil {
+		t.Errorf("expected no error from MkdirAllMock.MkdirAll, but got: %v", err)
+	}
+}
+
 func TestPathRenameMock(t *testing.T) {
 	mock := &PathRenameMock{
 		RenameMock: func(oldpath, newpath string) error {
--- a/pkg/gotenberg/pdfengine.go
+++ b/pkg/gotenberg/pdfengine.go
@@ -12,6 +12,10 @@ var (
 	// PdfEngine interface is not supported by its current implementation.
 	ErrPdfEngineMethodNotSupported = errors.New("method not supported")

+	// ErrPdfSplitModeNotSupported is returned when the Split method of the
+	// PdfEngine interface does not sumport a requested PDF split mode.
+	ErrPdfSplitModeNotSupported = errors.New("split mode not supported")
+
 	// ErrPdfFormatNotSupported is returned when the Convert method of the
 	// PdfEngine interface does not support a requested PDF format conversion.
 	ErrPdfFormatNotSupported = errors.New("PDF format not supported")
@@ -21,6 +25,30 @@ var (
 	ErrPdfEngineMetadataValueNotSupported = errors.New("metadata value not supported")
 )

+const (
+	// SplitModeIntervals represents a mode where a PDF is split at specific
+	// intervals.
+	SplitModeIntervals string = "intervals"
+
+	// SplitModePages represents a mode where a PDF is split at specific page
+	// ranges.
+	SplitModePages string = "pages"
+)
+
+// SplitMode gathers the data required to split a PDF into multiple parts.
+type SplitMode struct {
+	// Mode is either "intervals" or "pages".
+	Mode string
+
+	// Span is either the intervals or the page ranges to extract, depending on
+	// the selected mode.
+	Span string
+
+	// Unify specifies whether to put extracted pages into a single file or as
+	// many files as there are page ranges. Only works with "pages" mode.
+	Unify bool
+}
+
 const (
 	// PdfA1a represents the PDF/A-1a format.
 	PdfA1a string = "PDF/A-1a"
@@ -65,6 +93,9 @@ type PdfEngine interface {
 	// is determined by the order of files provided in inputPaths.
 	Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error

+	// Split splits a given PDF file.
+	Split(ctx context.Context, logger *zap.Logger, mode SplitMode, inputPath, outputDirPath string) ([]string, error)
+
 	// Convert transforms a given PDF to the specified formats defined in
 	// PdfFormats. If no format, it does nothing.
 	Convert(ctx context.Context, logger *zap.Logger, formats PdfFormats, inputPath, outputPath string) error
--- a/pkg/gotenberg/supervisor.go
+++ b/pkg/gotenberg/supervisor.go
@@ -173,6 +173,20 @@ func (s *processSupervisor) Healthy() bool {
 }

 func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task func() error) error {
+	// A user reported a potential issue:
+	//
+	// "Although the counting operation is atomic, nothing prevent 2 concurrent
+	// goroutines to retrieve the same 'currentQueueSize' and to compare its
+	// value against the max limit. Then, resulting queue size would be 1 above
+	// the allowed limit."
+	//
+	// However, he was unable to actually trigger this issue, even when sending
+	// a lot of requests.
+	//
+	// For now, the best option is to consider this issue to be unlikely to
+	// happen, and keep the code as it is because it is more readable this way.
+	//
+	// See https://github.com/gotenberg/gotenberg/issues/951.
 	currentQueueSize := s.reqQueueSize.Load()
 	if s.maxQueueSize > 0 && currentQueueSize >= s.maxQueueSize {
 		return ErrMaximumQueueSizeExceeded
@@ -187,10 +201,13 @@ func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task fu
 				logger.Debug("process lock acquired")
 				s.reqQueueSize.Add(-1)
 				s.reqCounter.Add(1)
+				releaseMutexChan := true

 				defer func() {
-					logger.Debug("process lock released")
-					<-s.mutexChan
+					if releaseMutexChan {
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}
 				}()

 				if !s.firstStart.Load() {
@@ -212,18 +229,26 @@ func (s *processSupervisor) Run(ctx context.Context, logger *zap.Logger, task fu
 					}
 				}

+				err := s.runWithDeadline(ctx, task)
+
 				if s.maxReqLimit > 0 && s.reqCounter.Load() >= s.maxReqLimit {
-					s.logger.Debug("max request limit reached, restarting...")
-					err := s.runWithDeadline(ctx, func() error {
-						return s.restart()
-					})
-					if err != nil {
-						return fmt.Errorf("process restart before task: %w", err)
-					}
+					s.logger.Debug("max request limit reached, restarting eagerly...")
+					releaseMutexChan = false
+
+					go func() {
+						err := s.runWithDeadline(context.Background(), func() error {
+							return s.restart()
+						})
+						if err != nil {
+							s.logger.Error(fmt.Sprintf("process restart after task: %v", err))
+						}
+						logger.Debug("process lock released")
+						<-s.mutexChan
+					}()
 				}

 				// Note: no error wrapping because it leaks on Chromium console exceptions output.
-				return s.runWithDeadline(ctx, task)
+				return err
 			case <-ctx.Done():
 				logger.Debug("failed to acquire process lock before deadline")
 				s.reqQueueSize.Add(-1)
--- a/pkg/gotenberg/supervisor_test.go
+++ b/pkg/gotenberg/supervisor_test.go
@@ -325,7 +325,7 @@ func TestProcessSupervisor_Run(t *testing.T) {
 			expectedStopCalls:    1,
 		},
 		{
-			scenario:             "cannot restart after reaching max request limit",
+			scenario:             "auto-restart after reaching max request limit",
 			startError:           errors.New("start error"),
 			initiallyStarted:     true,
 			isRestarting:         false,
@@ -451,6 +451,10 @@ func TestProcessSupervisor_Run(t *testing.T) {
 				return
 			}

+			// Making sure restarts are finished.
+			ps.mutexChan <- struct{}{}
+			<-ps.mutexChan
+
 			if startCalls.Load() != tc.expectedStartCalls {
 				t.Errorf("expected %d process.Start calls, got %d", tc.expectedStartCalls, startCalls.Load())
 			}
--- a/pkg/modules/api/api.go
+++ b/pkg/modules/api/api.go
@@ -4,12 +4,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
 	"sort"
 	"strings"
 	"time"

 	"github.com/alexliesenfeld/health"
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/multierr"
@@ -28,14 +30,17 @@ func init() {
 // middlewares or health checks.
 type Api struct {
 	port                      int
+	bindIp                    string
 	tlsCertFile               string
 	tlsKeyFile                string
 	startTimeout              time.Duration
+	bodyLimit                 int64
 	timeout                   time.Duration
 	rootPath                  string
 	traceHeader               string
 	basicAuthUsername         string
 	basicAuthPassword         string
+	downloadFromCfg           downloadFromConfig
 	disableHealthCheckLogging bool

 	routes              []Route
@@ -47,6 +52,13 @@ type Api struct {
 	srv                 *echo.Echo
 }

+type downloadFromConfig struct {
+	allowList *regexp2.Regexp
+	denyList  *regexp2.Regexp
+	maxRetry  int
+	disable   bool
+}
+
 // Router is a module interface which adds routes to the [Api].
 type Router interface {
 	Routes() ([]Route, error)
@@ -161,13 +173,19 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 			fs := flag.NewFlagSet("api", flag.ExitOnError)
 			fs.Int("api-port", 3000, "Set the port on which the API should listen")
 			fs.String("api-port-from-env", "", "Set the environment variable with the port on which the API should listen - override the default port")
+			fs.String("api-bind-ip", "", "Set the IP address the API should bind to for incoming connections")
 			fs.String("api-tls-cert-file", "", "Path to the TLS/SSL certificate file - for HTTPS support")
 			fs.String("api-tls-key-file", "", "Path to the TLS/SSL key file - for HTTPS support")
 			fs.Duration("api-start-timeout", time.Duration(30)*time.Second, "Set the time limit for the API to start")
 			fs.Duration("api-timeout", time.Duration(30)*time.Second, "Set the time limit for requests")
+			fs.String("api-body-limit", "", "Set the body limit for multipart/form-data requests - it accepts values like 5MB, 1GB, etc")
 			fs.String("api-root-path", "/", "Set the root path of the API - for service discovery via URL paths")
 			fs.String("api-trace-header", "Gotenberg-Trace", "Set the header name to use for identifying requests")
 			fs.Bool("api-enable-basic-auth", false, "Enable basic authentication - will look for the GOTENBERG_API_BASIC_AUTH_USERNAME and GOTENBERG_API_BASIC_AUTH_PASSWORD environment variables")
+			fs.String("api-download-from-allow-list", "", "Set the allowed URLs for the download from feature using a regular expression")
+			fs.String("api-download-from-deny-list", "", "Set the denied URLs for the download from feature using a regular expression")
+			fs.Int("api-download-from-max-retry", 4, "Set the maximum number of retries for the download from feature")
+			fs.Bool("api-disable-download-from", false, "Disable the download from feature")
 			fs.Bool("api-disable-health-check-logging", false, "Disable health check logging")
 			return fs
 		}(),
@@ -179,12 +197,20 @@ func (a *Api) Descriptor() gotenberg.ModuleDescriptor {
 func (a *Api) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
 	a.port = flags.MustInt("api-port")
+	a.bindIp = flags.MustString("api-bind-ip")
 	a.tlsCertFile = flags.MustString("api-tls-cert-file")
 	a.tlsKeyFile = flags.MustString("api-tls-key-file")
 	a.startTimeout = flags.MustDuration("api-start-timeout")
 	a.timeout = flags.MustDuration("api-timeout")
+	a.bodyLimit = flags.MustHumanReadableBytes("api-body-limit")
 	a.rootPath = flags.MustString("api-root-path")
 	a.traceHeader = flags.MustString("api-trace-header")
+	a.downloadFromCfg = downloadFromConfig{
+		allowList: flags.MustRegexp("api-download-from-allow-list"),
+		denyList:  flags.MustRegexp("api-download-from-deny-list"),
+		maxRetry:  flags.MustInt("api-download-from-max-retry"),
+		disable:   flags.MustBool("api-disable-download-from"),
+	}
 	a.disableHealthCheckLogging = flags.MustBool("api-disable-health-check-logging")

 	// Port from env?
@@ -292,7 +318,7 @@ func (a *Api) Provision(ctx *gotenberg.Context) error {
 	a.logger = logger

 	// File system.
-	a.fs = gotenberg.NewFileSystem()
+	a.fs = gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 	return nil
 }
@@ -307,6 +333,10 @@ func (a *Api) Validate() error {
 		)
 	}

+	if a.bindIp != "" && net.ParseIP(a.bindIp) == nil {
+		err = multierr.Append(err, errors.New("IP must be a valid IP address"))
+	}
+
 	if (a.tlsCertFile != "" && a.tlsKeyFile == "") || (a.tlsCertFile == "" && a.tlsKeyFile != "") {
 		err = multierr.Append(err,
 			errors.New("both TLS certificate and key files must be set"),
@@ -411,13 +441,6 @@ func (a *Api) Start() error {
 		loggerMiddleware(a.logger, disableLoggingForPaths),
 	)

-	// Basic auth?
-	if a.basicAuthUsername != "" {
-		a.srv.Pre(
-			basicAuthMiddleware(a.basicAuthUsername, a.basicAuthPassword),
-		)
-	}
-
 	// Add the modules' middlewares in their respective stacks.
 	var externalMultipartMiddlewares []Middleware
 	for _, externalMiddleware := range a.externalMiddlewares {
@@ -437,8 +460,13 @@ func (a *Api) Start() error {
 	for _, route := range a.routes {
 		var middlewares []echo.MiddlewareFunc

+		// Basic auth?
+		if a.basicAuthUsername != "" {
+			middlewares = append(middlewares, basicAuthMiddleware(a.basicAuthUsername, a.basicAuthPassword))
+		}
+
 		if route.IsMultipart {
-			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout))
+			middlewares = append(middlewares, contextMiddleware(a.fs, a.timeout, a.bodyLimit, a.downloadFromCfg))

 			for _, externalMultipartMiddleware := range externalMultipartMiddlewares {
 				middlewares = append(middlewares, externalMultipartMiddleware.Handler)
@@ -455,13 +483,22 @@ func (a *Api) Start() error {
 		)
 	}

-	// Let's not forget the health check route...
+	// Let's not forget the health check routes...
+	checks := append(a.healthChecks, health.WithTimeout(a.timeout))
+	checker := health.NewChecker(checks...)
+	healthCheckHandler := health.NewHandler(checker)
+
 	a.srv.GET(
 		fmt.Sprintf("%s%s", a.rootPath, "health"),
 		func() echo.HandlerFunc {
-			checks := append(a.healthChecks, health.WithTimeout(a.timeout))
-			checker := health.NewChecker(checks...)
-			return echo.WrapHandler(health.NewHandler(checker))
+			return echo.WrapHandler(healthCheckHandler)
+		}(),
+		hardTimeoutMiddleware(hardTimeout),
+	)
+	a.srv.HEAD(
+		fmt.Sprintf("%s%s", a.rootPath, "health"),
+		func() echo.HandlerFunc {
+			return echo.WrapHandler(healthCheckHandler)
 		}(),
 		hardTimeoutMiddleware(hardTimeout),
 	)
@@ -493,11 +530,11 @@ func (a *Api) Start() error {
 		var err error
 		if a.tlsCertFile != "" && a.tlsKeyFile != "" {
 			// Start an HTTPS server (supports HTTP/2).
-			err = a.srv.StartTLS(fmt.Sprintf(":%d", a.port), a.tlsCertFile, a.tlsKeyFile)
+			err = a.srv.StartTLS(fmt.Sprintf("%s:%d", a.bindIp, a.port), a.tlsCertFile, a.tlsKeyFile)
 		} else {
 			// Start an HTTP/2 Cleartext (non-HTTPS) server.
 			server := &http2.Server{}
-			err = a.srv.StartH2CServer(fmt.Sprintf(":%d", a.port), server)
+			err = a.srv.StartH2CServer(fmt.Sprintf("%s:%d", a.bindIp, a.port), server)
 		}
 		if !errors.Is(err, http.ErrServerClosed) {
 			a.logger.Fatal(err.Error())
@@ -509,7 +546,11 @@ func (a *Api) Start() error {

 // StartupMessage returns a custom startup message.
 func (a *Api) StartupMessage() string {
-	return fmt.Sprintf("server listening on port %d", a.port)
+	ip := a.bindIp
+	if a.bindIp == "" {
+		ip = "[::]"
+	}
+	return fmt.Sprintf("server started on %s:%d", ip, a.port)
 }

 // Stop stops the HTTP server.
--- a/pkg/modules/api/api_test.go
+++ b/pkg/modules/api/api_test.go
@@ -57,6 +57,30 @@ func TestApi_Provision(t *testing.T) {
 			}(),
 			expectError: true,
 		},
+		{
+			scenario: "port from env: invalid environment variable value",
+			ctx: func() *gotenberg.Context {
+				fs := new(Api).Descriptor().FlagSet
+				err := fs.Parse([]string{"--api-port-from-env=PORT"})
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return gotenberg.NewContext(
+					gotenberg.ParsedFlags{
+						FlagSet: fs,
+					},
+					nil,
+				)
+			}(),
+			setEnv: func() {
+				err := os.Setenv("PORT", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+			},
+			expectError: true,
+		},
 		{
 			scenario: "basic auth: non-existing GOTENBERG_API_BASIC_AUTH_USERNAME environment variable",
 			ctx: func() *gotenberg.Context {
@@ -99,30 +123,6 @@ func TestApi_Provision(t *testing.T) {
 			},
 			expectError: true,
 		},
-		{
-			scenario: "port from env: invalid environment variable value",
-			ctx: func() *gotenberg.Context {
-				fs := new(Api).Descriptor().FlagSet
-				err := fs.Parse([]string{"--api-port-from-env=PORT"})
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return gotenberg.NewContext(
-					gotenberg.ParsedFlags{
-						FlagSet: fs,
-					},
-					nil,
-				)
-			}(),
-			setEnv: func() {
-				err := os.Setenv("PORT", "foo")
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-			},
-			expectError: true,
-		},
 		{
 			scenario: "no valid routers",
 			ctx: func() *gotenberg.Context {
@@ -462,6 +462,7 @@ func TestApi_Validate(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
 		port        int
+		bindIp      string
 		tlsCertFile string
 		tlsKeyFile  string
 		rootPath    string
@@ -473,6 +474,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid port (< 1)",
 			port:        0,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -482,6 +484,17 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid port (> 65535)",
 			port:        65536,
+			bindIp:      "127.0.0.1",
+			rootPath:    "/foo/",
+			traceHeader: "foo",
+			routes:      nil,
+			middlewares: nil,
+			expectError: true,
+		},
+		{
+			scenario:    "invalid IP",
+			port:        10,
+			bindIp:      "foo",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -491,6 +504,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid TLS files: only cert file provided",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			tlsCertFile: "cert.pem",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
@@ -501,6 +515,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid TLS files: only key file provided",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			tlsKeyFile:  "key.pem",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
@@ -511,6 +526,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid root path: missing / prefix",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -520,6 +536,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid root path: missing / suffix",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo",
 			traceHeader: "foo",
 			routes:      nil,
@@ -529,6 +546,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid trace header",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "",
 			routes:      nil,
@@ -538,6 +556,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: empty path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -551,6 +570,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: missing / prefix in path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -564,6 +584,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid multipart route: no /forms prefix in path",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -578,6 +599,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: no method",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -592,6 +614,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: nil handler",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -607,6 +630,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid route: path already existing",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -627,6 +651,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "invalid middleware: nil handler",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes:      nil,
@@ -641,6 +666,7 @@ func TestApi_Validate(t *testing.T) {
 		{
 			scenario:    "success",
 			port:        10,
+			bindIp:      "127.0.0.1",
 			rootPath:    "/foo/",
 			traceHeader: "foo",
 			routes: []Route{
@@ -694,6 +720,7 @@ func TestApi_Validate(t *testing.T) {
 		t.Run(tc.scenario, func(t *testing.T) {
 			mod := Api{
 				port:                tc.port,
+				bindIp:              tc.bindIp,
 				tlsCertFile:         tc.tlsCertFile,
 				tlsKeyFile:          tc.tlsKeyFile,
 				rootPath:            tc.rootPath,
@@ -823,7 +850,7 @@ func TestApi_Start(t *testing.T) {
 				},
 			}
 			mod.readyFn = tc.readyFn
-			mod.fs = gotenberg.NewFileSystem()
+			mod.fs = gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			mod.logger = zap.NewNop()

 			err := mod.Start()
@@ -839,20 +866,23 @@ func TestApi_Start(t *testing.T) {
 				return
 			}

-			// health request.
+			// health requests.
 			recorder := httptest.NewRecorder()
-			healthRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
-			healthRequest.SetBasicAuth(mod.basicAuthUsername, mod.basicAuthPassword)

-			mod.srv.ServeHTTP(recorder, healthRequest)
+			healthGetRequest := httptest.NewRequest(http.MethodGet, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthGetRequest)
+			if recorder.Code != http.StatusOK {
+				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
+			}
+
+			healthHeadRequest := httptest.NewRequest(http.MethodHead, "/health", nil)
+			mod.srv.ServeHTTP(recorder, healthHeadRequest)
 			if recorder.Code != http.StatusOK {
 				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
 			}

 			// version request.
 			versionRequest := httptest.NewRequest(http.MethodGet, "/version", nil)
-			versionRequest.SetBasicAuth(mod.basicAuthUsername, mod.basicAuthPassword)
-
 			mod.srv.ServeHTTP(recorder, versionRequest)
 			if recorder.Code != http.StatusOK {
 				t.Errorf("expected %d status code but got %d", http.StatusOK, recorder.Code)
@@ -861,7 +891,6 @@ func TestApi_Start(t *testing.T) {
 			// "multipart/form-data" request.
 			multipartRequest := func(url string) *http.Request {
 				body := &bytes.Buffer{}
-
 				writer := multipart.NewWriter(body)

 				defer func() {
@@ -916,15 +945,36 @@ func TestApi_Start(t *testing.T) {
 }

 func TestApi_StartupMessage(t *testing.T) {
-	mod := Api{
-		port: 3000,
-	}
+	for _, tc := range []struct {
+		scenario      string
+		port          int
+		bindIp        string
+		expectMessage string
+	}{
+		{
+			scenario:      "no custom IP",
+			port:          3000,
+			bindIp:        "",
+			expectMessage: "server started on [::]:3000",
+		},
+		{
+			scenario:      "custom IP",
+			port:          3000,
+			bindIp:        "127.0.0.1",
+			expectMessage: "server started on 127.0.0.1:3000",
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			mod := Api{
+				port:   tc.port,
+				bindIp: tc.bindIp,
+			}

-	actual := mod.StartupMessage()
-	expect := "server listening on port 3000"
-
-	if actual != expect {
-		t.Errorf("expected '%s' but got '%s'", expect, actual)
+			actual := mod.StartupMessage()
+			if actual != tc.expectMessage {
+				t.Errorf("expected '%s' but got '%s'", tc.expectMessage, actual)
+			}
+		})
 	}
 }

--- a/pkg/modules/api/context.go
+++ b/pkg/modules/api/context.go
@@ -3,20 +3,25 @@ package api
 import (
 	"compress/flate"
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
+	"mime"
 	"mime/multipart"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"time"

 	"github.com/google/uuid"
+	"github.com/hashicorp/go-retryablehttp"
 	"github.com/labstack/echo/v4"
 	"github.com/mholt/archiver/v3"
 	"go.uber.org/zap"
+	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/unicode/norm"

 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -42,26 +47,68 @@ type Context struct {

 	logger     *zap.Logger
 	echoCtx    echo.Context
+	mkdirAll   gotenberg.MkdirAll
 	pathRename gotenberg.PathRename
 	context.Context
 }

-type osPathRename struct{}
+type trackingReader struct {
+	R            io.Reader
+	AddReadBytes func(n int64) error
+}

-func (o *osPathRename) Rename(oldpath, newpath string) error {
-	return os.Rename(oldpath, newpath)
+func (t *trackingReader) Read(p []byte) (int, error) {
+	n, err := t.R.Read(p)
+	if n > 0 {
+		errAddRead := t.AddReadBytes(int64(n))
+		if errAddRead != nil {
+			return n, fmt.Errorf("add read bytes: %w", errAddRead)
+		}
+	}
+	if err != nil {
+		// It's a common practice in Go to return io.EOF unwrapped to signal
+		// the end of a data stream. Wrapping it can lead to unexpected
+		// behavior in standard library functions.
+		return n, err
+	}
+	return n, nil
+}
+
+type downloadFrom struct {
+	// Url is the URL to download a file from.
+	Url string `json:"url"`
+
+	// ExtraHttpHeaders are the HTTP headers to send alongside.
+	ExtraHttpHeaders map[string]string `json:"extraHttpHeaders"`
 }

 // newContext returns a [Context] by parsing a "multipart/form-data" request.
-func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration) (*Context, context.CancelFunc, error) {
+func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig, traceHeader, trace string) (*Context, context.CancelFunc, error) {
 	processCtx, processCancel := context.WithTimeout(context.Background(), timeout)

+	// We want to make sure the multipart/form-data does not exceed a given
+	// limit. We consider: form fields (keys, values, files) and files
+	// downloaded remotely ("download from" feature).
+	var totalBytesRead atomic.Int64
+
+	addReadBytes := func(n int64) error {
+		newTotal := totalBytesRead.Add(n)
+		if bodyLimit != 0 && newTotal > bodyLimit {
+			return WrapError(
+				fmt.Errorf("body limit reached (> %d)", bodyLimit),
+				NewSentinelHttpError(http.StatusRequestEntityTooLarge, http.StatusText(http.StatusRequestEntityTooLarge)),
+			)
+		}
+		return nil
+	}
+
 	ctx := &Context{
 		outputPaths: make([]string, 0),
 		cancelled:   false,
 		logger:      logger,
 		echoCtx:     echoCtx,
-		pathRename:  new(osPathRename),
+		mkdirAll:    new(gotenberg.OsMkdirAll),
+		pathRename:  new(gotenberg.OsPathRename),
 		Context:     processCtx,
 	}

@@ -117,6 +164,19 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		return nil, cancel, fmt.Errorf("get multipart form: %w", err)
 	}

+	// This will ensure we do not exceed the body limit.
+	var formValuesSize int64
+	for key, valArray := range form.Value {
+		formValuesSize += int64(len(key))
+		for _, val := range valArray {
+			formValuesSize += int64(len(val))
+		}
+	}
+	err = addReadBytes(formValuesSize)
+	if err != nil {
+		return nil, cancel, fmt.Errorf("add read bytes: %w", err)
+	}
+
 	dirPath, err := fs.MkdirAll()
 	if err != nil {
 		return nil, cancel, fmt.Errorf("create working directory: %w", err)
@@ -126,6 +186,150 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 	ctx.values = form.Value
 	ctx.files = make(map[string]string)

+	// First, try to download files listed in the "downloadFrom" form field, if
+	// any.
+	raw, ok := ctx.values["downloadFrom"]
+	if !downloadFromCfg.disable && ok {
+		var dls []downloadFrom
+		err = json.Unmarshal([]byte(raw[0]), &dls)
+		if err != nil {
+			return nil, cancel, WrapError(
+				fmt.Errorf("unmarshal json: %w", err),
+				NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field value: %s", err)),
+			)
+		}
+
+		eg, _ := errgroup.WithContext(ctx)
+		for i, dl := range dls {
+			eg.Go(func() error {
+				deadline, ok := ctx.Deadline()
+				if !ok {
+					// Should not happen, as context is created with a timeout.
+					return errors.New("context has no deadline")
+				}
+
+				if strings.TrimSpace(dl.Url) == "" {
+					return WrapError(
+						errors.New("empty download from URL"),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'downloadFrom' form field entry %d: URL must be set", i)),
+					)
+				}
+
+				err := gotenberg.FilterDeadline(downloadFromCfg.allowList, downloadFromCfg.denyList, dl.Url, deadline)
+				if err != nil {
+					return fmt.Errorf("filter URL: %w", err)
+				}
+
+				logger.Debug(fmt.Sprintf("download file from '%s'", dl.Url))
+
+				req, err := retryablehttp.NewRequest(http.MethodGet, dl.Url, nil)
+				if err != nil {
+					return fmt.Errorf("create request to '%s': %w", dl.Url, err)
+				}
+
+				req.Header.Set("User-Agent", "Gotenberg")
+				for key, value := range dl.ExtraHttpHeaders {
+					req.Header.Set(key, value)
+				}
+				req.Header.Set(traceHeader, trace)
+
+				client := &retryablehttp.Client{
+					HTTPClient: &http.Client{
+						Timeout: time.Until(deadline),
+					},
+					RetryMax:     downloadFromCfg.maxRetry,
+					RetryWaitMin: time.Duration(1) * time.Second,
+					RetryWaitMax: time.Until(deadline),
+					Logger:       gotenberg.NewLeveledLogger(logger),
+					CheckRetry:   retryablehttp.DefaultRetryPolicy,
+					Backoff:      retryablehttp.DefaultBackoff,
+				}
+
+				resp, err := client.Do(req)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': %w", dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': %s", dl.Url, err)),
+					)
+				}
+				defer func() {
+					err := resp.Body.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close response body from '%s': %s", dl.Url, err))
+					}
+				}()
+
+				if resp.StatusCode != http.StatusOK {
+					return WrapError(
+						fmt.Errorf("download file from to '%s': got status: '%s'", dl.Url, resp.Status),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Unable to download file from '%s': got status: '%s'", dl.Url, resp.Status)),
+					)
+				}
+
+				contentDisposition := resp.Header.Get("Content-Disposition")
+				if contentDisposition == "" {
+					return WrapError(
+						fmt.Errorf("no 'Content-Disposition' header from '%s'", dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("No 'Content-Disposition' header from '%s'", dl.Url)),
+					)
+				}
+
+				// FIXME: the implementation of this method might not be
+				//  complete, as it fails to parse an empty mediatype.
+				//  See: https://github.com/golang/go/issues/69551.
+				_, params, err := mime.ParseMediaType(contentDisposition)
+				if err != nil {
+					return WrapError(
+						fmt.Errorf("parse 'Content-Disposition' header '%s' from '%s': %w", contentDisposition, dl.Url, err),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': %s", contentDisposition, dl.Url, err)),
+					)
+				}
+
+				filename, ok := params["filename"]
+				if !ok {
+					return WrapError(
+						fmt.Errorf("get filename from 'Content-Disposition' header '%s' from '%s'", contentDisposition, dl.Url),
+						NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Invalid 'Content-Disposition' header '%s' from '%s': no filename", contentDisposition, dl.Url)),
+					)
+				}
+
+				// Avoid directory traversal and make sure filename characters are
+				// normalized.
+				// See: https://github.com/gotenberg/gotenberg/issues/662.
+				filename = norm.NFC.String(filepath.Base(filename))
+				path := fmt.Sprintf("%s/%s", ctx.dirPath, filename)
+
+				out, err := os.Create(path)
+				if err != nil {
+					return fmt.Errorf("create local file: %w", err)
+				}
+				defer func() {
+					err := out.Close()
+					if err != nil {
+						logger.Error(fmt.Sprintf("close local file: %s", err))
+					}
+				}()
+
+				// This will ensure we do not exceed the body limit.
+				reader := &trackingReader{R: resp.Body, AddReadBytes: addReadBytes}
+
+				_, err = io.Copy(out, reader)
+				if err != nil {
+					return fmt.Errorf("copy downloaded file from '%s' to local file: %w", dl.Url, err)
+				}
+
+				ctx.files[filename] = path
+
+				return nil
+			})
+		}
+
+		err = eg.Wait()
+		if err != nil {
+			return ctx, cancel, err
+		}
+	}
+
 	copyToDisk := func(fh *multipart.FileHeader) error {
 		in, err := fh.Open()
 		if err != nil {
@@ -139,6 +343,9 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 			}
 		}()

+		// This will ensure we do not exceed the body limit.
+		reader := &trackingReader{R: in, AddReadBytes: addReadBytes}
+
 		// Avoid directory traversal and make sure filename characters are
 		// normalized.
 		// See: https://github.com/gotenberg/gotenberg/issues/662.
@@ -149,7 +356,6 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		if err != nil {
 			return fmt.Errorf("create local file: %w", err)
 		}
-
 		defer func() {
 			err := out.Close()
 			if err != nil {
@@ -157,7 +363,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 			}
 		}()

-		_, err = io.Copy(out, in)
+		_, err = io.Copy(out, reader)
 		if err != nil {
 			return fmt.Errorf("copy multipart file to local file: %w", err)
 		}
@@ -167,6 +373,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst
 		return nil
 	}

+	// Then, copy the form files, if any.
 	for _, files := range form.File {
 		for _, fh := range files {
 			err = copyToDisk(fh)
@@ -178,6 +385,7 @@ func newContext(echoCtx echo.Context, logger *zap.Logger, fs *gotenberg.FileSyst

 	ctx.Log().Debug(fmt.Sprintf("form fields: %+v", ctx.values))
 	ctx.Log().Debug(fmt.Sprintf("form files: %+v", ctx.files))
+	ctx.Log().Debug(fmt.Sprintf("total bytes: %d", totalBytesRead.Load()))

 	return ctx, cancel, err
 }
@@ -202,9 +410,21 @@ func (ctx *Context) GeneratePath(extension string) string {
 	return fmt.Sprintf("%s/%s%s", ctx.dirPath, uuid.New().String(), extension)
 }

+// CreateSubDirectory creates a subdirectory within the context's working
+// directory.
+func (ctx *Context) CreateSubDirectory(dirName string) (string, error) {
+	path := fmt.Sprintf("%s/%s", ctx.dirPath, dirName)
+	err := ctx.mkdirAll.MkdirAll(path, 0o755)
+	if err != nil {
+		return "", fmt.Errorf("create sub-directory %s: %w", path, err)
+	}
+	return path, nil
+}
+
 // Rename is just a wrapper around [os.Rename], as we need to mock this
 // behavior in our tests.
 func (ctx *Context) Rename(oldpath, newpath string) error {
+	ctx.Log().Debug(fmt.Sprintf("rename %s to %s", oldpath, newpath))
 	err := ctx.pathRename.Rename(oldpath, newpath)
 	if err != nil {
 		return fmt.Errorf("rename path: %w", err)
@@ -284,8 +504,3 @@ func (ctx *Context) OutputFilename(outputPath string) string {

 	return fmt.Sprintf("%s%s", filename, filepath.Ext(outputPath))
 }
-
-// Interface guard.
-var (
-	_ gotenberg.PathRename = (*osPathRename)(nil)
-)
--- a/pkg/modules/api/context_test.go
+++ b/pkg/modules/api/context_test.go
@@ -2,82 +2,47 @@ package api

 import (
 	"bytes"
+	"context"
 	"errors"
-	"fmt"
-	"io"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
 	"os"
-	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
 	"time"

-	"github.com/google/uuid"
+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"

 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

-func TestOsPathRename_Rename(t *testing.T) {
-	dirPath, err := gotenberg.NewFileSystem().MkdirAll()
-	if err != nil {
-		t.Fatalf("create working directory: %v", err)
-	}
-
-	path := "/tests/test/testdata/api/sample1.txt"
-	copyPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
-
-	in, err := os.Open(path)
-	if err != nil {
-		t.Fatalf("open file: %v", err)
-	}
-
-	defer func() {
-		err := in.Close()
-		if err != nil {
-			t.Fatalf("close file: %v", err)
-		}
-	}()
-
-	out, err := os.Create(copyPath)
-	if err != nil {
-		t.Fatalf("create new file: %v", err)
-	}
-
-	defer func() {
-		err := out.Close()
-		if err != nil {
-			t.Fatalf("close new file: %v", err)
-		}
-	}()
-
-	_, err = io.Copy(out, in)
-	if err != nil {
-		t.Fatalf("copy file to new file: %v", err)
-	}
-
-	rename := new(osPathRename)
-	newPath := filepath.Join(dirPath, fmt.Sprintf("%s.txt", uuid.NewString()))
-
-	err = rename.Rename(copyPath, newPath)
-	if err != nil {
-		t.Errorf("expected no error but got: %v", err)
-	}
-
-	err = os.RemoveAll(dirPath)
-	if err != nil {
-		t.Fatalf("remove working directory: %v", err)
-	}
-}
-
 func TestNewContext(t *testing.T) {
+	defaultAllowList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDenyList, err := regexp2.Compile("", 0)
+	if err != nil {
+		t.Fatalf("expected no error but got: %v", err)
+	}
+	defaultDownloadFromCfg := downloadFromConfig{
+		allowList: defaultAllowList,
+		denyList:  defaultDenyList,
+		maxRetry:  1,
+		disable:   false,
+	}
+
 	for _, tc := range []struct {
 		scenario         string
 		request          *http.Request
+		bodyLimit        int64
+		downloadFromCfg  downloadFromConfig
+		downloadFromSrv  *echo.Echo
+		expectContext    *Context
 		expectError      bool
 		expectHttpError  bool
 		expectHttpStatus int
@@ -123,6 +88,325 @@ func TestNewContext(t *testing.T) {
 			expectHttpError:  true,
 			expectHttpStatus: http.StatusBadRequest,
 		},
+		{
+			scenario: "request entity too large: form values",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("key", "value")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			bodyLimit:        1,
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "request entity too large: downloadFrom",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			bodyLimit: 45, // form values = 44 bytes.
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, `attachment; filename="bar.txt"`)
+					c.Response().Header().Set(echo.HeaderContentType, "text/plain")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "request entity too large: form files",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				part, err := writer.CreateFormFile("foo.txt", "foo.txt")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				_, err = part.Write([]byte("foo"))
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			bodyLimit:        1,
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusRequestEntityTooLarge,
+		},
+		{
+			scenario: "invalid downloadFrom form field: cannot unmarshal",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", "foo")
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: filtered URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"https://foo.bar"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg: func() downloadFromConfig {
+				denyList, err := regexp2.Compile("https://foo.bar", 0)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				return downloadFromConfig{allowList: defaultAllowList, denyList: denyList, maxRetry: 1, disable: false}
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "invalid downloadFrom form field: unreachable URL",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: invalid status code",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusNotFound, http.StatusText(http.StatusNotFound))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: malformed 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, ";;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
+		{
+			scenario: "invalid downloadFrom form field: no filename parameter in 'Content-Disposition' header",
+			request: func() *http.Request {
+				body := &bytes.Buffer{}
+				writer := multipart.NewWriter(body)
+				defer func() {
+					err := writer.Close()
+					if err != nil {
+						t.Fatalf("expected no error but got: %v", err)
+					}
+				}()
+				err := writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/"}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+				req := httptest.NewRequest(http.MethodPost, "/", body)
+				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
+				return req
+			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					c.Response().Header().Set(echo.HeaderContentDisposition, "inline;")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg:  defaultDownloadFromCfg,
+			expectError:      true,
+			expectHttpError:  true,
+			expectHttpStatus: http.StatusBadRequest,
+		},
 		{
 			scenario: "success",
 			request: func() *http.Request {
@@ -146,17 +430,69 @@ func TestNewContext(t *testing.T) {
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
+				err = writer.WriteField("downloadFrom", `[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
 				req := httptest.NewRequest(http.MethodPost, "/", body)
 				req.Header.Set(echo.HeaderContentType, writer.FormDataContentType())
 				return req
 			}(),
+			downloadFromSrv: func() *echo.Echo {
+				srv := echo.New()
+				srv.HideBanner = true
+				srv.GET("/", func(c echo.Context) error {
+					if c.Request().Header.Get("User-Agent") != "Gotenberg" {
+						t.Fatalf("expected 'Gotenberg' from header 'User-Agent', but got '%s'", c.Request().Header.Get("User-Agent"))
+					}
+					if c.Request().Header.Get("X-Foo") != "Bar" {
+						t.Fatalf("expected 'Bar' from header 'X-Foo', but got '%s'", c.Request().Header.Get("X-Foo"))
+					}
+					if c.Request().Header.Get("Gotenberg-Trace") != "123" {
+						t.Fatalf("expected '123' from header 'Gotenberg-Trace', but got '%s'", c.Request().Header.Get("Gotenberg-Trace"))
+					}
+					c.Response().Header().Set(echo.HeaderContentDisposition, `attachment; filename="bar.txt"`)
+					c.Response().Header().Set(echo.HeaderContentType, "text/plain")
+					return c.String(http.StatusOK, http.StatusText(http.StatusOK))
+				})
+				return srv
+			}(),
+			downloadFromCfg: defaultDownloadFromCfg,
+			expectContext: &Context{
+				values: map[string][]string{
+					"foo": {"foo"},
+					"downloadFrom": {
+						`[{"url":"http://localhost:80/","extraHttpHeaders":{"X-Foo":"Bar"}}]`,
+					},
+				},
+				files: map[string]string{
+					"foo.txt": "foo.txt",
+					"bar.txt": "bar.txt", // downloadFrom.
+				},
+			},
 			expectError:     false,
 			expectHttpError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
+			if tc.downloadFromSrv != nil {
+				go func() {
+					err := tc.downloadFromSrv.Start(":80")
+					if !errors.Is(err, http.ErrServerClosed) {
+						t.Error(err)
+						return
+					}
+				}()
+				defer func() {
+					err := tc.downloadFromSrv.Shutdown(context.TODO())
+					if err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+
 			handler := func(c echo.Context) error {
-				_, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(), time.Duration(10)*time.Second)
+				ctx, cancel, err := newContext(c, zap.NewNop(), gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)), time.Duration(10)*time.Second, tc.bodyLimit, tc.downloadFromCfg, "Gotenberg-Trace", "123")
 				defer cancel()
 				// Context already cancelled.
 				defer cancel()
@@ -165,6 +501,20 @@ func TestNewContext(t *testing.T) {
 					return err
 				}

+				if tc.expectContext != nil {
+					if !reflect.DeepEqual(tc.expectContext.values, ctx.values) {
+						t.Fatalf("expected context.values to be %v but got %v", tc.expectContext.values, ctx.values)
+					}
+					if len(tc.expectContext.files) != len(ctx.files) {
+						t.Fatalf("expected context.files to contain %d items but got %d", len(tc.expectContext.files), len(ctx.files))
+					}
+					for key, value := range tc.expectContext.files {
+						if !strings.HasSuffix(ctx.files[key], value) {
+							t.Fatalf("expected context.files to contain '%s' but got '%s'", value, ctx.files[key])
+						}
+					}
+				}
+
 				return nil
 			}

@@ -241,6 +591,42 @@ func TestContext_FormData(t *testing.T) {
 	}
 }

+func TestContext_CreateSubDirectory(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *Context
+		expectError bool
+	}{
+		{
+			scenario: "failure",
+			ctx: &Context{mkdirAll: &gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+				return errors.New("cannot rename")
+			}}},
+			expectError: true,
+		},
+		{
+			scenario: "success",
+			ctx: &Context{mkdirAll: &gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+				return nil
+			}}},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.logger = zap.NewNop()
+			_, err := tc.ctx.CreateSubDirectory("foo")
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
 func TestContext_GeneratePath(t *testing.T) {
 	ctx := &Context{
 		dirPath: "/foo",
@@ -274,6 +660,7 @@ func TestContext_Rename(t *testing.T) {
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.logger = zap.NewNop()
 			err := tc.ctx.Rename("", "")

 			if tc.expectError && err == nil {
@@ -382,7 +769,7 @@ func TestContext_BuildOutputFile(t *testing.T) {
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
-			fs := gotenberg.NewFileSystem()
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			dirPath, err := fs.MkdirAll()
 			if err != nil {
 				t.Fatalf("expected no erro but got: %v", err)
--- a/pkg/modules/api/middlewares.go
+++ b/pkg/modules/api/middlewares.go
@@ -48,6 +48,10 @@ func ParseError(err error) (int, string) {
 		return http.StatusTooManyRequests, http.StatusText(http.StatusTooManyRequests)
 	}

+	if errors.Is(err, gotenberg.ErrPdfSplitModeNotSupported) {
+		return http.StatusBadRequest, "At least one PDF engine cannot process the requested PDF split mode, while others may have failed to split due to different issues"
+	}
+
 	if errors.Is(err, gotenberg.ErrPdfFormatNotSupported) {
 		return http.StatusBadRequest, "At least one PDF engine cannot process the requested PDF format, while others may have failed to convert due to different issues"
 	}
@@ -236,14 +240,16 @@ func basicAuthMiddleware(username, password string) echo.MiddlewareFunc {
 //
 //	ctx := c.Get("context").(*api.Context)
 //	cancel := c.Get("cancel").(context.CancelFunc)
-func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration) echo.MiddlewareFunc {
+func contextMiddleware(fs *gotenberg.FileSystem, timeout time.Duration, bodyLimit int64, downloadFromCfg downloadFromConfig) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {
 		return func(c echo.Context) error {
 			logger := c.Get("logger").(*zap.Logger)
+			traceHeader := c.Get("traceHeader").(string)
+			trace := c.Get("trace").(string)

 			// We create a context with a timeout so that underlying processes are
 			// able to stop early and handle correctly a timeout scenario.
-			ctx, cancel, err := newContext(c, logger, fs, timeout)
+			ctx, cancel, err := newContext(c, logger, fs, timeout, bodyLimit, downloadFromCfg, traceHeader, trace)
 			if err != nil {
 				cancel()

--- a/pkg/modules/api/middlewares_test.go
+++ b/pkg/modules/api/middlewares_test.go
@@ -38,6 +38,11 @@ func TestParseError(t *testing.T) {
 			expectStatus:  http.StatusTooManyRequests,
 			expectMessage: http.StatusText(http.StatusTooManyRequests),
 		},
+		{
+			err:           gotenberg.ErrPdfSplitModeNotSupported,
+			expectStatus:  http.StatusBadRequest,
+			expectMessage: "At least one PDF engine cannot process the requested PDF split mode, while others may have failed to split due to different issues",
+		},
 		{
 			err:           gotenberg.ErrPdfFormatNotSupported,
 			expectStatus:  http.StatusBadRequest,
@@ -458,10 +463,11 @@ func TestContextMiddleware(t *testing.T) {

 		c := srv.NewContext(tc.request, recorder)
 		c.Set("logger", zap.NewNop())
+		c.Set("traceHeader", "Gotenberg-Trace")
 		c.Set("trace", "foo")
 		c.Set("startTime", time.Now())

-		err := contextMiddleware(gotenberg.NewFileSystem(), time.Duration(10)*time.Second)(tc.next)(c)
+		err := contextMiddleware(gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)), time.Duration(10)*time.Second, 0, downloadFromConfig{})(tc.next)(c)

 		if tc.expectErr && err == nil {
 			t.Errorf("test %d: expected error but got: %v", i, err)
--- a/pkg/modules/api/mocks.go
+++ b/pkg/modules/api/mocks.go
@@ -86,6 +86,14 @@ func (ctx *ContextMock) SetEchoContext(c echo.Context) {
 	ctx.Context.echoCtx = c
 }

+// SetMkdirAll sets the [gotenberg.MkdirAll].
+//
+//	ctx := &api.ContextMock{Context: &api.Context{}}
+//	ctx.SetMkdirAll(mkdirAll)
+func (ctx *ContextMock) SetMkdirAll(mkdirAll gotenberg.MkdirAll) {
+	ctx.Context.mkdirAll = mkdirAll
+}
+
 // SetPathRename sets the [gotenberg.PathRename].
 //
 //	ctx := &api.ContextMock{Context: &api.Context{}}
--- a/pkg/modules/api/mocks_test.go
+++ b/pkg/modules/api/mocks_test.go
@@ -7,6 +7,8 @@ import (
 	"github.com/alexliesenfeld/health"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
+
+	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

 func TestContextMock_SetDirPath(t *testing.T) {
@@ -117,10 +119,23 @@ func TestContextMock_SetEchoContext(t *testing.T) {
 	}
 }

+func TestContextMock_SetMkdirAll(t *testing.T) {
+	mock := ContextMock{&Context{}}
+
+	expect := new(gotenberg.OsMkdirAll)
+	mock.SetMkdirAll(expect)
+
+	actual := mock.mkdirAll
+
+	if actual != expect {
+		t.Errorf("expected %v but got %v", expect, actual)
+	}
+}
+
 func TestContextMock_SetPathRename(t *testing.T) {
 	mock := ContextMock{&Context{}}

-	expect := new(osPathRename)
+	expect := new(gotenberg.OsPathRename)
 	mock.SetPathRename(expect)

 	actual := mock.pathRename
--- a/pkg/modules/chromium/browser.go
+++ b/pkg/modules/chromium/browser.go
@@ -62,7 +62,7 @@ func newChromiumBrowser(arguments browserArguments) browser {
 	b := &chromiumBrowser{
 		initialCtx: context.Background(),
 		arguments:  arguments,
-		fs:         gotenberg.NewFileSystem(),
+		fs:         gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 	}
 	b.isStarted.Store(false)

@@ -228,7 +228,6 @@ func (b *chromiumBrowser) pdf(ctx context.Context, logger *zap.Logger, url, outp
 		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
 		setCookiesActionFunc(logger, options.Cookies),
 		userAgentOverride(logger, options.UserAgent),
-		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, options.PrintBackground),
 		forceExactColorsActionFunc(),
@@ -252,7 +251,6 @@ func (b *chromiumBrowser) screenshot(ctx context.Context, logger *zap.Logger, ur
 		disableJavaScriptActionFunc(logger, b.arguments.disableJavaScript),
 		setCookiesActionFunc(logger, options.Cookies),
 		userAgentOverride(logger, options.UserAgent),
-		extraHttpHeadersActionFunc(logger, options.ExtraHttpHeaders),
 		navigateActionFunc(logger, url, options.SkipNetworkIdleEvent),
 		hideDefaultWhiteBackgroundActionFunc(logger, options.OmitBackground, true),
 		forceExactColorsActionFunc(),
@@ -291,17 +289,35 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 	defer taskCancel()

 	// We validate all others requests against our allow / deny lists.
-	// If a request does not pass the validation, we make it fail.
-	listenForEventRequestPaused(taskCtx, logger, b.arguments.allowList, b.arguments.denyList)
+	// If a request does not pass the validation, we make it fail. It also set
+	// the extra HTTP headers, if any.
+	// See https://github.com/gotenberg/gotenberg/issues/1011.
+	listenForEventRequestPaused(taskCtx, logger, eventRequestPausedOptions{
+		allowList:        b.arguments.allowList,
+		denyList:         b.arguments.denyList,
+		extraHttpHeaders: options.ExtraHttpHeaders,
+	})

 	var (
-		invalidHttpStatusCode   error
-		invalidHttpStatusCodeMu sync.RWMutex
+		invalidHttpStatusCode           error
+		invalidHttpStatusCodeMu         sync.RWMutex
+		invalidResourceHttpStatusCode   error
+		invalidResourceHttpStatusCodeMu sync.RWMutex
 	)

-	// See https://github.com/gotenberg/gotenberg/issues/613.
-	if len(options.FailOnHttpStatusCodes) != 0 {
-		listenForEventResponseReceived(taskCtx, logger, url, options.FailOnHttpStatusCodes, &invalidHttpStatusCode, &invalidHttpStatusCodeMu)
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/613.
+	// https://github.com/gotenberg/gotenberg/issues/1021.
+	if len(options.FailOnHttpStatusCodes) != 0 || len(options.FailOnResourceHttpStatusCodes) != 0 {
+		listenForEventResponseReceived(taskCtx, logger, eventResponseReceivedOptions{
+			mainPageUrl:                     url,
+			failOnHttpStatusCodes:           options.FailOnHttpStatusCodes,
+			invalidHttpStatusCode:           &invalidHttpStatusCode,
+			invalidHttpStatusCodeMu:         &invalidHttpStatusCodeMu,
+			failOnResourceOnHttpStatusCode:  options.FailOnResourceHttpStatusCodes,
+			invalidResourceHttpStatusCode:   &invalidResourceHttpStatusCode,
+			invalidResourceHttpStatusCodeMu: &invalidResourceHttpStatusCodeMu,
+		})
 	}

 	var (
@@ -314,6 +330,24 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		listenForEventExceptionThrown(taskCtx, logger, &consoleExceptions, &consoleExceptionsMu)
 	}

+	var (
+		loadingFailed           error
+		loadingFailedMu         sync.RWMutex
+		resourceLoadingFailed   error
+		resourceLoadingFailedMu sync.RWMutex
+	)
+
+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/913.
+	// https://github.com/gotenberg/gotenberg/issues/959.
+	// https://github.com/gotenberg/gotenberg/issues/1021.
+	listenForEventLoadingFailed(taskCtx, logger, eventLoadingFailedOptions{
+		loadingFailed:           &loadingFailed,
+		loadingFailedMu:         &loadingFailedMu,
+		resourceLoadingFailed:   &resourceLoadingFailed,
+		resourceLoadingFailedMu: &resourceLoadingFailedMu,
+	})
+
 	err = chromedp.Run(taskCtx, tasks...)
 	if err != nil {
 		errMessage := err.Error()
@@ -341,6 +375,14 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		return fmt.Errorf("%v: %w", invalidHttpStatusCode, ErrInvalidHttpStatusCode)
 	}

+	// See https://github.com/gotenberg/gotenberg/issues/1021.
+	invalidResourceHttpStatusCodeMu.RLock()
+	defer invalidResourceHttpStatusCodeMu.RUnlock()
+
+	if invalidResourceHttpStatusCode != nil {
+		return fmt.Errorf("%v: %w", invalidResourceHttpStatusCode, ErrInvalidResourceHttpStatusCode)
+	}
+
 	// See https://github.com/gotenberg/gotenberg/issues/262.
 	consoleExceptionsMu.RLock()
 	defer consoleExceptionsMu.RUnlock()
@@ -349,6 +391,23 @@ func (b *chromiumBrowser) do(ctx context.Context, logger *zap.Logger, url string
 		return fmt.Errorf("%v: %w", consoleExceptions, ErrConsoleExceptions)
 	}

+	// See:
+	// https://github.com/gotenberg/gotenberg/issues/913.
+	// https://github.com/gotenberg/gotenberg/issues/959.
+	loadingFailedMu.RLock()
+	defer loadingFailedMu.RUnlock()
+
+	if loadingFailed != nil {
+		return fmt.Errorf("%v: %w", loadingFailed, ErrLoadingFailed)
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/1021.
+	if options.FailOnResourceLoadingFailed {
+		if resourceLoadingFailed != nil {
+			return fmt.Errorf("%v: %w", resourceLoadingFailed, ErrResourceLoadingFailed)
+		}
+	}
+
 	return nil
 }

--- a/pkg/modules/chromium/browser_test.go
+++ b/pkg/modules/chromium/browser_test.go
@@ -249,6 +249,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 		browser            browser
 		fs                 *gotenberg.FileSystem
 		options            PdfOptions
+		url                string
 		noDeadline         bool
 		start              bool
 		expectError        bool
@@ -262,7 +263,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				b.isStarted.Store(false)
 				return b
 			}(),
-			fs:          gotenberg.NewFileSystem(),
+			fs:          gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:  false,
 			start:       false,
 			expectError: true,
@@ -274,7 +275,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:          gotenberg.NewFileSystem(),
+			fs:          gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:  true,
 			start:       false,
 			expectError: true,
@@ -290,7 +291,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:            gotenberg.NewFileSystem(),
+			fs:            gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:    false,
 			start:         false,
 			expectError:   true,
@@ -307,7 +308,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:            gotenberg.NewFileSystem(),
+			fs:            gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:    false,
 			start:         false,
 			expectError:   true,
@@ -324,7 +325,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -356,7 +357,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -378,7 +379,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 			},
 		},
 		{
-			scenario: "skip networkIdle event",
+			scenario: "do not skip networkIdle event",
 			browser: newChromiumBrowser(
 				browserArguments{
 					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
@@ -388,7 +389,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -403,13 +404,13 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				return fs
 			}(),
 			options: PdfOptions{
-				Options: Options{SkipNetworkIdleEvent: true},
+				Options: Options{SkipNetworkIdleEvent: false},
 			},
 			noDeadline:  false,
 			start:       true,
 			expectError: false,
 			expectedLogEntries: []string{
-				"skipping network idle event",
+				"event networkIdle fired",
 			},
 		},
 		{
@@ -423,7 +424,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -445,6 +446,44 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrInvalidHttpStatusCode,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/style.css", fs.WorkingDirPath()), []byte("body{font-family: Arial, Helvetica, sans-serif;}"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/index.html", fs.WorkingDirPath()), []byte("<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><h1>ErrInvalidResourceHttpStatusCode</h1></body></html>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: PdfOptions{
+				Options: Options{FailOnResourceHttpStatusCodes: []int64{200}},
+			},
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrInvalidResourceHttpStatusCode,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			browser: newChromiumBrowser(
@@ -456,7 +495,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -478,6 +517,65 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrConsoleExceptions,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				return fs
+			}(),
+			url:           "http://localhost:100",
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrLoadingFailed,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/index.html", fs.WorkingDirPath()), []byte("<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"http://localhost:100/style.css\"></head><body><h1>ErrResourceLoadingFailed</h1></body></html>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: PdfOptions{
+				Options: Options{FailOnResourceLoadingFailed: true},
+			},
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrResourceLoadingFailed,
+		},
 		{
 			scenario: "clear cache",
 			browser: newChromiumBrowser(
@@ -490,7 +588,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -523,7 +621,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -556,7 +654,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -590,7 +688,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -625,7 +723,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -660,7 +758,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -675,8 +773,21 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				return fs
 			}(),
 			options: PdfOptions{
-				Options: Options{ExtraHttpHeaders: map[string]string{
-					"X-Foo": "Bar",
+				Options: Options{ExtraHttpHeaders: []ExtraHttpHeader{
+					{
+						Name:  "X-Foo",
+						Value: "foo",
+					},
+					{
+						Name:  "X-Bar",
+						Value: "bar",
+						Scope: regexp2.MustCompile(`.*index\.html.*`, 0),
+					},
+					{
+						Name:  "X-Baz",
+						Value: "baz",
+						Scope: regexp2.MustCompile(`.*another\.html.*`, 0),
+					},
 				}},
 			},
 			noDeadline:  false,
@@ -684,6 +795,10 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 			expectError: false,
 			expectedLogEntries: []string{
 				"extra HTTP headers:",
+				"extra HTTP header 'X-Foo' will be set for request URL",
+				"extra HTTP header 'X-Bar' (scoped) will be set for request URL",
+				"extra HTTP header 'X-Baz' (scoped) will not be set for request URL",
+				"setting extra HTTP headers for request URL",
 			},
 		},
 		{
@@ -697,7 +812,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -730,7 +845,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -766,7 +881,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -799,7 +914,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -834,7 +949,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -869,7 +984,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -904,7 +1019,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -950,7 +1065,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -985,7 +1100,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1031,7 +1146,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1066,7 +1181,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1102,7 +1217,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1140,7 +1255,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1173,7 +1288,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1198,6 +1313,7 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				"no cookies to set",
 				"no extra HTTP headers",
 				"navigate to",
+				"skipping network idle event",
 				"default white background not hidden",
 				"no emulated media type",
 				"no wait delay",
@@ -1243,10 +1359,15 @@ func TestChromiumBrowser_pdf(t *testing.T) {
 				defer cancel()
 			}

+			url := fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath())
+			if tc.url != "" {
+				url = tc.url
+			}
+
 			err := tc.browser.pdf(
 				ctx,
 				logger,
-				fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath()),
+				url,
 				fmt.Sprintf("%s/%s.pdf", tc.fs.WorkingDirPath(), uuid.NewString()),
 				tc.options,
 			)
@@ -1286,6 +1407,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 		browser            browser
 		fs                 *gotenberg.FileSystem
 		options            ScreenshotOptions
+		url                string
 		noDeadline         bool
 		start              bool
 		expectError        bool
@@ -1299,7 +1421,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				b.isStarted.Store(false)
 				return b
 			}(),
-			fs:          gotenberg.NewFileSystem(),
+			fs:          gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:  false,
 			start:       false,
 			expectError: true,
@@ -1315,7 +1437,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:          gotenberg.NewFileSystem(),
+			fs:          gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:  true,
 			start:       false,
 			expectError: true,
@@ -1331,7 +1453,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:            gotenberg.NewFileSystem(),
+			fs:            gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:    false,
 			start:         false,
 			expectError:   true,
@@ -1348,7 +1470,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				b.isStarted.Store(true)
 				return b
 			}(),
-			fs:            gotenberg.NewFileSystem(),
+			fs:            gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			noDeadline:    false,
 			start:         false,
 			expectError:   true,
@@ -1365,7 +1487,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1397,7 +1519,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1419,7 +1541,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 			},
 		},
 		{
-			scenario: "skip networkIdle event",
+			scenario: "do not skip networkIdle event",
 			browser: newChromiumBrowser(
 				browserArguments{
 					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
@@ -1429,7 +1551,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1444,13 +1566,13 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				return fs
 			}(),
 			options: ScreenshotOptions{
-				Options: Options{SkipNetworkIdleEvent: true},
+				Options: Options{SkipNetworkIdleEvent: false},
 			},
 			noDeadline:  false,
 			start:       true,
 			expectError: false,
 			expectedLogEntries: []string{
-				"skipping network idle event",
+				"event networkIdle fired",
 			},
 		},
 		{
@@ -1464,7 +1586,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1486,6 +1608,44 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrInvalidHttpStatusCode,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/style.css", fs.WorkingDirPath()), []byte("body{font-family: Arial, Helvetica, sans-serif;}"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/index.html", fs.WorkingDirPath()), []byte("<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><h1>ErrInvalidResourceHttpStatusCode</h1></body></html>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: ScreenshotOptions{
+				Options: Options{FailOnResourceHttpStatusCodes: []int64{299}},
+			},
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrInvalidResourceHttpStatusCode,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			browser: newChromiumBrowser(
@@ -1497,7 +1657,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1519,6 +1679,65 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 			expectError:   true,
 			expectedError: ErrConsoleExceptions,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				return fs
+			}(),
+			url:           "http://localhost:100",
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrLoadingFailed,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/index.html", fs.WorkingDirPath()), []byte("<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"http://localhost:100/style.css\"></head><body><h1>ErrResourceLoadingFailed</h1></body></html>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: ScreenshotOptions{
+				Options: Options{FailOnResourceLoadingFailed: true},
+			},
+			noDeadline:    false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrResourceLoadingFailed,
+		},
 		{
 			scenario: "clear cache",
 			browser: newChromiumBrowser(
@@ -1531,7 +1750,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1564,7 +1783,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1597,7 +1816,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1631,7 +1850,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1655,6 +1874,41 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				"set cookie",
 			},
 		},
+		{
+			scenario: "user agent override",
+			browser: newChromiumBrowser(
+				browserArguments{
+					binPath:          os.Getenv("CHROMIUM_BIN_PATH"),
+					wsUrlReadTimeout: 5 * time.Second,
+					allowList:        regexp2.MustCompile("", 0),
+					denyList:         regexp2.MustCompile("", 0),
+				},
+			),
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				err = os.WriteFile(fmt.Sprintf("%s/index.html", fs.WorkingDirPath()), []byte("<h1>User-Agent override</h1>"), 0o755)
+				if err != nil {
+					t.Fatalf("expected no error but got: %v", err)
+				}
+
+				return fs
+			}(),
+			options: ScreenshotOptions{
+				Options: Options{UserAgent: "foo"},
+			},
+			noDeadline:  false,
+			start:       true,
+			expectError: false,
+			expectedLogEntries: []string{
+				fmt.Sprintf("user agent override: foo"),
+			},
+		},
 		{
 			scenario: "extra HTTP headers",
 			browser: newChromiumBrowser(
@@ -1666,7 +1920,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1681,8 +1935,21 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				return fs
 			}(),
 			options: ScreenshotOptions{
-				Options: Options{ExtraHttpHeaders: map[string]string{
-					"X-Foo": "Bar",
+				Options: Options{ExtraHttpHeaders: []ExtraHttpHeader{
+					{
+						Name:  "X-Foo",
+						Value: "foo",
+					},
+					{
+						Name:  "X-Bar",
+						Value: "bar",
+						Scope: regexp2.MustCompile(`.*index\.html.*`, 0),
+					},
+					{
+						Name:  "X-Baz",
+						Value: "baz",
+						Scope: regexp2.MustCompile(`.*another\.html.*`, 0),
+					},
 				}},
 			},
 			noDeadline:  false,
@@ -1690,6 +1957,10 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 			expectError: false,
 			expectedLogEntries: []string{
 				"extra HTTP headers:",
+				"extra HTTP header 'X-Foo' will be set for request URL",
+				"extra HTTP header 'X-Bar' (scoped) will be set for request URL",
+				"extra HTTP header 'X-Baz' (scoped) will not be set for request URL",
+				"setting extra HTTP headers for request URL",
 			},
 		},
 		{
@@ -1703,7 +1974,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1738,7 +2009,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1771,7 +2042,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1806,7 +2077,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1841,7 +2112,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1876,7 +2147,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1922,7 +2193,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -1957,7 +2228,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -2003,7 +2274,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -2046,7 +2317,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -2094,7 +2365,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -2124,6 +2395,7 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				"no user agent override",
 				"no extra HTTP headers",
 				"navigate to",
+				"skipping network idle event",
 				"default white background not hidden",
 				"no emulated media type",
 				"no wait delay",
@@ -2169,10 +2441,15 @@ func TestChromiumBrowser_screenshot(t *testing.T) {
 				defer cancel()
 			}

+			url := fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath())
+			if tc.url != "" {
+				url = tc.url
+			}
+
 			err := tc.browser.screenshot(
 				ctx,
 				logger,
-				fmt.Sprintf("file://%s/index.html", tc.fs.WorkingDirPath()),
+				url,
 				fmt.Sprintf("%s/%s.pdf", tc.fs.WorkingDirPath(), uuid.NewString()),
 				tc.options,
 			)
--- a/pkg/modules/chromium/chromium.go
+++ b/pkg/modules/chromium/chromium.go
@@ -9,6 +9,7 @@ import (

 	"github.com/alexliesenfeld/health"
 	"github.com/chromedp/cdproto/network"
+	"github.com/dlclark/regexp2"
 	flag "github.com/spf13/pflag"
 	"go.uber.org/zap"

@@ -37,11 +38,22 @@ var (
 	// matches with one of the entry in [Options.FailOnHttpStatusCodes].
 	ErrInvalidHttpStatusCode = errors.New("invalid HTTP status code")

+	// ErrInvalidResourceHttpStatusCode happens when the status code from one
+	// or more resources matches with one of the entry in
+	// [Options.FailOnResourceHttpStatusCodes].
+	ErrInvalidResourceHttpStatusCode = errors.New("invalid resource HTTP status code")
+
 	// ErrConsoleExceptions happens when there are exceptions in the Chromium
 	// console. It also happens only if the [Options.FailOnConsoleExceptions]
 	// is set to true.
 	ErrConsoleExceptions = errors.New("console exceptions")

+	// ErrLoadingFailed happens when the main page failed to load.
+	ErrLoadingFailed = errors.New("loading failed")
+
+	// ErrResourceLoadingFailed happens when one or more resources failed to load.
+	ErrResourceLoadingFailed = errors.New("resource loading failed")
+
 	// PDF specific.

 	// ErrOmitBackgroundWithoutPrintBackground happens if
@@ -76,72 +88,71 @@ type Options struct {
 	// "networkIdle" event, drastically improving the conversion speed. It may
 	// not be suitable for all HTML documents, as some may not be fully
 	// rendered until this event is fired.
-	// Optional.
 	SkipNetworkIdleEvent bool

 	// FailOnHttpStatusCodes sets if the conversion should fail if the status
 	// code from the main page matches with one of its entries.
-	// Optional.
 	FailOnHttpStatusCodes []int64

+	// FailOnResourceHttpStatusCodes sets if the conversion should fail if the
+	// status code from at least one resource matches with one if its entries.
+	FailOnResourceHttpStatusCodes []int64
+
+	// FailOnResourceLoadingFailed sets if the conversion should fail like the
+	// main page if Chromium fails to load at least one resource.
+	FailOnResourceLoadingFailed bool
+
 	// FailOnConsoleExceptions sets if the conversion should fail if there are
 	// exceptions in the Chromium console.
-	// Optional.
 	FailOnConsoleExceptions bool

 	// WaitDelay is the duration to wait when loading an HTML document before
 	// converting it.
-	// Optional.
 	WaitDelay time.Duration

 	// WaitWindowStatus is the window.status value to wait for before
 	// converting an HTML document.
-	// Optional.
 	WaitWindowStatus string

 	// WaitForExpression is the custom JavaScript expression to wait before
 	// converting an HTML document until it returns true
-	// Optional.
 	WaitForExpression string

 	// Cookies are the cookies to put in the Chromium cookies' jar.
-	// Optional
 	Cookies []Cookie

 	// UserAgent overrides the default 'User-Agent' HTTP header.
-	// Optional.
 	UserAgent string

 	// ExtraHttpHeaders are extra HTTP headers to send by Chromium while
 	// loading he HTML document.
-	// Optional.
-	ExtraHttpHeaders map[string]string
+	ExtraHttpHeaders []ExtraHttpHeader

 	// EmulatedMediaType is the media type to emulate, either "screen" or
 	// "print".
-	// Optional.
 	EmulatedMediaType string

 	// OmitBackground hides default white background and allows generating PDFs
 	// with transparency.
-	// Optional.
 	OmitBackground bool
 }

 // DefaultOptions returns the default values for Options.
 func DefaultOptions() Options {
 	return Options{
-		SkipNetworkIdleEvent:    false,
-		FailOnHttpStatusCodes:   []int64{499, 599},
-		FailOnConsoleExceptions: false,
-		WaitDelay:               0,
-		WaitWindowStatus:        "",
-		WaitForExpression:       "",
-		Cookies:                 nil,
-		UserAgent:               "",
-		ExtraHttpHeaders:        nil,
-		EmulatedMediaType:       "",
-		OmitBackground:          false,
+		SkipNetworkIdleEvent:          true,
+		FailOnHttpStatusCodes:         []int64{499, 599},
+		FailOnResourceHttpStatusCodes: nil,
+		FailOnResourceLoadingFailed:   false,
+		FailOnConsoleExceptions:       false,
+		WaitDelay:                     0,
+		WaitWindowStatus:              "",
+		WaitForExpression:             "",
+		Cookies:                       nil,
+		UserAgent:                     "",
+		ExtraHttpHeaders:              nil,
+		EmulatedMediaType:             "",
+		OmitBackground:                false,
 	}
 }

@@ -150,48 +161,37 @@ type PdfOptions struct {
 	Options

 	// Landscape sets the paper orientation.
-	// Optional.
 	Landscape bool

 	// PrintBackground prints the background graphics.
-	// Optional.
 	PrintBackground bool

 	// Scale is the scale of the page rendering.
-	// Optional.
 	Scale float64

 	// SinglePage defines whether to print the entire content in one single
 	// page.
-	// Optional.
 	SinglePage bool

 	// PaperWidth is the paper width, in inches.
-	// Optional.
 	PaperWidth float64

 	// PaperHeight is the paper height, in inches.
-	// Optional.
 	PaperHeight float64

 	// MarginTop is the top margin, in inches.
-	// Optional.
 	MarginTop float64

 	// MarginBottom is the bottom margin, in inches.
-	// Optional.
 	MarginBottom float64

 	// MarginLeft is the left margin, in inches.
-	// Optional.
 	MarginLeft float64

 	// MarginRight is the right margin, in inches.
-	// Optional.
 	MarginRight float64

 	// Page ranges to print, e.g., '1-5, 8, 11-13'. Empty means all pages.
-	// Optional.
 	PageRanges string

 	// HeaderTemplate is the HTML template of the header. It should be valid
@@ -204,38 +204,40 @@ type PdfOptions struct {
 	// - totalPages: total pages in the document
 	// For example, <span class=title></span> would generate span containing
 	// the title.
-	// Optional.
 	HeaderTemplate string

 	// FooterTemplate is the HTML template of the footer. It should use the
 	// same format as the HeaderTemplate.
-	// Optional.
 	FooterTemplate string

 	// PreferCssPageSize defines whether to prefer page size as defined by CSS.
 	// If false, the content will be scaled to fit the paper size.
-	// Optional.
 	PreferCssPageSize bool
+
+	// GenerateDocumentOutline defines whether the document outline should be
+	// embedded into the PDF.
+	GenerateDocumentOutline bool
 }

 // DefaultPdfOptions returns the default values for PdfOptions.
 func DefaultPdfOptions() PdfOptions {
 	return PdfOptions{
-		Options:           DefaultOptions(),
-		Landscape:         false,
-		PrintBackground:   false,
-		Scale:             1.0,
-		SinglePage:        false,
-		PaperWidth:        8.5,
-		PaperHeight:       11,
-		MarginTop:         0.39,
-		MarginBottom:      0.39,
-		MarginLeft:        0.39,
-		MarginRight:       0.39,
-		PageRanges:        "",
-		HeaderTemplate:    "<html><head></head><body></body></html>",
-		FooterTemplate:    "<html><head></head><body></body></html>",
-		PreferCssPageSize: false,
+		Options:                 DefaultOptions(),
+		Landscape:               false,
+		PrintBackground:         false,
+		Scale:                   1.0,
+		SinglePage:              false,
+		PaperWidth:              8.5,
+		PaperHeight:             11,
+		MarginTop:               0.39,
+		MarginBottom:            0.39,
+		MarginLeft:              0.39,
+		MarginRight:             0.39,
+		PageRanges:              "",
+		HeaderTemplate:          "<html><head></head><body></body></html>",
+		FooterTemplate:          "<html><head></head><body></body></html>",
+		PreferCssPageSize:       false,
+		GenerateDocumentOutline: false,
 	}
 }

@@ -245,30 +247,24 @@ type ScreenshotOptions struct {
 	Options

 	// Width is the device screen width in pixels.
-	// Optional.
 	Width int

 	// Height is the device screen height in pixels.
-	// Optional.
 	Height int

 	// Clip defines whether to clip the screenshot according to the device
 	// dimensions.
-	// Optional.
 	Clip bool

 	// Format is the image compression format, either "png" or "jpeg" or
 	// "webp".
-	// Optional.
 	Format string

 	// Quality is the compression quality from range [0..100] (jpeg only).
-	// Optional.
 	Quality int

 	// OptimizeForSpeed defines whether to optimize image encoding for speed,
 	// not for resulting size.
-	// Optional.
 	OptimizeForSpeed bool
 }

@@ -317,6 +313,22 @@ type Cookie struct {
 	SameSite network.CookieSameSite `json:"sameSite,omitempty"`
 }

+// ExtraHttpHeader are extra HTTP headers to send by Chromium.
+type ExtraHttpHeader struct {
+	// Name is the header name.
+	// Required.
+	Name string
+
+	// Value is the header value.
+	// Required.
+	Value string
+
+	// Scope is the header scope. If nil, the header will be applied to ALL
+	// requests from the page.
+	// Optional.
+	Scope *regexp2.Regexp
+}
+
 // Api helps to interact with Chromium for converting HTML documents to PDF.
 type Api interface {
 	Pdf(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error
--- a/pkg/modules/chromium/chromium_test.go
+++ b/pkg/modules/chromium/chromium_test.go
@@ -15,6 +15,15 @@ import (
 )

 func TestDefaultOptions(t *testing.T) {
+	actual := DefaultOptions()
+	notExpect := Options{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
+func TestDefaultPdfOptions(t *testing.T) {
 	actual := DefaultPdfOptions()
 	notExpect := PdfOptions{}

@@ -23,6 +32,15 @@ func TestDefaultOptions(t *testing.T) {
 	}
 }

+func TestDefaultScreenshotOptions(t *testing.T) {
+	actual := DefaultScreenshotOptions()
+	notExpect := ScreenshotOptions{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
 func TestChromium_Descriptor(t *testing.T) {
 	descriptor := new(Chromium).Descriptor()

--- a/pkg/modules/chromium/events.go
+++ b/pkg/modules/chromium/events.go
@@ -3,6 +3,7 @@ package chromium
 import (
 	"context"
 	"fmt"
+	"net/http"
 	"slices"
 	"sync"

@@ -20,9 +21,22 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

+type eventRequestPausedOptions struct {
+	allowList, denyList *regexp2.Regexp
+	extraHttpHeaders    []ExtraHttpHeader
+}
+
 // listenForEventRequestPaused listens for requests to check if they are
-// allowed or not.
-func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowList *regexp2.Regexp, denyList *regexp2.Regexp) {
+// allowed or not.  It also set the extra HTTP headers, if any.
+// See https://github.com/gotenberg/gotenberg/issues/1011.
+// TODO: https://chromedevtools.github.io/devtools-protocol/tot/Network/#method-setBlockedURLs (experimental for now).
+func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, options eventRequestPausedOptions) {
+	if len(options.extraHttpHeaders) == 0 {
+		logger.Debug("no extra HTTP headers")
+	} else {
+		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", options.extraHttpHeaders))
+	}
+
 	chromedp.ListenTarget(ctx, func(ev interface{}) {
 		switch e := ev.(type) {
 		case *fetch.EventRequestPaused:
@@ -36,7 +50,7 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 					return
 				}

-				err := gotenberg.FilterDeadline(allowList, denyList, e.Request.URL, deadline)
+				err := gotenberg.FilterDeadline(options.allowList, options.denyList, e.Request.URL, deadline)
 				if err != nil {
 					logger.Warn(err.Error())
 					allow = false
@@ -45,33 +59,114 @@ func listenForEventRequestPaused(ctx context.Context, logger *zap.Logger, allowL
 				cctx := chromedp.FromContext(ctx)
 				executorCtx := cdp.WithExecutor(ctx, cctx.Target)

-				if allow {
-					req := fetch.ContinueRequest(e.RequestID)
+				if !allow {
+					req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
 					err = req.Do(executorCtx)
 					if err != nil {
-						logger.Error(fmt.Sprintf("continue request: %s", err))
+						logger.Error(fmt.Sprintf("fail request: %s", err))
 					}
 					return
 				}

-				req := fetch.FailRequest(e.RequestID, network.ErrorReasonAccessDenied)
+				req := fetch.ContinueRequest(e.RequestID)
+
+				var extraHttpHeadersToSet []ExtraHttpHeader
+				if len(options.extraHttpHeaders) > 0 {
+					// The user want to set extra HTTP headers.
+
+					// First, we have to check if at least one header has to be
+					// set for current request.
+					for _, header := range options.extraHttpHeaders {
+						if header.Scope == nil {
+							// Non-scoped header.
+							logger.Debug(fmt.Sprintf("extra HTTP header '%s' will be set for request URL '%s'", header.Name, e.Request.URL))
+							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
+							continue
+						}
+
+						ok, err := header.Scope.MatchString(e.Request.URL)
+						if err != nil {
+							logger.Error(fmt.Sprintf("fail to match extra HTTP header '%s' scope with URL '%s': %s", header.Name, e.Request.URL, err))
+						} else if ok {
+							logger.Debug(fmt.Sprintf("extra HTTP header '%s' (scoped) will be set for request URL '%s'", header.Name, e.Request.URL))
+							extraHttpHeadersToSet = append(extraHttpHeadersToSet, header)
+						} else {
+							logger.Debug(fmt.Sprintf("scoped extra HTTP header '%s' (scoped) will not be set for request URL '%s'", header.Name, e.Request.URL))
+						}
+					}
+				}
+
+				if len(extraHttpHeadersToSet) > 0 {
+					logger.Debug(fmt.Sprintf("setting extra HTTP headers for request URL '%s': %+v", e.Request.URL, extraHttpHeadersToSet))
+
+					originalHeaders := e.Request.Headers
+					headers := make(map[string]string)
+
+					for key, value := range originalHeaders {
+						strValue, ok := value.(string)
+						if ok {
+							headers[key] = strValue
+						} else {
+							logger.Error(fmt.Sprintf("ignoring header '%s' for URL '%s' since it cannot be cast to a string", key, e.Request.URL))
+						}
+					}
+
+					var headersEntries []*fetch.HeaderEntry
+					for key, value := range headers {
+						headersEntries = append(headersEntries, &fetch.HeaderEntry{
+							Name:  key,
+							Value: value,
+						})
+					}
+					for _, header := range extraHttpHeadersToSet {
+						headersEntries = append(headersEntries, &fetch.HeaderEntry{
+							Name:  header.Name,
+							Value: header.Value,
+						})
+					}
+
+					req.Headers = headersEntries
+				}
+
 				err = req.Do(executorCtx)
 				if err != nil {
-					logger.Error(fmt.Sprintf("fail request: %s", err))
+					logger.Error(fmt.Sprintf("continue request: %s", err))
 				}
 			}()
 		}
 	})
 }

-// listenForEventResponseReceived listens for an invalid HTTP status code is
-// returned by the main page.
-// See https://github.com/gotenberg/gotenberg/issues/613.
-func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url string, failOnHttpStatusCodes []int64, invalidHttpStatusCode *error, invalidHttpStatusCodeMu *sync.RWMutex) {
+type eventResponseReceivedOptions struct {
+	mainPageUrl                     string
+	failOnHttpStatusCodes           []int64
+	invalidHttpStatusCode           *error
+	invalidHttpStatusCodeMu         *sync.RWMutex
+	failOnResourceOnHttpStatusCode  []int64
+	invalidResourceHttpStatusCode   *error
+	invalidResourceHttpStatusCodeMu *sync.RWMutex
+}
+
+// listenForEventResponseReceived listens for an invalid HTTP status code that
+// is returned by the main page or by one or more resources.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/613.
+// https://github.com/gotenberg/gotenberg/issues/1021.
+func listenForEventResponseReceived(
+	ctx context.Context,
+	logger *zap.Logger,
+	options eventResponseReceivedOptions,
+) {
 	for _, code := range []int64{199, 299, 399, 499, 599} {
-		if slices.Contains(failOnHttpStatusCodes, code) {
+		if slices.Contains(options.failOnHttpStatusCodes, code) {
 			for i := code - 99; i <= code; i++ {
-				failOnHttpStatusCodes = append(failOnHttpStatusCodes, i)
+				options.failOnHttpStatusCodes = append(options.failOnHttpStatusCodes, i)
+			}
+		}
+
+		if slices.Contains(options.failOnResourceOnHttpStatusCode, code) {
+			for i := code - 99; i <= code; i++ {
+				options.failOnResourceOnHttpStatusCode = append(options.failOnResourceOnHttpStatusCode, i)
 			}
 		}
 	}
@@ -79,22 +174,99 @@ func listenForEventResponseReceived(ctx context.Context, logger *zap.Logger, url
 	chromedp.ListenTarget(ctx, func(ev interface{}) {
 		switch ev := ev.(type) {
 		case *network.EventResponseReceived:
-			if ev.Response.URL != url {
+			if ev.Response.URL == options.mainPageUrl {
+				logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+
+				if slices.Contains(options.failOnHttpStatusCodes, ev.Response.Status) {
+					options.invalidHttpStatusCodeMu.Lock()
+					defer options.invalidHttpStatusCodeMu.Unlock()
+
+					*options.invalidHttpStatusCode = fmt.Errorf("%d: %s", ev.Response.Status, ev.Response.StatusText)
+				}
+
 				return
 			}

-			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for main page: %+v", ev.Response))
+			logger.Debug(fmt.Sprintf("event EventResponseReceived fired for a resource: %+v", ev.Response))

-			if slices.Contains(failOnHttpStatusCodes, ev.Response.Status) {
-				invalidHttpStatusCodeMu.Lock()
-				defer invalidHttpStatusCodeMu.Unlock()
+			if slices.Contains(options.failOnResourceOnHttpStatusCode, ev.Response.Status) {
+				options.invalidResourceHttpStatusCodeMu.Lock()
+				defer options.invalidResourceHttpStatusCodeMu.Unlock()

-				*invalidHttpStatusCode = fmt.Errorf("%d: %s", ev.Response.Status, ev.Response.StatusText)
+				*options.invalidResourceHttpStatusCode = multierr.Append(
+					*options.invalidResourceHttpStatusCode,
+					fmt.Errorf("%s - %d: %s", ev.Response.URL, ev.Response.Status, http.StatusText(int(ev.Response.Status))),
+				)
 			}
 		}
 	})
 }

+type eventLoadingFailedOptions struct {
+	loadingFailed           *error
+	loadingFailedMu         *sync.RWMutex
+	resourceLoadingFailed   *error
+	resourceLoadingFailedMu *sync.RWMutex
+}
+
+// listenForEventLoadingFailed listens for an event indicating that the main
+// page or one or more resources failed to load.
+// See:
+// https://github.com/gotenberg/gotenberg/issues/913.
+// https://github.com/gotenberg/gotenberg/issues/959.
+// https://github.com/gotenberg/gotenberg/issues/1021.
+func listenForEventLoadingFailed(ctx context.Context, logger *zap.Logger, options eventLoadingFailedOptions) {
+	chromedp.ListenTarget(ctx, func(ev interface{}) {
+		switch ev := ev.(type) {
+		case *network.EventLoadingFailed:
+			logger.Debug(fmt.Sprintf("event EventLoadingFailed fired: %+v", ev.ErrorText))
+
+			// We are looking for common errors.
+			// TODO: sufficient?
+			errors := []string{
+				"net::ERR_CONNECTION_CLOSED",
+				"net::ERR_CONNECTION_RESET",
+				"net::ERR_CONNECTION_REFUSED",
+				"net::ERR_CONNECTION_ABORTED",
+				"net::ERR_CONNECTION_FAILED",
+				"net::ERR_NAME_NOT_RESOLVED",
+				"net::ERR_INTERNET_DISCONNECTED",
+				"net::ERR_ADDRESS_UNREACHABLE",
+				"net::ERR_BLOCKED_BY_CLIENT",
+				"net::ERR_BLOCKED_BY_RESPONSE",
+				"net::ERR_FILE_NOT_FOUND",
+			}
+			if !slices.Contains(errors, ev.ErrorText) {
+				logger.Debug(fmt.Sprintf("skip EventLoadingFailed: '%s' is not part of %+v", ev.ErrorText, errors))
+				return
+			}
+
+			if ev.Type == network.ResourceTypeDocument {
+				// Supposition: except iframe, an event loading failed with a
+				// resource type Document is about the main page.
+				logger.Debug("event EventLoadingFailed fired for main page")
+
+				options.loadingFailedMu.Lock()
+				defer options.loadingFailedMu.Unlock()
+
+				*options.loadingFailed = fmt.Errorf("%s", ev.ErrorText)
+
+				return
+			}
+
+			logger.Debug("event EventLoadingFailed fired for a resource")
+
+			options.resourceLoadingFailedMu.Lock()
+			defer options.resourceLoadingFailedMu.Unlock()
+
+			*options.resourceLoadingFailed = multierr.Append(
+				*options.resourceLoadingFailed,
+				fmt.Errorf("resource %s: %s", ev.Type, ev.ErrorText),
+			)
+		}
+	})
+}
+
 // listenForEventExceptionThrown listens for exceptions in the console and
 // appends those exceptions to the given error pointer.
 // See https://github.com/gotenberg/gotenberg/issues/262.
--- a/pkg/modules/chromium/routes.go
+++ b/pkg/modules/chromium/routes.go
@@ -13,6 +13,7 @@ import (
 	"strings"
 	"time"

+	"github.com/dlclark/regexp2"
 	"github.com/labstack/echo/v4"
 	"github.com/microcosm-cc/bluemonday"
 	"github.com/russross/blackfriday/v2"
@@ -20,6 +21,7 @@ import (

 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/pdfengines"
 )

 // FormDataChromiumOptions creates [Options] from the form data. Fallback to
@@ -28,17 +30,19 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 	defaultOptions := DefaultOptions()

 	var (
-		skipNetworkIdleEvent    bool
-		failOnHttpStatusCodes   []int64
-		failOnConsoleExceptions bool
-		waitDelay               time.Duration
-		waitWindowStatus        string
-		waitForExpression       string
-		cookies                 []Cookie
-		userAgent               string
-		extraHttpHeaders        map[string]string
-		emulatedMediaType       string
-		omitBackground          bool
+		skipNetworkIdleEvent          bool
+		failOnHttpStatusCodes         []int64
+		failOnResourceHttpStatusCodes []int64
+		failOnResourceLoadingFailed   bool
+		failOnConsoleExceptions       bool
+		waitDelay                     time.Duration
+		waitWindowStatus              string
+		waitForExpression             string
+		cookies                       []Cookie
+		userAgent                     string
+		extraHttpHeaders              []ExtraHttpHeader
+		emulatedMediaType             string
+		omitBackground                bool
 	)

 	form := ctx.FormData().
@@ -56,6 +60,20 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {

 			return nil
 		}).
+		Custom("failOnResourceHttpStatusCodes", func(value string) error {
+			if value == "" {
+				failOnResourceHttpStatusCodes = defaultOptions.FailOnResourceHttpStatusCodes
+				return nil
+			}
+
+			err := json.Unmarshal([]byte(value), &failOnResourceHttpStatusCodes)
+			if err != nil {
+				return fmt.Errorf("unmarshal failOnResourceHttpStatusCodes: %w", err)
+			}
+
+			return nil
+		}).
+		Bool("failOnResourceLoadingFailed", &failOnResourceLoadingFailed, defaultOptions.FailOnResourceLoadingFailed).
 		Bool("failOnConsoleExceptions", &failOnConsoleExceptions, defaultOptions.FailOnConsoleExceptions).
 		Duration("waitDelay", &waitDelay, defaultOptions.WaitDelay).
 		String("waitWindowStatus", &waitWindowStatus, defaultOptions.WaitWindowStatus).
@@ -86,12 +104,59 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 				return nil
 			}

-			err := json.Unmarshal([]byte(value), &extraHttpHeaders)
+			var headers map[string]string
+			err := json.Unmarshal([]byte(value), &headers)
 			if err != nil {
 				return fmt.Errorf("unmarshal extraHttpHeaders: %w", err)
 			}

-			return nil
+			for k, v := range headers {
+				var scope string
+				var valueTokens []string
+				var invalidScopeToken bool
+
+				tokens := strings.Split(v, ";")
+				for _, token := range tokens {
+					if strings.HasPrefix(strings.ToLower(strings.TrimSpace(token)), "scope") {
+						tokenNoSpaces := strings.Join(strings.Fields(token), "")
+						parts := strings.SplitN(tokenNoSpaces, "=", 2)
+
+						if len(parts) == 2 && strings.ToLower(parts[0]) == "scope" && parts[1] != "" {
+							scope = parts[1]
+						} else {
+							err = multierr.Append(err, fmt.Errorf("invalid scope '%s' for header '%s'", scope, k))
+							invalidScopeToken = true
+							break
+						}
+					} else {
+						if token != "" {
+							valueTokens = append(valueTokens, token)
+						}
+					}
+				}
+
+				if invalidScopeToken {
+					continue
+				}
+
+				var scopeRegexp *regexp2.Regexp
+				if len(scope) > 0 {
+					p, errCompile := regexp2.Compile(scope, 0)
+					if errCompile != nil {
+						err = multierr.Append(err, fmt.Errorf("invalid scope regex pattern for header '%s': %w", k, errCompile))
+						continue
+					}
+					scopeRegexp = p
+				}
+
+				extraHttpHeaders = append(extraHttpHeaders, ExtraHttpHeader{
+					Name:  k,
+					Value: strings.Join(valueTokens, "; "),
+					Scope: scopeRegexp,
+				})
+			}
+
+			return err
 		}).
 		Custom("emulatedMediaType", func(value string) error {
 			if value == "" {
@@ -110,17 +175,19 @@ func FormDataChromiumOptions(ctx *api.Context) (*api.FormData, Options) {
 		Bool("omitBackground", &omitBackground, defaultOptions.OmitBackground)

 	options := Options{
-		SkipNetworkIdleEvent:    skipNetworkIdleEvent,
-		FailOnHttpStatusCodes:   failOnHttpStatusCodes,
-		FailOnConsoleExceptions: failOnConsoleExceptions,
-		WaitDelay:               waitDelay,
-		WaitWindowStatus:        waitWindowStatus,
-		WaitForExpression:       waitForExpression,
-		Cookies:                 cookies,
-		UserAgent:               userAgent,
-		ExtraHttpHeaders:        extraHttpHeaders,
-		EmulatedMediaType:       emulatedMediaType,
-		OmitBackground:          omitBackground,
+		SkipNetworkIdleEvent:          skipNetworkIdleEvent,
+		FailOnHttpStatusCodes:         failOnHttpStatusCodes,
+		FailOnResourceHttpStatusCodes: failOnResourceHttpStatusCodes,
+		FailOnResourceLoadingFailed:   failOnResourceLoadingFailed,
+		FailOnConsoleExceptions:       failOnConsoleExceptions,
+		WaitDelay:                     waitDelay,
+		WaitWindowStatus:              waitWindowStatus,
+		WaitForExpression:             waitForExpression,
+		Cookies:                       cookies,
+		UserAgent:                     userAgent,
+		ExtraHttpHeaders:              extraHttpHeaders,
+		EmulatedMediaType:             emulatedMediaType,
+		OmitBackground:                omitBackground,
 	}

 	return form, options
@@ -139,6 +206,7 @@ func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
 		pageRanges                                       string
 		headerTemplate, footerTemplate                   string
 		preferCssPageSize                                bool
+		generateDocumentOutline                          bool
 	)

 	form.
@@ -155,24 +223,26 @@ func FormDataChromiumPdfOptions(ctx *api.Context) (*api.FormData, PdfOptions) {
 		String("nativePageRanges", &pageRanges, defaultPdfOptions.PageRanges).
 		Content("header.html", &headerTemplate, defaultPdfOptions.HeaderTemplate).
 		Content("footer.html", &footerTemplate, defaultPdfOptions.FooterTemplate).
-		Bool("preferCssPageSize", &preferCssPageSize, defaultPdfOptions.PreferCssPageSize)
+		Bool("preferCssPageSize", &preferCssPageSize, defaultPdfOptions.PreferCssPageSize).
+		Bool("generateDocumentOutline", &generateDocumentOutline, defaultPdfOptions.GenerateDocumentOutline)

 	pdfOptions := PdfOptions{
-		Options:           options,
-		Landscape:         landscape,
-		PrintBackground:   printBackground,
-		Scale:             scale,
-		SinglePage:        singlePage,
-		PaperWidth:        paperWidth,
-		PaperHeight:       paperHeight,
-		MarginTop:         marginTop,
-		MarginBottom:      marginBottom,
-		MarginLeft:        marginLeft,
-		MarginRight:       marginRight,
-		PageRanges:        pageRanges,
-		HeaderTemplate:    headerTemplate,
-		FooterTemplate:    footerTemplate,
-		PreferCssPageSize: preferCssPageSize,
+		Options:                 options,
+		Landscape:               landscape,
+		PrintBackground:         printBackground,
+		Scale:                   scale,
+		SinglePage:              singlePage,
+		PaperWidth:              paperWidth,
+		PaperHeight:             paperHeight,
+		MarginTop:               marginTop,
+		MarginBottom:            marginBottom,
+		MarginLeft:              marginLeft,
+		MarginRight:             marginRight,
+		PageRanges:              pageRanges,
+		HeaderTemplate:          headerTemplate,
+		FooterTemplate:          footerTemplate,
+		PreferCssPageSize:       preferCssPageSize,
+		GenerateDocumentOutline: generateDocumentOutline,
 	}

 	return form, pdfOptions
@@ -247,39 +317,6 @@ func FormDataChromiumScreenshotOptions(ctx *api.Context) (*api.FormData, Screens
 	return form, screenshotOptions
 }

-// FormDataChromiumPdfFormats creates [gotenberg.PdfFormats] from the form
-// data. Fallback to default value if the considered key is not present.
-func FormDataChromiumPdfFormats(form *api.FormData) gotenberg.PdfFormats {
-	var (
-		pdfa  string
-		pdfua bool
-	)
-
-	form.
-		String("pdfa", &pdfa, "").
-		Bool("pdfua", &pdfua, false)
-
-	return gotenberg.PdfFormats{
-		PdfA:  pdfa,
-		PdfUa: pdfua,
-	}
-}
-
-// FormDataPdfMetadata creates metadata object from the form data.
-func FormDataPdfMetadata(form *api.FormData) map[string]interface{} {
-	var metadata map[string]interface{}
-	form.Custom("metadata", func(value string) error {
-		if len(value) > 0 {
-			err := json.Unmarshal([]byte(value), &metadata)
-			if err != nil {
-				return fmt.Errorf("unmarshal metadata: %w", err)
-			}
-		}
-		return nil
-	})
-	return metadata
-}
-
 // convertUrlRoute returns an [api.Route] which can convert a URL to PDF.
 func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
@@ -289,8 +326,9 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
-			pdfFormats := FormDataChromiumPdfFormats(form)
-			metadata := FormDataPdfMetadata(form)
+			mode := pdfengines.FormDataPdfSplitMode(form, false)
+			pdfFormats := pdfengines.FormDataPdfFormats(form)
+			metadata := pdfengines.FormDataPdfMetadata(form, false)

 			var url string
 			err := form.
@@ -300,7 +338,7 @@ func convertUrlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert URL to PDF: %w", err)
 			}
@@ -349,8 +387,9 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
-			pdfFormats := FormDataChromiumPdfFormats(form)
-			metadata := FormDataPdfMetadata(form)
+			mode := pdfengines.FormDataPdfSplitMode(form, false)
+			pdfFormats := pdfengines.FormDataPdfFormats(form)
+			metadata := pdfengines.FormDataPdfMetadata(form, false)

 			var inputPath string
 			err := form.
@@ -361,7 +400,7 @@ func convertHtmlRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 			}

 			url := fmt.Sprintf("file://%s", inputPath)
-			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert HTML to PDF: %w", err)
 			}
@@ -411,8 +450,9 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
 			form, options := FormDataChromiumPdfOptions(ctx)
-			pdfFormats := FormDataChromiumPdfFormats(form)
-			metadata := FormDataPdfMetadata(form)
+			mode := pdfengines.FormDataPdfSplitMode(form, false)
+			pdfFormats := pdfengines.FormDataPdfFormats(form)
+			metadata := pdfengines.FormDataPdfMetadata(form, false)

 			var (
 				inputPath     string
@@ -432,7 +472,7 @@ func convertMarkdownRoute(chromium Api, engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("transform markdown file(s) to HTML: %w", err)
 			}

-			err = convertUrl(ctx, chromium, engine, url, options, pdfFormats, metadata)
+			err = convertUrl(ctx, chromium, engine, url, options, mode, pdfFormats, metadata)
 			if err != nil {
 				return fmt.Errorf("convert markdown to PDF: %w", err)
 			}
@@ -556,7 +596,7 @@ func markdownToHtml(ctx *api.Context, inputPath string, markdownPaths []string)
 	return fmt.Sprintf("file://%s", inputPath), nil
 }

-func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, options PdfOptions, pdfFormats gotenberg.PdfFormats, metadata map[string]interface{}) error {
+func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url string, options PdfOptions, mode gotenberg.SplitMode, pdfFormats gotenberg.PdfFormats, metadata map[string]interface{}) error {
 	outputPath := ctx.GeneratePath(".pdf")

 	err := chromium.Pdf(ctx, ctx.Log(), url, outputPath, options)
@@ -595,34 +635,39 @@ func convertUrl(ctx *api.Context, chromium Api, engine gotenberg.PdfEngine, url
 		return fmt.Errorf("convert to PDF: %w", err)
 	}

-	// So far so good, the URL has been converted to PDF.
-	// Now, let's check if the client want to convert the resulting PDF
-	// to specific formats.
-	zeroValued := gotenberg.PdfFormats{}
-	if pdfFormats != zeroValued {
-		convertInputPath := outputPath
-		convertOutputPath := ctx.GeneratePath(".pdf")
-
-		err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
-		if err != nil {
-			return fmt.Errorf("convert PDF: %w", err)
-		}
-
-		// Important: the output path is now the converted file.
-		outputPath = convertOutputPath
-	}
-
-	// Writes and potentially overrides metadata entries, if any.
-	if len(metadata) > 0 {
-		err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
-		if err != nil {
-			return fmt.Errorf("write metadata: %w", err)
-		}
-	}
-
-	err = ctx.AddOutputPaths(outputPath)
+	outputPaths, err := pdfengines.SplitPdfStub(ctx, engine, mode, []string{outputPath})
 	if err != nil {
-		return fmt.Errorf("add output path: %w", err)
+		return fmt.Errorf("split PDF: %w", err)
+	}
+
+	convertOutputPaths, err := pdfengines.ConvertStub(ctx, engine, pdfFormats, outputPaths)
+	if err != nil {
+		return fmt.Errorf("convert PDF(s): %w", err)
+	}
+
+	err = pdfengines.WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
+	if err != nil {
+		return fmt.Errorf("write metadata: %w", err)
+	}
+
+	zeroValuedSplitMode := gotenberg.SplitMode{}
+	zeroValuedPdfFormats := gotenberg.PdfFormats{}
+	if mode != zeroValuedSplitMode && pdfFormats != zeroValuedPdfFormats {
+		// The PDF has been split and split parts have been converted to a
+		// specific format. We want to keep the split naming.
+		for i, convertOutputPath := range convertOutputPaths {
+			err = ctx.Rename(convertOutputPath, outputPaths[i])
+			if err != nil {
+				return fmt.Errorf("rename output path: %w", err)
+			}
+		}
+	} else {
+		outputPaths = convertOutputPaths
+	}
+
+	err = ctx.AddOutputPaths(outputPaths...)
+	if err != nil {
+		return fmt.Errorf("add output paths: %w", err)
 	}

 	return nil
@@ -678,12 +723,42 @@ func handleChromiumError(err error, options Options) error {
 		)
 	}

+	if errors.Is(err, ErrInvalidResourceHttpStatusCode) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Invalid HTTP status code from resources:\n%s", strings.ReplaceAll(err.Error(), fmt.Sprintf(": %s", ErrInvalidResourceHttpStatusCode.Error()), "")),
+			),
+		)
+	}
+
 	if errors.Is(err, ErrConsoleExceptions) {
 		return api.WrapError(
 			err,
 			api.NewSentinelHttpError(
 				http.StatusConflict,
-				fmt.Sprintf("Chromium console exceptions:\n %s", strings.ReplaceAll(err.Error(), ErrConsoleExceptions.Error(), "")),
+				fmt.Sprintf("Chromium console exceptions:\n%s", strings.ReplaceAll(err.Error(), ErrConsoleExceptions.Error(), "")),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrLoadingFailed) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusBadRequest,
+				fmt.Sprintf("Chromium returned %v", err),
+			),
+		)
+	}
+
+	if errors.Is(err, ErrResourceLoadingFailed) {
+		return api.WrapError(
+			err,
+			api.NewSentinelHttpError(
+				http.StatusConflict,
+				fmt.Sprintf("Chromium failed to load resources: %v", strings.ReplaceAll(err.Error(), fmt.Sprintf(": %s", ErrResourceLoadingFailed.Error()), "")),
 			),
 		)
 	}
--- a/pkg/modules/chromium/routes_test.go
+++ b/pkg/modules/chromium/routes_test.go
@@ -7,8 +7,10 @@ import (
 	"net/http"
 	"os"
 	"reflect"
+	"sort"
 	"testing"

+	"github.com/dlclark/regexp2"
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"
@@ -19,14 +21,18 @@ import (

 func TestFormDataChromiumOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions Options
+		scenario                string
+		ctx                     *api.ContextMock
+		expectedOptions         Options
+		compareWithoutDeepEqual bool
+		expectValidationError   bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultOptions(),
+			scenario:                "no custom form fields",
+			ctx:                     &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
 		},
 		{
 			scenario: "invalid failOnHttpStatusCodes form field",
@@ -44,6 +50,8 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.FailOnHttpStatusCodes = nil
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "valid failOnHttpStatusCodes form field",
@@ -61,6 +69,46 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.FailOnHttpStatusCodes = []int64{399, 499, 599}
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
+		},
+		{
+			scenario: "invalid failOnResourceHttpStatusCodes form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"failOnResourceHttpStatusCodes": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				options.FailOnResourceHttpStatusCodes = nil
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "valid failOnResourceHttpStatusCodes form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"failOnResourceHttpStatusCodes": {
+						`[399,499,599]`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions: func() Options {
+				options := DefaultOptions()
+				options.FailOnResourceHttpStatusCodes = []int64{399, 499, 599}
+				return options
+			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
 		},
 		{
 			scenario: "invalid cookies form field",
@@ -73,7 +121,9 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedOptions: DefaultOptions(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "invalid cookies form field (missing required values)",
@@ -93,6 +143,8 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.Cookies = []Cookie{{}}
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "valid cookies form field",
@@ -114,9 +166,11 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				}}
 				return options
 			}(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   false,
 		},
 		{
-			scenario: "invalid extraHttpHeaders form field",
+			scenario: "invalid extraHttpHeaders form field: cannot unmarshall",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetValues(map[string][]string{
@@ -126,7 +180,39 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedOptions: DefaultOptions(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "invalid extraHttpHeaders form field: invalid scope",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						`{"foo":"bar;scope;;"}`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
+		},
+		{
+			scenario: "invalid extraHttpHeaders form field: invalid scope regex pattern",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"extraHttpHeaders": {
+						`{"foo":"bar;scope=*."}`,
+					},
+				})
+				return ctx
+			}(),
+			expectedOptions:         DefaultOptions(),
+			compareWithoutDeepEqual: false,
+			expectValidationError:   true,
 		},
 		{
 			scenario: "valid extraHttpHeaders form field",
@@ -134,18 +220,28 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetValues(map[string][]string{
 					"extraHttpHeaders": {
-						`{"foo":"bar"}`,
+						`{"foo":"bar","baz":"qux;scope=https?:\\/\\/([a-zA-Z0-9-]+\\.)*qux\\.com\\/.*"}`,
 					},
 				})
 				return ctx
 			}(),
 			expectedOptions: func() Options {
 				options := DefaultOptions()
-				options.ExtraHttpHeaders = map[string]string{
-					"foo": "bar",
+				options.ExtraHttpHeaders = []ExtraHttpHeader{
+					{
+						Name:  "foo",
+						Value: "bar",
+					},
+					{
+						Name:  "baz",
+						Value: "qux",
+						Scope: regexp2.MustCompile(`https?:\/\/([a-zA-Z0-9-]+\.)*qux\.com\/.*`, 0),
+					},
 				}
 				return options
 			}(),
+			compareWithoutDeepEqual: true,
+			expectValidationError:   false,
 		},
 		{
 			scenario: "invalid emulatedMediaType form field",
@@ -158,7 +254,8 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				})
 				return ctx
 			}(),
-			expectedOptions: DefaultOptions(),
+			expectedOptions:       DefaultOptions(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid emulatedMediaType form field",
@@ -176,14 +273,61 @@ func TestFormDataChromiumOptions(t *testing.T) {
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumOptions(tc.ctx.Context)

-			if !reflect.DeepEqual(actual, tc.expectedOptions) {
-				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
+			if tc.compareWithoutDeepEqual {
+				if len(tc.expectedOptions.ExtraHttpHeaders) != len(actual.ExtraHttpHeaders) {
+					t.Fatalf("expected %d extra HTTP headers, but got %d", len(tc.expectedOptions.ExtraHttpHeaders), len(actual.ExtraHttpHeaders))
+				}
+
+				sort.Slice(tc.expectedOptions.ExtraHttpHeaders, func(i, j int) bool {
+					return tc.expectedOptions.ExtraHttpHeaders[i].Name < tc.expectedOptions.ExtraHttpHeaders[j].Name
+				})
+				sort.Slice(actual.ExtraHttpHeaders, func(i, j int) bool {
+					return actual.ExtraHttpHeaders[i].Name < actual.ExtraHttpHeaders[j].Name
+				})
+
+				for i := range tc.expectedOptions.ExtraHttpHeaders {
+					if tc.expectedOptions.ExtraHttpHeaders[i].Name != actual.ExtraHttpHeaders[i].Name {
+						t.Fatalf("expected '%s' extra HTTP header, but got '%s'", tc.expectedOptions.ExtraHttpHeaders[i].Name, tc.expectedOptions.ExtraHttpHeaders[i].Name)
+					}
+
+					if tc.expectedOptions.ExtraHttpHeaders[i].Value != actual.ExtraHttpHeaders[i].Value {
+						t.Fatalf("expected '%s' as value for extra HTTP header '%s', but got '%s'", tc.expectedOptions.ExtraHttpHeaders[i].Value, tc.expectedOptions.ExtraHttpHeaders[i].Name, actual.ExtraHttpHeaders[i].Value)
+					}
+
+					var expectedScope string
+					if tc.expectedOptions.ExtraHttpHeaders[i].Scope != nil {
+						expectedScope = tc.expectedOptions.ExtraHttpHeaders[i].Scope.String()
+					}
+					var actualScope string
+					if actual.ExtraHttpHeaders[i].Scope != nil {
+						actualScope = actual.ExtraHttpHeaders[i].Scope.String()
+					}
+
+					if expectedScope != actualScope {
+						t.Fatalf("expected '%s' as scope for extra HTTP header '%s', but got '%s'", expectedScope, tc.expectedOptions.ExtraHttpHeaders[i].Name, actualScope)
+					}
+				}
+			} else {
+				if !reflect.DeepEqual(actual, tc.expectedOptions) {
+					t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
+				}
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
 			}
 		})
 	}
@@ -191,14 +335,16 @@ func TestFormDataChromiumOptions(t *testing.T) {

 func TestFormDataChromiumPdfOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions PdfOptions
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedOptions       PdfOptions
+		expectValidationError bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultPdfOptions(),
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:       DefaultPdfOptions(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "custom form fields (Options & PdfOptions)",
@@ -220,29 +366,42 @@ func TestFormDataChromiumPdfOptions(t *testing.T) {
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumPdfOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumPdfOptions(tc.ctx.Context)

 			if !reflect.DeepEqual(actual, tc.expectedOptions) {
 				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
 			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
 		})
 	}
 }

 func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 	for _, tc := range []struct {
-		scenario        string
-		ctx             *api.ContextMock
-		expectedOptions ScreenshotOptions
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedOptions       ScreenshotOptions
+		expectValidationError bool
 	}{
 		{
-			scenario:        "no custom form fields",
-			ctx:             &api.ContextMock{Context: new(api.Context)},
-			expectedOptions: DefaultScreenshotOptions(),
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedOptions:       DefaultScreenshotOptions(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "invalid format form field",
@@ -260,6 +419,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = ""
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid png format form field",
@@ -277,6 +437,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "png"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "valid jpeg format form field",
@@ -294,6 +455,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "jpeg"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "valid webp format form field",
@@ -311,6 +473,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Format = "webp"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "invalid quality form field (not an integer)",
@@ -328,6 +491,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "invalid quality form field (< 0)",
@@ -345,6 +509,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "invalid quality form field (> 100)",
@@ -362,6 +527,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 0
 				return options
 			}(),
+			expectValidationError: true,
 		},
 		{
 			scenario: "valid quality form field",
@@ -379,6 +545,7 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.Quality = 50
 				return options
 			}(),
+			expectValidationError: false,
 		},
 		{
 			scenario: "custom form fields (Options & ScreenshotOptions)",
@@ -412,104 +579,25 @@ func TestFormDataChromiumScreenshotOptions(t *testing.T) {
 				options.EmulatedMediaType = "screen"
 				return options
 			}(),
+			expectValidationError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			_, actual := FormDataChromiumScreenshotOptions(tc.ctx.Context)
+			form, actual := FormDataChromiumScreenshotOptions(tc.ctx.Context)

 			if !reflect.DeepEqual(actual, tc.expectedOptions) {
 				t.Fatalf("expected %+v but got: %+v", tc.expectedOptions, actual)
 			}
-		})
-	}
-}

-func TestFormDataChromiumPdfFormats(t *testing.T) {
-	for _, tc := range []struct {
-		scenario           string
-		ctx                *api.ContextMock
-		expectedPdfFormats gotenberg.PdfFormats
-	}{
-		{
-			scenario:           "no custom form fields",
-			ctx:                &api.ContextMock{Context: new(api.Context)},
-			expectedPdfFormats: gotenberg.PdfFormats{},
-		},
-		{
-			scenario: "pdfa and pdfua form fields",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetValues(map[string][]string{
-					"pdfa": {
-						"foo",
-					},
-					"pdfua": {
-						"true",
-					},
-				})
-				return ctx
-			}(),
-			expectedPdfFormats: gotenberg.PdfFormats{PdfA: "foo", PdfUa: true},
-		},
-	} {
-		t.Run(tc.scenario, func(t *testing.T) {
-			tc.ctx.SetLogger(zap.NewNop())
-			actual := FormDataChromiumPdfFormats(tc.ctx.Context.FormData())
+			err := form.Validate()

-			if !reflect.DeepEqual(actual, tc.expectedPdfFormats) {
-				t.Fatalf("expected %+v but got: %+v", tc.expectedPdfFormats, actual)
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
 			}
-		})
-	}
-}

-func TestFormDataPdfMetadata(t *testing.T) {
-	for _, tc := range []struct {
-		scenario         string
-		ctx              *api.ContextMock
-		expectedMetadata map[string]interface{}
-	}{
-		{
-			scenario:         "no metadata form field",
-			ctx:              &api.ContextMock{Context: new(api.Context)},
-			expectedMetadata: nil,
-		},
-		{
-			scenario: "invalid metadata form field",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetValues(map[string][]string{
-					"metadata": {
-						"foo",
-					},
-				})
-				return ctx
-			}(),
-			expectedMetadata: nil,
-		},
-		{
-			scenario: "valid metadata form field",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetValues(map[string][]string{
-					"metadata": {
-						"{\"foo\":\"bar\"}",
-					},
-				})
-				return ctx
-			}(),
-			expectedMetadata: map[string]interface{}{
-				"foo": "bar",
-			},
-		},
-	} {
-		t.Run(tc.scenario, func(t *testing.T) {
-			tc.ctx.SetLogger(zap.NewNop())
-			actual := FormDataPdfMetadata(tc.ctx.Context.FormData())
-
-			if !reflect.DeepEqual(actual, tc.expectedMetadata) {
-				t.Fatalf("expected %+v but got: %+v", tc.expectedMetadata, actual)
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
 			}
 		})
 	}
@@ -1340,6 +1428,7 @@ func TestConvertUrl(t *testing.T) {
 		api                    Api
 		engine                 gotenberg.PdfEngine
 		options                PdfOptions
+		splitMode              gotenberg.SplitMode
 		pdfFormats             gotenberg.PdfFormats
 		metadata               map[string]interface{}
 		expectError            bool
@@ -1423,6 +1512,18 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrInvalidResourceHttpStatusCode
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1435,6 +1536,30 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrLoadingFailed
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return ErrResourceLoadingFailed
+			}},
+			options:                DefaultPdfOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "error from Chromium",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1446,6 +1571,36 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "PDF engine split error",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+				return nil, errors.New("foo")
+			}},
+			options:                DefaultPdfOptions(),
+			splitMode:              gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "success with split mode",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+				return []string{inputPath}, nil
+			}},
+			options:                DefaultPdfOptions(),
+			splitMode:              gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1"},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
 		{
 			scenario: "PDF engine convert error",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1476,6 +1631,27 @@ func TestConvertUrl(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "success with split mode and PDF formats",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{PdfMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options PdfOptions) error {
+				return nil
+			}},
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			options:                DefaultPdfOptions(),
+			splitMode:              gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1"},
+			pdfFormats:             gotenberg.PdfFormats{PdfA: gotenberg.PdfA1b},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 1,
+		},
 		{
 			scenario: "PDF engine write metadata error",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1535,7 +1711,13 @@ func TestConvertUrl(t *testing.T) {
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
-			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.options, tc.pdfFormats, tc.metadata)
+			tc.ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+				return nil
+			}})
+			tc.ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return nil
+			}})
+			err := convertUrl(tc.ctx.Context, tc.api, tc.engine, "", tc.options, tc.splitMode, tc.pdfFormats, tc.metadata)

 			if tc.expectError && err == nil {
 				t.Fatal("expected error but got none", err)
@@ -1621,6 +1803,18 @@ func TestScreenshotUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrInvalidResourceHttpStatusCode",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrInvalidResourceHttpStatusCode
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "ErrConsoleExceptions",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
@@ -1633,6 +1827,30 @@ func TestScreenshotUrl(t *testing.T) {
 			expectHttpStatus:       http.StatusConflict,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "ErrLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrLoadingFailed
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrResourceLoadingFailed",
+			ctx:      &api.ContextMock{Context: new(api.Context)},
+			api: &ApiMock{ScreenshotMock: func(ctx context.Context, logger *zap.Logger, url, outputPath string, options ScreenshotOptions) error {
+				return ErrResourceLoadingFailed
+			}},
+			options:                DefaultScreenshotOptions(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusConflict,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "error from Chromium",
 			ctx:      &api.ContextMock{Context: new(api.Context)},
--- a/pkg/modules/chromium/tasks.go
+++ b/pkg/modules/chromium/tasks.go
@@ -48,6 +48,7 @@ func printToPdfActionFunc(logger *zap.Logger, outputPath string, options PdfOpti
 			WithMarginRight(options.MarginRight).
 			WithPageRanges(pageRanges).
 			WithPreferCSSPageSize(options.PreferCssPageSize).
+			WithGenerateDocumentOutline(options.GenerateDocumentOutline).
 			// Does not seem to work.
 			// See https://github.com/gotenberg/gotenberg/issues/831.
 			WithGenerateTaggedPDF(false)
@@ -298,28 +299,33 @@ func userAgentOverride(logger *zap.Logger, userAgent string) chromedp.ActionFunc
 	}
 }

-func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
-	return func(ctx context.Context) error {
-		if len(extraHttpHeaders) == 0 {
-			logger.Debug("no extra HTTP headers")
-			return nil
-		}
-
-		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
-
-		headers := make(network.Headers, len(extraHttpHeaders))
-		for key, value := range extraHttpHeaders {
-			headers[key] = value
-		}
-
-		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
-		if err == nil {
-			return nil
-		}
-
-		return fmt.Errorf("set extra HTTP headers: %w", err)
-	}
-}
+// This code has been replaced with the listenForEventRequestPaused function.
+// Indeed, the user may want to scope the headers per domain, but using
+// network.SetExtraHTTPHeaders set the headers for ALL requests from the page.
+// See https://github.com/gotenberg/gotenberg/issues/1011.
+//
+//func extraHttpHeadersActionFunc(logger *zap.Logger, extraHttpHeaders map[string]string) chromedp.ActionFunc {
+//	return func(ctx context.Context) error {
+//		if len(extraHttpHeaders) == 0 {
+//			logger.Debug("no extra HTTP headers")
+//			return nil
+//		}
+//
+//		logger.Debug(fmt.Sprintf("extra HTTP headers: %+v", extraHttpHeaders))
+//
+//		headers := make(network.Headers, len(extraHttpHeaders))
+//		for key, value := range extraHttpHeaders {
+//			headers[key] = value
+//		}
+//
+//		err := network.SetExtraHTTPHeaders(headers).Do(ctx)
+//		if err == nil {
+//			return nil
+//		}
+//
+//		return fmt.Errorf("set extra HTTP headers: %w", err)
+//	}
+//}

 func navigateActionFunc(logger *zap.Logger, url string, skipNetworkIdleEvent bool) chromedp.ActionFunc {
 	return func(ctx context.Context) error {
--- a/pkg/modules/exiftool/exiftool.go
+++ b/pkg/modules/exiftool/exiftool.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"reflect"

 	"github.com/barasher/go-exiftool"
 	"go.uber.org/zap"
@@ -57,6 +58,11 @@ func (engine *ExifTool) Merge(ctx context.Context, logger *zap.Logger, inputPath
 	return fmt.Errorf("merge PDFs with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }

+// Split is not available in this implementation.
+func (engine *ExifTool) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	return nil, fmt.Errorf("split PDF with ExifTool: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Convert is not available in this implementation.
 func (engine *ExifTool) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with ExifTool: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
@@ -109,6 +115,17 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 			fileMetadata[0].SetString(key, val)
 		case []string:
 			fileMetadata[0].SetStrings(key, val)
+		case []interface{}:
+			// See https://github.com/gotenberg/gotenberg/issues/1048.
+			strings := make([]string, len(val))
+			for i, entry := range val {
+				if str, ok := entry.(string); ok {
+					strings[i] = str
+					continue
+				}
+				return fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeOf(val), gotenberg.ErrPdfEngineMetadataValueNotSupported)
+			}
+			fileMetadata[0].SetStrings(key, strings)
 		case bool:
 			fileMetadata[0].SetString(key, fmt.Sprintf("%t", val))
 		case int:
@@ -122,7 +139,7 @@ func (engine *ExifTool) WriteMetadata(ctx context.Context, logger *zap.Logger, m
 		// TODO: support more complex cases, e.g., arrays and nested objects
 		// 	(limitations in underlying library).
 		default:
-			return fmt.Errorf("write PDF metadata with ExifTool: %w", gotenberg.ErrPdfEngineMetadataValueNotSupported)
+			return fmt.Errorf("write PDF metadata with ExifTool: %s %+v %s %w", key, val, reflect.TypeOf(val), gotenberg.ErrPdfEngineMetadataValueNotSupported)
 		}
 	}

--- a/pkg/modules/exiftool/exiftool_test.go
+++ b/pkg/modules/exiftool/exiftool_test.go
@@ -82,6 +82,15 @@ func TestExiftool_Merge(t *testing.T) {
 	}
 }

+func TestExiftool_Split(t *testing.T) {
+	engine := new(ExifTool)
+	_, err := engine.Split(context.Background(), zap.NewNop(), gotenberg.SplitMode{}, "", "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
 func TestExiftool_Convert(t *testing.T) {
 	engine := new(ExifTool)
 	err := engine.Convert(context.Background(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
@@ -162,7 +171,20 @@ func TestExiftool_WriteMetadata(t *testing.T) {
 			expectError: true,
 		},
 		{
-			scenario:   "gotenberg.ErrPdfEngineMetadataValueNotSupported",
+			scenario:   "gotenberg.ErrPdfEngineMetadataValueNotSupported (not string array)",
+			createCopy: true,
+			inputPath:  "/tests/test/testdata/pdfengines/sample1.pdf",
+			metadata: map[string]interface{}{
+				"Unsupported": []interface{}{
+					"foo",
+					1,
+				},
+			},
+			expectError:   true,
+			expectedError: gotenberg.ErrPdfEngineMetadataValueNotSupported,
+		},
+		{
+			scenario:   "gotenberg.ErrPdfEngineMetadataValueNotSupported (default)",
 			createCopy: true,
 			inputPath:  "/tests/test/testdata/pdfengines/sample1.pdf",
 			metadata: map[string]interface{}{
@@ -171,6 +193,24 @@ func TestExiftool_WriteMetadata(t *testing.T) {
 			expectError:   true,
 			expectedError: gotenberg.ErrPdfEngineMetadataValueNotSupported,
 		},
+		{
+			scenario:   "success (interface array to string array)",
+			createCopy: true,
+			inputPath:  "/tests/test/testdata/pdfengines/sample1.pdf",
+			metadata: map[string]interface{}{
+				"Keywords": []interface{}{
+					"first",
+					"second",
+				},
+			},
+			expectMetadata: map[string]interface{}{
+				"Keywords": []interface{}{
+					"first",
+					"second",
+				},
+			},
+			expectError: false,
+		},
 		{
 			scenario:   "success",
 			createCopy: true,
@@ -226,7 +266,7 @@ func TestExiftool_WriteMetadata(t *testing.T) {

 			var destinationPath string
 			if tc.createCopy {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 				outputDir, err := fs.MkdirAll()
 				if err != nil {
 					t.Fatalf("expected error no but got: %v", err)
--- a/pkg/modules/libreoffice/api/api.go
+++ b/pkg/modules/libreoffice/api/api.go
@@ -25,9 +25,16 @@ var (
 	// by LibreOffice.
 	ErrInvalidPdfFormats = errors.New("invalid PDF formats")

-	// ErrMalformedPageRanges happens if the page ranges option cannot be
-	// interpreted by LibreOffice.
-	ErrMalformedPageRanges = errors.New("page ranges are malformed")
+	// ErrUnoException happens when unoconverter returns an exit code 5.
+	ErrUnoException = errors.New("uno exception")
+
+	// ErrRuntimeException happens when unoconverter returns an exit code 6.
+	ErrRuntimeException = errors.New("uno exception")
+
+	// ErrCoreDumped happens randomly; sometime a conversion will work as
+	// expected, and some other time the same conversion will fail.
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	ErrCoreDumped = errors.New("core dumped")
 )

 // Api is a module which provides a [Uno] to interact with LibreOffice.
@@ -41,40 +48,133 @@ type Api struct {
 }

 // Options gathers available options when converting a document to PDF.
+// See: https://help.libreoffice.org/latest/en-US/text/shared/guide/pdf_params.html.
 type Options struct {
+	// Password specifies the password for opening the source file.
+	Password string
+
 	// Landscape allows to change the orientation of the resulting PDF.
-	// Optional.
 	Landscape bool

 	// PageRanges allows to select the pages to convert.
-	// Optional.
 	PageRanges string

-	// ExportFormFields allows to... export form fields in the resulting PDF.
-	// Optional.
+	// ExportFormFields specifies whether form fields are exported as widgets
+	// or only their fixed print representation is exported.
 	ExportFormFields bool

-	// SinglePageSheets allows to output each sheet as a single page in the
-	// resulting PDF.
-	// Optional
+	// AllowDuplicateFieldNames specifies whether multiple form fields exported
+	// are allowed to have the same field name.
+	AllowDuplicateFieldNames bool
+
+	// ExportBookmarks specifies if bookmarks are exported to PDF.
+	ExportBookmarks bool
+
+	// ExportBookmarksToPdfDestination specifies that the bookmarks contained
+	// in the source LibreOffice file should be exported to the PDF file as
+	// Named Destination.
+	ExportBookmarksToPdfDestination bool
+
+	// ExportPlaceholders exports the placeholders fields visual markings only.
+	// The exported placeholder is ineffective.
+	ExportPlaceholders bool
+
+	// ExportNotes specifies if notes are exported to PDF.
+	ExportNotes bool
+
+	// ExportNotesPages specifies if notes pages are exported to PDF.
+	// Notes pages are available in Impress documents only.
+	ExportNotesPages bool
+
+	// ExportOnlyNotesPages specifies, if the property ExportNotesPages is set
+	// to true, if only notes pages are exported to PDF.
+	ExportOnlyNotesPages bool
+
+	// ExportNotesInMargin specifies if notes in margin are exported to PDF.
+	ExportNotesInMargin bool
+
+	// ConvertOooTargetToPdfTarget specifies that the target documents with
+	// .od[tpgs] extension, will have that extension changed to .pdf when the
+	// link is exported to PDF. The source document remains untouched.
+	ConvertOooTargetToPdfTarget bool
+
+	// ExportLinksRelativeFsys specifies that the file system related
+	// hyperlinks (file:// protocol) present in the document will be exported
+	// as relative to the source document location.
+	ExportLinksRelativeFsys bool
+
+	// ExportHiddenSlides exports, for LibreOffice Impress, slides that are not
+	// included in slide shows.
+	ExportHiddenSlides bool
+
+	// SkipEmptyPages specifies that automatically inserted empty pages are
+	// suppressed. This option is active only if storing Writer documents.
+	SkipEmptyPages bool
+
+	// AddOriginalDocumentAsStream specifies that a stream is inserted to the
+	// PDF file which contains the original document for archiving purposes.
+	AddOriginalDocumentAsStream bool
+
+	// SinglePageSheets ignores each sheet’s paper size, print ranges and
+	// shown/hidden status and puts every sheet (even hidden sheets) on exactly
+	// one page.
 	SinglePageSheets bool

-	// LosslessImageCompression allows turning lossless compression on or off
-	// to tweak image conversion performance.
-	// Optional
+	// LosslessImageCompression specifies if images are exported to PDF using
+	// a lossless compression format like PNG or compressed using the JPEG
+	// format.
 	LosslessImageCompression bool

-	// ReduceImageResolution allows turning on or off image resolution
-	// reduction to tweak image conversion performance.
-	// Optional
+	// Quality specifies the quality of the JPG export. A higher value produces
+	// a higher-quality image and a larger file. Between 1 and 100.
+	Quality int
+
+	// ReduceImageResolution specifies if the resolution of each image is
+	// reduced to the resolution specified by the property MaxImageResolution.
 	ReduceImageResolution bool

+	// MaxImageResolution, if the property ReduceImageResolution is set to
+	// true, tells if all images will be reduced to the given value in DPI.
+	// Possible values are: 75, 150, 300, 600 and 1200.
+	MaxImageResolution int
+
 	// PdfFormats allows to convert the resulting PDF to PDF/A-1b, PDF/A-2b,
 	// PDF/A-3b and PDF/UA.
-	// Optional.
 	PdfFormats gotenberg.PdfFormats
 }

+// DefaultOptions returns the default values for Options.
+func DefaultOptions() Options {
+	return Options{
+		Password:                        "",
+		Landscape:                       false,
+		PageRanges:                      "",
+		ExportFormFields:                true,
+		AllowDuplicateFieldNames:        false,
+		ExportBookmarks:                 true,
+		ExportBookmarksToPdfDestination: false,
+		ExportPlaceholders:              false,
+		ExportNotes:                     false,
+		ExportNotesPages:                false,
+		ExportOnlyNotesPages:            false,
+		ExportNotesInMargin:             false,
+		ConvertOooTargetToPdfTarget:     false,
+		ExportLinksRelativeFsys:         false,
+		ExportHiddenSlides:              false,
+		SkipEmptyPages:                  false,
+		AddOriginalDocumentAsStream:     false,
+		SinglePageSheets:                false,
+		LosslessImageCompression:        false,
+		Quality:                         90,
+		ReduceImageResolution:           false,
+		MaxImageResolution:              300,
+		PdfFormats: gotenberg.PdfFormats{
+			PdfA:  "",
+			PdfUa: false,
+		},
+	}
+}
+
 // Uno is an abstraction on top of the Universal Network Objects API.
 type Uno interface {
 	Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
@@ -276,9 +376,21 @@ func (a *Api) LibreOffice() (Uno, error) {

 // Pdf converts a document to PDF.
 func (a *Api) Pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
-	return a.supervisor.Run(ctx, logger, func() error {
+	err := a.supervisor.Run(ctx, logger, func() error {
 		return a.libreOffice.pdf(ctx, logger, inputPath, outputPath, options)
 	})
+
+	if err == nil {
+		return nil
+	}
+
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	if errors.Is(err, ErrCoreDumped) {
+		logger.Debug(fmt.Sprintf("got a '%s' error, retry conversion", err))
+		return a.Pdf(ctx, logger, inputPath, outputPath, options)
+	}
+
+	return fmt.Errorf("supervisor run task: %w", err)
 }

 // Extensions returns the file extensions available for conversions.
--- a/pkg/modules/libreoffice/api/api_test.go
+++ b/pkg/modules/libreoffice/api/api_test.go
@@ -14,6 +14,15 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 )

+func TestDefaultOptions(t *testing.T) {
+	actual := DefaultOptions()
+	notExpect := Options{}
+
+	if reflect.DeepEqual(actual, notExpect) {
+		t.Errorf("expected %v and got identical %v", actual, notExpect)
+	}
+}
+
 func TestApi_Descriptor(t *testing.T) {
 	descriptor := new(Api).Descriptor()

@@ -424,6 +433,13 @@ func TestApi_Pdf(t *testing.T) {
 			}},
 			expectError: true,
 		},
+		{
+			scenario: "ErrCoreDumped",
+			libreOffice: &libreOfficeMock{pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+				return ErrCoreDumped
+			}},
+			expectError: false,
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			a := new(Api)
--- a/pkg/modules/libreoffice/api/libreoffice.go
+++ b/pkg/modules/libreoffice/api/libreoffice.go
@@ -8,6 +8,7 @@ import (
 	"net"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -43,7 +44,7 @@ type libreOfficeProcess struct {
 func newLibreOfficeProcess(arguments libreOfficeArguments) libreOffice {
 	p := &libreOfficeProcess{
 		arguments: arguments,
-		fs:        gotenberg.NewFileSystem(),
+		fs:        gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 	}
 	p.isStarted.Store(false)

@@ -265,6 +266,10 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 		args = append(args, "-vvv")
 	}

+	if options.Password != "" {
+		args = append(args, "--password", options.Password)
+	}
+
 	if options.Landscape {
 		args = append(args, "--printer", "PaperOrientation=landscape")
 	}
@@ -273,21 +278,26 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 		args = append(args, "--export", fmt.Sprintf("PageRange=%s", options.PageRanges))
 	}

-	if !options.ExportFormFields {
-		args = append(args, "--export", "ExportFormFields=false")
-	}
-
-	if options.SinglePageSheets {
-		args = append(args, "--export", "SinglePageSheets=true")
-	}
-
-	if options.LosslessImageCompression {
-		args = append(args, "--export", "UseLosslessCompression=true")
-	}
-
-	if !options.ReduceImageResolution {
-		args = append(args, "--export", "ReduceImageResolution=false")
-	}
+	args = append(args, "--export", fmt.Sprintf("ExportFormFields=%t", options.ExportFormFields))
+	args = append(args, "--export", fmt.Sprintf("AllowDuplicateFieldNames=%t", options.AllowDuplicateFieldNames))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarks=%t", options.ExportBookmarks))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarks=%t", options.ExportBookmarks))
+	args = append(args, "--export", fmt.Sprintf("ExportBookmarksToPDFDestination=%t", options.ExportBookmarksToPdfDestination))
+	args = append(args, "--export", fmt.Sprintf("ExportPlaceholders=%t", options.ExportPlaceholders))
+	args = append(args, "--export", fmt.Sprintf("ExportNotes=%t", options.ExportNotes))
+	args = append(args, "--export", fmt.Sprintf("ExportNotesPages=%t", options.ExportNotesPages))
+	args = append(args, "--export", fmt.Sprintf("ExportOnlyNotesPages=%t", options.ExportOnlyNotesPages))
+	args = append(args, "--export", fmt.Sprintf("ExportNotesInMargin=%t", options.ExportNotesInMargin))
+	args = append(args, "--export", fmt.Sprintf("ConvertOOoTargetToPDFTarget=%t", options.ConvertOooTargetToPdfTarget))
+	args = append(args, "--export", fmt.Sprintf("ExportLinksRelativeFsys=%t", options.ExportLinksRelativeFsys))
+	args = append(args, "--export", fmt.Sprintf("ExportHiddenSlides=%t", options.ExportHiddenSlides))
+	args = append(args, "--export", fmt.Sprintf("IsSkipEmptyPages=%t", options.SkipEmptyPages))
+	args = append(args, "--export", fmt.Sprintf("IsAddStream=%t", options.AddOriginalDocumentAsStream))
+	args = append(args, "--export", fmt.Sprintf("SinglePageSheets=%t", options.SinglePageSheets))
+	args = append(args, "--export", fmt.Sprintf("UseLosslessCompression=%t", options.LosslessImageCompression))
+	args = append(args, "--export", fmt.Sprintf("Quality=%d", options.Quality))
+	args = append(args, "--export", fmt.Sprintf("ReduceImageResolution=%t", options.ReduceImageResolution))
+	args = append(args, "--export", fmt.Sprintf("MaxImageResolution=%d", options.MaxImageResolution))

 	switch options.PdfFormats.PdfA {
 	case "":
@@ -304,12 +314,14 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 	if options.PdfFormats.PdfUa {
 		args = append(
 			args,
+			"--export", "PDFUACompliance=true",
 			"--export", "UseTaggedPDF=true",
 			"--export", "EnableTextAccessForAccessibilityTools=true",
 		)
 	} else {
 		args = append(
 			args,
+			"--export", "PDFUACompliance=false",
 			"--export", "UseTaggedPDF=false",
 			"--export", "EnableTextAccessForAccessibilityTools=false",
 		)
@@ -335,19 +347,24 @@ func (p *libreOfficeProcess) pdf(ctx context.Context, logger *zap.Logger, inputP
 	}

 	// LibreOffice's errors are not explicit.
-	// That's why we have to make an educated guess according to the exit code
-	// and given inputs.
-	if exitCode == 5 && options.PageRanges != "" {
-		return ErrMalformedPageRanges
+	// For instance, an exit code 5 may be explained by a malformed page
+	// ranges, but also by a not required password.
+
+	// We may want to retry in case of a core dumped event.
+	// See https://github.com/gotenberg/gotenberg/issues/639.
+	if strings.Contains(err.Error(), "core dumped") {
+		return ErrCoreDumped
+	}
+
+	if exitCode == 5 {
+		// Potentially malformed page ranges or password not required.
+		return ErrUnoException
+	}
+	if exitCode == 6 {
+		// Password potentially required or invalid.
+		return ErrRuntimeException
 	}

-	// Possible errors:
-	// 1. LibreOffice failed for some reason.
-	// 2. Context done.
-	//
-	// On the second scenario, LibreOffice might not have time to remove some
-	// of its temporary files, as it has been killed without warning. The
-	// garbage collector will delete them for us (if the module is loaded).
 	return fmt.Errorf("convert to PDF: %w", err)
 }

--- a/pkg/modules/libreoffice/api/libreoffice_test.go
+++ b/pkg/modules/libreoffice/api/libreoffice_test.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"os"
 	"testing"
 	"time"
@@ -229,7 +230,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				p.isStarted.Store(false)
 				return p
 			}(),
-			fs:           gotenberg.NewFileSystem(),
+			fs:           gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			cancelledCtx: false,
 			start:        false,
 			expectError:  true,
@@ -242,7 +243,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				p.isStarted.Store(true)
 				return p
 			}(),
-			fs:            gotenberg.NewFileSystem(),
+			fs:            gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll)),
 			options:       Options{PdfFormats: gotenberg.PdfFormats{PdfA: "foo"}},
 			cancelledCtx:  false,
 			start:         false,
@@ -250,7 +251,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			expectedError: ErrInvalidPdfFormats,
 		},
 		{
-			scenario: "ErrMalformedPageRanges",
+			scenario: "ErrUnoException",
 			libreOffice: newLibreOfficeProcess(
 				libreOfficeArguments{
 					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
@@ -260,14 +261,14 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			),
 			options: Options{PageRanges: "foo"},
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
 					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
 				}

-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("ErrMalformedPageRanges"), 0o755)
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Context done"), 0o755)
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -277,7 +278,61 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			cancelledCtx:  false,
 			start:         true,
 			expectError:   true,
-			expectedError: ErrMalformedPageRanges,
+			expectedError: ErrUnoException,
+		},
+		{
+			scenario: "ErrRuntimeException",
+			libreOffice: newLibreOfficeProcess(
+				libreOfficeArguments{
+					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
+					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
+					startTimeout: 5 * time.Second,
+				},
+			),
+			options: Options{Password: "foo"},
+			fs: func() *gotenberg.FileSystem {
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+
+				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				in, err := os.Open("/tests/test/testdata/libreoffice/protected.docx")
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				defer func() {
+					err := in.Close()
+					if err != nil {
+						t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+					}
+				}()
+
+				out, err := os.Create(fmt.Sprintf("%s/protected.docx", fs.WorkingDirPath()))
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				defer func() {
+					err := out.Close()
+					if err != nil {
+						t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+					}
+				}()
+
+				_, err = io.Copy(out, in)
+				if err != nil {
+					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
+				}
+
+				return fs
+			}(),
+			cancelledCtx:  false,
+			start:         true,
+			expectError:   true,
+			expectedError: ErrRuntimeException,
 		},
 		{
 			scenario: "context done",
@@ -289,7 +344,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -317,7 +372,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -336,7 +391,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 			expectError:  false,
 		},
 		{
-			scenario: "success (landscape)",
+			scenario: "success (not default options)",
 			libreOffice: newLibreOfficeProcess(
 				libreOfficeArguments{
 					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
@@ -345,166 +400,44 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
 					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
 				}

-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
+				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Success"), 0o755)
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}

 				return fs
 			}(),
-			options:      Options{Landscape: true},
-			cancelledCtx: false,
-			start:        true,
-			expectError:  false,
-		},
-		{
-			scenario: "success (disable form fields)",
-			libreOffice: newLibreOfficeProcess(
-				libreOfficeArguments{
-					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
-					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
-					startTimeout: 5 * time.Second,
-				},
-			),
-			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
-
-				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
-				if err != nil {
-					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
-				}
-
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("DisableFormFields"), 0o755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return fs
-			}(),
-			options:      Options{ExportFormFields: false},
-			cancelledCtx: false,
-			start:        true,
-			expectError:  false,
-		},
-		{
-			scenario: "success (single page sheets)",
-			libreOffice: newLibreOfficeProcess(
-				libreOfficeArguments{
-					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
-					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
-					startTimeout: 5 * time.Second,
-				},
-			),
-			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
-
-				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
-				if err != nil {
-					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
-				}
-
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("SinglePageSheets"), 0o755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return fs
-			}(),
-			options:      Options{SinglePageSheets: true},
-			cancelledCtx: false,
-			start:        true,
-			expectError:  false,
-		},
-		{
-			scenario: "success (page ranges)",
-			libreOffice: newLibreOfficeProcess(
-				libreOfficeArguments{
-					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
-					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
-					startTimeout: 5 * time.Second,
-				},
-			),
-			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
-
-				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
-				if err != nil {
-					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
-				}
-
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("Landscape"), 0o755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return fs
-			}(),
-			options:      Options{PageRanges: "1-1"},
-			cancelledCtx: false,
-			start:        true,
-			expectError:  false,
-		},
-		{
-			scenario: "success LosslessImageCompression",
-			libreOffice: newLibreOfficeProcess(
-				libreOfficeArguments{
-					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
-					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
-					startTimeout: 5 * time.Second,
-				},
-			),
-			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
-
-				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
-				if err != nil {
-					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
-				}
-
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("LosslessImageCompression"), 0o755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return fs
-			}(),
-			options:      Options{LosslessImageCompression: true},
-			cancelledCtx: false,
-			start:        true,
-			expectError:  false,
-		},
-		{
-			scenario: "success ReduceImageResolution",
-			libreOffice: newLibreOfficeProcess(
-				libreOfficeArguments{
-					binPath:      os.Getenv("LIBREOFFICE_BIN_PATH"),
-					unoBinPath:   os.Getenv("UNOCONVERTER_BIN_PATH"),
-					startTimeout: 5 * time.Second,
-				},
-			),
-			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
-
-				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
-				if err != nil {
-					t.Fatalf(fmt.Sprintf("expected no error but got: %v", err))
-				}
-
-				err = os.WriteFile(fmt.Sprintf("%s/document.txt", fs.WorkingDirPath()), []byte("ReduceImageResolution"), 0o755)
-				if err != nil {
-					t.Fatalf("expected no error but got: %v", err)
-				}
-
-				return fs
-			}(),
-			options:      Options{ReduceImageResolution: false},
+			options: Options{
+				Password:                        "", // Ok, the only exception in this list.
+				Landscape:                       true,
+				PageRanges:                      "1",
+				ExportFormFields:                false,
+				AllowDuplicateFieldNames:        true,
+				ExportBookmarks:                 false,
+				ExportBookmarksToPdfDestination: true,
+				ExportPlaceholders:              true,
+				ExportNotes:                     true,
+				ExportNotesPages:                true,
+				ExportOnlyNotesPages:            true,
+				ExportNotesInMargin:             true,
+				ConvertOooTargetToPdfTarget:     true,
+				ExportLinksRelativeFsys:         true,
+				ExportHiddenSlides:              true,
+				SkipEmptyPages:                  true,
+				AddOriginalDocumentAsStream:     true,
+				SinglePageSheets:                true,
+				LosslessImageCompression:        true,
+				Quality:                         100,
+				ReduceImageResolution:           true,
+				MaxImageResolution:              600,
+			},
 			cancelledCtx: false,
 			start:        true,
 			expectError:  false,
@@ -519,7 +452,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -548,7 +481,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -577,7 +510,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -606,7 +539,7 @@ func TestLibreOfficeProcess_pdf(t *testing.T) {
 				},
 			),
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -692,7 +625,7 @@ func TestNonBasicLatinCharactersGuard(t *testing.T) {
 		{
 			scenario: "basic latin characters",
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
@@ -713,7 +646,7 @@ func TestNonBasicLatinCharactersGuard(t *testing.T) {
 		{
 			scenario: "non-basic latin characters",
 			fs: func() *gotenberg.FileSystem {
-				fs := gotenberg.NewFileSystem()
+				fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))

 				err := os.MkdirAll(fs.WorkingDirPath(), 0o755)
 				if err != nil {
--- a/pkg/modules/libreoffice/api/mocks.go
+++ b/pkg/modules/libreoffice/api/mocks.go
@@ -2,6 +2,7 @@ package api

 import (
 	"context"
+	"errors"

 	"go.uber.org/zap"

@@ -33,12 +34,21 @@ func (provider *ProviderMock) LibreOffice() (Uno, error) {

 // libreOfficeMock is a mock for the [libreOffice] interface.
 type libreOfficeMock struct {
+	errCoreDumpedCount int
+
 	gotenberg.ProcessMock
 	pdfMock func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error
 }

 func (b *libreOfficeMock) pdf(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
-	return b.pdfMock(ctx, logger, inputPath, outputPath, options)
+	err := b.pdfMock(ctx, logger, inputPath, outputPath, options)
+	if errors.Is(err, ErrCoreDumped) {
+		b.errCoreDumpedCount += 1
+	}
+	if b.errCoreDumpedCount > 1 {
+		return nil
+	}
+	return err
 }

 // Interface guards.
--- a/pkg/modules/libreoffice/api/mocks_test.go
+++ b/pkg/modules/libreoffice/api/mocks_test.go
@@ -42,14 +42,53 @@ func TestProviderMock(t *testing.T) {
 }

 func TestLibreOfficeMock(t *testing.T) {
-	mock := &libreOfficeMock{
-		pdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options Options) error {
-			return nil
+	for _, tc := range []struct {
+		scenario    string
+		mock        *libreOfficeMock
+		expectError bool
+	}{
+		{
+			scenario: "success",
+			mock: &libreOfficeMock{
+				pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+					return nil
+				},
+			},
+			expectError: false,
 		},
-	}
+		{
+			scenario: "ErrCoreDumped (first call)",
+			mock: &libreOfficeMock{
+				pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+					return ErrCoreDumped
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "ErrCoreDumped (second call)",
+			mock: func() *libreOfficeMock {
+				m := &libreOfficeMock{
+					pdfMock: func(ctx context.Context, logger *zap.Logger, input, outputPath string, options Options) error {
+						return ErrCoreDumped
+					},
+				}
+				m.pdf(context.Background(), zap.NewNop(), "", "", Options{})
+				return m
+			}(),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := tc.mock.pdf(context.Background(), zap.NewNop(), "", "", Options{})

-	err := mock.pdf(context.Background(), zap.NewNop(), "", "", Options{})
-	if err != nil {
-		t.Errorf("expected no error from libreOfficeMock.pdf, but got: %v", err)
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error from libreOfficeMock.pdf but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error from libreOfficeMock.pdf but got none")
+			}
+		})
 	}
 }
--- a/pkg/modules/libreoffice/pdfengine/pdfengine.go
+++ b/pkg/modules/libreoffice/pdfengine/pdfengine.go
@@ -51,14 +51,19 @@ func (engine *LibreOfficePdfEngine) Merge(ctx context.Context, logger *zap.Logge
 	return fmt.Errorf("merge PDFs with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
 }

+// Split is not available in this implementation.
+func (engine *LibreOfficePdfEngine) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	return nil, fmt.Errorf("split PDF with LibreOffice: %w", gotenberg.ErrPdfEngineMethodNotSupported)
+}
+
 // Convert converts the given PDF to a specific PDF format. Currently, only the
 // PDF/A-1b, PDF/A-2b, PDF/A-3b and PDF/UA formats are available. If another
 // PDF format is requested, it returns a [gotenberg.ErrPdfFormatNotSupported]
 // error.
 func (engine *LibreOfficePdfEngine) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, api.Options{
-		PdfFormats: formats,
-	})
+	opts := api.DefaultOptions()
+	opts.PdfFormats = formats
+	err := engine.unoApi.Pdf(ctx, logger, inputPath, outputPath, opts)

 	if err == nil {
 		return nil
--- a/pkg/modules/libreoffice/pdfengine/pdfengine_test.go
+++ b/pkg/modules/libreoffice/pdfengine/pdfengine_test.go
@@ -118,11 +118,21 @@ func TestLibreOfficePdfEngine_Merge(t *testing.T) {
 	}
 }

+func TestLibreOfficePdfEngine_Split(t *testing.T) {
+	engine := new(LibreOfficePdfEngine)
+	_, err := engine.Split(context.Background(), zap.NewNop(), gotenberg.SplitMode{}, "", "")
+
+	if !errors.Is(err, gotenberg.ErrPdfEngineMethodNotSupported) {
+		t.Errorf("expected error %v, but got: %v", gotenberg.ErrPdfEngineMethodNotSupported, err)
+	}
+}
+
 func TestLibreOfficePdfEngine_Convert(t *testing.T) {
 	for _, tc := range []struct {
-		scenario    string
-		api         api.Uno
-		expectError bool
+		scenario      string
+		api           api.Uno
+		expectError   bool
+		expectedError error
 	}{
 		{
 			scenario: "convert success",
@@ -134,13 +144,14 @@ func TestLibreOfficePdfEngine_Convert(t *testing.T) {
 			expectError: false,
 		},
 		{
-			scenario: "invalid PDF format",
+			scenario: "ErrInvalidPdfFormats",
 			api: &api.ApiMock{
 				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options api.Options) error {
 					return api.ErrInvalidPdfFormats
 				},
 			},
-			expectError: true,
+			expectError:   true,
+			expectedError: gotenberg.ErrPdfFormatNotSupported,
 		},
 		{
 			scenario: "convert fail",
@@ -163,6 +174,10 @@ func TestLibreOfficePdfEngine_Convert(t *testing.T) {
 			if tc.expectError && err == nil {
 				t.Fatal("expected error but got none")
 			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
 		})
 	}
 }
--- a/pkg/modules/libreoffice/routes.go
+++ b/pkg/modules/libreoffice/routes.go
@@ -5,12 +5,15 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"slices"
+	"strconv"

 	"github.com/labstack/echo/v4"

 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 	libreofficeapi "github.com/gotenberg/gotenberg/v8/pkg/modules/libreoffice/api"
+	"github.com/gotenberg/gotenberg/v8/pkg/modules/pdfengines"
 )

 // convertRoute returns an [api.Route] which can convert LibreOffice documents
@@ -22,33 +25,105 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 		IsMultipart: true,
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)
+			defaultOptions := libreofficeapi.DefaultOptions()
+
+			form := ctx.FormData()
+			splitMode := pdfengines.FormDataPdfSplitMode(form, false)
+			pdfFormats := pdfengines.FormDataPdfFormats(form)
+			metadata := pdfengines.FormDataPdfMetadata(form, false)
+
+			zeroValuedSplitMode := gotenberg.SplitMode{}

-			// Let's get the data from the form and validate them.
 			var (
-				inputPaths               []string
-				landscape                bool
-				nativePageRanges         string
-				exportFormFields         bool
-				singlePageSheets         bool
-				losslessImageCompression bool
-				reduceImageResolution    bool
-				pdfa                     string
-				pdfua                    bool
-				nativePdfFormats         bool
-				merge                    bool
-				metadata                 map[string]interface{}
+				inputPaths                      []string
+				password                        string
+				landscape                       bool
+				nativePageRanges                string
+				exportFormFields                bool
+				allowDuplicateFieldNames        bool
+				exportBookmarks                 bool
+				exportBookmarksToPdfDestination bool
+				exportPlaceholders              bool
+				exportNotes                     bool
+				exportNotesPages                bool
+				exportOnlyNotesPages            bool
+				exportNotesInMargin             bool
+				convertOooTargetToPdfTarget     bool
+				exportLinksRelativeFsys         bool
+				exportHiddenSlides              bool
+				skipEmptyPages                  bool
+				addOriginalDocumentAsStream     bool
+				singlePageSheets                bool
+				losslessImageCompression        bool
+				quality                         int
+				reduceImageResolution           bool
+				maxImageResolution              int
+				nativePdfFormats                bool
+				merge                           bool
 			)

-			err := ctx.FormData().
+			err := form.
 				MandatoryPaths(libreOffice.Extensions(), &inputPaths).
-				Bool("landscape", &landscape, false).
-				String("nativePageRanges", &nativePageRanges, "").
-				Bool("exportFormFields", &exportFormFields, true).
-				Bool("singlePageSheets", &singlePageSheets, false).
-				Bool("losslessImageCompression", &losslessImageCompression, false).
-				Bool("reduceImageResolution", &reduceImageResolution, true).
-				String("pdfa", &pdfa, "").
-				Bool("pdfua", &pdfua, false).
+				String("password", &password, defaultOptions.Password).
+				Bool("landscape", &landscape, defaultOptions.Landscape).
+				String("nativePageRanges", &nativePageRanges, defaultOptions.PageRanges).
+				Bool("exportFormFields", &exportFormFields, defaultOptions.ExportFormFields).
+				Bool("allowDuplicateFieldNames", &allowDuplicateFieldNames, defaultOptions.AllowDuplicateFieldNames).
+				Bool("exportBookmarks", &exportBookmarks, defaultOptions.ExportBookmarks).
+				Bool("exportBookmarksToPdfDestination", &exportBookmarksToPdfDestination, defaultOptions.ExportBookmarksToPdfDestination).
+				Bool("exportPlaceholders", &exportPlaceholders, defaultOptions.ExportPlaceholders).
+				Bool("exportNotes", &exportNotes, defaultOptions.ExportNotes).
+				Bool("exportNotesPages", &exportNotesPages, defaultOptions.ExportNotesPages).
+				Bool("exportOnlyNotesPages", &exportOnlyNotesPages, defaultOptions.ExportOnlyNotesPages).
+				Bool("exportNotesInMargin", &exportNotesInMargin, defaultOptions.ExportNotesInMargin).
+				Bool("convertOooTargetToPdfTarget", &convertOooTargetToPdfTarget, defaultOptions.ConvertOooTargetToPdfTarget).
+				Bool("exportLinksRelativeFsys", &exportLinksRelativeFsys, defaultOptions.ExportLinksRelativeFsys).
+				Bool("exportHiddenSlides", &exportHiddenSlides, defaultOptions.ExportHiddenSlides).
+				Bool("skipEmptyPages", &skipEmptyPages, defaultOptions.SkipEmptyPages).
+				Bool("addOriginalDocumentAsStream", &addOriginalDocumentAsStream, defaultOptions.AddOriginalDocumentAsStream).
+				Bool("singlePageSheets", &singlePageSheets, defaultOptions.SinglePageSheets).
+				Bool("losslessImageCompression", &losslessImageCompression, defaultOptions.LosslessImageCompression).
+				Custom("quality", func(value string) error {
+					if value == "" {
+						quality = defaultOptions.Quality
+						return nil
+					}
+
+					intValue, err := strconv.Atoi(value)
+					if err != nil {
+						return err
+					}
+
+					if intValue < 1 {
+						return errors.New("value is inferior to 1")
+					}
+
+					if intValue > 100 {
+						return errors.New("value is superior to 100")
+					}
+
+					quality = intValue
+					return nil
+				}).
+				Bool("reduceImageResolution", &reduceImageResolution, defaultOptions.ReduceImageResolution).
+				Custom("maxImageResolution", func(value string) error {
+					if value == "" {
+						maxImageResolution = defaultOptions.MaxImageResolution
+						return nil
+					}
+
+					intValue, err := strconv.Atoi(value)
+					if err != nil {
+						return err
+					}
+
+					if !slices.Contains([]int{75, 150, 300, 600, 1200}, intValue) {
+						return errors.New("value is not 75, 150, 300, 600 or 1200")
+					}
+
+					maxImageResolution = intValue
+					return nil
+				}).
 				Bool("nativePdfFormats", &nativePdfFormats, true).
 				Bool("merge", &merge, false).
 				Custom("metadata", func(value string) error {
@@ -65,25 +140,37 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			pdfFormats := gotenberg.PdfFormats{
-				PdfA:  pdfa,
-				PdfUa: pdfua,
-			}
-
-			// Alright, let's convert each document to PDF.
 			outputPaths := make([]string, len(inputPaths))
 			for i, inputPath := range inputPaths {
 				outputPaths[i] = ctx.GeneratePath(".pdf")
 				options := libreofficeapi.Options{
-					Landscape:                landscape,
-					PageRanges:               nativePageRanges,
-					ExportFormFields:         exportFormFields,
-					SinglePageSheets:         singlePageSheets,
-					LosslessImageCompression: losslessImageCompression,
-					ReduceImageResolution:    reduceImageResolution,
+					Password:                        password,
+					Landscape:                       landscape,
+					PageRanges:                      nativePageRanges,
+					ExportFormFields:                exportFormFields,
+					AllowDuplicateFieldNames:        allowDuplicateFieldNames,
+					ExportBookmarks:                 exportBookmarks,
+					ExportBookmarksToPdfDestination: exportBookmarksToPdfDestination,
+					ExportPlaceholders:              exportPlaceholders,
+					ExportNotes:                     exportNotes,
+					ExportNotesPages:                exportNotesPages,
+					ExportOnlyNotesPages:            exportOnlyNotesPages,
+					ExportNotesInMargin:             exportNotesInMargin,
+					ConvertOooTargetToPdfTarget:     convertOooTargetToPdfTarget,
+					ExportLinksRelativeFsys:         exportLinksRelativeFsys,
+					ExportHiddenSlides:              exportHiddenSlides,
+					SkipEmptyPages:                  skipEmptyPages,
+					AddOriginalDocumentAsStream:     addOriginalDocumentAsStream,
+					SinglePageSheets:                singlePageSheets,
+					LosslessImageCompression:        losslessImageCompression,
+					Quality:                         quality,
+					ReduceImageResolution:           reduceImageResolution,
+					MaxImageResolution:              maxImageResolution,
 				}

-				if nativePdfFormats {
+				if nativePdfFormats && splitMode == zeroValuedSplitMode {
+					// Only apply natively given PDF formats if we're not
+					// splitting the PDF later.
 					options.PdfFormats = pdfFormats
 				}

@@ -99,10 +186,17 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 						)
 					}

-					if errors.Is(err, libreofficeapi.ErrMalformedPageRanges) {
+					if errors.Is(err, libreofficeapi.ErrUnoException) {
 						return api.WrapError(
 							fmt.Errorf("convert to PDF: %w", err),
-							api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("Malformed page ranges '%s' (nativePageRanges)", options.PageRanges)),
+							api.NewSentinelHttpError(http.StatusBadRequest, fmt.Sprintf("LibreOffice failed to process a document: possible causes include malformed page ranges '%s' (nativePageRanges), or, if a password has been provided, it may not be required. In any case, the exact cause is uncertain.", options.PageRanges)),
+						)
+					}
+
+					if errors.Is(err, libreofficeapi.ErrRuntimeException) {
+						return api.WrapError(
+							fmt.Errorf("convert to PDF: %w", err),
+							api.NewSentinelHttpError(http.StatusBadRequest, "LibreOffice failed to process a document: a password may be required, or, if one has been given, it is invalid. In any case, the exact cause is uncertain."),
 						)
 					}

@@ -110,11 +204,8 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}

-			// So far so good, let's check if we have to merge the PDFs.
-			if len(outputPaths) > 1 && merge {
-				outputPath := ctx.GeneratePath(".pdf")
-
-				err = engine.Merge(ctx, ctx.Log(), outputPaths, outputPath)
+			if merge {
+				outputPath, err := pdfengines.MergeStub(ctx, engine, outputPaths)
 				if err != nil {
 					return fmt.Errorf("merge PDFs: %w", err)
 				}
@@ -123,37 +214,54 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				outputPaths = []string{outputPath}
 			}

-			// Let's check if the client want to convert each PDF to a specific
-			// PDF format.
-			zeroValued := gotenberg.PdfFormats{}
-			if !nativePdfFormats && pdfFormats != zeroValued {
-				convertOutputPaths := make([]string, len(outputPaths))
+			if splitMode != zeroValuedSplitMode {
+				if !merge {
+					// document.docx -> document.docx.pdf, so that split naming
+					// document.docx_0.pdf, etc.
+					for i, inputPath := range inputPaths {
+						outputPath := fmt.Sprintf("%s.pdf", inputPath)

-				for i, outputPath := range outputPaths {
-					convertInputPath := outputPath
-					convertOutputPaths[i] = ctx.GeneratePath(".pdf")
+						err = ctx.Rename(outputPaths[i], outputPath)
+						if err != nil {
+							return fmt.Errorf("rename output path: %w", err)
+						}

-					err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPaths[i])
-					if err != nil {
-						return fmt.Errorf("convert PDF: %w", err)
+						outputPaths[i] = outputPath
 					}
 				}

-				// Important: the output paths are now the converted files.
-				outputPaths = convertOutputPaths
-			}
-
-			// Writes and potentially overrides metadata entries, if any.
-			if len(metadata) > 0 {
-				for _, outputPath := range outputPaths {
-					err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
-					if err != nil {
-						return fmt.Errorf("write metadata: %w", err)
-					}
+				outputPaths, err = pdfengines.SplitPdfStub(ctx, engine, splitMode, outputPaths)
+				if err != nil {
+					return fmt.Errorf("split PDFs: %w", err)
 				}
 			}

-			if len(outputPaths) > 1 {
+			if !nativePdfFormats || (nativePdfFormats && splitMode != zeroValuedSplitMode) {
+				convertOutputPaths, err := pdfengines.ConvertStub(ctx, engine, pdfFormats, outputPaths)
+				if err != nil {
+					return fmt.Errorf("convert PDFs: %w", err)
+				}
+
+				if splitMode != zeroValuedSplitMode {
+					// The PDF has been split and split parts have been converted to
+					// specific formats. We want to keep the split naming.
+					for i, convertOutputPath := range convertOutputPaths {
+						err = ctx.Rename(convertOutputPath, outputPaths[i])
+						if err != nil {
+							return fmt.Errorf("rename output path: %w", err)
+						}
+					}
+				} else {
+					outputPaths = convertOutputPaths
+				}
+			}
+
+			err = pdfengines.WriteMetadataStub(ctx, engine, metadata, outputPaths)
+			if err != nil {
+				return fmt.Errorf("write metadata: %w", err)
+			}
+
+			if len(outputPaths) > 1 && splitMode == zeroValuedSplitMode {
 				// If .zip archive, document.docx -> document.docx.pdf.
 				for i, inputPath := range inputPaths {
 					outputPath := fmt.Sprintf("%s.pdf", inputPath)
@@ -167,8 +275,6 @@ func convertRoute(libreOffice libreofficeapi.Uno, engine gotenberg.PdfEngine) ap
 				}
 			}

-			// Last but not least, add the output paths to the context so that
-			// the API is able to send them as a response to the client.
 			err = ctx.AddOutputPaths(outputPaths...)
 			if err != nil {
 				return fmt.Errorf("add output paths: %w", err)
--- a/pkg/modules/libreoffice/routes_test.go
+++ b/pkg/modules/libreoffice/routes_test.go
@@ -3,7 +3,10 @@ package libreoffice
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/http"
+	"os"
+	"path/filepath"
 	"slices"
 	"testing"

@@ -39,6 +42,116 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpStatus:       http.StatusBadRequest,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "invalid quality form field (not an integer)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid quality form field (< 1)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"0",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid quality form field (> 100)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"quality": {
+						"101",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid maxImageResolution form field (not an integer)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"maxImageResolution": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "invalid maxImageResolution form field (not in range)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"maxImageResolution": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{ExtensionsMock: func() []string {
+				return []string{".docx"}
+			}},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "invalid metadata form field",
 			ctx: func() *api.ContextMock {
@@ -84,14 +197,14 @@ func TestConvertRoute(t *testing.T) {
 			expectOutputPathsCount: 0,
 		},
 		{
-			scenario: "ErrMalformedPageRanges",
+			scenario: "ErrUnoException",
 			ctx: func() *api.ContextMock {
 				ctx := &api.ContextMock{Context: new(api.Context)}
 				ctx.SetFiles(map[string]string{
 					"document.docx": "/document.docx",
 				})
 				ctx.SetValues(map[string][]string{
-					"pdfa": {
+					"nativePageRanges": {
 						"foo",
 					},
 				})
@@ -99,7 +212,34 @@ func TestConvertRoute(t *testing.T) {
 			}(),
 			libreOffice: &libreofficeapi.ApiMock{
 				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return libreofficeapi.ErrMalformedPageRanges
+					return libreofficeapi.ErrUnoException
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "ErrRuntimeException",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"password": {
+						"invalid",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return libreofficeapi.ErrRuntimeException
 				},
 				ExtensionsMock: func() []string {
 					return []string{".docx"}
@@ -163,6 +303,40 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
+		{
+			scenario: "PDF engine split error",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx": "/document.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return nil, errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
 		{
 			scenario: "PDF engine convert error",
 			ctx: func() *api.ContextMock {
@@ -228,32 +402,6 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 0,
 		},
-		{
-			scenario: "cannot rename many files",
-			ctx: func() *api.ContextMock {
-				ctx := &api.ContextMock{Context: new(api.Context)}
-				ctx.SetFiles(map[string]string{
-					"document.docx":  "/document.docx",
-					"document2.docx": "/document2.docx",
-					"document2.doc":  "/document2.doc",
-				})
-				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
-					return errors.New("cannot rename")
-				}})
-				return ctx
-			}(),
-			libreOffice: &libreofficeapi.ApiMock{
-				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
-					return nil
-				},
-				ExtensionsMock: func() []string {
-					return []string{".docx", ".doc"}
-				},
-			},
-			expectError:            true,
-			expectHttpError:        false,
-			expectOutputPathsCount: 0,
-		},
 		{
 			scenario: "cannot add output paths",
 			ctx: func() *api.ContextMock {
@@ -285,6 +433,12 @@ func TestConvertRoute(t *testing.T) {
 					"document2.docx": "/document2.docx",
 				})
 				ctx.SetValues(map[string][]string{
+					"quality": {
+						"100",
+					},
+					"maxImageResolution": {
+						"1200",
+					},
 					"merge": {
 						"true",
 					},
@@ -407,9 +561,173 @@ func TestConvertRoute(t *testing.T) {
 			expectHttpError:        false,
 			expectOutputPathsCount: 1,
 		},
+		{
+			scenario: "success with split (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					inputPathNoExt := inputPath[:len(inputPath)-len(filepath.Ext(inputPath))]
+					filenameNoExt := filepath.Base(inputPathNoExt)
+					return []string{
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 0,
+						),
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 1,
+						),
+					}, nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 4,
+			expectOutputPaths:      []string{"/document_docx/document.docx_0.pdf", "/document_docx/document.docx_1.pdf", "/document2_docx/document2.docx_0.pdf", "/document2_docx/document2.docx_1.pdf"},
+		},
+		{
+			scenario: "success with merge and split",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"merge": {
+						"true",
+					},
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					inputPathNoExt := inputPath[:len(inputPath)-len(filepath.Ext(inputPath))]
+					filenameNoExt := filepath.Base(inputPathNoExt)
+					return []string{
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 0,
+						),
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 1,
+						),
+					}, nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 2,
+		},
+		{
+			scenario: "success with split and native PDF/A & PDF/UA (many files)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"document.docx":  "/document.docx",
+					"document2.docx": "/document2.docx",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+					"pdfa": {
+						gotenberg.PdfA1b,
+					},
+					"pdfua": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			libreOffice: &libreofficeapi.ApiMock{
+				PdfMock: func(ctx context.Context, logger *zap.Logger, inputPath, outputPath string, options libreofficeapi.Options) error {
+					return nil
+				},
+				ExtensionsMock: func() []string {
+					return []string{".docx"}
+				},
+			},
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					inputPathNoExt := inputPath[:len(inputPath)-len(filepath.Ext(inputPath))]
+					filenameNoExt := filepath.Base(inputPathNoExt)
+					return []string{
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 0,
+						),
+						fmt.Sprintf(
+							"%s/%s_%d.pdf",
+							outputDirPath, filenameNoExt, 1,
+						),
+					}, nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 4,
+			expectOutputPaths:      []string{"/document_docx/document.docx_0.pdf", "/document_docx/document.docx_1.pdf", "/document2_docx/document2.docx_0.pdf", "/document2_docx/document2.docx_1.pdf"},
+		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			tc.ctx.SetLogger(zap.NewNop())
+			tc.ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+				return nil
+			}})
+			tc.ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return nil
+			}})
 			c := echo.New().NewContext(nil, nil)
 			c.Set("context", tc.ctx.Context)

--- a/pkg/modules/pdfcpu/doc.go
+++ b/pkg/modules/pdfcpu/doc.go
@@ -1,7 +1,8 @@
 // Package pdfcpu provides an implementation of the gotenberg.PdfEngine
-// interface using the pdfcpu library. This package allows for:
+// interface using the pdfcpu command-line tool. This package allows for:
 //
 // 1. The merging of PDF files.
+// 2. The splitting of PDF files.
 //
 // See: https://github.com/pdfcpu/pdfcpu.
 package pdfcpu
--- a/pkg/modules/pdfcpu/pdfcpu.go
+++ b/pkg/modules/pdfcpu/pdfcpu.go
@@ -2,11 +2,11 @@ package pdfcpu

 import (
 	"context"
+	"errors"
 	"fmt"
+	"os"
+	"path/filepath"

-	pdfcpuAPI "github.com/pdfcpu/pdfcpu/pkg/api"
-	pdfcpuLog "github.com/pdfcpu/pdfcpu/pkg/log"
-	pdfcpuConfig "github.com/pdfcpu/pdfcpu/pkg/pdfcpu/model"
 	"go.uber.org/zap"

 	"github.com/gotenberg/gotenberg/v8/pkg/gotenberg"
@@ -16,10 +16,10 @@ func init() {
 	gotenberg.MustRegisterModule(new(PdfCpu))
 }

-// PdfCpu abstracts the pdfcpu library and implements the [gotenberg.PdfEngine]
-// interface.
+// PdfCpu abstracts the CLI tool pdfcpu and implements the
+// [gotenberg.PdfEngine] interface.
 type PdfCpu struct {
-	conf *pdfcpuConfig.Configuration
+	binPath string
 }

 // Descriptor returns a [PdfCpu]'s module descriptor.
@@ -32,16 +32,38 @@ func (engine *PdfCpu) Descriptor() gotenberg.ModuleDescriptor {

 // Provision sets the engine properties.
 func (engine *PdfCpu) Provision(ctx *gotenberg.Context) error {
-	pdfcpuConfig.ConfigPath = "disable"
-	pdfcpuLog.DisableLoggers()
-	engine.conf = pdfcpuConfig.NewDefaultConfiguration()
+	binPath, ok := os.LookupEnv("PDFCPU_BIN_PATH")
+	if !ok {
+		return errors.New("PDFCPU_BIN_PATH environment variable is not set")
+	}
+
+	engine.binPath = binPath
+
+	return nil
+}
+
+// Validate validates the module properties.
+func (engine *PdfCpu) Validate() error {
+	_, err := os.Stat(engine.binPath)
+	if os.IsNotExist(err) {
+		return fmt.Errorf("pdfcpu binary path does not exist: %w", err)
+	}

 	return nil
 }

 // Merge combines multiple PDFs into a single PDF.
 func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-	err := pdfcpuAPI.MergeCreateFile(inputPaths, outputPath, false, engine.conf)
+	var args []string
+	args = append(args, "merge", outputPath)
+	args = append(args, inputPaths...)
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
 	if err == nil {
 		return nil
 	}
@@ -49,6 +71,42 @@ func (engine *PdfCpu) Merge(ctx context.Context, logger *zap.Logger, inputPaths
 	return fmt.Errorf("merge PDFs with pdfcpu: %w", err)
 }

+// Split splits a given PDF file.
+func (engine *PdfCpu) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	var args []string
+
+	switch mode.Mode {
+	case gotenberg.SplitModeIntervals:
+		args = append(args, "split", "-mode", "span", inputPath, outputDirPath, mode.Span)
+	case gotenberg.SplitModePages:
+		if mode.Unify {
+			outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
+			args = append(args, "trim", "-pages", mode.Span, inputPath, outputPath)
+			break
+		}
+		args = append(args, "extract", "-mode", "page", "-pages", mode.Span, inputPath, outputDirPath)
+	default:
+		return nil, fmt.Errorf("split PDFs using mode '%s' with pdfcpu: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+	}
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return nil, fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
+	if err != nil {
+		return nil, fmt.Errorf("split PDFs with pdfcpu: %w", err)
+	}
+
+	outputPaths, err := gotenberg.WalkDir(outputDirPath, ".pdf")
+	if err != nil {
+		return nil, fmt.Errorf("walk directory to find resulting PDFs from split with pdfcpu: %w", err)
+	}
+
+	return outputPaths, nil
+}
+
 // Convert is not available in this implementation.
 func (engine *PdfCpu) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	return fmt.Errorf("convert PDF to '%+v' with pdfcpu: %w", formats, gotenberg.ErrPdfEngineMethodNotSupported)
@@ -68,5 +126,6 @@ func (engine *PdfCpu) WriteMetadata(ctx context.Context, logger *zap.Logger, met
 var (
 	_ gotenberg.Module      = (*PdfCpu)(nil)
 	_ gotenberg.Provisioner = (*PdfCpu)(nil)
+	_ gotenberg.Validator   = (*PdfCpu)(nil)
 	_ gotenberg.PdfEngine   = (*PdfCpu)(nil)
 )
--- a/pkg/modules/pdfcpu/pdfcpu_test.go
+++ b/pkg/modules/pdfcpu/pdfcpu_test.go
@@ -33,14 +33,59 @@ func TestPdfCpu_Provision(t *testing.T) {
 	}
 }

+func TestPdfCpu_Validate(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		binPath     string
+		expectError bool
+	}{
+		{
+			scenario:    "empty bin path",
+			binPath:     "",
+			expectError: true,
+		},
+		{
+			scenario:    "bin path does not exist",
+			binPath:     "/foo",
+			expectError: true,
+		},
+		{
+			scenario:    "validate success",
+			binPath:     os.Getenv("PDFTK_BIN_PATH"),
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfCpu)
+			engine.binPath = tc.binPath
+			err := engine.Validate()
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
 func TestPdfCpu_Merge(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
+		ctx         context.Context
 		inputPaths  []string
 		expectError bool
 	}{
+		{
+			scenario:    "invalid context",
+			ctx:         nil,
+			expectError: true,
+		},
 		{
 			scenario: "invalid input path",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"foo",
 			},
@@ -48,6 +93,7 @@ func TestPdfCpu_Merge(t *testing.T) {
 		},
 		{
 			scenario: "single file success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
@@ -55,10 +101,12 @@ func TestPdfCpu_Merge(t *testing.T) {
 		},
 		{
 			scenario: "many files success",
+			ctx:      context.TODO(),
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -68,7 +116,7 @@ func TestPdfCpu_Merge(t *testing.T) {
 				t.Fatalf("expected error but got: %v", err)
 			}

-			fs := gotenberg.NewFileSystem()
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			outputDir, err := fs.MkdirAll()
 			if err != nil {
 				t.Fatalf("expected error but got: %v", err)
@@ -81,7 +129,7 @@ func TestPdfCpu_Merge(t *testing.T) {
 				}
 			}()

-			err = engine.Merge(nil, nil, tc.inputPaths, outputDir+"/foo.pdf")
+			err = engine.Merge(tc.ctx, zap.NewNop(), tc.inputPaths, outputDir+"/foo.pdf")

 			if !tc.expectError && err != nil {
 				t.Fatalf("expected no error but got: %v", err)
@@ -94,6 +142,103 @@ func TestPdfCpu_Merge(t *testing.T) {
 	}
 }

+func TestPdfCpu_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    context.Context
+		mode                   gotenberg.SplitMode
+		inputPath              string
+		expectError            bool
+		expectedError          error
+		expectOutputPathsCount int
+	}{
+		{
+			scenario:               "ErrPdfSplitModeNotSupported",
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid context",
+			ctx:                    nil,
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid input path",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			inputPath:              "",
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "success (intervals)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 3,
+		},
+		{
+			scenario:               "success (pages)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1"},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 1,
+		},
+		{
+			scenario:               "success (pages & unify)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfCpu)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+			outputDir, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			defer func() {
+				err = os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			outputPaths, err := engine.Split(tc.ctx, zap.NewNop(), tc.mode, tc.inputPath, outputDir)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+
+			if tc.expectOutputPathsCount != len(outputPaths) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(outputPaths))
+			}
+		})
+	}
+}
+
 func TestPdfCpu_Convert(t *testing.T) {
 	mod := new(PdfCpu)
 	err := mod.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
--- a/pkg/modules/pdfengines/multi.go
+++ b/pkg/modules/pdfengines/multi.go
@@ -12,12 +12,26 @@ import (
 )

 type multiPdfEngines struct {
-	engines []gotenberg.PdfEngine
+	mergeEngines       []gotenberg.PdfEngine
+	splitEngines       []gotenberg.PdfEngine
+	convertEngines     []gotenberg.PdfEngine
+	readMedataEngines  []gotenberg.PdfEngine
+	writeMedataEngines []gotenberg.PdfEngine
 }

-func newMultiPdfEngines(engines ...gotenberg.PdfEngine) *multiPdfEngines {
+func newMultiPdfEngines(
+	mergeEngines,
+	splitEngines,
+	convertEngines,
+	readMetadataEngines,
+	writeMedataEngines []gotenberg.PdfEngine,
+) *multiPdfEngines {
 	return &multiPdfEngines{
-		engines: engines,
+		mergeEngines:       mergeEngines,
+		splitEngines:       splitEngines,
+		convertEngines:     convertEngines,
+		readMedataEngines:  readMetadataEngines,
+		writeMedataEngines: writeMedataEngines,
 	}
 }

@@ -27,7 +41,7 @@ func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inp
 	var err error
 	errChan := make(chan error, 1)

-	for _, engine := range multi.engines {
+	for _, engine := range multi.mergeEngines {
 		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.Merge(ctx, logger, inputPaths, outputPath)
 		}(engine)
@@ -46,13 +60,51 @@ func (multi *multiPdfEngines) Merge(ctx context.Context, logger *zap.Logger, inp
 	return fmt.Errorf("merge PDFs with multi PDF engines: %w", err)
 }

+type splitResult struct {
+	outputPaths []string
+	err         error
+}
+
+// Split tries to split at intervals a given PDF thanks to its children. If the
+// context is done, it stops and returns an error.
+func (multi *multiPdfEngines) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	var err error
+	var mu sync.Mutex // to safely append errors.
+
+	resultChan := make(chan splitResult, len(multi.splitEngines))
+
+	for _, engine := range multi.splitEngines {
+		go func(engine gotenberg.PdfEngine) {
+			outputPaths, err := engine.Split(ctx, logger, mode, inputPath, outputDirPath)
+			resultChan <- splitResult{outputPaths: outputPaths, err: err}
+		}(engine)
+	}
+
+	for range multi.splitEngines {
+		select {
+		case result := <-resultChan:
+			if result.err != nil {
+				mu.Lock()
+				err = multierr.Append(err, result.err)
+				mu.Unlock()
+			} else {
+				return result.outputPaths, nil
+			}
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		}
+	}
+
+	return nil, fmt.Errorf("split PDF with multi PDF engines: %w", err)
+}
+
 // Convert converts the given PDF to a specific PDF format. thanks to its
 // children. If the context is done, it stops and returns an error.
 func (multi *multiPdfEngines) Convert(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
 	var err error
 	errChan := make(chan error, 1)

-	for _, engine := range multi.engines {
+	for _, engine := range multi.convertEngines {
 		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.Convert(ctx, logger, formats, inputPath, outputPath)
 		}(engine)
@@ -80,16 +132,16 @@ func (multi *multiPdfEngines) ReadMetadata(ctx context.Context, logger *zap.Logg
 	var err error
 	var mu sync.Mutex // to safely append errors.

-	resultChan := make(chan readMetadataResult, len(multi.engines))
+	resultChan := make(chan readMetadataResult, len(multi.readMedataEngines))

-	for _, engine := range multi.engines {
+	for _, engine := range multi.readMedataEngines {
 		go func(engine gotenberg.PdfEngine) {
 			metadata, err := engine.ReadMetadata(ctx, logger, inputPath)
 			resultChan <- readMetadataResult{metadata: metadata, err: err}
 		}(engine)
 	}

-	for range multi.engines {
+	for range multi.readMedataEngines {
 		select {
 		case result := <-resultChan:
 			if result.err != nil {
@@ -111,7 +163,7 @@ func (multi *multiPdfEngines) WriteMetadata(ctx context.Context, logger *zap.Log
 	var err error
 	errChan := make(chan error, 1)

-	for _, engine := range multi.engines {
+	for _, engine := range multi.writeMedataEngines {
 		go func(engine gotenberg.PdfEngine) {
 			errChan <- engine.WriteMetadata(ctx, logger, metadata, inputPath)
 		}(engine)
--- a/pkg/modules/pdfengines/multi_test.go
+++ b/pkg/modules/pdfengines/multi_test.go
@@ -19,59 +19,67 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 	}{
 		{
 			scenario: "nominal behavior",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: false,
 		},
 		{
 			scenario: "at least one engine does not return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
-					},
-				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: false,
 		},
 		{
 			scenario: "all engines return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return errors.New("foo")
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return errors.New("foo")
-					},
-				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: true,
 		},
 		{
 			scenario: "context expired",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				mergeEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
 				cancel()
@@ -95,6 +103,97 @@ func TestMultiPdfEngines_Merge(t *testing.T) {
 	}
 }

+func TestMultiPdfEngines_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      *multiPdfEngines
+		ctx         context.Context
+		expectError bool
+	}{
+		{
+			scenario: "nominal behavior",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "at least one engine does not return an error",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: context.Background(),
+		},
+		{
+			scenario: "all engines return an error",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, errors.New("foo")
+						},
+					},
+				},
+			},
+			ctx:         context.Background(),
+			expectError: true,
+		},
+		{
+			scenario: "context expired",
+			engine: &multiPdfEngines{
+				splitEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+							return nil, nil
+						},
+					},
+				},
+			},
+			ctx: func() context.Context {
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				return ctx
+			}(),
+			expectError: true,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := tc.engine.Split(tc.ctx, zap.NewNop(), gotenberg.SplitMode{}, "", "")
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+		})
+	}
+}
+
 func TestMultiPdfEngines_Convert(t *testing.T) {
 	for _, tc := range []struct {
 		scenario    string
@@ -104,57 +203,65 @@ func TestMultiPdfEngines_Convert(t *testing.T) {
 	}{
 		{
 			scenario: "nominal behavior",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "at least one engine does not return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
-					},
-				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "all engines return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return errors.New("foo")
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return errors.New("foo")
-					},
-				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: true,
 		},
 		{
 			scenario: "context expired",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				convertEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
 				cancel()
@@ -187,57 +294,65 @@ func TestMultiPdfEngines_ReadMetadata(t *testing.T) {
 	}{
 		{
 			scenario: "nominal behavior",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return make(map[string]interface{}), nil
+			engine: &multiPdfEngines{
+				readMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
 					},
 				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "at least one engine does not return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return nil, errors.New("foo")
+			engine: &multiPdfEngines{
+				readMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return make(map[string]interface{}), nil
-					},
-				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "all engines return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return nil, errors.New("foo")
+			engine: &multiPdfEngines{
+				readMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return nil, errors.New("foo")
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return nil, errors.New("foo")
-					},
-				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: true,
 		},
 		{
 			scenario: "context expired",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
-						return make(map[string]interface{}), nil
+			engine: &multiPdfEngines{
+				readMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						ReadMetadataMock: func(ctx context.Context, logger *zap.Logger, inputPath string) (map[string]interface{}, error) {
+							return make(map[string]interface{}), nil
+						},
 					},
 				},
-			),
+			},
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
 				cancel()
@@ -270,57 +385,65 @@ func TestMultiPdfEngines_WriteMetadata(t *testing.T) {
 	}{
 		{
 			scenario: "nominal behavior",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				writeMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "at least one engine does not return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				writeMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return nil
-					},
-				},
-			),
+			},
 			ctx: context.Background(),
 		},
 		{
 			scenario: "all engines return an error",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return errors.New("foo")
+			engine: &multiPdfEngines{
+				writeMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
+					},
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return errors.New("foo")
+						},
 					},
 				},
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return errors.New("foo")
-					},
-				},
-			),
+			},
 			ctx:         context.Background(),
 			expectError: true,
 		},
 		{
 			scenario: "context expired",
-			engine: newMultiPdfEngines(
-				&gotenberg.PdfEngineMock{
-					WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
-						return nil
+			engine: &multiPdfEngines{
+				writeMedataEngines: []gotenberg.PdfEngine{
+					&gotenberg.PdfEngineMock{
+						WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+							return nil
+						},
 					},
 				},
-			),
+			},
 			ctx: func() context.Context {
 				ctx, cancel := context.WithCancel(context.Background())
 				cancel()
--- a/pkg/modules/pdfengines/pdfengines.go
+++ b/pkg/modules/pdfengines/pdfengines.go
@@ -27,9 +27,13 @@ func init() {
 // the [api.Router] interface to expose relevant PDF processing routes if
 // enabled.
 type PdfEngines struct {
-	names         []string
-	engines       []gotenberg.PdfEngine
-	disableRoutes bool
+	mergeNames        []string
+	splitNames        []string
+	convertNames      []string
+	readMetadataNames []string
+	writeMedataNames  []string
+	engines           []gotenberg.PdfEngine
+	disableRoutes     bool
 }

 // Descriptor returns a PdfEngines' module descriptor.
@@ -38,9 +42,19 @@ func (mod *PdfEngines) Descriptor() gotenberg.ModuleDescriptor {
 		ID: "pdfengines",
 		FlagSet: func() *flag.FlagSet {
 			fs := flag.NewFlagSet("pdfengines", flag.ExitOnError)
-			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the PDF engines and their order - all by default")
+			fs.StringSlice("pdfengines-merge-engines", []string{"qpdf", "pdfcpu", "pdftk"}, "Set the PDF engines and their order for the merge feature - empty means all")
+			fs.StringSlice("pdfengines-split-engines", []string{"pdfcpu", "qpdf", "pdftk"}, "Set the PDF engines and their order for the split feature - empty means all")
+			fs.StringSlice("pdfengines-convert-engines", []string{"libreoffice-pdfengine"}, "Set the PDF engines and their order for the convert feature - empty means all")
+			fs.StringSlice("pdfengines-read-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the read metadata feature - empty means all")
+			fs.StringSlice("pdfengines-write-metadata-engines", []string{"exiftool"}, "Set the PDF engines and their order for the write metadata feature - empty means all")
 			fs.Bool("pdfengines-disable-routes", false, "Disable the routes")

+			fs.StringSlice("pdfengines-engines", make([]string, 0), "Set the default PDF engines and their default order - all by default")
+			err := fs.MarkDeprecated("pdfengines-engines", "use other flags for a more granular selection of PDF engines per method")
+			if err != nil {
+				panic(err)
+			}
+
 			return fs
 		}(),
 		New: func() gotenberg.Module { return new(PdfEngines) },
@@ -51,7 +65,11 @@ func (mod *PdfEngines) Descriptor() gotenberg.ModuleDescriptor {
 // selected by the user thanks to the "engines" flag.
 func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 	flags := ctx.ParsedFlags()
-	names := flags.MustStringSlice("pdfengines-engines")
+	mergeNames := flags.MustStringSlice("pdfengines-merge-engines")
+	splitNames := flags.MustStringSlice("pdfengines-split-engines")
+	convertNames := flags.MustStringSlice("pdfengines-convert-engines")
+	readMetadataNames := flags.MustStringSlice("pdfengines-read-metadata-engines")
+	writeMetadataNames := flags.MustStringSlice("pdfengines-write-metadata-engines")
 	mod.disableRoutes = flags.MustBool("pdfengines-disable-routes")

 	engines, err := ctx.Modules(new(gotenberg.PdfEngine))
@@ -65,26 +83,42 @@ func (mod *PdfEngines) Provision(ctx *gotenberg.Context) error {
 		mod.engines[i] = engine.(gotenberg.PdfEngine)
 	}

-	if len(names) > 0 {
-		// Selection from user.
-		mod.names = names
-
-		// Example in case of deprecated module name.
-		//for i, name := range names {
-		//	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
-		//		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
-		//		mod.names[i] = "libreoffice-pdfengine"
-		//	}
-		//}
-
-		return nil
+	defaultNames := make([]string, len(mod.engines))
+	for i, engine := range mod.engines {
+		defaultNames[i] = engine.(gotenberg.Module).Descriptor().ID
 	}

-	// No selection from user, use all PDF engines available.
-	mod.names = make([]string, len(mod.engines))
+	// Example in case of deprecated module name.
+	//for i, name := range defaultNames {
+	//	if name == "unoconv-pdfengine" || name == "uno-pdfengine" {
+	//		logger.Warn(fmt.Sprintf("%s is deprecated; prefer libreoffice-pdfengine instead", name))
+	//		mod.defaultNames[i] = "libreoffice-pdfengine"
+	//	}
+	//}

-	for i, engine := range mod.engines {
-		mod.names[i] = engine.(gotenberg.Module).Descriptor().ID
+	mod.mergeNames = defaultNames
+	if len(mergeNames) > 0 {
+		mod.mergeNames = mergeNames
+	}
+
+	mod.splitNames = defaultNames
+	if len(splitNames) > 0 {
+		mod.splitNames = splitNames
+	}
+
+	mod.convertNames = defaultNames
+	if len(convertNames) > 0 {
+		mod.convertNames = convertNames
+	}
+
+	mod.readMetadataNames = defaultNames
+	if len(readMetadataNames) > 0 {
+		mod.readMetadataNames = readMetadataNames
+	}
+
+	mod.writeMedataNames = defaultNames
+	if len(writeMetadataNames) > 0 {
+		mod.writeMedataNames = writeMetadataNames
 	}

 	return nil
@@ -105,22 +139,41 @@ func (mod *PdfEngines) Validate() error {
 	}

 	nonExistingEngines := make([]string, 0)
+	findNonExistingEngines := func(names []string) {
+		for _, name := range names {
+			engineExists := false

-	for _, name := range mod.names {
-		engineExists := false
+			for _, engine := range mod.engines {
+				if name == engine.(gotenberg.Module).Descriptor().ID {
+					engineExists = true
+					break
+				}
+			}

-		for _, engine := range mod.engines {
-			if name == engine.(gotenberg.Module).Descriptor().ID {
-				engineExists = true
-				break
+			if engineExists {
+				continue
+			}
+
+			alreadyInSlice := false
+			for _, engine := range nonExistingEngines {
+				if engine == name {
+					alreadyInSlice = true
+					break
+				}
+			}
+
+			if !alreadyInSlice {
+				nonExistingEngines = append(nonExistingEngines, name)
 			}
 		}
-
-		if !engineExists {
-			nonExistingEngines = append(nonExistingEngines, name)
-		}
 	}

+	findNonExistingEngines(mod.mergeNames)
+	findNonExistingEngines(mod.splitNames)
+	findNonExistingEngines(mod.convertNames)
+	findNonExistingEngines(mod.readMetadataNames)
+	findNonExistingEngines(mod.writeMedataNames)
+
 	if len(nonExistingEngines) == 0 {
 		return nil
 	}
@@ -132,24 +185,37 @@ func (mod *PdfEngines) Validate() error {
 // modules.
 func (mod *PdfEngines) SystemMessages() []string {
 	return []string{
-		strings.Join(mod.names[:], " "),
+		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames[:], " ")),
+		fmt.Sprintf("split engines - %s", strings.Join(mod.splitNames[:], " ")),
+		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames[:], " ")),
+		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames[:], " ")),
+		fmt.Sprintf("write medata engines - %s", strings.Join(mod.writeMedataNames[:], " ")),
 	}
 }

 // PdfEngine returns a [gotenberg.PdfEngine].
 func (mod *PdfEngines) PdfEngine() (gotenberg.PdfEngine, error) {
-	engines := make([]gotenberg.PdfEngine, len(mod.names))
-
-	for i, name := range mod.names {
-		for _, engine := range mod.engines {
-			if name == engine.(gotenberg.Module).Descriptor().ID {
-				engines[i] = engine
-				break
+	engines := func(names []string) []gotenberg.PdfEngine {
+		list := make([]gotenberg.PdfEngine, len(names))
+		for i, name := range names {
+			for _, engine := range mod.engines {
+				if name == engine.(gotenberg.Module).Descriptor().ID {
+					list[i] = engine
+					break
+				}
 			}
 		}
+
+		return list
 	}

-	return newMultiPdfEngines(engines...), nil
+	return newMultiPdfEngines(
+		engines(mod.mergeNames),
+		engines(mod.splitNames),
+		engines(mod.convertNames),
+		engines(mod.readMetadataNames),
+		engines(mod.writeMedataNames),
+	), nil
 }

 // Routes returns the HTTP routes.
@@ -167,6 +233,7 @@ func (mod *PdfEngines) Routes() ([]api.Route, error) {

 	return []api.Route{
 		mergeRoute(engine),
+		splitRoute(engine),
 		convertRoute(engine),
 		readMetadataRoute(engine),
 		writeMetadataRoute(engine),
--- a/pkg/modules/pdfengines/pdfengines_test.go
+++ b/pkg/modules/pdfengines/pdfengines_test.go
@@ -2,6 +2,7 @@ package pdfengines

 import (
 	"errors"
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -22,10 +23,14 @@ func TestPdfEngines_Descriptor(t *testing.T) {

 func TestPdfEngines_Provision(t *testing.T) {
 	for _, tc := range []struct {
-		scenario           string
-		ctx                *gotenberg.Context
-		expectedPdfEngines []string
-		expectError        bool
+		scenario                        string
+		ctx                             *gotenberg.Context
+		expectedMergePdfEngines         []string
+		expectedSplitPdfEngines         []string
+		expectedConvertPdfEngines       []string
+		expectedReadMetadataPdfEngines  []string
+		expectedWriteMetadataPdfEngines []string
+		expectError                     bool
 	}{
 		{
 			scenario: "no selection from user",
@@ -61,8 +66,12 @@ func TestPdfEngines_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectedPdfEngines: []string{"bar"},
-			expectError:        false,
+			expectedMergePdfEngines:         []string{"qpdf", "pdfcpu", "pdftk"},
+			expectedSplitPdfEngines:         []string{"pdfcpu", "qpdf", "pdftk"},
+			expectedConvertPdfEngines:       []string{"libreoffice-pdfengine"},
+			expectedReadMetadataPdfEngines:  []string{"exiftool"},
+			expectedWriteMetadataPdfEngines: []string{"exiftool"},
+			expectError:                     false,
 		},
 		{
 			scenario: "selection from user",
@@ -100,7 +109,7 @@ func TestPdfEngines_Provision(t *testing.T) {
 				}

 				fs := new(PdfEngines).Descriptor().FlagSet
-				err := fs.Parse([]string{"--pdfengines-engines=b", "--pdfengines-engines=a"})
+				err := fs.Parse([]string{"--pdfengines-merge-engines=b", "--pdfengines-split-engines=a", "--pdfengines-convert-engines=b", "--pdfengines-read-metadata-engines=a", "--pdfengines-write-metadata-engines=a"})
 				if err != nil {
 					t.Fatalf("expected no error but got: %v", err)
 				}
@@ -116,8 +125,13 @@ func TestPdfEngines_Provision(t *testing.T) {
 					},
 				)
 			}(),
-			expectedPdfEngines: []string{"b", "a"},
-			expectError:        false,
+
+			expectedMergePdfEngines:         []string{"b"},
+			expectedSplitPdfEngines:         []string{"a"},
+			expectedConvertPdfEngines:       []string{"b"},
+			expectedReadMetadataPdfEngines:  []string{"a"},
+			expectedWriteMetadataPdfEngines: []string{"a"},
+			expectError:                     false,
 		},
 		{
 			scenario: "no valid PDF engine",
@@ -167,13 +181,49 @@ func TestPdfEngines_Provision(t *testing.T) {
 				t.Fatal("expected error but got none")
 			}

-			if len(tc.expectedPdfEngines) != len(mod.names) {
-				t.Fatalf("expected %d names but got %d", len(tc.expectedPdfEngines), len(mod.names))
+			if len(tc.expectedMergePdfEngines) != len(mod.mergeNames) {
+				t.Fatalf("expected %d merge names but got %d", len(tc.expectedMergePdfEngines), len(mod.mergeNames))
 			}

-			for index, name := range mod.names {
-				if name != tc.expectedPdfEngines[index] {
-					t.Fatalf("expected scenario at index %d to be %s, but got: %s", index, name, tc.expectedPdfEngines[index])
+			if len(tc.expectedConvertPdfEngines) != len(mod.convertNames) {
+				t.Fatalf("expected %d convert names but got %d", len(tc.expectedConvertPdfEngines), len(mod.convertNames))
+			}
+
+			if len(tc.expectedReadMetadataPdfEngines) != len(mod.readMetadataNames) {
+				t.Fatalf("expected %d read metadata names but got %d", len(tc.expectedReadMetadataPdfEngines), len(mod.readMetadataNames))
+			}
+
+			if len(tc.expectedWriteMetadataPdfEngines) != len(mod.writeMedataNames) {
+				t.Fatalf("expected %d write metadata names but got %d", len(tc.expectedWriteMetadataPdfEngines), len(mod.writeMedataNames))
+			}
+
+			for index, name := range mod.mergeNames {
+				if name != tc.expectedMergePdfEngines[index] {
+					t.Fatalf("expected merge name at index %d to be %s, but got: %s", index, name, tc.expectedMergePdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.splitNames {
+				if name != tc.expectedSplitPdfEngines[index] {
+					t.Fatalf("expected split name at index %d to be %s, but got: %s", index, name, tc.expectedSplitPdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.convertNames {
+				if name != tc.expectedConvertPdfEngines[index] {
+					t.Fatalf("expected convert name at index %d to be %s, but got: %s", index, name, tc.expectedConvertPdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.readMetadataNames {
+				if name != tc.expectedReadMetadataPdfEngines[index] {
+					t.Fatalf("expected read metadata name at index %d to be %s, but got: %s", index, name, tc.expectedReadMetadataPdfEngines[index])
+				}
+			}
+
+			for index, name := range mod.writeMedataNames {
+				if name != tc.expectedWriteMetadataPdfEngines[index] {
+					t.Fatalf("expected write metadat name at index %d to be %s, but got: %s", index, name, tc.expectedWriteMetadataPdfEngines[index])
 				}
 			}
 		})
@@ -239,8 +289,11 @@ func TestPdfEngines_Validate(t *testing.T) {
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
 			mod := PdfEngines{
-				names:   tc.names,
-				engines: tc.engines,
+				mergeNames:        tc.names,
+				convertNames:      tc.names,
+				readMetadataNames: tc.names,
+				writeMedataNames:  tc.names,
+				engines:           tc.engines,
 			}

 			err := mod.Validate()
@@ -258,22 +311,39 @@ func TestPdfEngines_Validate(t *testing.T) {

 func TestPdfEngines_SystemMessages(t *testing.T) {
 	mod := new(PdfEngines)
-	mod.names = []string{"foo", "bar"}
+	mod.mergeNames = []string{"foo", "bar"}
+	mod.splitNames = []string{"foo", "bar"}
+	mod.convertNames = []string{"foo", "bar"}
+	mod.readMetadataNames = []string{"foo", "bar"}
+	mod.writeMedataNames = []string{"foo", "bar"}

 	messages := mod.SystemMessages()
-	if len(messages) != 1 {
+	if len(messages) != 5 {
 		t.Errorf("expected one and only one message, but got %d", len(messages))
 	}

-	expect := strings.Join(mod.names[:], " ")
-	if messages[0] != expect {
-		t.Errorf("expected message '%s', but got '%s'", expect, messages[0])
+	expect := []string{
+		fmt.Sprintf("merge engines - %s", strings.Join(mod.mergeNames[:], " ")),
+		fmt.Sprintf("split engines - %s", strings.Join(mod.splitNames[:], " ")),
+		fmt.Sprintf("convert engines - %s", strings.Join(mod.convertNames[:], " ")),
+		fmt.Sprintf("read metadata engines - %s", strings.Join(mod.readMetadataNames[:], " ")),
+		fmt.Sprintf("write medata engines - %s", strings.Join(mod.writeMedataNames[:], " ")),
+	}
+
+	for i, message := range messages {
+		if message != expect[i] {
+			t.Errorf("expected message at index %d to be %s, but got %s", i, message, expect[i])
+		}
 	}
 }

 func TestPdfEngines_PdfEngine(t *testing.T) {
 	mod := PdfEngines{
-		names: []string{"foo", "bar"},
+		mergeNames:        []string{"foo", "bar"},
+		splitNames:        []string{"foo", "bar"},
+		convertNames:      []string{"foo", "bar"},
+		readMetadataNames: []string{"foo", "bar"},
+		writeMedataNames:  []string{"foo", "bar"},
 		engines: func() []gotenberg.PdfEngine {
 			engine1 := &struct {
 				gotenberg.ModuleMock
@@ -312,7 +382,7 @@ func TestPdfEngines_Routes(t *testing.T) {
 	}{
 		{
 			scenario:      "routes not disabled",
-			expectRoutes:  4,
+			expectRoutes:  5,
 			disableRoutes: false,
 		},
 		{
--- a/pkg/modules/pdfengines/routes.go
+++ b/pkg/modules/pdfengines/routes.go
@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"net/http"
 	"path/filepath"
+	"strconv"
+	"strings"

 	"github.com/labstack/echo/v4"

@@ -13,6 +15,232 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

+// FormDataPdfSplitMode creates a [gotenberg.SplitMode] from the form data.
+func FormDataPdfSplitMode(form *api.FormData, mandatory bool) gotenberg.SplitMode {
+	var (
+		mode  string
+		span  string
+		unify bool
+	)
+
+	splitModeFunc := func(value string) error {
+		if value != "" && value != gotenberg.SplitModeIntervals && value != gotenberg.SplitModePages {
+			return fmt.Errorf("wrong value, expected either '%s' or '%s'", gotenberg.SplitModeIntervals, gotenberg.SplitModePages)
+		}
+		mode = value
+		return nil
+	}
+
+	splitSpanFunc := func(value string) error {
+		value = strings.Join(strings.Fields(value), "")
+
+		if mode == gotenberg.SplitModeIntervals {
+			intValue, err := strconv.Atoi(value)
+			if err != nil {
+				return err
+			}
+			if intValue < 1 {
+				return errors.New("value is inferior to 1")
+			}
+		}
+
+		span = value
+
+		return nil
+	}
+
+	if mandatory {
+		form.
+			MandatoryCustom("splitMode", func(value string) error {
+				return splitModeFunc(value)
+			}).
+			MandatoryCustom("splitSpan", func(value string) error {
+				return splitSpanFunc(value)
+			})
+	} else {
+		form.
+			Custom("splitMode", func(value string) error {
+				return splitModeFunc(value)
+			}).
+			Custom("splitSpan", func(value string) error {
+				return splitSpanFunc(value)
+			})
+	}
+
+	form.
+		Bool("splitUnify", &unify, false).
+		Custom("splitUnify", func(value string) error {
+			if value != "" && unify && mode != gotenberg.SplitModePages {
+				return fmt.Errorf("unify is not available for split mode '%s'", mode)
+			}
+			return nil
+		})
+
+	return gotenberg.SplitMode{
+		Mode:  mode,
+		Span:  span,
+		Unify: unify,
+	}
+}
+
+// FormDataPdfFormats creates [gotenberg.PdfFormats] from the form data.
+// Fallback to default value if the considered key is not present.
+func FormDataPdfFormats(form *api.FormData) gotenberg.PdfFormats {
+	var (
+		pdfa  string
+		pdfua bool
+	)
+
+	form.
+		String("pdfa", &pdfa, "").
+		Bool("pdfua", &pdfua, false)
+
+	return gotenberg.PdfFormats{
+		PdfA:  pdfa,
+		PdfUa: pdfua,
+	}
+}
+
+// FormDataPdfMetadata creates metadata object from the form data.
+func FormDataPdfMetadata(form *api.FormData, mandatory bool) map[string]interface{} {
+	var metadata map[string]interface{}
+
+	metadataFunc := func(value string) error {
+		if len(value) > 0 {
+			err := json.Unmarshal([]byte(value), &metadata)
+			if err != nil {
+				return fmt.Errorf("unmarshal metadata: %w", err)
+			}
+		}
+		return nil
+	}
+
+	if mandatory {
+		form.MandatoryCustom("metadata", func(value string) error {
+			return metadataFunc(value)
+		})
+	} else {
+		form.Custom("metadata", func(value string) error {
+			return metadataFunc(value)
+		})
+	}
+
+	return metadata
+}
+
+// MergeStub merges given PDFs. If only one input PDF, it does nothing and
+// returns the corresponding input path.
+func MergeStub(ctx *api.Context, engine gotenberg.PdfEngine, inputPaths []string) (string, error) {
+	if len(inputPaths) == 0 {
+		return "", errors.New("no input paths")
+	}
+
+	if len(inputPaths) == 1 {
+		return inputPaths[0], nil
+	}
+
+	outputPath := ctx.GeneratePath(".pdf")
+	err := engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
+	if err != nil {
+		return "", fmt.Errorf("merge %d PDFs: %w", len(inputPaths), err)
+	}
+
+	return outputPath, nil
+}
+
+// SplitPdfStub splits a list of PDF files based on [gotenberg.SplitMode].
+// It returns a list of output paths or the list of provided input paths if no
+// split requested.
+func SplitPdfStub(ctx *api.Context, engine gotenberg.PdfEngine, mode gotenberg.SplitMode, inputPaths []string) ([]string, error) {
+	zeroValued := gotenberg.SplitMode{}
+	if mode == zeroValued {
+		return inputPaths, nil
+	}
+
+	var outputPaths []string
+	for _, inputPath := range inputPaths {
+		inputPathNoExt := inputPath[:len(inputPath)-len(filepath.Ext(inputPath))]
+		filenameNoExt := filepath.Base(inputPathNoExt)
+		outputDirPath, err := ctx.CreateSubDirectory(strings.ReplaceAll(filepath.Base(filenameNoExt), ".", "_"))
+		if err != nil {
+			return nil, fmt.Errorf("create subdirectory from input path: %w", err)
+		}
+
+		paths, err := engine.Split(ctx, ctx.Log(), mode, inputPath, outputDirPath)
+		if err != nil {
+			return nil, fmt.Errorf("split PDF '%s': %w", inputPath, err)
+		}
+
+		// Keep the original filename.
+		for i, path := range paths {
+			var newPath string
+			if mode.Unify && mode.Mode == gotenberg.SplitModePages {
+				newPath = fmt.Sprintf(
+					"%s/%s.pdf",
+					outputDirPath, filenameNoExt,
+				)
+			} else {
+				newPath = fmt.Sprintf(
+					"%s/%s_%d.pdf",
+					outputDirPath, filenameNoExt, i,
+				)
+			}
+
+			err = ctx.Rename(path, newPath)
+			if err != nil {
+				return nil, fmt.Errorf("rename path: %w", err)
+			}
+
+			outputPaths = append(outputPaths, newPath)
+
+			if mode.Unify && mode.Mode == gotenberg.SplitModePages {
+				break
+			}
+		}
+	}
+
+	return outputPaths, nil
+}
+
+// ConvertStub transforms a given PDF to the specified formats defined in
+// [gotenberg.PdfFormats]. If no format, it does nothing and returns the input
+// paths.
+func ConvertStub(ctx *api.Context, engine gotenberg.PdfEngine, formats gotenberg.PdfFormats, inputPaths []string) ([]string, error) {
+	zeroValued := gotenberg.PdfFormats{}
+	if formats == zeroValued {
+		return inputPaths, nil
+	}
+
+	outputPaths := make([]string, len(inputPaths))
+	for i, inputPath := range inputPaths {
+		outputPaths[i] = ctx.GeneratePath(".pdf")
+
+		err := engine.Convert(ctx, ctx.Log(), formats, inputPath, outputPaths[i])
+		if err != nil {
+			return nil, fmt.Errorf("convert '%s': %w", inputPath, err)
+		}
+	}
+
+	return outputPaths, nil
+}
+
+// WriteMetadataStub writes the metadata into PDF files. If no metadata, it
+// does nothing.
+func WriteMetadataStub(ctx *api.Context, engine gotenberg.PdfEngine, metadata map[string]interface{}, inputPaths []string) error {
+	if len(metadata) == 0 {
+		return nil
+	}
+
+	for _, inputPath := range inputPaths {
+		err := engine.WriteMetadata(ctx, ctx.Log(), metadata, inputPath)
+		if err != nil {
+			return fmt.Errorf("write metadata into '%s': %w", inputPath, err)
+		}
+	}
+
+	return nil
+}
+
 // mergeRoute returns an [api.Route] which can merge PDFs.
 func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 	return api.Route{
@@ -22,75 +250,96 @@ func mergeRoute(engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)

-			// Let's get the data from the form and validate them.
-			var (
-				inputPaths []string
-				pdfa       string
-				pdfua      bool
-				metadata   map[string]interface{}
-			)
+			form := ctx.FormData()
+			pdfFormats := FormDataPdfFormats(form)
+			metadata := FormDataPdfMetadata(form, false)

-			err := ctx.FormData().
+			var inputPaths []string
+			err := form.
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				String("pdfa", &pdfa, "").
-				Bool("pdfua", &pdfua, false).
-				Custom("metadata", func(value string) error {
-					if len(value) > 0 {
-						err := json.Unmarshal([]byte(value), &metadata)
-						if err != nil {
-							return fmt.Errorf("unmarshal metadata: %w", err)
-						}
-					}
-					return nil
-				}).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			pdfFormats := gotenberg.PdfFormats{
-				PdfA:  pdfa,
-				PdfUa: pdfua,
-			}
-
-			// Alright, let's merge the PDFs.
 			outputPath := ctx.GeneratePath(".pdf")
-
 			err = engine.Merge(ctx, ctx.Log(), inputPaths, outputPath)
 			if err != nil {
 				return fmt.Errorf("merge PDFs: %w", err)
 			}

-			// So far so good, the PDFs are merged into one unique PDF.
-			// Now, let's check if the client want to convert this result PDF
-			// to specific PDF formats.
-			zeroValued := gotenberg.PdfFormats{}
-			if pdfFormats != zeroValued {
-				convertInputPath := outputPath
-				convertOutputPath := ctx.GeneratePath(".pdf")
-
-				err = engine.Convert(ctx, ctx.Log(), pdfFormats, convertInputPath, convertOutputPath)
-				if err != nil {
-					return fmt.Errorf("convert PDF: %w", err)
-				}
-
-				// Important: the output path is now the converted file.
-				outputPath = convertOutputPath
-			}
-
-			// Writes and potentially overrides metadata entries, if any.
-			if len(metadata) > 0 {
-				err = engine.WriteMetadata(ctx, ctx.Log(), metadata, outputPath)
-				if err != nil {
-					return fmt.Errorf("write metadata: %w", err)
-				}
-			}
-
-			// Last but not least, add the output path to the context so that
-			// the API is able to send it as a response to the client.
-			err = ctx.AddOutputPaths(outputPath)
+			outputPaths, err := ConvertStub(ctx, engine, pdfFormats, []string{outputPath})
 			if err != nil {
-				return fmt.Errorf("add output path: %w", err)
+				return fmt.Errorf("convert PDF: %w", err)
+			}
+
+			err = WriteMetadataStub(ctx, engine, metadata, outputPaths)
+			if err != nil {
+				return fmt.Errorf("write metadata: %w", err)
+			}
+
+			err = ctx.AddOutputPaths(outputPaths...)
+			if err != nil {
+				return fmt.Errorf("add output paths: %w", err)
+			}
+
+			return nil
+		},
+	}
+}
+
+// splitRoute returns an [api.Route] which can extract pages from a PDF.
+func splitRoute(engine gotenberg.PdfEngine) api.Route {
+	return api.Route{
+		Method:      http.MethodPost,
+		Path:        "/forms/pdfengines/split",
+		IsMultipart: true,
+		Handler: func(c echo.Context) error {
+			ctx := c.Get("context").(*api.Context)
+
+			form := ctx.FormData()
+			mode := FormDataPdfSplitMode(form, true)
+			pdfFormats := FormDataPdfFormats(form)
+			metadata := FormDataPdfMetadata(form, false)
+
+			var inputPaths []string
+			err := form.
+				MandatoryPaths([]string{".pdf"}, &inputPaths).
+				Validate()
+			if err != nil {
+				return fmt.Errorf("validate form data: %w", err)
+			}
+
+			outputPaths, err := SplitPdfStub(ctx, engine, mode, inputPaths)
+			if err != nil {
+				return fmt.Errorf("split PDFs: %w", err)
+			}
+
+			convertOutputPaths, err := ConvertStub(ctx, engine, pdfFormats, outputPaths)
+			if err != nil {
+				return fmt.Errorf("convert PDFs: %w", err)
+			}
+
+			err = WriteMetadataStub(ctx, engine, metadata, convertOutputPaths)
+			if err != nil {
+				return fmt.Errorf("write metadata: %w", err)
+			}
+
+			zeroValuedSplitMode := gotenberg.SplitMode{}
+			zeroValuedPdfFormats := gotenberg.PdfFormats{}
+			if mode != zeroValuedSplitMode && pdfFormats != zeroValuedPdfFormats {
+				// Rename the files to keep the split naming.
+				for i, convertOutputPath := range convertOutputPaths {
+					err = ctx.Rename(convertOutputPath, outputPaths[i])
+					if err != nil {
+						return fmt.Errorf("rename output path: %w", err)
+					}
+				}
+			}
+
+			err = ctx.AddOutputPaths(outputPaths...)
+			if err != nil {
+				return fmt.Errorf("add output paths: %w", err)
 			}

 			return nil
@@ -108,27 +357,17 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)

-			// Let's get the data from the form and validate them.
-			var (
-				inputPaths []string
-				pdfa       string
-				pdfua      bool
-			)
+			form := ctx.FormData()
+			pdfFormats := FormDataPdfFormats(form)

-			err := ctx.FormData().
+			var inputPaths []string
+			err := form.
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				String("pdfa", &pdfa, "").
-				Bool("pdfua", &pdfua, false).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			pdfFormats := gotenberg.PdfFormats{
-				PdfA:  pdfa,
-				PdfUa: pdfua,
-			}
-
 			zeroValued := gotenberg.PdfFormats{}
 			if pdfFormats == zeroValued {
 				return api.WrapError(
@@ -140,18 +379,14 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 				)
 			}

-			// Alright, let's convert the PDFs.
-			outputPaths := make([]string, len(inputPaths))
-			for i, inputPath := range inputPaths {
-				outputPaths[i] = ctx.GeneratePath(".pdf")
+			outputPaths, err := ConvertStub(ctx, engine, pdfFormats, inputPaths)
+			if err != nil {
+				return fmt.Errorf("convert PDFs: %w", err)
+			}

-				err = engine.Convert(ctx, ctx.Log(), pdfFormats, inputPath, outputPaths[i])
-				if err != nil {
-					return fmt.Errorf("convert PDF: %w", err)
-				}
-
-				if len(outputPaths) > 1 {
-					// If .zip archive, keep the original filename.
+			if len(outputPaths) > 1 {
+				// If .zip archive, keep the original filename.
+				for i, inputPath := range inputPaths {
 					err = ctx.Rename(outputPaths[i], inputPath)
 					if err != nil {
 						return fmt.Errorf("rename output path: %w", err)
@@ -161,8 +396,6 @@ func convertRoute(engine gotenberg.PdfEngine) api.Route {
 				}
 			}

-			// Last but not least, add the output paths to the context so that
-			// the API is able to send them as a response to the client.
 			err = ctx.AddOutputPaths(outputPaths...)
 			if err != nil {
 				return fmt.Errorf("add output paths: %w", err)
@@ -182,9 +415,7 @@ func readMetadataRoute(engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)

-			// Let's get the data from the form and validate them.
 			var inputPaths []string
-
 			err := ctx.FormData().
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
 				Validate()
@@ -192,7 +423,6 @@ func readMetadataRoute(engine gotenberg.PdfEngine) api.Route {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			// Alright, let's read the metadata.
 			res := make(map[string]map[string]interface{}, len(inputPaths))
 			for _, inputPath := range inputPaths {
 				metadata, err := engine.ReadMetadata(ctx, ctx.Log(), inputPath)
@@ -223,41 +453,22 @@ func writeMetadataRoute(engine gotenberg.PdfEngine) api.Route {
 		Handler: func(c echo.Context) error {
 			ctx := c.Get("context").(*api.Context)

-			// Let's get the data from the form and validate them.
-			var (
-				inputPaths []string
-				metadata   map[string]interface{}
-			)
+			form := ctx.FormData()
+			metadata := FormDataPdfMetadata(form, true)

-			err := ctx.FormData().
+			var inputPaths []string
+			err := form.
 				MandatoryPaths([]string{".pdf"}, &inputPaths).
-				MandatoryCustom("metadata", func(value string) error {
-					if len(value) > 0 {
-						err := json.Unmarshal([]byte(value), &metadata)
-						if err != nil {
-							return fmt.Errorf("unmarshal metadata: %w", err)
-						}
-					}
-					if len(metadata) == 0 {
-						return errors.New("no metadata")
-					}
-					return nil
-				}).
 				Validate()
 			if err != nil {
 				return fmt.Errorf("validate form data: %w", err)
 			}

-			// Alright, let's convert the PDFs.
-			for _, inputPath := range inputPaths {
-				err = engine.WriteMetadata(ctx, ctx.Log(), metadata, inputPath)
-				if err != nil {
-					return fmt.Errorf("write metadata: %w", err)
-				}
+			err = WriteMetadataStub(ctx, engine, metadata, inputPaths)
+			if err != nil {
+				return fmt.Errorf("write metadata: %w", err)
 			}

-			// Last but not least, add the output paths to the context so that
-			// the API is able to send them as a response to the client.
 			err = ctx.AddOutputPaths(inputPaths...)
 			if err != nil {
 				return fmt.Errorf("add output paths: %w", err)
--- a/pkg/modules/pdfengines/routes_test.go
+++ b/pkg/modules/pdfengines/routes_test.go
@@ -3,12 +3,16 @@ package pdfengines
 import (
 	"context"
 	"errors"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"os"
+	"reflect"
 	"slices"
 	"strings"
 	"testing"

+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"go.uber.org/zap"

@@ -16,6 +20,594 @@ import (
 	"github.com/gotenberg/gotenberg/v8/pkg/modules/api"
 )

+func TestFormDataPdfSplitMode(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		ctx                   *api.ContextMock
+		mandatory             bool
+		expectedSplitMode     gotenberg.SplitMode
+		expectValidationError bool
+	}{
+		{
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{},
+			expectValidationError: false,
+		},
+		{
+			scenario:              "no custom form fields (mandatory)",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			mandatory:             true,
+			expectedSplitMode:     gotenberg.SplitMode{},
+			expectValidationError: true,
+		},
+		{
+			scenario: "invalid splitMode",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{},
+			expectValidationError: true,
+		},
+		{
+			scenario: "invalid splitSpan (intervals)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"intervals",
+					},
+					"splitSpan": {
+						"1-2",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals},
+			expectValidationError: true,
+		},
+		{
+			scenario: "splitSpan inferior to 1 (intervals)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"intervals",
+					},
+					"splitSpan": {
+						"-1",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals},
+			expectValidationError: true,
+		},
+		{
+			scenario: "invalid splitUnify (intervals)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"intervals",
+					},
+					"splitSpan": {
+						"1",
+					},
+					"splitUnify": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1", Unify: true},
+			expectValidationError: true,
+		},
+		{
+			scenario: "valid form fields (intervals)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"intervals",
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			expectValidationError: false,
+		},
+		{
+			scenario: "valid form fields (pages)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"pages",
+					},
+					"splitSpan": {
+						"1-2",
+					},
+					"splitUnify": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			expectValidationError: false,
+		},
+		{
+			scenario: "valid form fields (mandatory)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						"intervals",
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             true,
+			expectedSplitMode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			expectValidationError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			form := tc.ctx.Context.FormData()
+			actual := FormDataPdfSplitMode(form, tc.mandatory)
+
+			if !reflect.DeepEqual(actual, tc.expectedSplitMode) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedSplitMode, actual)
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestFormDataPdfFormats(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		ctx                   *api.ContextMock
+		expectedPdfFormats    gotenberg.PdfFormats
+		expectValidationError bool
+	}{
+		{
+			scenario:              "no custom form fields",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			expectedPdfFormats:    gotenberg.PdfFormats{},
+			expectValidationError: false,
+		},
+		{
+			scenario: "pdfa and pdfua form fields",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"pdfa": {
+						"foo",
+					},
+					"pdfua": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			expectedPdfFormats:    gotenberg.PdfFormats{PdfA: "foo", PdfUa: true},
+			expectValidationError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			form := tc.ctx.Context.FormData()
+			actual := FormDataPdfFormats(form)
+
+			if !reflect.DeepEqual(actual, tc.expectedPdfFormats) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedPdfFormats, actual)
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestFormDataPdfMetadata(t *testing.T) {
+	for _, tc := range []struct {
+		scenario              string
+		ctx                   *api.ContextMock
+		mandatory             bool
+		expectedMetadata      map[string]interface{}
+		expectValidationError bool
+	}{
+		{
+			scenario:              "no metadata form field",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			mandatory:             false,
+			expectedMetadata:      nil,
+			expectValidationError: false,
+		},
+		{
+			scenario:              "no metadata form field (mandatory)",
+			ctx:                   &api.ContextMock{Context: new(api.Context)},
+			mandatory:             true,
+			expectedMetadata:      nil,
+			expectValidationError: true,
+		},
+		{
+			scenario: "invalid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"foo",
+					},
+				})
+				return ctx
+			}(),
+			mandatory:             false,
+			expectedMetadata:      nil,
+			expectValidationError: true,
+		},
+		{
+			scenario: "valid metadata form field",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetValues(map[string][]string{
+					"metadata": {
+						"{\"foo\":\"bar\"}",
+					},
+				})
+				return ctx
+			}(),
+			mandatory: false,
+			expectedMetadata: map[string]interface{}{
+				"foo": "bar",
+			},
+			expectValidationError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			form := tc.ctx.Context.FormData()
+			actual := FormDataPdfMetadata(form, tc.mandatory)
+
+			if !reflect.DeepEqual(actual, tc.expectedMetadata) {
+				t.Fatalf("expected %+v but got: %+v", tc.expectedMetadata, actual)
+			}
+
+			err := form.Validate()
+
+			if tc.expectValidationError && err == nil {
+				t.Fatal("expected validation error but got none", err)
+			}
+
+			if !tc.expectValidationError && err != nil {
+				t.Fatalf("expected no validation error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestMergeStub(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      gotenberg.PdfEngine
+		inputPaths  []string
+		expectError bool
+	}{
+		{
+			scenario:    "no input path (nil)",
+			inputPaths:  nil,
+			expectError: true,
+		},
+		{
+			scenario:    "no input path (empty)",
+			inputPaths:  make([]string, 0),
+			expectError: true,
+		},
+		{
+			scenario:    "only one input path",
+			inputPaths:  []string{"my.pdf"},
+			expectError: false,
+		},
+		{
+			scenario: "merge error",
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			inputPaths:  []string{"my.pdf", "my2.pdf"},
+			expectError: true,
+		},
+		{
+			scenario: "merge success",
+			engine: &gotenberg.PdfEngineMock{
+				MergeMock: func(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
+					return nil
+				},
+			},
+			inputPaths:  []string{"my.pdf", "my2.pdf"},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := MergeStub(new(api.Context), tc.engine, tc.inputPaths)
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestSplitPdfStub(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		ctx         *api.ContextMock
+		engine      gotenberg.PdfEngine
+		mode        gotenberg.SplitMode
+		expectError bool
+	}{
+		{
+			scenario:    "no split mode",
+			mode:        gotenberg.SplitMode{},
+			ctx:         &api.ContextMock{Context: new(api.Context)},
+			expectError: false,
+		},
+		{
+			scenario: "cannot create subdirectory",
+			mode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+					return errors.New("cannot create subdirectory")
+				}})
+				return ctx
+			}(),
+			expectError: true,
+		},
+		{
+			scenario: "split error",
+			mode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+					return nil
+				}})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return nil, errors.New("foo")
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "rename error",
+			mode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+					return nil
+				}})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return errors.New("cannot rename")
+				}})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+			},
+			expectError: true,
+		},
+		{
+			scenario: "success (intervals)",
+			mode:     gotenberg.SplitMode{Mode: gotenberg.SplitModeIntervals, Span: "1"},
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+					return nil
+				}})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return nil
+				}})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+			},
+			expectError: false,
+		},
+		{
+			scenario: "success (pages)",
+			mode:     gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+					return nil
+				}})
+				ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+					return nil
+				}})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			dirPath := fmt.Sprintf("%s/%s", os.TempDir(), uuid.NewString())
+			tc.ctx.SetDirPath(dirPath)
+			tc.ctx.SetLogger(zap.NewNop())
+
+			_, err := SplitPdfStub(tc.ctx.Context, tc.engine, tc.mode, []string{"my.pdf", "my2.pdf"})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestConvertStub(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      gotenberg.PdfEngine
+		pdfFormats  gotenberg.PdfFormats
+		expectError bool
+	}{
+		{
+			scenario:    "no PDF formats",
+			pdfFormats:  gotenberg.PdfFormats{},
+			expectError: false,
+		},
+		{
+			scenario: "convert error",
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			pdfFormats: gotenberg.PdfFormats{
+				PdfA:  gotenberg.PdfA3b,
+				PdfUa: true,
+			},
+			expectError: true,
+		},
+		{
+			scenario: "convert success",
+			engine: &gotenberg.PdfEngineMock{
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+			},
+			pdfFormats: gotenberg.PdfFormats{
+				PdfA:  gotenberg.PdfA3b,
+				PdfUa: true,
+			},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			_, err := ConvertStub(new(api.Context), tc.engine, tc.pdfFormats, []string{"my.pdf", "my2.pdf"})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
+func TestWriteMetadataStub(t *testing.T) {
+	for _, tc := range []struct {
+		scenario    string
+		engine      gotenberg.PdfEngine
+		metadata    map[string]interface{}
+		expectError bool
+	}{
+		{
+			scenario:    "no metadata (nil)",
+			metadata:    nil,
+			expectError: false,
+		},
+		{
+			scenario:    "no metadata (empty)",
+			metadata:    make(map[string]interface{}, 0),
+			expectError: false,
+		},
+		{
+			scenario: "write metadata error",
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			metadata:    map[string]interface{}{"foo": "bar"},
+			expectError: true,
+		},
+		{
+			scenario: "write metadata success",
+			engine: &gotenberg.PdfEngineMock{
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
+			metadata:    map[string]interface{}{"foo": "bar"},
+			expectError: false,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			err := WriteMetadataStub(new(api.Context), tc.engine, tc.metadata, []string{"my.pdf", "my2.pdf"})
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+		})
+	}
+}
+
 func TestMergeHandler(t *testing.T) {
 	for _, tc := range []struct {
 		scenario               string
@@ -221,6 +813,248 @@ func TestMergeHandler(t *testing.T) {
 	}
 }

+func TestSplitHandler(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    *api.ContextMock
+		engine                 gotenberg.PdfEngine
+		expectError            bool
+		expectHttpError        bool
+		expectHttpStatus       int
+		expectOutputPathsCount int
+		expectOutputPaths      []string
+	}{
+		{
+			scenario:               "missing at least one mandatory file",
+			ctx:                    &api.ContextMock{Context: new(api.Context)},
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "no split mode",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				return ctx
+			}(),
+			expectError:            true,
+			expectHttpError:        true,
+			expectHttpStatus:       http.StatusBadRequest,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error from PDF engine (split)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return nil, errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error from PDF engine (convert)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+					"pdfua": {
+						"true",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "error from PDF engine (write metadata)",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return errors.New("foo")
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "cannot add output paths",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+				})
+				ctx.SetCancelled(true)
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{inputPath}, nil
+				},
+			},
+			expectError:            true,
+			expectHttpError:        false,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario: "success",
+			ctx: func() *api.ContextMock {
+				ctx := &api.ContextMock{Context: new(api.Context)}
+				ctx.SetFiles(map[string]string{
+					"file.pdf": "/file.pdf",
+				})
+				ctx.SetValues(map[string][]string{
+					"splitMode": {
+						gotenberg.SplitModeIntervals,
+					},
+					"splitSpan": {
+						"1",
+					},
+					"pdfua": {
+						"true",
+					},
+					"metadata": {
+						"{\"Creator\": \"foo\", \"Producer\": \"bar\" }",
+					},
+				})
+				return ctx
+			}(),
+			engine: &gotenberg.PdfEngineMock{
+				SplitMock: func(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+					return []string{"file_split_1.pdf", "file_split_2.pdf"}, nil
+				},
+				ConvertMock: func(ctx context.Context, logger *zap.Logger, formats gotenberg.PdfFormats, inputPath, outputPath string) error {
+					return nil
+				},
+				WriteMetadataMock: func(ctx context.Context, logger *zap.Logger, metadata map[string]interface{}, inputPath string) error {
+					return nil
+				},
+			},
+			expectError:            false,
+			expectHttpError:        false,
+			expectOutputPathsCount: 2,
+			expectOutputPaths:      []string{"/file/file_0.pdf", "/file/file_1.pdf"},
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			tc.ctx.SetLogger(zap.NewNop())
+			tc.ctx.SetMkdirAll(&gotenberg.MkdirAllMock{MkdirAllMock: func(path string, perm os.FileMode) error {
+				return nil
+			}})
+			tc.ctx.SetPathRename(&gotenberg.PathRenameMock{RenameMock: func(oldpath, newpath string) error {
+				return nil
+			}})
+			c := echo.New().NewContext(nil, nil)
+			c.Set("context", tc.ctx.Context)
+
+			err := splitRoute(tc.engine).Handler(c)
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none", err)
+			}
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			var httpErr api.HttpError
+			isHttpError := errors.As(err, &httpErr)
+
+			if tc.expectHttpError && !isHttpError {
+				t.Errorf("expected an HTTP error but got: %v", err)
+			}
+
+			if !tc.expectHttpError && isHttpError {
+				t.Errorf("expected no HTTP error but got one: %v", httpErr)
+			}
+
+			if err != nil && tc.expectHttpError && isHttpError {
+				status, _ := httpErr.HttpError()
+				if status != tc.expectHttpStatus {
+					t.Errorf("expected %d as HTTP status code but got %d", tc.expectHttpStatus, status)
+				}
+			}
+
+			if tc.expectOutputPathsCount != len(tc.ctx.OutputPaths()) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(tc.ctx.OutputPaths()))
+			}
+
+			for _, path := range tc.expectOutputPaths {
+				if !slices.Contains(tc.ctx.OutputPaths(), path) {
+					t.Errorf("expected '%s' in output paths %v", path, tc.ctx.OutputPaths())
+				}
+			}
+		})
+	}
+}
+
 func TestConvertHandler(t *testing.T) {
 	for _, tc := range []struct {
 		scenario               string
--- a/pkg/modules/pdftk/doc.go
+++ b/pkg/modules/pdftk/doc.go
@@ -2,6 +2,7 @@
 // interface using the PDFtk command-line tool. This package allows for:
 //
 // 1. The merging of PDF files.
+// 2. The splitting of PDF files.
 //
 // The path to the PDFtk binary must be specified using the PDFTK_BIN_PATH
 // environment variable.
--- a/pkg/modules/pdftk/pdftk.go
+++ b/pkg/modules/pdftk/pdftk.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"path/filepath"

 	"go.uber.org/zap"

@@ -45,12 +46,40 @@ func (engine *PdfTk) Provision(ctx *gotenberg.Context) error {
 func (engine *PdfTk) Validate() error {
 	_, err := os.Stat(engine.binPath)
 	if os.IsNotExist(err) {
-		return fmt.Errorf("PdfTk binary path does not exist: %w", err)
+		return fmt.Errorf("PDFtk binary path does not exist: %w", err)
 	}

 	return nil
 }

+// Split splits a given PDF file.
+func (engine *PdfTk) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	var args []string
+	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
+
+	switch mode.Mode {
+	case gotenberg.SplitModePages:
+		if !mode.Unify {
+			return nil, fmt.Errorf("split PDFs using mode '%s' without unify with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		}
+		args = append(args, inputPath, "cat", mode.Span, "output", outputPath)
+	default:
+		return nil, fmt.Errorf("split PDFs using mode '%s' with PDFtk: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+	}
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return nil, fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
+	if err != nil {
+		return nil, fmt.Errorf("split PDFs with PDFtk: %w", err)
+	}
+
+	return []string{outputPath}, nil
+}
+
 // Merge combines multiple PDFs into a single PDF.
 func (engine *PdfTk) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var args []string
--- a/pkg/modules/pdftk/pdftk_test.go
+++ b/pkg/modules/pdftk/pdftk_test.go
@@ -97,6 +97,7 @@ func TestPdfTk_Merge(t *testing.T) {
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
+			expectError: false,
 		},
 		{
 			scenario: "many files success",
@@ -105,6 +106,7 @@ func TestPdfTk_Merge(t *testing.T) {
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -114,7 +116,7 @@ func TestPdfTk_Merge(t *testing.T) {
 				t.Fatalf("expected error but got: %v", err)
 			}

-			fs := gotenberg.NewFileSystem()
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			outputDir, err := fs.MkdirAll()
 			if err != nil {
 				t.Fatalf("expected error but got: %v", err)
@@ -140,6 +142,96 @@ func TestPdfTk_Merge(t *testing.T) {
 	}
 }

+func TestPdfCpu_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    context.Context
+		mode                   gotenberg.SplitMode
+		inputPath              string
+		expectError            bool
+		expectedError          error
+		expectOutputPathsCount int
+		expectOutputPaths      []string
+	}{
+		{
+			scenario:               "ErrPdfSplitModeNotSupported",
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "ErrPdfSplitModeNotSupported (no unify with pages)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1", Unify: false},
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid context",
+			ctx:                    nil,
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid input path",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			inputPath:              "",
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "success (pages & unify)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(PdfTk)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+			outputDir, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			defer func() {
+				err = os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			outputPaths, err := engine.Split(tc.ctx, zap.NewNop(), tc.mode, tc.inputPath, outputDir)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+
+			if tc.expectOutputPathsCount != len(outputPaths) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(outputPaths))
+			}
+		})
+	}
+}
+
 func TestPdfTk_Convert(t *testing.T) {
 	engine := new(PdfTk)
 	err := engine.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
--- a/pkg/modules/qpdf/doc.go
+++ b/pkg/modules/qpdf/doc.go
@@ -2,6 +2,7 @@
 // interface using the QPDF command-line tool. This package allows for:
 //
 // 1. The merging of PDF files.
+// 2. The splitting of PDF files.
 //
 // The path to the QPDF binary must be specified using the QPDK_BIN_PATH
 // environment variable.
--- a/pkg/modules/qpdf/qpdf.go
+++ b/pkg/modules/qpdf/qpdf.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"path/filepath"

 	"go.uber.org/zap"

@@ -45,12 +46,40 @@ func (engine *QPdf) Provision(ctx *gotenberg.Context) error {
 func (engine *QPdf) Validate() error {
 	_, err := os.Stat(engine.binPath)
 	if os.IsNotExist(err) {
-		return fmt.Errorf("QPdf binary path does not exist: %w", err)
+		return fmt.Errorf("QPDF binary path does not exist: %w", err)
 	}

 	return nil
 }

+// Split splits a given PDF file.
+func (engine *QPdf) Split(ctx context.Context, logger *zap.Logger, mode gotenberg.SplitMode, inputPath, outputDirPath string) ([]string, error) {
+	var args []string
+	outputPath := fmt.Sprintf("%s/%s", outputDirPath, filepath.Base(inputPath))
+
+	switch mode.Mode {
+	case gotenberg.SplitModePages:
+		if !mode.Unify {
+			return nil, fmt.Errorf("split PDFs using mode '%s' without unify with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+		}
+		args = append(args, inputPath, "--pages", ".", mode.Span, "--", outputPath)
+	default:
+		return nil, fmt.Errorf("split PDFs using mode '%s' with QPDF: %w", mode.Mode, gotenberg.ErrPdfSplitModeNotSupported)
+	}
+
+	cmd, err := gotenberg.CommandContext(ctx, logger, engine.binPath, args...)
+	if err != nil {
+		return nil, fmt.Errorf("create command: %w", err)
+	}
+
+	_, err = cmd.Exec()
+	if err != nil {
+		return nil, fmt.Errorf("split PDFs with QPDF: %w", err)
+	}
+
+	return []string{outputPath}, nil
+}
+
 // Merge combines multiple PDFs into a single PDF.
 func (engine *QPdf) Merge(ctx context.Context, logger *zap.Logger, inputPaths []string, outputPath string) error {
 	var args []string
--- a/pkg/modules/qpdf/qpdf_test.go
+++ b/pkg/modules/qpdf/qpdf_test.go
@@ -97,6 +97,7 @@ func TestQPdf_Merge(t *testing.T) {
 			inputPaths: []string{
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 			},
+			expectError: false,
 		},
 		{
 			scenario: "many files success",
@@ -105,6 +106,7 @@ func TestQPdf_Merge(t *testing.T) {
 				"/tests/test/testdata/pdfengines/sample1.pdf",
 				"/tests/test/testdata/pdfengines/sample2.pdf",
 			},
+			expectError: false,
 		},
 	} {
 		t.Run(tc.scenario, func(t *testing.T) {
@@ -114,7 +116,7 @@ func TestQPdf_Merge(t *testing.T) {
 				t.Fatalf("expected error but got: %v", err)
 			}

-			fs := gotenberg.NewFileSystem()
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
 			outputDir, err := fs.MkdirAll()
 			if err != nil {
 				t.Fatalf("expected error but got: %v", err)
@@ -140,6 +142,96 @@ func TestQPdf_Merge(t *testing.T) {
 	}
 }

+func TestQPdf_Split(t *testing.T) {
+	for _, tc := range []struct {
+		scenario               string
+		ctx                    context.Context
+		mode                   gotenberg.SplitMode
+		inputPath              string
+		expectError            bool
+		expectedError          error
+		expectOutputPathsCount int
+		expectOutputPaths      []string
+	}{
+		{
+			scenario:               "ErrPdfSplitModeNotSupported",
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "ErrPdfSplitModeNotSupported (no unify with pages)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1", Unify: false},
+			expectError:            true,
+			expectedError:          gotenberg.ErrPdfSplitModeNotSupported,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid context",
+			ctx:                    nil,
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "invalid input path",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			inputPath:              "",
+			expectError:            true,
+			expectOutputPathsCount: 0,
+		},
+		{
+			scenario:               "success (pages & unify)",
+			ctx:                    context.TODO(),
+			mode:                   gotenberg.SplitMode{Mode: gotenberg.SplitModePages, Span: "1-2", Unify: true},
+			inputPath:              "/tests/test/testdata/pdfengines/sample1.pdf",
+			expectError:            false,
+			expectOutputPathsCount: 1,
+		},
+	} {
+		t.Run(tc.scenario, func(t *testing.T) {
+			engine := new(QPdf)
+			err := engine.Provision(nil)
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			fs := gotenberg.NewFileSystem(new(gotenberg.OsMkdirAll))
+			outputDir, err := fs.MkdirAll()
+			if err != nil {
+				t.Fatalf("expected error but got: %v", err)
+			}
+
+			defer func() {
+				err = os.RemoveAll(fs.WorkingDirPath())
+				if err != nil {
+					t.Fatalf("expected no error while cleaning up but got: %v", err)
+				}
+			}()
+
+			outputPaths, err := engine.Split(tc.ctx, zap.NewNop(), tc.mode, tc.inputPath, outputDir)
+
+			if !tc.expectError && err != nil {
+				t.Fatalf("expected no error but got: %v", err)
+			}
+
+			if tc.expectError && err == nil {
+				t.Fatal("expected error but got none")
+			}
+
+			if tc.expectedError != nil && !errors.Is(err, tc.expectedError) {
+				t.Fatalf("expected error %v but got: %v", tc.expectedError, err)
+			}
+
+			if tc.expectOutputPathsCount != len(outputPaths) {
+				t.Errorf("expected %d output paths but got %d", tc.expectOutputPathsCount, len(outputPaths))
+			}
+		})
+	}
+}
+
 func TestQPdf_Convert(t *testing.T) {
 	engine := new(QPdf)
 	err := engine.Convert(context.TODO(), zap.NewNop(), gotenberg.PdfFormats{}, "", "")
--- a/pkg/modules/webhook/client.go
+++ b/pkg/modules/webhook/client.go
@@ -27,9 +27,9 @@ type client struct {

 // send call the webhook either to send the success response or the error response.
 func (c client) send(body io.Reader, headers map[string]string, erroed bool) error {
-	URL := c.url
+	url := c.url
 	if erroed {
-		URL = c.errorUrl
+		url = c.errorUrl
 	}

 	method := c.method
@@ -37,9 +37,9 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err
 		method = c.errorMethod
 	}

-	req, err := retryablehttp.NewRequest(method, URL, body)
+	req, err := retryablehttp.NewRequest(method, url, body)
 	if err != nil {
-		return fmt.Errorf("create '%s' request to '%s': %w", method, URL, err)
+		return fmt.Errorf("create '%s' request to '%s': %w", method, url, err)
 	}

 	req.Header.Set("User-Agent", "Gotenberg")
@@ -75,17 +75,17 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err

 	resp, err := c.client.Do(req)
 	if err != nil {
-		return fmt.Errorf("send '%s' request to '%s': %w", method, URL, err)
+		return fmt.Errorf("send '%s' request to '%s': %w", method, url, err)
 	}

 	if resp.StatusCode >= http.StatusBadRequest {
-		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, URL, resp.Status)
+		return fmt.Errorf("send '%s' request to '%s': got status: '%s'", method, url, resp.Status)
 	}

 	defer func() {
 		err := resp.Body.Close()
 		if err != nil {
-			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", URL, err))
+			c.logger.Error(fmt.Sprintf("close response body from '%s': %s", url, err))
 		}
 	}()

@@ -94,7 +94,7 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err

 	// Now let's log!
 	fields := make([]zap.Field, 5)
-	fields[0] = zap.String("webhook_url", URL)
+	fields[0] = zap.String("webhook_url", url)
 	fields[1] = zap.String("method", method)
 	fields[2] = zap.Int64("latency", int64(finishTime.Sub(c.startTime)))
 	fields[3] = zap.String("latency_human", finishTime.Sub(c.startTime).String())
@@ -110,34 +110,3 @@ func (c client) send(body io.Reader, headers map[string]string, erroed bool) err

 	return nil
 }
-
-// leveledLogger is wrapper around a [zap.Logger] which is used by the
-// [retryablehttp.Client].
-type leveledLogger struct {
-	logger *zap.Logger
-}
-
-// Error logs a message at error level using the wrapped zap.Logger.
-func (leveled leveledLogger) Error(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Error(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Warn logs a message at warning level using the wrapped zap.Logger.
-func (leveled leveledLogger) Warn(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Warn(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Info logs a message at info level using the wrapped zap.Logger.
-func (leveled leveledLogger) Info(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Info(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Debug logs a message at debug level using the wrapped zap.Logger.
-func (leveled leveledLogger) Debug(msg string, keysAndValues ...interface{}) {
-	leveled.logger.Debug(fmt.Sprintf("%s: %+v", msg, keysAndValues))
-}
-
-// Interface guards.
-var (
-	_ retryablehttp.LeveledLogger = (*leveledLogger)(nil)
-)
--- a/pkg/modules/webhook/middleware.go
+++ b/pkg/modules/webhook/middleware.go
@@ -100,11 +100,11 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 					}

 					// What about extra HTTP headers?
-					var extraHTTPHeaders map[string]string
+					var extraHttpHeaders map[string]string

-					extraHTTPHeadersJSON := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
-					if extraHTTPHeadersJSON != "" {
-						err = json.Unmarshal([]byte(extraHTTPHeadersJSON), &extraHTTPHeaders)
+					extraHttpHeadersJson := c.Request().Header.Get("Gotenberg-Webhook-Extra-Http-Headers")
+					if extraHttpHeadersJson != "" {
+						err = json.Unmarshal([]byte(extraHttpHeadersJson), &extraHttpHeaders)
 						if err != nil {
 							return api.WrapError(
 								fmt.Errorf("unmarshal webhook extra HTTP headers: %w", err),
@@ -113,13 +113,19 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}
 					}

+					// Retrieve values from echo.Context before it get recycled.
+					// See https://github.com/gotenberg/gotenberg/issues/1000.
+					startTime := c.Get("startTime").(time.Time)
+					traceHeader := c.Get("traceHeader").(string)
+					trace := c.Get("trace").(string)
+
 					client := &client{
 						url:              webhookUrl,
 						method:           webhookMethod,
 						errorUrl:         webhookErrorUrl,
 						errorMethod:      webhookErrorMethod,
-						extraHttpHeaders: extraHTTPHeaders,
-						startTime:        c.Get("startTime").(time.Time),
+						extraHttpHeaders: extraHttpHeaders,
+						startTime:        startTime,

 						client: &retryablehttp.Client{
 							HTTPClient: &http.Client{
@@ -128,11 +134,9 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 							RetryMax:     w.maxRetry,
 							RetryWaitMin: w.retryMinWait,
 							RetryWaitMax: w.retryMaxWait,
-							Logger: leveledLogger{
-								logger: ctx.Log(),
-							},
-							CheckRetry: retryablehttp.DefaultRetryPolicy,
-							Backoff:    retryablehttp.DefaultBackoff,
+							Logger:       gotenberg.NewLeveledLogger(ctx.Log()),
+							CheckRetry:   retryablehttp.DefaultRetryPolicy,
+							Backoff:      retryablehttp.DefaultBackoff,
 						},
 						logger: ctx.Log(),
 					}
@@ -159,8 +163,8 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 						}

 						headers := map[string]string{
-							echo.HeaderContentType:        echo.MIMEApplicationJSON,
-							c.Get("traceHeader").(string): c.Get("trace").(string),
+							echo.HeaderContentType: echo.MIMEApplicationJSON,
+							traceHeader:            trace,
 						}

 						err = client.send(bytes.NewReader(b), headers, true)
@@ -238,7 +242,7 @@ func webhookMiddleware(w *Webhook) api.Middleware {
 							echo.HeaderContentDisposition: fmt.Sprintf("attachement; filename=%q", ctx.OutputFilename(outputPath)),
 							echo.HeaderContentType:        http.DetectContentType(fileHeader),
 							echo.HeaderContentLength:      strconv.FormatInt(fileStat.Size(), 10),
-							c.Get("traceHeader").(string): c.Get("trace").(string),
+							traceHeader:                   trace,
 						}

 						// Send the output file to the webhook.
--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -2,50 +2,61 @@

 set -e

+# Args.
 GOLANG_VERSION="$1"
 GOTENBERG_VERSION="$2"
 GOTENBERG_USER_GID="$3"
 GOTENBERG_USER_UID="$4"
 NOTO_COLOR_EMOJI_VERSION="$5"
 PDFTK_VERSION="$6"
-DOCKER_REPOSITORY="$7"
-
-if [ "$GOTENBERG_VERSION" == "edge" ]; then
-  docker buildx build \
-    --build-arg GOLANG_VERSION="$GOLANG_VERSION" \
-    --build-arg GOTENBERG_VERSION="$GOTENBERG_VERSION" \
-    --build-arg GOTENBERG_USER_GID="$GOTENBERG_USER_GID" \
-    --build-arg GOTENBERG_USER_UID="$GOTENBERG_USER_UID" \
-    --build-arg NOTO_COLOR_EMOJI_VERSION="$NOTO_COLOR_EMOJI_VERSION" \
-    --build-arg PDFTK_VERSION="$PDFTK_VERSION" \
-    --platform linux/amd64 \
-    --platform linux/arm64 \
-    --platform linux/386 \
-    --platform linux/arm/v7 \
-    -t "$DOCKER_REPOSITORY/gotenberg:edge" \
-    --push \
-    -f build/Dockerfile .
-
-  # Cloud Run variant.
-  # Only linux/amd64! See https://github.com/gotenberg/gotenberg/issues/505#issuecomment-1264679278.
-  docker buildx build \
-    --build-arg DOCKER_REPOSITORY="$DOCKER_REPOSITORY" \
-    --build-arg GOTENBERG_VERSION="$GOTENBERG_VERSION" \
-    --platform linux/amd64 \
-    -t "$DOCKER_REPOSITORY/gotenberg:edge-cloudrun" \
-    --push \
-    -f build/Dockerfile.cloudrun .
-
-  exit 0
-fi
+PDFCPU_VERSION="$7"
+DOCKER_REGISTRY="$8"
+DOCKER_REPOSITORY="$9"
+LINUX_AMD64_RELEASE="${10}"

+# Find out if given version is "semver".
 GOTENBERG_VERSION="${GOTENBERG_VERSION//v}"
 IFS='.' read -ra SEMVER <<< "$GOTENBERG_VERSION"
 VERSION_LENGTH=${#SEMVER[@]}
+TAGS=()
+TAGS_CLOUD_RUN=()

-if [ "$VERSION_LENGTH" -ne 3 ]; then
-  echo "$VERSION is not semver."
-  exit 1
+if [ "$VERSION_LENGTH" -eq 3 ]; then
+  MAJOR="${SEMVER[0]}"
+  MINOR="${SEMVER[1]}"
+  PATCH="${SEMVER[2]}"
+
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:latest")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR")
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR.$PATCH")
+
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:latest-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR-cloudrun")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$MAJOR.$MINOR.$PATCH-cloudrun")
+else
+    # Normalizes version.
+    GOTENBERG_VERSION="${GOTENBERG_VERSION// /-}"
+    GOTENBERG_VERSION="$(echo "$GOTENBERG_VERSION" | tr -cd '[:alnum:]._\-')"
+
+    if [[ "$GOTENBERG_VERSION" =~ ^[\.\-] ]]; then
+      GOTENBERG_VERSION="_${GOTENBERG_VERSION#?}"
+    fi
+
+    if [ "${#GOTENBERG_VERSION}" -gt 128 ]; then
+      GOTENBERG_VERSION="${GOTENBERG_VERSION:0:128}"
+    fi
+
+  TAGS+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION")
+  TAGS_CLOUD_RUN+=("-t" "$DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION-cloudrun")
+fi
+
+# Multi-arch build takes a lot of time.
+if [ "$LINUX_AMD64_RELEASE" = true ]; then
+    PLATFORM_FLAG="--platform linux/amd64"
+else
+    PLATFORM_FLAG="--platform linux/amd64,linux/arm64,linux/386,linux/arm/v7"
 fi

 docker buildx build \
@@ -55,26 +66,19 @@ docker buildx build \
  --build-arg GOTENBERG_USER_UID="$GOTENBERG_USER_UID" \
  --build-arg NOTO_COLOR_EMOJI_VERSION="$NOTO_COLOR_EMOJI_VERSION" \
  --build-arg PDFTK_VERSION="$PDFTK_VERSION" \
-  --platform linux/amd64 \
-  --platform linux/arm64 \
-  --platform linux/386 \
-  --platform linux/arm/v7 \
-  -t "$DOCKER_REPOSITORY/gotenberg:latest" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}.${SEMVER[2]}" \
+  --build-arg PDFCPU_VERSION="$PDFCPU_VERSION" \
+  $PLATFORM_FLAG \
+  "${TAGS[@]}" \
  --push \
  -f build/Dockerfile .

 # Cloud Run variant.
 # Only linux/amd64! See https://github.com/gotenberg/gotenberg/issues/505#issuecomment-1264679278.
 docker buildx build \
+  --build-arg DOCKER_REGISTRY="$DOCKER_REGISTRY" \
  --build-arg DOCKER_REPOSITORY="$DOCKER_REPOSITORY" \
  --build-arg GOTENBERG_VERSION="$GOTENBERG_VERSION" \
  --platform linux/amd64 \
-  -t "$DOCKER_REPOSITORY/gotenberg:latest-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}-cloudrun" \
-  -t "$DOCKER_REPOSITORY/gotenberg:${SEMVER[0]}.${SEMVER[1]}.${SEMVER[2]}-cloudrun" \
+  "${TAGS_CLOUD_RUN[@]}" \
  --push \
-  -f build/Dockerfile.cloudrun .
+  -f build/Dockerfile.cloudrun .
--- a/test/Dockerfile
+++ b/test/Dockerfile
@@ -1,19 +1,20 @@
 ARG GOLANG_VERSION
+ARG DOCKER_REGISTRY
 ARG DOCKER_REPOSITORY
 ARG GOTENBERG_VERSION
 ARG GOLANGCI_LINT_VERSION

-FROM golang:$GOLANG_VERSION-bookworm as golang
+FROM golang:$GOLANG_VERSION-bookworm AS golang

 # We're extending the Gotenberg's Docker image because our code relies on external
 # dependencies like Google Chrome, LibreOffice, etc.
-FROM $DOCKER_REPOSITORY/gotenberg:$GOTENBERG_VERSION
+FROM $DOCKER_REGISTRY/$DOCKER_REPOSITORY:$GOTENBERG_VERSION

 USER root

-ENV GOPATH /go
-ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
-ENV CGO_ENABLED 1
+ENV GOPATH=/go
+ENV PATH=$GOPATH/bin:/usr/local/go/bin:$PATH
+ENV CGO_ENABLED=1

 COPY --from=golang /usr/local/go /usr/local/go

--- a/test/testdata/chromium/html/index.html
+++ b/test/testdata/chromium/html/index.html
@@ -2,6 +2,12 @@
 <html lang="en">
 <head>
    <meta charset="utf-8">
+    <!-- net::ERR_FILE_NOT_FOUND -->
+    <link rel="stylesheet" type="text/css" href="doesnotexist.css">
+    <!-- net::ERR_CONNECTION_REFUSED -->
+    <link rel="stylesheet" type="text/css" href="http://localhost:100/style.css">
+    <!-- 400 Bad Request -->
+    <link rel="stylesheet" type="text/css" href="https://httpstat.us/400">
    <link rel="stylesheet" type="text/css" href="style.css">
    <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
    <title>Gutenberg</title>
@@ -23,7 +29,7 @@

    <blockquote cite="https://sites.google.com/site/johanngutenbergper5/q">
        <p>It is a press, certainly, but a press from which shall flow in inexhaustible streams...Through it, God will spread His Word. A spring of truth shall flow from it: like a new star it shall scatter the darkness of ignorance, and cause a light heretofore unknown to shine amongst men.</p>
-        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></cite></footer>
+        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></footer>
    </blockquote>
 </div>

--- a/test/testdata/chromium/markdown/index.html
+++ b/test/testdata/chromium/markdown/index.html
@@ -2,6 +2,12 @@
 <html lang="en">
 <head>
    <meta charset="utf-8">
+    <!-- net::ERR_FILE_NOT_FOUND -->
+    <link rel="stylesheet" type="text/css" href="doesnotexist.css">
+    <!-- net::ERR_CONNECTION_REFUSED -->
+    <link rel="stylesheet" type="text/css" href="http://localhost:100/style.css">
+    <!-- 400 Bad Request -->
+    <link rel="stylesheet" type="text/css" href="https://httpstat.us/400">
    <link rel="stylesheet" type="text/css" href="style.css">
    <link href="https://fonts.googleapis.com/css?family=Montserrat" rel="stylesheet">
    <title>Gutenberg</title>
@@ -15,7 +21,7 @@

    <blockquote cite="https://sites.google.com/site/johanngutenbergper5/q">
        <p>It is a press, certainly, but a press from which shall flow in inexhaustible streams...Through it, God will spread His Word. A spring of truth shall flow from it: like a new star it shall scatter the darkness of ignorance, and cause a light heretofore unknown to shine amongst men.</p>
-        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></cite></footer>
+        <footer>— <a href="https://sites.google.com/site/johanngutenbergper5/q">Johannes Gutenberg</a></footer>
    </blockquote>
 </div>

--- a/test/testdata/libreoffice/protected.docx
+++ b/test/testdata/libreoffice/protected.docx
Author	SHA1	Message	Date
Julien Neuhart	16807bd57f	fix(split): wrong output paths when converting to PDF/A & PDF/UA	2024-12-23 10:04:24 +01:00
Julien Neuhart	8bc29ad92d	feat(split): add splitUnify form field	2024-12-21 12:45:20 +01:00
Julien Neuhart	51a913a5e4	chore(deps): update Go depencies	2024-12-20 16:16:32 +01:00
Julien Neuhart	c30da805b3	feat(pdfengines): add split feature	2024-12-20 16:16:32 +01:00
Julien Neuhart	42ee593708	chore(pdfengines): add stubs for common workflows	2024-11-25 09:28:42 +01:00
Julien Neuhart	1b49b35365	fix(exiftool): convert interface{} array to string array	2024-11-21 09:55:10 +01:00
Julien Neuhart	333ab7066c	chore(libreoffice): remove non-relevant comment about old gc module	2024-11-19 14:25:07 +01:00
Julien Neuhart	66dbdc09b5	chore(deps): update Go dependencies	2024-11-18 09:39:32 +01:00
Tam Nguyen	79f396f6ff	feat(chromium): add GenerateDocumentOutline option	2024-11-18 08:58:26 +01:00
Julien Neuhart	62ba4877ac	chore(deps): update golangci-lint	2024-11-05 11:53:20 +01:00
Julien Neuhart	e65a5e6d22	chore(deps): update Go dependencies	2024-11-05 11:44:29 +01:00
Julien Neuhart	711b43070d	feat(chromium): add failOnResourceLoadingFailed and failOnResourceHttpStatusCodes form fields	2024-11-05 11:44:01 +01:00
Julien Neuhart	b2f957d1d8	chore(pdfengines): update new flags with a description of the empty value behavior	2024-10-14 09:24:42 +02:00
Julien Neuhart	249745f256	feat(pdfengines): one flag per PDF engine method for a more granular selection of PDF engines	2024-10-13 11:59:26 +02:00
Julien Neuhart	8ff9d3bcf1	feat(chromium): add scope to extraHttpHeaders	2024-10-11 13:45:07 +02:00
Julien Neuhart	99c328c302	fix(ci): LINUX_AMD64_RELEASE is no more ignored thanks to curly braces	2024-10-10 13:27:36 +02:00
Julien Neuhart	8a9f0a245e	chore(api): improve --api-body-limit flag description to include examples	2024-10-08 19:58:08 +02:00
Julien Neuhart	9daecc127a	chore(deps): update Go dependencies	2024-10-08 19:58:08 +02:00
Julien Neuhart	119bba4f04	feat(api): add flag --api-bind-ip	2024-10-08 19:58:08 +02:00
Julien Neuhart	bf205c579d	fix(pdfcpu): switch to CLI	2024-10-06 18:32:09 +02:00
Julien Neuhart	aa57b17254	chore(deps): update Go dependencies	2024-10-06 09:52:48 +02:00
Julien Neuhart	7df786c5c6	fix(webhook): retrieve values from echo.Context before it get recycled	2024-10-05 14:24:22 +02:00
Julien Neuhart	b315464e98	chore(deps): update Noto Color Emoji to Unicode 16.0	2024-10-05 11:46:00 +02:00
Julien Neuhart	1252ea076b	feat(chromium): skipNetworkIdleEvent is now true by default	2024-09-29 18:04:37 +02:00
Julien Neuhart	d970e446a8	chore(deps): update Go dependencies	2024-09-29 17:47:51 +02:00
Julien Neuhart	fe40f3727b	feat(api): add --api-body-limit flag that set the body limit for multipart/form-data requests	2024-09-29 17:46:20 +02:00
Julien Neuhart	10a290b065	chore(libreoffice): improve HTTP error messages	2024-09-29 13:19:44 +02:00
Julien Neuhart	0abb11b42a	chore(deps): update Go dependencies	2024-09-21 09:52:48 +02:00
Julien Neuhart	1eb6eb729a	chore(downloadFrom): add godoc for issue https://github.com/golang/go/issues/69551	2024-09-20 21:06:11 +02:00
Julien Neuhart	e371a4a3c3	fix: add DOCKER_REGISTRY for tests image	2024-09-20 21:06:11 +02:00
Julien Neuhart	f2b6bd3d4b	feat(api): add 'downloadForm' form field	2024-09-20 21:06:11 +02:00
Julien Neuhart	d21f87b543	feat(ci): add snapshot release	2024-09-20 21:06:11 +02:00
Julien Neuhart	b8cdee4f45	fix(cmd): failing test	2024-09-20 20:58:17 +02:00
Julien Neuhart	b06d7445d9	feat(libreoffice): add password form field for converting protected document	2024-09-20 20:36:45 +02:00
Julien Neuhart	2aa9cceb32	fix(README): wrong link to thecodingmachine/gotenberg repository	2024-09-18 07:57:22 +02:00
Julien Neuhart	ae2a2a8a07	chore: improve README	2024-09-17 16:47:52 +02:00
Julien Neuhart	286555411b	chore(supervisor): add a comment about an unlikely issue	2024-09-17 16:47:41 +02:00
Julien Neuhart	3c42aec180	chore(deps): update Go dependencies	2024-09-13 16:47:31 +02:00
Julien Neuhart	a203ae00c6	fix(cmd): leaking error logs if reader already closed	2024-09-13 16:47:03 +02:00
Julien Neuhart	68784616a4	chore(godoc): removing dots	2024-09-13 16:44:12 +02:00
Julien Neuhart	5cd8c6a5da	feat(api): add HEAD method for health route (#963 )	2024-09-07 17:31:43 +02:00
Julien Neuhart	a3647fea8a	fix(chromium): increase the scope of loading failed errors (#962 )	2024-09-07 15:54:01 +02:00
Julien Neuhart	300e73f07d	chore(deps): update Go dependencies	2024-09-05 09:23:33 +02:00
Gabriel Vasile	03ced23f05	fix(deps): download go1.23 toolchain not available (#957 )	2024-09-05 09:22:59 +02:00
Julien Neuhart	da8eeb5d8f	fix(golangci-lint): false positive and remove deprecated exportloopref linter	2024-09-03 09:59:40 +02:00
Julien Neuhart	16cf02896f	chore(deps): update Go dependencies + Golang to 1.23	2024-09-03 09:45:36 +02:00
Julien Neuhart	c9f10d248e	fix(libreoffice): use default options in PDF engines method - resolves #939	2024-08-11 14:53:05 +02:00
Julien Neuhart	3297e41289	chore(deps): update Golang dependencies	2024-07-29 10:22:08 +02:00
Julien Neuhart	4e1b347797	feat(libreoffice): retry on core dumped (#930 )	2024-07-23 14:21:09 +02:00
Julien Neuhart	4602332dbb	chore(Dockerfile): remove legacy alerts	2024-07-19 15:16:30 +02:00
Julien Neuhart	e1f69ee533	chore(deps): update Golang dependencies	2024-07-18 14:35:38 +02:00
Julien Neuhart	d90e431b5b	fix(libreoffice): add PDFUACompliance arg	2024-07-11 15:14:50 +02:00
Julien Neuhart	45a9eca0ce	chore(sponsors): new Zolsec logo	2024-07-04 15:58:24 +02:00
Julien Neuhart	af202f4871	chore(sponsors): move down sponsorship link	2024-07-04 15:04:57 +02:00
Julien Neuhart	7b32fa35f3	feat(sponsors): add Zolsec sponsorship	2024-07-04 15:03:30 +02:00
Julien Neuhart	0c40b230dc	chore(libreoffice): fix wrong comment on quality option	2024-07-03 10:35:23 +02:00
Maxime Lapointe	2baba67bfc	feat: eagerly auto restart processes (#916 ) * Fix auto-restart's initial number of requests It would need 1 less requests on the first restart The number of request was technically off by one after the first restart * Supervisor now eagerly restarts processes When the maxReqLimit is reached, restart the process in the background * Update pkg/gotenberg/supervisor.go Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com> --------- Co-authored-by: Julien Neuhart <neuhart.julien@gmail.com>	2024-07-02 18:29:57 +02:00
Julien Neuhart	b1e69a9059	feat: add FUNDING.yml	2024-07-02 17:07:42 +02:00
Julien Neuhart	f87362ec1b	feat(chromium): HTTP Bad Request on net::ERR_CONNECTION_REFUSED	2024-07-01 13:40:12 +02:00
Julien Neuhart	84dc57373a	feat(libreoffice): add many more options for conversions	2024-06-30 21:34:57 +02:00
Julien Neuhart	b3f4a02658	chore(chromium): add missing tests on default options	2024-06-30 20:40:40 +02:00
Julien Neuhart	50304dbefe	chore(chromium): remove some 'Optional' comments	2024-06-27 11:53:18 +02:00
Julien Neuhart	bf01af0bf3	chore(deps): update Golang dependencies	2024-06-27 11:32:49 +02:00
Julien Neuhart	0e3fe3463b	chore(stale): recude number of days of inactivity	2024-06-21 20:39:34 +02:00
Julien Neuhart	3956763825	fix(api): basic auth only for modules' routes	2024-06-21 20:38:30 +02:00
maniack	d6fe895f6e	feat(libreoffice): add exportNotesInMargin form field (#904 ) * ExportNotesInMargin allows to export comments in margin https://help.libreoffice.org/latest/en-US/text/shared/guide/pdf_params.html * Resolve requested changes Move ExportNotesInMargin above LosslessImageCompression Remove overhead ExportNotes=true	2024-06-17 08:31:42 +02:00