Does it support fillable AcroForm fields and inserting signatures?

“Signature” means two different things

People asking about signatures usually mean one of two jobs, and a PDF stores them very differently. DartPDF does both, and can combine them.

Fillable AcroForm fields

AcroForms are the standard interactive form fields defined by the PDF specification. They are what Acrobat, Word's PDF export, and most form designers produce. DartPDF finds every field in the document, including widgets a broken file left attached to a page but missing from the field tree, and handles each field type as follows:

The important detail is appearance generation. In a PDF, a field's value and how it looks on the page are stored separately. A library that only sets the value leaves a form that looks empty in some viewers, or that Acrobat redraws with its own layout. DartPDF redraws every field it fills, including wrapping, auto-sizing, quadding (alignment), borders, backgrounds, and page rotation, and then clears /NeedAppearances. The saved file looks the same in every viewer, and it prints correctly.

In a Flutter app

Form filling is on by default. PdfEditorView (the full editor) and PdfReader (the read-only viewer) both let users tap into fields. Tapping a text field opens an inline editor, checkboxes and radios toggle, choice fields open a menu, and image buttons open the host's image picker. To add form filling to a custom viewer, pass it an editing controller:

final session = PdfEditingController(pdfBytes);

PdfViewer(
  formController: session, // tap-to-fill, no editing toolbar
  formImagePicker: (context, field) => pickImageBytes(context),
);

// Or fill from code, e.g. to prefill from your backend:
session.setFormFieldText('applicant.name', 'Ada Lovelace');
session.toggleFormCheckBox('terms');
session.setFormChoiceValue('country', 'Australia');

final Uint8List filled = session.bytes;

Every change is an incremental revision, so undo and redo work for form input too.

In pure Dart (server, CLI, tests)

The form engine is in pdf_document, which has no Flutter dependency. That makes it a good fit for batch-filling a template on a server:

import 'package:pdf_document/pdf_document.dart';

Uint8List fillApplication(Uint8List template) {
  final editor = PdfEditor(PdfDocument.open(template));
  final form = editor.acroForm!;

  for (final field in form.fields) {
    print('${field.name}: ${field.type} = ${field.value}');
  }

  editor.setTextValue(form.fieldNamed('name')!, 'John Doe');
  editor.setCheckBoxValue(form.fieldNamed('agree')!, true);
  editor.setRadioValue(form.fieldNamed('color')!, 'Blue');
  editor.setChoiceValue(form.fieldNamed('size')!, 'Large');

  // Optional: burn the values into the page so they can't be edited.
  editor.flattenForm();

  return editor.save();
}

To add fields, use addTextField, addCheckBoxField, and addPushButtonField. renameField, removeField, and changeFieldType handle field management. If the document has no AcroForm yet, the first new field creates one. The editor UI has matching tools, so users can draw fields onto a plain PDF and turn it into a fillable form.

Drawn (handwritten) signatures

The editor ships a signature pad with pressure-sensitive strokes, pen colour and width, and a saved signature library. Users draw once, then tap anywhere to place the signature. The library persists on the device through PdfEditingPreferences, and users can rename, redraw, or delete entries.

// Show the pad, keep the result in the library, and place it.
final ink = await showPdfSignatureDialog(context);
if (ink != null) {
  session.addSavedSignature(ink, name: 'Full signature');
  session.placeSignature(0, 300, 200); // page 0, centred on (300, 200) in PDF points
}

A placed signature is a vector ink annotation. It stays crisp at any zoom, can be moved and resized, and appears in any viewer. To stop it being moved or removed, flatten it into the page content, using the editor's Flatten action or flattenDocument(). If a form has an image button meant for a signature, filling that button with a picture of the signature also works.

Digital signatures (PAdES)

DartPDF writes standard adbe.pkcs7.detached / PAdES signatures, and it does the cryptography (CMS, X.509, RSA, ECDSA) in Dart. It has no OpenSSL dependency and no native plugin. The output is interoperable: pyHanko rates our PAdES B-LTA files valid and LTV-enabled with no network access.

Sign with a visible box

final identity = PdfSigningIdentity.generate(
  name: 'Ada Lovelace',
  email: 'ada@example.com',
);

final editor = PdfEditor(PdfDocument.open(filledPdf));
final signed = await editor.saveSelfSignedPades(
  identity: identity,
  level: PdfPadesLevel.bT,                  // trusted time from a TSA
  timestampClient: myTimestampClient,       // you supply the HTTP call
  reason: 'Approved',
  location: 'Melbourne',
  appearance: PdfSignatureAppearance(
    page: 0,
    rect: const PdfRect(72, 80, 320, 150),
    graphic: PdfEmbeddableImage.png(drawnSignaturePng),
  ),
);

To sign into a field the form already has, pass fieldName: 'ApproverSig'. The box then takes the field's existing position. For a company certificate, use saveSignedPades with your RsaPrivateKey and certificate chain. The library does no network I/O of its own: timestamp, OCSP, and CRL transports are callbacks you provide, so it runs on the web and never contacts a server you didn't choose.

In the Flutter editor

The editor's signature-box tool lets users drag out a rectangle on the page. Your onPlaceSignature callback receives the page and rectangle, and the controller does the signing:

final identity = PdfDigitalSignatureIdentity.fromFiles(
  privateKey: privateKeyBytes,
  certificates: certificateFileBytes,
);
await session.addDigitalSignature(
  identity,
  reason: 'Approved',
  appearance: PdfSignatureAppearance(page: pageIndex, rect: pageRect),
);

Before committing a signature, the controller re-opens and validates it. So it will never save a signature that doesn't verify. addSelfSignedSignature and addKeylessSignature cover the other identity types. The package also ships a “Create signing identity” dialog and secure key storage. The DartPDF app wires all of this into a single Digitally sign… dialog.

Verify signatures

for (final sig in PdfSignature.of(PdfDocument.open(bytes))) {
  final result = sig.validate(trustStore: PdfTrustStore.trusting([caDer]));
  print('${sig.signerName}: intact=${result.intact} '
      'trusted=${result.chainTrusted} level=${result.padesLevel}');
}

The editor's annotations panel shows the same result next to each signature.

What isn't supported (yet)

These are the gaps you're most likely to hit, so you know before you build on it:

• XFA forms. XFA is the older XML-based Adobe forms format. Pure-XFA (“dynamic”) forms won't show their fields. Hybrid forms work through their AcroForm half.
• Form JavaScript. There is deliberately no JS engine, so calculated totals, format/validation scripts, and scripted show/hide don't run. Scripts are exposed read-only so your app can inspect them.
• Comb fields, /MaxLen, and password masking are not enforced when filling.
• Tab to the next field isn't implemented yet. Users tap each field.
• Multi-select list boxes take a single value.
• Authoring covers text, checkbox, and image-button fields. You can't yet add radio groups, choice fields, or empty signature fields for someone else to sign later.
• Signing encrypted (password-protected) PDFs is refused. Sign an unencrypted copy instead. Adding password encryption afterwards rewrites the signed bytes and invalidates the signature; an encrypted, signed output is not currently supported.
• Trust roots. No certificate authorities are bundled. Validation tells you whether the chain reaches a root you supplied (for example, the AATL or your organisation's CA), and it doesn't query live revocation during validation. A self-signed signature validates as intact, but Acrobat shows its signer as unknown until the certificate is trusted.

If one of these blocks you, open an issue with a sample PDF. Real forms decide what we work on next.

Common questions