Migrate from Apryse, Foxit, IronPDF, or iText
Migrate from Apryse to PDFluent
- 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.
Beforerust<!-- .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" - 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.
Beforerustusing 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().
Beforerustusing 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)rustuse 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.
Beforerustusing 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)rustlet 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.
Beforerustdoc.Save("output.pdf", SDFDoc.SaveOptions.e_linearized); PDFNet.Terminate(); // must clean upAfter (PDFluent)rustdoc.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
- 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.5.0, and Cargo fetches and compiles it. No DLL to distribute, no shared library to load at runtime.
Beforerust// 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")?; - 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.
Beforerust// 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.
BeforerustFPDF_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)rustlet 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
- 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.
Beforerust<!-- .csproj --> <PackageReference Include="IronPdf" Version="2024.3.4" />After (PDFluent)rust# Cargo.toml [dependencies] pdfluent = "1.5.0" - Step 2
Open an existing PDF
IronPDF uses PdfDocument.FromFile(). PDFluent uses Document::open.
Beforerustusing IronPdf; var doc = PdfDocument.FromFile("report.pdf"); Console.WriteLine($"Pages: {doc.PageCount}");After (PDFluent)rustuse 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.
Beforerustvar doc = PdfDocument.FromFile("report.pdf"); // IronPDF text extraction routes through the browser engine string allText = doc.ExtractAllText(); Console.WriteLine(allText);After (PDFluent)rustlet 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.
Beforerustvar 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)rustlet 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().
Beforerustdoc.SaveAs("output.pdf");After (PDFluent)rustdoc.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
- Step 1
Replace the dependency
Remove the iText Maven dependency and add PDFluent to your Rust project with cargo add.
Beforerust<!-- 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" - Step 2
Open a document
iText uses PdfReader and PdfDocument. PDFluent uses Document::open which returns a Result.
Beforerustimport com.itextpdf.kernel.pdf.PdfDocument; import com.itextpdf.kernel.pdf.PdfReader; PdfDocument pdf = new PdfDocument(new PdfReader("report.pdf"));After (PDFluent)rustuse 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.
Beforerustimport 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)rustlet 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.
Beforerustimport 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)rustlet 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.
Beforerustimport com.itextpdf.kernel.pdf.PdfWriter; PdfDocument out = new PdfDocument( new PdfReader("input.pdf"), new PdfWriter("output.pdf") ); // ... modifications ... out.close();After (PDFluent)rustdoc.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.