The Node.js PDF Library
This tutorial will dive into IronPDF's JavaScript SDK and PDFKit - two big names in JavaScript PDF libraries. Both are solid choices for Node.js projects, but they've got their strengths and weaknesses.
The purpose of this article is to give readers a real sense of how IronPDF and PDFKit tools can fit into a developer's Node.js workflow. Whether knocking out basic PDFs or dealing with complicated layouts, understanding what IronPDF and PDFKit can (and can't) do is super important.
PDFKit is an advanced JavaScript PDF generation library for Node.js and browser environments. Its comprehensive set of tools makes it ideal for creating multipage, printable documents with ease. The library is designed to be easy to use, streamlining the process of generating complex documents.
PDFKit stands out for its powerful vector graphics capabilities, extensive text and font styling options, image embedding features, and support for interactive and secure PDF documents. Its ease of use, combined with its versatility for both server-side and browser environments, makes it a valuable tool for developers needing to generate custom PDFs in a variety of applications.
Flexible PDF Generation
PDFKit does not rely on HTML-to-PDF conversion; instead, it generates PDFs directly through JavaScript code. This approach provides developers with precise control over the layout, style, and content of the PDF files they create, so generating complex documents is easier.
Graphics and Text Formatting
The library supports advanced graphics capabilities, including lines, curves, rectangles, circles, and more. Text formatting features such as custom fonts, sizes, and colors enable the creation of visually appealing documents.
Image Embedding and Vector Graphics
PDFKit allows the embedding of images in various formats and supports vector graphics, making it ideal for high-quality print documents. Image embedding supports JPEG and PNG files.
Advanced Document Features
Developers can add annotations, bookmarks, and hyperlinks to their PDFs. The library also supports the creation of headers and footers, as well as the inclusion of page numbers and custom JavaScript.
Customizable and Reusable Components
The PDFKit API facilitates the creation of reusable components, streamlining the development process for documents with repetitive structures like invoices or reports.
Vector Graphics
PDFKit offers an HTML5 canvas-like API for vector graphics, including path operations, SVG path parsing, transformations, and gradients. This is ideal for creating scalable, high-quality graphics in PDFs. The library supports line wrapping, various text alignments, and bulleted lists.
Embedded Fonts
PDFKit supports a wide range of font formats like TrueType, OpenType, WOFF, and more, allowing for consistent typography in PDFs. Font subsetting is also available, ensuring that the document size remains manageable.
With IronPDF, you can easily convert HTML strings, files, or even entire web pages into PDFs that look exactly like the original content, complete with CSS styling and images. This is crucial for delivering professional-grade documents such as invoices, contracts, and reports that need to retain the branding and layout specified by web designs.
IronPDF excels at converting HTML content into high-fidelity PDF documents. Its capabilities include:
IronPDF provides comprehensive formatting tools that allow for the customization and enhancement of PDFs created from HTML content, such as:
IronPDF's editing capabilities are extensive, providing the ability to modify existing PDFs to fit specific needs:
IronPDF supports the creation and manipulation of PDF forms, allowing for interactive elements within the PDF:
PDF Forms: This includes creating forms that can be filled out digitally, enabling businesses to automate the data collection process. With IronPDF, you can programmatically create forms, populate fields, and even retrieve information, which streamlines workflows and reduces manual data entry.
IronPDF supports various platforms, making it versatile for different development environments. It is compatible with Node.js version 12.0 and above and can be used on Windows, Linux, Mac, and Docker.
Before diving into the world of PDF generation, you need to set up your project environment. Visual Studio Code (VS Code) provides an ideal, user-friendly platform for this. Start by launching VS Code and creating a new JavaScript project. You can do this by setting up a new folder for your project and opening it in VS Code. This environment will be where you'll write your code and manage your project's files.
Once your folder is open in VS Code, the next step is to initialize a new JavaScript project. Open the integrated terminal in VS Code (usually found under Terminal > New Terminal in the menu) and type npm init. This command will walk you through creating a package.json file, which is crucial for managing your project's dependencies and metadata.
With your JavaScript project set up, it's time to install the IronPDF library. In your VS Code terminal, run the following command:
npm install ironpdfThis command fetches and installs the IronPDF library, adding it to your project's dependencies.
After installation, make sure that IronPDF is listed in your package.json file under the dependencies section. This ensures that IronPDF is correctly integrated into your project, paving the way for seamless PDF generation and manipulation.
Next up is PDFKit, a robust and versatile PDF document generation library. To add PDFKit to your project, execute the following command in your terminal within VS Code:
npm install pdfkitThis will install PDFKit and add it to your project's dependencies.
Upon successful installation, verify that PDFKit appears in the dependencies of your package.json file. This confirmation is crucial for confirming that your project is now equipped with the tools necessary for creating complex, detailed, and visually appealing PDF files.
IronPDF for Node.js excels in converting HTML to PDF, offering an efficient solution for developers. This library is adept at handling complex tasks like rendering CSS styles, executing JavaScript, and incorporating custom headers and footers. These functionalities significantly enhance its ability to create professional-grade PDFs from HTML sources. IronPDF for Node.js provides three convenient methods for this conversion process:
This method allows developers to directly convert HTML code strings into PDF files. This function is incredibly useful for scenarios involving dynamic content generation. Whether you're creating customized reports, generating invoices on the fly, or need to present data-driven content in a polished, professional format, this feature simplifies the process.
import { PdfDocument, PdfGenerator } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
try {
// Input the license key
const IronPdfConfig = {
licenseKey: "Your-License-Key",
};
// Set the config with the license key
IronPdfGlobalConfig.setConfig(IronPdfConfig);
// Create a PDF from the HTML String
const pdf = await PdfDocument.fromHtml(
"<h1>Hello JavaScript Developers! This is an Example PDF created with IronPDF NodeJS!</h1>"
);
// Save the PDF document to the file system.
await pdf.saveAs("HtmlStringToPDF.pdf");
} catch (error) {
// Handle errors here
console.error("An error occurred:", error);
}
})();Here you can see the output of the code:
With this function, developers can convert existing HTML files into PDFs. This functionality is especially beneficial for handling static HTML documents. Whether you're working with pre-designed web pages, standardized forms, or information brochures, this feature provides a straightforward path to convert them into PDFs.
import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
try {
// Input the license key
const IronPdfConfig = {
licenseKey: "Your-License-Key",
};
// Set the config with the license key
IronPdfGlobalConfig.setConfig(IronPdfConfig);
// Create a PDF from the HTML File"
const pdf = await PdfDocument.fromFile("invoice.html");
// Save the PDF document to the file system.
await pdf.saveAs("invoice.pdf");
} catch (error) {
// Handle errors here
console.error("An error occurred:", error);
}
})();Here is the output invoice PDF generated:
This feature enables the conversion of web pages into PDFs by simply using their URLs. This functionality is particularly useful for capturing live, online content. Whether it's for archiving web pages, creating offline copies of online articles, or generating reports from web-based data, this feature handles it effortlessly.
import { PdfDocument } from "@ironsoftware/ironpdf";
import { IronPdfGlobalConfig } from "@ironsoftware/ironpdf";
import fs from "fs";
(async function createPDFs() {
try {
// Input the license key
const IronPdfConfig = {
licenseKey: "Your-License-Key",
};
// Set the config with the license key
IronPdfGlobalConfig.setConfig(IronPdfConfig);
// URL of the web page to convert to PDF
const url = "https://en.wikipedia.org/wiki/PDF";
// Convert the Web Page to a pixel-perfect PDF file.
const urlPDF = await PdfDocument.fromUrl(url);
// Save the document.
await urlPDF.saveAs("UrlToPdf.pdf");
} catch (error) {
// Handle errors here
console.error("An error occurred:", error);
}
})();Here is the output PDF file generated from the URL:
PDFKit, although not primarily designed for HTML to PDF conversion like IronPDF, still offers a way to programmatically create PDF documents directly from JavaScript code. Below is an example demonstrating how to create a simple PDF file:
const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
doc.pipe(fs.createWriteStream('output.pdf'));
doc.fontSize(25)
.text('PDFKit - Text to PDF Example', 100, 100);
doc.end();This code snippet creates a PDF file with a text headline. While PDFKit doesn't convert HTML to PDF directly, it allows for detailed control over text placement and formatting.
Here is the output file generated by PDFKit:
Passwords, Security & Metadata: IronPDF empowers developers to bolster the security of their PDF files through various features. It allows the setting of passwords, adding an extra layer of protection that requires users to enter a password to view the document. Additionally, IronPDF provides the capability to embed metadata within the PDF, which can include author information, titles, and keywords, thereby enhancing document management and organization.
import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
// Import a PDF document or create a new PDF from Html
const pdf = await PdfDocument.open("encrypted.pdf", "password");
// Create an empty Map
const newMetadata = new Map();
// Add key-value pairs of metadata
newMetadata.set("Author", "Satoshi Nakamoto");
newMetadata.set("Keywords", "SEO, Friendly");
await pdf.overrideMetadata(newMetadata);
await pdf.removePasswordsAndEncryption();
// Make PDF read-only
await pdf.makePdfDocumentReadOnly("secret-key");
// Configure permissions
const permissions = {
AllowAnnotations: false,
AllowExtractContent: false,
AllowFillForms: false,
AllowPrint: true,
};
await pdf.setPermission(permissions);
// Change or set the document encrpytion password
await pdf.saveAs("secured.pdf", {
ownerPassword: "top-secret",
userPassword: "my-password",
});
})();PDF Encryption & Decryption: Encryption and decryption are vital components of document security, and IronPDF handles this with ease. It offers different levels of encryption, from simple password protection to advanced encryption standards, ensuring that sensitive information remains secure. The decryption feature is equally robust, providing authorized users with the means to access and modify encrypted documents.
Digital Signatures: In the era of digital documentation, authenticity and integrity are paramount. IronPDF's digital signatures functionality allows users to sign their PDFs digitally, which not only verifies the identity of the document's originator but also indicates that the document has not been altered since the signature was applied, thereby ensuring its authenticity.
import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
// Step 1. Import a PDF
const pdf = await PdfDocument.open("sample.pdf");
// Step 2. Sign the PDF with digital certificate
await pdf.signDigitalSignature({
certificatePath: "IronSoftware.pfx",
certificatePassword: "123456",
signingReason: "To show how to sign a PDF",
signingLocation: "Chicago, USA",
signatureImage: {
SignatureImagePath: "logo.png"
}
});
//Step 3. The PDF is not signed until saved to file.
await pdf.saveAs("signed.pdf");
})();PDF Compression: IronPDF recognizes the need for efficient storage and swift sharing of documents. It includes a PDF compression feature that reduces file sizes significantly, which is crucial for optimizing storage space and expediting document transmission without compromising the quality and integrity of the content within the PDFs.
import {PdfDocument} from "@ironsoftware/ironpdf";
(async () => {
// Load the existing PDF document
const pdf = await PdfDocument.fromFile("my-content.pdf");
// Compress images with quality parameter (1-100)
await pdf.compressSize(60);
// Save the compressed PDF
await pdf.saveAs("document_compressed.pdf");
// Compress images and scale down based on visible size in the PDF document
await pdf.compressSize(90, true);
// Save the scaled and compressed PDF
await pdf.saveAs("document_scaled_compressed.pdf");
});Merge Two or More PDFs: IronPDF provides a straightforward solution to merge multiple PDF documents into a single file. This feature is incredibly useful for combining various documents such as reports, contracts, or series of forms, facilitating better document management and distribution.
Remove Specific PDF Pages: Flexibility in editing is key for any PDF tool, and IronPDF offers the ability to remove specific pages from a PDF document. This is especially useful when tailoring content for different audiences or omitting unnecessary pages to create a more concise document.
Customizable Layout Engine: PDFKit features a customizable layout engine, giving developers control over every aspect of the PDF's layout, from text positioning to complex graphical elements.
const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument({ margin: 50 });
// Custom layouts
doc.text('Customized Layout Text', {
align: 'center',
valign: 'center'
});
doc.end();
doc.pipe(fs.createWriteStream('custom-layout.pdf'));In this example, PDFDocument is used to create a customized layout with centered text.
Advanced Graphic and Text Features: PDFKit offers advanced graphic and text features, allowing for intricate design and styling within PDF files. It enables the drawing of shapes and the addition of images and SVGs. When it comes to text, PDFKit provides a full suite of layout options, from basic text boxes to advanced typography controls, ensuring that the layout of each page is exactly as envisioned.
const PDFDocument = require('pdfkit');
const fs = require('fs');
let doc = new PDFDocument();
// Advanced graphics
doc.moveTo(100, 150)
.lineTo(100, 250)
.lineTo(200, 250)
.fill("#FF3300");
// Advanced text
doc.fontSize(15)
.font('Times-Roman')
.text('Advanced Text Features', 100, 300);
doc.end();
doc.pipe(fs.createWriteStream('advanced-graphics-text.pdf'));
Stream and Buffer Handling: PDFKit excels in stream and buffer handling, enabling efficient management of large PDF files and their data.
const PDFDocument = require('pdfkit');
const fs = require('fs');
const stream = require('stream');
let doc = new PDFDocument();
let buffers = [];
let writableStream = new stream.Writable();
writableStream._write = (chunk, encoding, done) => {
buffers.push(chunk);
done();
};
doc.pipe(writableStream);
doc.text('Streaming PDF Content');
doc.end();
writableStream.on('finish', () => {
let pdfData = Buffer.concat(buffers);
fs.writeFileSync('streamed.pdf', pdfData);
});Customizable Headers and Footers: Creating a professional-looking PDF involves attention to detail. PDFKit’s customizable headers and footers feature enables the precise placement of text and graphics at the top and bottom of pages. This is particularly useful for adding consistent branding, document titles, and pagination across a multi-page document.
Interactive Forms: PDFKit extends its capabilities to interactive forms within your PDF files, allowing for the creation of text fields, checkboxes, and radio buttons. This feature is invaluable for users looking to collect information or provide interactive content, enhancing the user experience and functionality of the PDF.
IronPDF's documentation provides a comprehensive guide to using the library, with detailed examples of key features such as rendering a URL as a PDF and creating a PDF from an HTML string. It offers customization options for PDF printing, like setting paper size and DPI, and for the appearance of documents, such as headers and footers with mail-merge fields. The documentation also covers more advanced aspects like using custom WebClients, creating editable PDF forms, and working with JavaScript within PDFs. You can browse documentation for complete API documentation and more examples.
For setting headers and footers, both HTML and text options are well-documented, allowing for meta-data to be merged using placeholder strings. Licensing details are provided, guiding users on how to remove watermarks and get licensed. The documentation even provides information on setting up the first-page number for PDF headers and footers and includes details on how long to wait after HTML rendering before printing, considering the rendering of JavaScript, AJAX, or animations.
IronPDF has a collection of troubleshooting guides that address common issues and provide step-by-step solutions. This can be the first stop for users trying to solve a problem. For more complex issues or those that cannot be resolved through guides, IronPDF offers technical support. Users can submit a request for engineering support which may include providing detailed information about the issue, such as platform or runtime specifics, to help the support team replicate and address the problem. You can also use the live chat option.
PDFKit’s npm documentation describes the library as a tool for creating complex, multi-page, printable documents easily. It emphasizes the chainability of its API and includes both low-level functions and abstractions for higher-level functionality, designed to be simple enough that generating complex documents can be as simple as a few function calls.
The features section of the documentation is comprehensive, covering vector graphics, text, font embedding, image embedding, annotations, form creation, outlines, and PDF security, all of which demonstrate the library's capability for creating accessible and secure documents.
PDFKit, being an open-source library, benefits from community support. Issues and feature requests can be handled through its GitHub repository, where users can contribute to the code, submit issues, and make pull requests. The community around PDFKit might also provide unofficial support channels like Stack Overflow, where developers often share their knowledge and solutions.
IronPDF operates on a commercial licensing model, which means developers or companies need to purchase a license to use the library in their projects without limitations.
Lite: Priced at $749, this one-time fee provides a basic package suitable for smaller projects.
Professional: At $1,499, this tier is for professional use, offering more features and capabilities.
Unlimited: The unlimited tier is priced at $2,999 and is ideal for large-scale deployments, providing full access to all features without restrictions.
IronPDF also offers a free trial version, allowing developers to evaluate the library before making a purchase. There is no free or freemium version available, and premium consulting or integration services are not offered.
PDFKit is an open-source library that is available under the MIT License. This permissive license allows for free use, modification, and distribution of the software. Being an open-source project, PDFKit does not have a pricing structure. It can be freely incorporated into any project, and users can contribute to its development through GitHub. The project accepts donations, which are not mandatory but support the ongoing development and maintenance of the library.
In conclusion, IronPDF for Node.js and PDFKit both serve as powerful tools for PDF generation and manipulation in their respective environments, yet IronPDF for Node.js has an edge with its extensive feature set tailored for the Node.js platform.
IronPDF’s capabilities in converting HTML to PDFs, advanced editing, and comprehensive support for JavaScript and other rich media make it a versatile solution for a wide range of PDF processing tasks. Additionally, IronPDF’s strong focus on security and its detailed documentation provide a level of assurance and accessibility that is crucial for developers.
PDFKit, being open-source, offers flexibility and ease of use that can be highly appealing to developers who prefer extensive community support and the ability to modify the source code. Its capabilities are impressive, especially considering the cost benefits of an open-source solution.
IronPDF offers a free trial that allows developers to assess its full range of features before committing financially. Furthermore, Iron Software's Iron Suite, which includes IronPDF among other valuable developer tools like IronXL, IronBarcode, IronQR, and IronOCR, presents a cost-effective package deal, delivering a comprehensive set of functionalities for the price of two products.
Ultimately, the choice between IronPDF for Node.js and PDFKit will hinge on the particular demands of the project and the preferences of the developer or development team. For those seeking a rich feature set and extensive documentation within the Node.js ecosystem, IronPDF for Node.js stands out as a fitting choice.
Want to deploy IronPDF to a live project for FREE?
Your trial key should be in the email.
The trial form was submitted
successfully.
If it is not, please contact
support@ironsoftware.com
Get started for FREE
No credit card required
Test in production without watermarks.
Works wherever you need it to.
Get 30 days of fully functional product.
Have it up and running in minutes.
Full access to our support engineering team during your product trial
No credit card or account creation required
Your trial key should be in the email.
If it is not, please contact
support@ironsoftware.com
9 .NET API products for your office documents
