Merge PDF with Node.js: A Comprehensive Guide (using Breeze PDF)

Why Merge PDF Files in Node.js?

Merging PDF files in Node.js applications is a crucial capability for a multitude of reasons. Consolidating reports, invoices, and scanned documents into a single, unified PDF streamlines document management and simplifies sharing. Businesses can also automate PDF processing tasks like combining book chapters or consolidating multiple reports into one comprehensive document, improving overall efficiency. Incorporating automated PDF processing can significantly improve your workflow and ensure that important information is easily accessible and well-organized.

Methods for Merging PDFs in Node.js

Several robust libraries are available for merging PDF files within Node.js, each offering a distinct approach and set of features. These libraries range from those that provide a higher-level API for simplified merging to those that offer more granular control over the merging process. Understanding the options available empowers developers to select the most suitable library for their specific project requirements, balancing ease of use with flexibility and performance.

Using pdf-merger-js

pdf-merger-js is a Node.js library specifically designed to merge multiple PDF documents or selected parts of them efficiently. Inspired by PHP PDFMerger, this library is built upon pdf-lib (formerly pdfjs), ensuring a javascript-only environment free from external dependencies. This makes it a convenient choice for projects that require straightforward PDF merging capabilities without the complexity of managing system-level dependencies.

Installation

To install pdf-merger-js, use the following npm command:

npm install pdf-merger-js

Code Example (Node.js)

Here's a Node.js code sample that demonstrates how to merge PDFs using pdf-merger-js:

const PDFMerger = require('pdf-merger-js');
var merger = new PDFMerger();

(async () => {
  merger.add('pdf1.pdf');
  merger.add('pdf2.pdf', [2]);
  merger.add('pdf2.pdf', [1, 3]);
  merger.add('pdf2.pdf', '4, 7, 8');
  merger.add('pdf3.pdf', '1 to 2');
  merger.add('pdf3.pdf', '3-4');
  await merger.save('merged.pdf');
})();

This code first imports the pdf-merger-js library and creates a new merger instance. The add method is then used to specify the PDF files to be merged, along with optional page ranges. Finally, the save method saves the merged PDF to a new file named merged.pdf. You can also use online PDF form maker to edit the PDF.

Code Sample (Browser - React)

Here's a React example showcasing how to use pdf-merger-js/browser:

import PDFMerger from 'pdf-merger-js/browser';
import React, { useEffect, useState } from 'react';

const Merger = (files) => {
  const [mergedPdfUrl, setMergedPdfUrl] = useState();

  useEffect(() => {
    const render = async () => {
      const merger = new PDFMerger();

      for(const file of files) {
        await merger.add(file)
      }

      const mergedPdf = await merger.saveAsBlob();
      const url = URL.createObjectURL(mergedPdf);

      return setMergedPdfUrl(url);
    };

    render().catch((err) => {
      throw err;
    });

    () => setMergedPdfUrl({});
  }, [files, setMergedPdfUrl]);

  return !data ? (
    <>Loading<>
  ) : (
    <iframe
      height={1000}
      src={`${mergedPdfUrl}`}
      title='pdf-viewer'
      width='100%s'
    ></iframe>
  );
};

This React component imports the browser version of pdf-merger-js. It defines a component that takes an array of files, iterates through them to add them to the merger, and then saves the merged PDF as a Blob. It then creates a URL for the Blob to display it in an iframe. This method provides flexibility in incorporating PDF merging into a React-based web application.

Using pdf-lib

pdf-lib is another powerful JavaScript library that can be used for creating, modifying, and merging PDF documents. It provides a lower-level API, giving developers more control over the PDF manipulation process. This library is well-suited for more complex merging scenarios or when finer control over the output is required, providing a more flexible solution for advanced PDF processing.

Installation

To install pdf-lib, use the following npm command:

npm install pdf-lib

Code Example

Here's a code example that demonstrates how to merge PDFs using pdf-lib:

const fs = require('fs');
const { PDFDocument } = require('pdf-lib');

async function mergePdfs(pdfPaths, outputPath) {
    const mergedPdf = await PDFDocument.create();

    for (const pdfPath of pdfPaths) {
        const pdfBytes = fs.readFileSync(pdfPath);
        const pdf = await PDFDocument.load(pdfBytes);
        const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
        copiedPages.forEach(page => mergedPdf.addPage(page));
    }

    const mergedPdfBytes = await mergedPdf.save();
    fs.writeFileSync(outputPath, mergedPdfBytes);
}

