PDFCanon vs. iLoveAPI: Infrastructure vs. PDF Utilities

iLoveAPI and PDFCanon turn up in the same developer search, but they solve different problems.

iLoveAPI is a utility toolkit: merge, split, compress, convert, and manipulate documents.

PDFCanon is an integrity layer: normalize untrusted PDFs, remove structural drift, produce a stable SHA-256, and return an audit report.

If you need a PDF utility belt, iLoveAPI may be the right fit.

If you need every uploaded PDF to become safe, stable, auditable, and verifiable, PDFCanon is the different category.

The core difference

Dimension	iLoveAPI	PDFCanon
Primary category	PDF utility API	Deterministic PDF normalization API
Main promise	Perform common PDF operations	Produce canonical PDFs with stable hashes
Best fit	Merge, split, compress, convert	Upload hardening, audit trails, deduplication
Security posture	Not primarily a hardening product	Strips active and hidden content by policy
Deterministic output	Not the main contract	Core contract
Audit report	Not the central artifact	Machine-readable report for every file

What iLoveAPI is good at

Utility APIs are useful because they remove a lot of everyday document plumbing.

Teams may use iLoveAPI-style products for:

• Merging several PDFs
• Splitting a PDF into pages
• Compressing large files
• Converting documents
• Performing simple PDF transformations
• Giving users familiar document tools inside an app

Those operations are valuable, but they are not the same as deterministic hardening.

Why utility operations are not enough for file integrity

Operations like compression and conversion are allowed to change bytes. That is the point.

But if your application uses a PDF as a record, byte drift becomes a problem:

• The same invoice may hash differently after re-export.
• The same contract may contain invisible incremental update history.
• Metadata timestamps may change on every save.
• Interactive form state may mutate without obvious visual changes.
• Hidden attachments or active actions may exist inside the file.

A utility API helps with what users want to do to a PDF.

A canonicalization API helps with what your system needs to trust about a PDF.

Where PDFCanon fits

PDFCanon sits between upload and storage:

user upload -> PDFCanon normalize -> canonical PDF + SHA-256 + audit report -> storage

The output is designed for:

• Deduplication
• Evidence chains
• Re-download verification
• Compliance reviews
• Secure document intake
• Downstream processing that should not see active content

PDFCanon does not try to replace merge, split, or conversion tools. It makes the file safe and stable before your system treats it as a record.

Example: the same invoice problem

Suppose two users upload what appears to be the same invoice. One came from Acrobat. One came from a browser print dialog.

They render the same. But the bytes differ because of:

• Producer strings
• Metadata timestamps
• Object stream layout
• Cross-reference offsets
• File identifiers

A utility API can compress or convert the files, but that does not guarantee they become deterministic.

PDFCanon normalizes the document structure and reports the canonical hash your system can store.

When iLoveAPI is the better fit

Choose a utility API when:

• Users need document editing features.
• The file is supposed to be transformed for convenience.
• Stable hashes are not part of your product contract.
• You need many small PDF operations quickly.
• Compliance evidence is not the buying reason.

When PDFCanon is the better fit

Choose PDFCanon when:

• User-uploaded PDFs flow into storage or evidence workflows.
• You need stable SHA-256 hashes.
• You need to strip JavaScript, hidden attachments, or risky actions.
• You need an audit report for every processed file.
• You are preparing for SOC 2, HIPAA, ISO 27001, legal discovery, or customer security reviews.
• You want the upload pipeline to be deterministic by default.

Can they be used together?

Yes, but the order matters.

For recordkeeping workflows, normalize before treating the document as evidence. If you later transform it for user convenience, treat that as a derived document with its own hash and metadata.

A clean architecture is:

1. Store the raw upload temporarily.
2. Canonicalize it with PDFCanon.
3. Store the canonical PDF and audit report as the record.
4. Run utility operations on copies when users need merge, split, compress, or conversion.

That prevents convenience transformations from becoming your integrity source of truth.

Bottom line

iLoveAPI is for common PDF utilities.

PDFCanon is for deterministic PDF integrity.

Both can be useful, but they should not be evaluated as if they solve the same problem. If your users need tools, use utilities. If your system needs proof, use canonicalization.