How to Generate a PDF From a JavaServer Faces Page With wkhtmltopdf

To generate a PDF from a JavaServer Faces (JSF) page, first expose or build print-ready HTML that wkhtmltopdf can load, then run the command-line renderer from your Java application and return its PDF bytes as an HTTP response. The renderer is a separate process—not a JSF component or Java API—so you must plan how it reaches the page, its assets, and any required data. After writing the PDF response, tell Faces the response is complete so it does not render a second view.

How the JSF-to-PDF flow works

JSF renders a view into HTML. wkhtmltopdf loads a URL or HTML input and converts it to PDF using Qt WebKit. Your Java application starts the executable, checks that conversion succeeded, and sends the resulting bytes to the browser with the content type application/pdf.

#	Preview	Product	Price
1		Core JavaServer Faces (Sun Core Series)	$7.22	Buy on Amazon
2		JavaServer Faces 2.0, The Complete Reference	$43.87	Buy on Amazon
3		Core JavaServer Faces	$19.99	Buy on Amazon
4		JavaServer Faces: Introduction by Example	$37.99	Buy on Amazon
5		Mastering JavaServer Faces (Java)	$36.17	Buy on Amazon

1. Prepare the print view. It should include the data, styles, fonts, and images required in the document, without interactive controls that make sense only on screen.
2. Make the input reachable. The renderer must be able to fetch the page and every resource from the machine or container where it runs.
3. Run conversion safely. Invoke a known executable with controlled arguments, enforce a timeout, and verify the output.
4. Return the PDF, not a JSF page. Set the response headers, write the binary stream, and complete the Faces response.

The official project describes wkhtmltopdf as a headless command-line tool that renders HTML to PDF using Qt WebKit. Its basic model is a command such as wkhtmltopdf http://host/path/print-view output.pdf. Because it is a separate process, browser state does not automatically carry over: a user being logged in to the JSF application in their browser does not mean the renderer is logged in too.

Choose a URL or an HTML file as the input

Either approach can work. Choose based on how your application can provide a safe, complete print document—not on an assumed performance difference. No JSF-specific benchmark establishes one as faster.

#1 Best Overall

Core JavaServer Faces (Sun Core Series)

$7.22

Buy on Amazon

A URL is often convenient because the application already knows how to render the view. But URL conversion is not a way to inherit a browser session. Prefer a controlled design such as a narrowly scoped, short-lived token for a dedicated print route, or generate the artifact within the application. Do not put a reusable session identifier into a command, log, or long-lived URL. Restrict which hosts and routes can be fetched; an endpoint that accepts any submitted URL can be abused to make your server request internal services.

For HTML files, keep the document and its resources in a job-specific temporary directory with restrictive permissions. The manual provides local-file-access controls, including --disable-local-file-access and --allow for explicitly permitted paths. Avoid broad local file access: it can expose files available to the process if input or arguments are manipulated.

Install and check wkhtmltopdf on the application host

Install a build appropriate for the operating system and architecture that actually runs the Java process. Confirm package provenance and compatibility for that deployment target; the available project information does not establish a current support matrix for every operating system or distribution.

Rank #2

Sale

JavaServer Faces 2.0, The Complete Reference

• New
• Mint Condition
• Dispatch same day for order received before 12 noon
• Guaranteed packaging
• No quibbles returns

$43.87

Buy on Amazon

The project downloads page identifies version 0.12.6 as its stable series and gives June 11, 2020 as its release date. The project repository is marked archived. Treat those as version and maintenance context, not as evidence that the binary is a recently maintained browser engine. Validate your selected build against your deployment environment before relying on it.

Check that the executable is present and runnable under the same service account and container as the application. A shell test such as wkhtmltopdf --version can confirm that the executable starts; it does not establish that the production view, fonts, network access, or page breaks will work.

Run the renderer from a JSF action and return the PDF

This Java 11+ example uses ProcessBuilder directly, a fixed print URL, a temporary output file, and a 60-second process limit. Set the executable path and URL for your environment. The URL should be a dedicated, controlled print route, not a value copied from an untrusted request parameter. The example is an integration pattern; adapt exception handling and bean configuration to the Faces version and application.

Rank #3

Sale

Core JavaServer Faces

$19.99

Buy on Amazon

import jakarta.faces.context.ExternalContext;
import jakarta.faces.context.FacesContext;
import jakarta.inject.Named;
import jakarta.enterprise.context.RequestScoped;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.TimeUnit;

@Named
@RequestScoped
public class PdfDownloadBean {
    // Configure these for your deployment; do not accept them from the request.
    private static final String WKHTMLTOPDF = "/usr/local/bin/wkhtmltopdf";
    private static final String PRINT_URL = "http://app-internal/reports/monthly/print";

