How do I deploy PDFluent without a DLL?

PDFluent compiles to a single static binary. There are no shared libraries to deploy. On Linux you link against pdfluent.a; on other platforms similar static linking applies.

Can I evaluate PDFluent without contacting sales?

Yes. Add pdfluent to Cargo.toml and every feature works, with no key and no time limit, under the AGPL. What closed-source use costs is published on the pricing page.

Does PDFluent convert HTML to PDF?

No. PDFluent focuses on native PDF operations. If HTML-to-PDF conversion is your primary use case, IronPDF or a headless browser approach is more suitable.

Does PDFluent support iText's pdfXFA add-on functionality?

PDFluent handles XFA forms natively, including static and dynamic XFA and FormCalc execution. No separate add-on is needed.

PDFluentSDK

Editor Download

Migrate from Apryse, Foxit, IronPDF, or iText

This guide provides the specific steps for developers to migrate their existing PDF operations from these four SDKs to PDFluent.

Migrate from Apryse to PDFluent

A step-by-step guide for replacing Apryse (PDFTron) with PDFluent. Covers dependency setup, license initialization, text extraction, form filling, and saving.

Step 1
Remove the Apryse NuGet package and DLL dependency
Apryse ships a native C++ DLL (PDFNetC.dll on Windows, libPDFNetC.so on Linux) alongside the managed wrapper. Remove both and add pdfluent to Cargo.toml.
Before
rust
```

<PackageReference Include="PDFTron.NET" Version="10.4.0" />

```
After (PDFluent)
rust
```
# Cargo.toml
[dependencies]
pdfluent = "1.1.0"
```
Step 2
Remove license initialization
Apryse requires calling PDFNet.Initialize() with a license key before any API use. PDFluent has nothing to initialise: no licence key, no environment variable, no activation call.
Before
rust
```
using Apryse;

// Must call before any Apryse API
PDFNet.Initialize("YOUR_LICENSE_KEY_HERE");
```
After (PDFluent)
rust
```
// Set PDFLUENT_LICENSE env var, or configure in pdfluent.toml
// No explicit initialization call required
```

Step 3

Open a document and extract text

Apryse uses PDFDoc plus TextExtractor. PDFluent uses Document::open and page.text().

Before

rust

using Apryse;

using var doc = new PDFDoc("invoice.pdf");
doc.InitSecurityHandler();

var page = doc.GetPage(1);
var extractor = new TextExtractor();
extractor.Begin(page);
string text = extractor.GetAsText();
Console.WriteLine(text);

After (PDFluent)

rust

use pdfluent::PdfDocument;

let doc = PdfDocument::open("invoice.pdf")?;
let text = doc.page(1)?.text()?;
println!("{}", text);

Step 4

Fill form fields

Apryse uses doc.GetField() to retrieve and set individual field values. PDFluent hands out a mutable form handle with doc.form_mut(), with one setter per field type.

Before

rust

using var doc = new PDFDoc("form.pdf");
doc.InitSecurityHandler();

var field = doc.GetField("company_name");
field.SetValue("Acme Corp");

var dateField = doc.GetField("contract_date");
dateField.SetValue("2024-04-14");

doc.Save("form_filled.pdf", SDFDoc.SaveOptions.e_linearized);
PDFNet.Terminate();

After (PDFluent)

rust

let mut doc = PdfDocument::open("form.pdf")?;

let mut form = doc.form_mut();
form.set_text("company_name", "Acme Corp")?;
form.set_text("contract_date", "2024-04-14")?;

doc.save("form_filled.pdf")?;

Step 5
Save the document
Apryse Save() takes a SaveOptions flags enum. PDFluent save() writes to the output path with sane defaults.
Before
rust
```
doc.Save("output.pdf", SDFDoc.SaveOptions.e_linearized);
PDFNet.Terminate(); // must clean up
```
After (PDFluent)
rust
```
doc.save("output.pdf")?;
// Rust drops doc automatically
```

Apryse uses 1-based page indexing (GetPage(1) is page 1). PDFluent uses 0-based indexing (page(0) is page 1).
Apryse requires PDFNet.Initialize() before any call. Forgetting this causes a runtime panic. PDFluent has no equivalent requirement.
Apryse's WebViewer (JavaScript viewer product) has no direct PDFluent equivalent. PDFluent WASM can power a custom viewer.

