NextPDF FAQ

At a glance

This page answers the questions that come up first when you evaluate NextPDF or start a new project. Each answer is short and links to the page that covers it in full. NextPDF is a PHP 8.4 engine that generates and inspects Portable Document Format (PDF) 2.0 documents, the file format defined by ISO 32000-2.

If you are brand new, read Get started first, then come back here for the specifics.

Getting started

Which edition do I need: Core, Pro, or Enterprise?

Start with Core. The open-source core (nextpdf/core) generates PDF output, renders supported HTML into PDFs, and inspects PDFs under the Apache-2.0 license and at no cost. Core already produces CMS SignedData signatures for the PDF Advanced Electronic Signatures (PAdES) B-B and B-T baseline levels. Choose Pro when you need advanced generation and document operations, electronic-invoice output (Factur-X / ZUGFeRD), or advanced signing workflows such as remote, cloud-KMS, and sequential signing. Choose Enterprise when you need PDF/A archival authoring workflows, the PAdES long-term levels (B-LT / B-LTA) with a Document Security Store and document timestamps, hardware-backed signing through a hardware security module (HSM), or qualified electronic signatures. Pro and Enterprise are the two licensed editions of NextPDF Premium, the paid line; see Choose your path.

Is it really Apache-2.0?

Yes, for the core. nextpdf/core declares "license": "Apache-2.0" and ships the full Apache License 2.0 text in its LICENSE file. You may use, modify, redistribute, and commercialize the core, subject to the attribution and NOTICE requirements (Apache-2.0 §4). NextPDF Pro and NextPDF Enterprise are proprietary commercial editions and are not covered by that license. The NextPDF name and logo are trademarks, separate from the code license. See Product licensing.

What is the minimum PHP version?

PHP 8.4. The package constraint is >=8.4 <9.0, so Composer refuses to install on PHP 8.3 or below, or on PHP 9. NextPDF targets one modern runtime and uses its language features directly. See Install NextPDF.

Does it need an external binary or a headless browser?

No, not for the core engine. The native engine is implemented in PHP and standard PHP extensions, with no external PDF binary and no mandatory headless browser: the fluent API and the built-in writeHtml() HTML pipeline run in-process with no browser and no network call. A Chrome or Chromium binary is optional and only needed for the Artisan renderer (writeHtmlChrome()), which you install separately as nextpdf/artisan. The Cloudflare and Gotenberg bridges are also optional and call out to a service. See Choose your path.

Which PHP extensions does it require?

The core’s composer.json requires the standard extensions ext-mbstring, ext-zlib, ext-intl, ext-gd, ext-curl, and ext-openssl, which are commonly available PHP extensions; ensure they are installed and enabled in your runtime. ext-curl backs the optional network round-trips — RFC 3161 timestamping and remote asset fetches — so offline native generation does not exercise it, but Composer still lists it as a hard requirement. Integrations check for the ones they need during boot and stop with a clear message if any are missing. The full list lives in the package composer.json; see Install NextPDF.

How do I generate my first PDF?

Install the core, then build a document with the fluent API:

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use NextPDF\Core\Document;

$document = Document::createStandalone();
$document->addPage();
$document->setFont('helvetica', 'B', 24);
$document->cell(0, 15, 'Hello, NextPDF!', newLine: true);
$document->save(__DIR__ . '/first.pdf');

Walk through it step by step in Your first PDF.

Editions and licensing

Does Core have any feature limits or watermark?

No. Core is the open-source engine for the Core feature set with no watermark and no nag screen. For the Core feature set — generation, inspection, encryption, PDF/A and PDF/UA output primitives, and software-key B-B/B-T signing (without the Premium long-term-validation and key-custody workflows) — Core is complete. The evaluation watermark applies only to a Premium evaluation grant, where you test the full Pro and Enterprise feature set behind a removable mark; a paid license removes it with no application code change. See Licensing and activation.

Do I need code changes to upgrade to Pro or Enterprise?

Mostly not. When you install nextpdf/premium, the framework integrations and the server detect it automatically and expose the extra capabilities. Most applications keep the same high-level integration points; some Premium workflows may require configuration or feature-specific calls. You activate a signed license envelope once per deployment. See Licensing and activation.

Can I use the core in a closed-source commercial product?