This function reads the bytes of each PDF file specified in pdfPaths, loads each PDF document, and copies its pages into a new merged PDF. The merged PDF is then saved to the specified outputPath. This provides a robust and flexible way to merge PDFs using pdf-lib. You can add password protection feature after creating the PDF using Breeze PDF's editor.

Other Libraries (Brief Mention)

While pdf-merger-js and pdf-lib are popular choices, other libraries are available, each with its own strengths and weaknesses. node-pdftk is a wrapper for the PDFtk command-line tool, which requires PDFtk to be installed on the system, potentially adding complexity to the deployment process. HummusJS also supports combining PDFs using its appendPDFPagesFromPDF method, but it is no longer actively supported by its creator, so use with caution. Always evaluate the suitability of each library based on your project's specific requirements, considering factors such as ease of use, dependencies, and community support.

Introduction to Breeze PDF as a Streamlined Solution

Managing dependencies and navigating complex configurations when using PDF manipulation libraries can be challenging, especially in larger projects. Breeze PDF emerges as a cloud-based API providing a simplified approach to PDF merging. Breeze PDF alleviates the overhead associated with local library installations and configurations, offering an efficient, easy-to-use solution. It reduces the code implementation and dependency management efforts required to perform PDF merging, so that the development process becomes more streamlined.

Using Breeze PDF to Merge PDFs

Breeze PDF offers a straightforward way to merge PDFs using its cloud-based API. To use Breeze PDF, you'll need a Nutrient API Key. Breeze PDF provides a simple way to manipulate PDFs using its cloud-based API endpoint: https://api.nutrient.io/build. This example shows how to merge two PDFs using Breeze PDF with a step-by-step guide and a code snippet.

const axios = require('axios')
const FormData = require('form-data')
const fs = require('fs')

const formData = new FormData()
formData.append('instructions', JSON.stringify({
  parts: [
    {
      file: "first_half"
    },
    {
      file: "second_half"
    }
  ]
}))
formData.append('first_half', fs.createReadStream('first_half.pdf'))
formData.append('second_half', fs.createReadStream('second_half.pdf'))

;(async () => {
  try {
    const response = await axios.post('https://api.nutrient.io/build', formData, {
      headers: formData.getHeaders({
        'Authorization': 'Bearer your_api_key_here'
      }),
      responseType: "stream"
    })

    response.data.pipe(fs.createWriteStream("result.pdf"))
  } catch (e) {
    const errorString = await streamToString(e.response.data)
    console.log(errorString)
  }
})()

function streamToString(stream) {
  const chunks = []
  return new Promise((resolve, reject) => {
    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)))
    stream.on("error", (err) => reject(err))
    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")))
  })
}

This JavaScript code uses axios to send a POST request to the Breeze PDF API endpoint. It creates a FormData object containing the instructions for merging the PDFs, including the names of the files to be merged. The files are appended to the FormData as streams, and the request includes an authorization header with the Nutrient API Key. The response is then piped to a file stream to save the merged PDF.

Benefits of Using Breeze PDF

Breeze PDF offers several compelling advantages over traditional library-based solutions. With Breeze PDF, there’s no dependency management, which simplifies your development process. The code implementation is streamlined, leading to faster development cycles and cleaner code. Benefit from a reliable and scalable cloud infrastructure, ensuring your PDF merging tasks are always handled efficiently. Breeze PDF also offers a simple and transparent pricing model, making it easier to budget for your PDF processing needs. Security is paramount with HTTPS encryption and no document storage, ensuring the privacy and security of your data, and you can make PDF editable as you like. Using Breeze PDF simplifies PDF manipulation while enhancing security and scalability.

Error Handling and Considerations

When working with PDF merging, error handling is crucial for ensuring the reliability of your application. Handle encrypted PDFs by checking for encryption and using appropriate decryption techniques before merging. Large files can cause performance issues, so consider streaming or processing them in chunks to avoid memory exhaustion. Address potential API errors by implementing robust error handling and retry mechanisms. These considerations are essential for building a resilient PDF merging solution.

Conclusion

This article explored various methods for merging PDFs in Node.js, covering popular libraries like pdf-merger-js and pdf-lib, as well as the streamlined approach offered by Breeze PDF. Breezepdf.com offers simplicity, scalability, and reliability. Breeze PDF significantly reduces the complexities associated with PDF manipulation. For those seeking a straightforward, efficient, and secure solution, Breeze PDF provides a compelling option that simplifies development while ensuring robust performance. Explore Breeze PDF for your PDF manipulation needs and experience the benefits of streamlined, cloud-based PDF processing.