    public void download() throws IOException {
        Path pdf = Files.createTempFile("jsf-report-", ".pdf");
        Path log = Files.createTempFile("wkhtmltopdf-", ".log");
        Process process = null;
        try {
            ProcessBuilder builder = new ProcessBuilder(
                WKHTMLTOPDF,
                "--quiet",
                "--disable-local-file-access",
                "--page-size", "A4",
                PRINT_URL,
                pdf.toString()
            );
            builder.redirectErrorStream(true);
            builder.redirectOutput(log.toFile());
            process = builder.start();

            boolean finished;
            try {
                finished = process.waitFor(60, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IOException("PDF conversion was interrupted", e);
            }
            if (!finished) {
                process.destroyForcibly();
                throw new IOException("PDF conversion timed out");
            }
            if (process.exitValue() != 0 || Files.size(pdf) == 0) {
                String detail = Files.readString(log);
                throw new IOException("wkhtmltopdf failed: " + detail);
            }

            byte[] bytes = Files.readAllBytes(pdf);
            FacesContext faces = FacesContext.getCurrentInstance();
            ExternalContext response = faces.getExternalContext();
            response.responseReset();
            response.setResponseContentType("application/pdf");
            response.setResponseHeader(
                "Content-Disposition", "attachment; filename=report.pdf");
            response.setResponseHeader(
                "Content-Length", Integer.toString(bytes.length));
            response.getResponseOutputStream().write(bytes);
            response.getResponseOutputStream().flush();
            faces.responseComplete();
        } finally {
            if (process != null && process.isAlive()) {
                process.destroyForcibly();
            }
            Files.deleteIfExists(pdf);
            Files.deleteIfExists(log);
        }
    }
}

The sample disables local file access because it assumes the print page uses network-accessible resources. If your design intentionally needs local resources, grant access only to the specific directory with the manual’s allow-list mechanism; do not simply enable unrestricted access. If the renderer must authenticate to the application, add a controlled authentication mechanism rather than embedding credentials in a user-controlled URL or logging them as command arguments.

responseReset() discards any response content or headers already prepared before the download. The Faces API provides getResponseOutputStream() for binary data, while responseComplete() tells the Faces lifecycle not to continue with normal view rendering. Do not mix the response writer with the output stream for the same download. For very large PDFs, consider a streaming or file-backed response strategy appropriate to your server rather than loading the entire file into a byte array as this concise example does.

Set rendering options for the document

Start with the smallest set of explicit options that produces the required document. The command-line manual distinguishes global options from options that apply to individual page objects, and also documents table-of-contents and outline behavior.

Rank #4

JavaServer Faces: Introduction by Example

$37.99

Buy on Amazon

• Page size and orientation: choose the required paper size and landscape mode where appropriate. Add margins deliberately, especially when headers or footers need space.
• Headers and footers: configure them only when the output needs page numbers, dates, or repeated labels. Verify placement and clipping with the actual page design.
• JavaScript: JavaScript is enabled by default in the documented manual, and a configurable delay is available. A delay is not proof that asynchronous application state has finished loading.
• Page objects and contents: use per-page options for documents assembled from multiple inputs; use table-of-contents or outline features only when they fit the document.
• Local resources: keep local-file access disabled by default or limit it with an explicit allow-list. Use stable resource paths and ensure fonts and images are available in the renderer’s environment.

Render representative documents on the exact deployment OS and build. Check page breaks, long tables, Unicode glyphs, headers and footers, missing images, and any fields populated by JavaScript. If a page relies on a modern frontend framework or promises, test that exact output: the existence of a JavaScript delay does not guarantee that every modern page will render correctly in Qt WebKit.

Security, reliability, and cost considerations

The project downloads page warns against processing untrusted HTML: unsanitized user-supplied HTML or JavaScript may lead to complete server takeover. Treat the renderer as a security-sensitive process, not as a harmless formatting library.

• Accept only application-owned templates and allow-listed print routes. Do not expose a public conversion endpoint that fetches arbitrary URLs or accepts arbitrary HTML.
• Run the process with least privilege, restrict its network reachability, and keep local-file permissions narrow.
• Apply a timeout, cap the size and frequency of jobs, and clean up temporary files even when conversion fails.
• Keep renderer diagnostics out of public error responses. Log enough operational detail for administrators without recording secrets or sensitive document content.
• Check process exit status and verify that an output file exists and is non-empty before setting PDF response headers. A successful process launch alone does not mean conversion succeeded.

There is no supported throughput or rendering-accuracy figure established here, so capacity should be measured with your own representative documents and deployment resources. Conversion consumes server CPU and memory and may wait on page loads and assets; bound concurrent jobs to avoid overloading the web process. The tool itself is a command-line executable, not an official Java API. The project documents a pure C binding for PDF functionality, but no official Java wrapper is established here.

Best Value

Sale

Mastering JavaServer Faces (Java)

$36.17

Buy on Amazon

Troubleshoot common failures

Or skip the browser setup

If your goal is to capture a page already reachable over HTTP rather than run your own renderer, ScreenshotNeo offers a website screenshot API and MCP server. It is a separate service, not a Java wrapper around wkhtmltopdf; use it when its hosted capture workflow fits your page and output needs. This cURL call captures a reachable URL as WebP:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://your.example/print-view -o shot.webp

See the ScreenshotNeo API documentation for PDF output and other request options. ScreenshotNeo removes cookie/consent banners, newsletter popups, and chat widgets before capture; bot checks, blank pages, and failed loads are not billed. Its MCP server lets AI agents use screenshot tools, and its free plan includes 1,000 screenshots per month without a card; paid plans start at $5 for 3,000. These are service details, not a replacement for securing a JSF print route or testing the document layout you need.

Sign up for 1,000 free screenshots a month, with no card required.

Quick Recap

Bestseller No. 1

Core JavaServer Faces (Sun Core Series)

$7.22

SaleBestseller No. 2

JavaServer Faces 2.0, The Complete Reference

New; Mint Condition; Dispatch same day for order received before 12 noon; Guaranteed packaging

$43.87

SaleBestseller No. 3

Core JavaServer Faces

$19.99

Bestseller No. 4

JavaServer Faces: Introduction by Example

$37.99

SaleBestseller No. 5

Mastering JavaServer Faces (Java)

$36.17

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.