How do I deploy PDFluent without a DLL?: PDFluent compiles to a single static binary. There are no shared libraries to deploy. On Linux you link against pdfluent.a; on other platforms similar static linking applies.
Apryse has a viewer component. Does PDFluent include one?: PDFluent does not include a viewer UI. It is a processing library. The WASM build can power a custom viewer built with any JavaScript framework.
Does PDFluent support Apryse's digital signature features?: PDFluent supports PAdES digital signatures including LTV (long-term validation) and timestamp tokens. The API differs from Apryse but the output is standards-compliant.
Apryse pricing requires a sales call. How does PDFluent compare?: PDFluent pricing is published on the pricing page and bought with a card. Every feature works from the first line of code under the AGPL; a paid licence is about not publishing your own source.

From Foxit SDK to PDFluent

Foxit requires per-seat licensing, ships native C++ binaries, and bundles DLL dependencies. PDFluent is a Rust crate with a published price, no native DLLs, and no licence key to install.

Step 1

Remove the Foxit native binaries

Foxit ships platform-specific DLLs or shared libraries that must travel with your application. PDFluent is a single Rust crate — cargo add pdfluent@1.1.0, and Cargo fetches and compiles it. No DLL to distribute, no shared library to load at runtime.

Before

rust

// C++ — Foxit SDK initialization
#include "include/fpdfview.h"

// fpdfview.dll / libfpdfview.so must be present at runtime
FPDF_InitLibrary();
FPDF_DOCUMENT doc = FPDF_LoadDocument("invoice.pdf", nullptr);
if (!doc) {
    // handle load failure
}

After (PDFluent)

rust

// Rust — PDFluent, no native library required
use pdfluent::PdfDocument;

let doc = PdfDocument::open("invoice.pdf")?;

Step 2
Delete the Foxit key initialisation: PDFluent has nothing to replace it with
Foxit requires a license key passed at initialization time, and licensing is per seat. PDFluent needs no key at all: nothing is validated at startup, and a licence covers an organisation or a product rather than a seat. Delete the Foxit key initialisation and replace it with nothing.
Before
rust
```
// Foxit — license key required before any API use
FPDF_InitLibraryWithConfig(&config);
// License key must match purchased seat count
const char* key = "YOUR_FOXIT_LICENSE_KEY";
FPDF_UnlockDDS(key, (int)strlen(key));
```
After (PDFluent)
rust
```
// PDFluent — no initialisation call, no licence key.
// The licence is a contract, not a file:
// See https://pdfluent.com/docs/licensing for the terms.
```

Step 3

Map Foxit document operations to PDFluent equivalents

Foxit operations map closely to PDFluent. Open a document, access pages by index, extract text or fill forms, and save. The main difference is error handling: Foxit returns null or numeric error codes; PDFluent returns Result types that the compiler forces you to handle.

Before

rust

FPDF_PAGE page = FPDF_LoadPage(doc, 0);
FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
int char_count = FPDFText_CountChars(text_page);

char16_t buf[4096];
FPDFText_GetText(text_page, 0, char_count, buf);

FPDFText_ClosePage(text_page);
FPDF_ClosePage(page);
FPDF_CloseDocument(doc);

After (PDFluent)

rust

let text = doc.page(1)?.text()?;
println!("{}", text);
// All resources freed when doc goes out of scope

Foxit page indexes are 0-based, matching PDFluent's 0-based indexing. No page number adjustments are needed.
Foxit's per-seat licensing means adding a server replica requires purchasing an additional seat. PDFluent is licensed per organisation or per product, so a replica costs nothing extra.
Foxit ships separate SDKs for different platforms (Windows, Linux, macOS, iOS, Android). PDFluent builds from one codebase for all targets, including WASM.
If you use Foxit's annotation APIs, verify PDFluent's annotation support covers your use case before migrating.

