# Migrate from Apryse, Foxit, IronPDF, or iText

Source: https://pdfluent.com/migrate/from-commercial/

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

## On this page

- Migrate from Apryse to PDFluent
- From Foxit SDK to PDFluent
- Migrate from IronPDF to PDFluent
- Migrate from iText 7 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.

1. Step 1 Remove the Apryse NuGet package and DLL dependencyApryse 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 `*<!--.csproj -->**<PackageReference Include="PDFTron.NET" Version="10.4.0" />**<!-- Also requires PDFNetC.dll in your output directory -->*` After (PDFluent) rust `*# Cargo.toml**[dependencies]**pdfluent = "1.5.0"*`
2. Step 2 Remove license initializationApryse 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*`
3. Step 3 Open a document and extract textApryse 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);*`
4. Step 4 Fill form fieldsApryse 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")?;*`
5. Step 5 Save the documentApryse 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.

1. Step 1 Remove the Foxit native binariesFoxit ships platform-specific DLLs or shared libraries that must travel with your application. PDFluent is a single Rust crate — cargo add pdfluent@1.5.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 system libraries to install**use pdfluent::PdfDocument;**let doc = PdfDocument::open("invoice.pdf")?;*`
2. Step 2 Delete the Foxit key initialisation: PDFluent has nothing to replace it withFoxit 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.*`
3. Step 3 Map Foxit document operations to PDFluent equivalentsFoxit 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.

1. Step 1 Replace the dependencyRemove 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 `*<!--.csproj -->**<PackageReference Include="IronPdf" Version="2024.3.4" />*` After (PDFluent) rust `*# Cargo.toml**[dependencies]**pdfluent = "1.5.0"*`
2. Step 2 Open an existing PDFIronPDF 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());*`
3. Step 3 Extract textIronPDF 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);**}*`
4. Step 4 Fill AcroForm fieldsIronPDF 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")?;*`
5. Step 5 Save the documentIronPDF 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 system libraries to install.

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.

1. Step 1 Replace the dependencyRemove 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.5.0"*`
2. Step 2 Open a documentiText 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")?;*`
3. Step 3 Extract textiText 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()?;*`
4. Step 4 Fill form fieldsiText 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")?;*`
5. Step 5 Save the outputiText 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.