Yes. The Apache License 2.0 has no non-commercial restriction. You may use the core in closed-source, paid, or internal commercial products, provided you honor the attribution and NOTICE obligations and do not treat the code license as permission to use the NextPDF brand. See Product licensing and Trademark and brand use.

Capabilities

Can it read and parse PDFs, or only write them?

Both, with a caveat. NextPDF writes PDFs and also reads them: the Inspect module reads an existing file into a structured InspectResult with complexity, font, image, and risk data, and you can merge and split existing documents. Inspect is marked experimental, so its result shape may change between minor versions — use it for diagnostics and gating, not as a long-lived contract. See the Inspect module.

Does it produce selectable, searchable text?

Yes. Both the fluent API and the built-in writeHtml() pipeline emit real text content, not rasterized images, so the output is selectable and searchable. The Artisan renderer’s writeHtmlChrome() also keeps text selectable. See Your first PDF.

How does HTML and CSS rendering work?

The core engine includes a pure-PHP HTML pipeline. writeHtml() renders an HTML fragment with a supported subset of CSS directly into the page, with no browser and no network call. When a layout needs full browser fidelity — such as flexbox, grid, or web fonts — install the Artisan renderer and call writeHtmlChrome(). Before you rely on a property, check the CSS support matrix.

How do fonts work?

The built-in standard font aliases such as Helvetica work with no setup for simple WinAnsi text, so your first document needs no font files. The built-in Latin standard fonts suit basic WinAnsi text; Symbol and ZapfDingbats use their own encodings; to render other scripts you register and embed a font whose character map and shaping path support that script. See the font support matrix and the Font module.

Does it support PDF/A and accessibility (PDF/UA)?

Yes, with a clear boundary: support for a profile is not conformance. The core ships the conformance discriminator and tagging primitives — enableTaggedPdf() enables tagged-PDF structure output used for PDF/UA workflows, and enablePdfA() selects a PDF/A output profile in Core; the Premium editions add higher-level archival authoring workflows and tooling (validation, policy, and production operations) on top. NextPDF emits the structural artifacts a profile requires; an independent validator such as veraPDF decides whether a given file actually conforms. See Conformance and the Accessibility module.

How do I sign a PDF?

The core can produce Cryptographic Message Syntax (CMS) SignedData signatures and can apply RFC 3161 timestamps (the B-T level), using supported software-key algorithms through the configured signing provider. Your code depends on the SignerInterface contract, so the same call works across editions. The PAdES B-LT and B-LTA long-term levels, HSM and PKCS#11 key custody, and qualified signatures are Enterprise capabilities; cloud and KMS-backed signing workflows ship in Pro. Core produces the B-B and B-T baseline structures. See the Signing module.

Production

Is it worker-safe and thread-safe?

A Document is single-use: once you have written one, create a fresh instance for the next document rather than reusing it. This makes it a natural fit for the per-request, per-job model used by PHP-FPM, queue workers, and frameworks — each unit of work builds its own document. When you parse or compose untrusted input, run that work in a constrained worker and keep the resource guards (maxFiles, maxTotalBytes, maxBytes) tight. See the Document module and the engine threat model.

Is the output deterministic?

It is structurally deterministic, but not byte-for-byte identical by default. Two runs of the same input produce structurally equal PDFs, but each carries a fresh trailer and document /ID, so the bytes differ. Signing and timestamps add further per-run variation by design. Plan comparisons around structural equality, or normalize the volatile fields, rather than expecting identical bytes across runs.

How do I deploy it?

Commit composer.lock so every deployed worker resolves the same engine version, then deploy as you would any PHP library — native generation needs no daemon, browser, or network; timestamping (B-T), remote assets, or the optional browser bridge require configured network access. If non-PHP services need the engine, run NextPDF Server, which exposes it over Model Context Protocol (MCP), REST, and gRPC. For Premium, place the signed license envelope where the deployment loads it and run the one-time activation step; cached license state means normal processing needs no license service, so air-gapped deployments are supported. See Install NextPDF and Licensing and activation.

Where do I take a failure when something goes wrong?

NextPDF reports errors by PHP exception class, not by a string error code, and context-aware exceptions carry structured diagnostic fields. The Troubleshooting maps common signature, PDF/A, PDF/UA, font, tagging, and encryption failures to their cause and resolution.