Can I evaluate PDFluent without contacting sales?: Yes. Add pdfluent to Cargo.toml and every feature works, with no key and no time limit, under the AGPL. What closed-source use costs is published on the pricing page.
Does PDFluent support the same XFA functionality as Foxit?: PDFluent handles static and dynamic XFA forms including FormCalc script execution. Foxit's XFA support is available only in specific SDK tiers. Check your current Foxit tier against PDFluent's feature list.
How much does removing Foxit DLLs reduce my deployment size?: Removing Foxit takes its native libraries out of the deployment package. PDFluent adds only the compiled Rust code.
Is the Foxit C++ API similar enough to PDFluent to migrate quickly?: The concepts are the same: open document, access page, extract or modify content, save. The syntax differs because PDFluent uses idiomatic Rust. Most teams complete a basic migration in a few days.

Migrate from IronPDF to PDFluent

A step-by-step guide for replacing IronPDF with PDFluent. Covers dependency setup, opening PDFs, text extraction, form filling, and saving.

Step 1
Replace the dependency
Remove the IronPdf NuGet package and add pdfluent to Cargo.toml. If your project is in C# you can call PDFluent through the C API or use the .NET binding package.
Before
rust
```

<PackageReference Include="IronPdf" Version="2024.3.4" />
```
After (PDFluent)
rust
```
# Cargo.toml
[dependencies]
pdfluent = "1.1.0"
```

Step 2

Open an existing PDF

IronPDF uses PdfDocument.FromFile(). PDFluent uses Document::open.

Before

rust

using IronPdf;

var doc = PdfDocument.FromFile("report.pdf");
Console.WriteLine($"Pages: {doc.PageCount}");

After (PDFluent)

rust

use pdfluent::PdfDocument;

let doc = PdfDocument::open("report.pdf")?;
println!("Pages: {}", doc.page_count());

Step 3

Extract text

IronPDF drives Chromium to extract text, which can produce inconsistent results on non-HTML PDFs. PDFluent reads directly from the PDF content stream.

Before

rust

var doc = PdfDocument.FromFile("report.pdf");

// IronPDF text extraction routes through the browser engine
string allText = doc.ExtractAllText();
Console.WriteLine(allText);

After (PDFluent)

rust

let doc = PdfDocument::open("report.pdf")?;

for i in 0..doc.page_count() {
    let text = doc.page(i)?.text()?;
    println!("{}", text);
}

Step 4

Fill AcroForm fields

IronPDF uses Form.GetFieldByName(). PDFluent uses form_mut().set_text(), with set_checkbox, set_radio, set_dropdown and set_multi_select for the other field types.

Before

rust

var doc = PdfDocument.FromFile("application.pdf");

var nameField = doc.Form.GetFieldByName("applicant_name");
nameField.Value = "Jane Smith";

var dateField = doc.Form.GetFieldByName("submission_date");
dateField.Value = "2024-04-14";

doc.SaveAs("application_filled.pdf");

After (PDFluent)

rust

let mut doc = PdfDocument::open("application.pdf")?;

let mut form = doc.form_mut();
form.set_text("applicant_name", "Jane Smith")?;
form.set_text("submission_date", "2024-04-14")?;

doc.save("application_filled.pdf")?;

Step 5
Save the document
IronPDF uses SaveAs(). PDFluent uses Document::save().
Before
rust
```
doc.SaveAs("output.pdf");
```
After (PDFluent)
rust
```
doc.save("output.pdf")?;
```

IronPDF's primary feature is HTML-to-PDF rendering via Chromium. PDFluent does not provide HTML-to-PDF conversion.
IronPDF licenses per developer per year. PDFluent is €999 a year for the whole organisation, or priced per product for OEM use, and never per developer.
IronPDF requires the Chromium binary to be present on the server. PDFluent has no native dependencies.

Does PDFluent convert HTML to PDF?: No. PDFluent focuses on native PDF operations. If HTML-to-PDF conversion is your primary use case, IronPDF or a headless browser approach is more suitable.
IronPDF is .NET. Can I use PDFluent from C#?: PDFluent has a C API that can be called from .NET via P/Invoke. A managed .NET wrapper is on the roadmap.
How does cold start time compare?: IronPDF launches a Chromium instance on startup. PDFluent does not start a browser.
Can PDFluent run in Docker?: Yes. PDFluent has no system-level dependencies. A minimal Docker image (scratch or alpine) works. IronPDF requires system libraries for Chromium which significantly increases image size.

Migrate from iText 7 to PDFluent

A step-by-step guide for moving an iText 7 Java codebase to PDFluent in Rust. Covers opening documents, text extraction, form filling, and saving.

Step 1

Replace the dependency

Remove the iText Maven dependency and add PDFluent to your Rust project with cargo add.

Before

rust

<!-- pom.xml -->
<dependency>
    <groupId>com.itextpdf</groupId>
    <artifactId>itext7-core</artifactId>
    <version>7.2.5</version>
    <type>pom</type>
</dependency>

After (PDFluent)

rust

# Cargo.toml
[dependencies]
pdfluent = "1.1.0"

Step 2

Open a document

iText uses PdfReader and PdfDocument. PDFluent uses Document::open which returns a Result.

Before

rust

import com.itextpdf.kernel.pdf.PdfDocument;
import com.itextpdf.kernel.pdf.PdfReader;

PdfDocument pdf = new PdfDocument(new PdfReader("report.pdf"));

After (PDFluent)

rust

use pdfluent::PdfDocument;

let doc = PdfDocument::open("report.pdf")?;

Step 3

Extract text

iText uses PdfTextExtractor with a LocationTextExtractionStrategy. PDFluent exposes a page-level extract_text method.

Before

rust

import com.itextpdf.kernel.pdf.canvas.parser.PdfTextExtractor;
import com.itextpdf.kernel.pdf.canvas.parser.listener.LocationTextExtractionStrategy;

String text = PdfTextExtractor.getTextFromPage(
    pdf.getPage(1),
    new LocationTextExtractionStrategy()
);

After (PDFluent)

rust

let text = doc.page(1)?.text()?;

Step 4

Fill form fields

iText uses PdfAcroForm.getField().setValue(). PDFluent uses form_mut().set_text(), with set_checkbox, set_radio, set_dropdown and set_multi_select for the other field types.

Before

rust

import com.itextpdf.forms.PdfAcroForm;

PdfAcroForm form = PdfAcroForm.getAcroForm(pdf, true);
form.getField("customer_name").setValue("Acme Corp");
form.getField("invoice_date").setValue("2024-04-14");

After (PDFluent)

rust

let mut form = doc.form_mut();
form.set_text("customer_name", "Acme Corp")?;
form.set_text("invoice_date", "2024-04-14")?;

Step 5

Save the output

iText writes to a PdfWriter. PDFluent uses Document::save.

Before

rust

import com.itextpdf.kernel.pdf.PdfWriter;

PdfDocument out = new PdfDocument(
    new PdfReader("input.pdf"),
    new PdfWriter("output.pdf")
);
// ... modifications ...
out.close();

After (PDFluent)

rust

doc.save("output.pdf")?;

iText page numbers are 1-indexed. PDFluent page numbers are 0-indexed.
iText AGPL requires source disclosure for commercial use. Check your license before migration.
iText's pdfHTML add-on (HTML to PDF) has no direct PDFluent equivalent.

Does PDFluent support iText's pdfXFA add-on functionality?: PDFluent handles XFA forms natively, including static and dynamic XFA and FormCalc execution. No separate add-on is needed.
iText uses 1-based page indexing. How does PDFluent differ?: PDFluent uses 0-based indexing. page(0) is the first page. Adjust your index references when migrating.
Can I keep using iText for some documents and PDFluent for others?: PDFluent can read PDFs produced by iText without issues. You can migrate incrementally, processing new documents with PDFluent while legacy documents continue through iText.
Does the migration require rewriting all PDF logic at once?: No. You can use PDFluent through its C API or language bindings from a Java service while migrating incrementally.

Migrate from Apryse, Foxit, IronPDF, or iText

On this page

Migrate from Apryse to PDFluent

Remove the Apryse NuGet package and DLL dependency

Remove license initialization

Open a document and extract text

Fill form fields

Save the document

From Foxit SDK to PDFluent

Remove the Foxit native binaries

Delete the Foxit key initialisation: PDFluent has nothing to replace it with

Map Foxit document operations to PDFluent equivalents

Migrate from IronPDF to PDFluent

Replace the dependency

Open an existing PDF

Extract text

Fill AcroForm fields

Save the document

Migrate from iText 7 to PDFluent

Replace the dependency

Open a document

Extract text

Fill form fields

Save the output