busboy vs formidable vs multer vs @fastify/multipart
Node.js File Upload Libraries Comparison
Search packages..
1 Year
busboyformidablemulter@fastify/multipartSimilar Packages:
What's Node.js File Upload Libraries?

File upload libraries in Node.js facilitate the handling of multipart/form-data, which is commonly used for uploading files. These libraries provide various functionalities such as parsing incoming request data, managing file streams, and handling file storage. They are essential for building applications that require file uploads, ensuring that developers can efficiently manage file data while adhering to best practices for security and performance.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
busboy16,968,9122,925124 kB34--
formidable11,861,436-204 kB-a month agoMIT
multer6,981,76511,79928.3 kB2488 days agoMIT
@fastify/multipart288,760505158 kB184 months agoMIT
Feature Comparison: busboy vs formidable vs multer vs @fastify/multipart

Performance

  • busboy:

    Busboy is lightweight and designed for streaming, which allows it to handle file uploads with minimal memory usage. Its performance is excellent for parsing large files as it processes data in chunks rather than loading everything into memory at once.

  • formidable:

    Formidable provides a good balance between performance and ease of use. While it may not be as fast as busboy or @fastify/multipart, it offers a comprehensive feature set that can be advantageous for more complex file handling scenarios.

  • multer:

    Multer is built on top of busboy and provides a middleware layer for Express.js applications. While it may introduce some overhead compared to busboy directly, its ease of integration with Express makes it a popular choice for many developers.

  • @fastify/multipart:

    @fastify/multipart is optimized for performance, leveraging Fastify's asynchronous architecture to handle file uploads efficiently. It minimizes overhead and maximizes throughput, making it suitable for applications with high file upload demands.

Ease of Use

  • busboy:

    Busboy requires more manual setup and handling compared to higher-level libraries. While it offers flexibility, developers may need to write more boilerplate code to manage file uploads effectively.

  • formidable:

    Formidable is user-friendly and provides a high-level API that abstracts much of the complexity involved in file uploads. Its built-in features for file renaming and storage make it easy to use for developers of all skill levels.

  • multer:

    Multer is very easy to set up and use within Express applications. Its middleware approach allows developers to quickly configure file upload handling with minimal code, making it a go-to choice for many Express.js developers.

  • @fastify/multipart:

    @fastify/multipart is designed to be straightforward for Fastify users, providing a simple API that integrates well with Fastify's request lifecycle. Its documentation is clear, making it easy to implement file uploads in Fastify applications.

File Handling Features

  • busboy:

    Busboy provides low-level access to file streams, allowing developers to implement custom file handling logic. However, it does not provide built-in features for file validation or storage, requiring developers to implement these functionalities themselves.

  • formidable:

    Formidable offers a rich set of features, including file renaming, automatic file storage, and customizable upload paths. It also supports handling of both files and fields in a single request, making it versatile for complex forms.

  • multer:

    Multer provides built-in support for file size limits and file type filtering, allowing developers to easily enforce upload constraints. It also supports multiple file uploads and can be configured to store files in memory or on disk.

  • @fastify/multipart:

    @fastify/multipart supports various file handling features, including file size limits, file type validation, and streaming uploads. It allows developers to customize the handling of uploaded files to fit their needs.

Integration

  • busboy:

    Busboy is a standalone library and can be integrated into any Node.js application. However, it requires more manual setup to work with frameworks like Express or Koa, as it does not provide built-in middleware.

  • formidable:

    Formidable can be used in any Node.js application, but it is particularly well-suited for Express due to its straightforward API. It requires minimal configuration to get started and works well with existing Express middleware.

  • multer:

    Multer is specifically designed for use with Express.js, making it easy to integrate as middleware. It fits naturally into the Express request handling flow, allowing for quick setup and configuration.

  • @fastify/multipart:

    @fastify/multipart is specifically designed for Fastify, ensuring seamless integration with its ecosystem. It takes advantage of Fastify's lifecycle hooks and asynchronous capabilities for optimal performance.

Community and Support

  • busboy:

    Busboy has a smaller community compared to some other libraries, but it is well-maintained and has been widely adopted in the Node.js ecosystem. Documentation is available, but may not be as extensive as other libraries.

  • formidable:

    Formidable has been around for a long time and has a strong user base. It offers good documentation and community support, making it a reliable choice for developers seeking assistance.

  • multer:

    Multer enjoys a large community due to its popularity within the Express ecosystem. It has extensive documentation and numerous tutorials available, making it easy for developers to find help and resources.

  • @fastify/multipart:

    @fastify/multipart benefits from the growing Fastify community, which provides active support and a wealth of resources for developers. Its documentation is comprehensive and regularly updated.

How to Choose: busboy vs formidable vs multer vs @fastify/multipart
  • busboy:

    Choose busboy if you are looking for a lightweight and low-level streaming parser for multipart form data. It is suitable for applications where you want fine-grained control over file uploads and processing, and you don't need additional features that come with higher-level libraries.

  • formidable:

    Choose formidable if you need a robust solution that supports file uploads and form parsing with a focus on ease of use. It provides a comprehensive set of features, including file renaming and storage options, making it a good choice for applications that require more than just basic file handling.

  • multer:

    Choose multer if you are using Express.js and need a middleware for handling multipart/form-data. It is easy to set up and provides a simple API for configuring file storage options, making it ideal for applications that require quick and straightforward file upload functionality.

  • @fastify/multipart:

    Choose @fastify/multipart if you are using the Fastify framework and need a high-performance solution that integrates seamlessly with Fastify's ecosystem. It is designed for speed and efficiency, making it ideal for applications that require handling large file uploads.

Similar Npm Packages to busboy

busboy is a Node.js library that provides a fast and efficient way to parse incoming form data, especially file uploads. It is designed to handle multipart/form-data requests, which are commonly used for file uploads in web applications. Busboy streams the data, allowing for efficient processing without consuming large amounts of memory, making it ideal for handling large files or high volumes of uploads.

While busboy is a powerful tool for handling file uploads, there are several alternatives available in the Node.js ecosystem that offer similar functionalities. Here are a few notable options:

  • connect-busboy is a middleware that integrates busboy with Connect, a popular framework for building web applications in Node.js. It allows you to easily handle file uploads in your Connect-based applications. If you're already using Connect and want to leverage busboy's capabilities, connect-busboy provides a straightforward way to do so.

  • express-fileupload is a simple and lightweight middleware for handling file uploads in Express applications. It allows you to easily manage file uploads with minimal setup. If you're looking for a quick and easy solution for file uploads in an Express app, express-fileupload is a great choice.

  • formidable is another popular library for parsing form data, including file uploads, in Node.js applications. It provides a robust set of features for handling multipart/form-data requests and is known for its reliability and ease of use. Formidable is a solid option if you need a comprehensive solution for handling form submissions and file uploads.

  • multer is a middleware for handling multipart/form-data, primarily used for uploading files in Express applications. It is easy to set up and provides various configuration options for managing file uploads, such as file size limits and storage options. If you're working with Express and need a dedicated solution for file uploads, multer is a popular and well-supported choice.

For a detailed comparison of these packages, check out the following link: Comparing busboy vs connect-busboy vs express-fileupload vs formidable vs multer.

Similar Npm Packages to formidable

formidable is a popular Node.js library for parsing form data, especially file uploads. It is designed to handle multipart/form-data, which is commonly used for uploading files via HTML forms. Formidable provides a simple and efficient way to process incoming form data, making it a go-to choice for developers building applications that require file uploads or form submissions. Its robust features include support for streaming uploads, progress tracking, and handling various form data types.

While formidable is a powerful option, there are several alternatives available for handling file uploads and form data in Node.js applications. Here are a few noteworthy alternatives:

  • busboy is a lightweight and fast streaming parser for multipart/form-data. It is designed to handle file uploads efficiently by processing data as it arrives, which can be beneficial for large files. Busboy is a great choice if you need a minimalistic solution that focuses on performance and low overhead, especially for applications that require handling file uploads without the additional features that come with more comprehensive libraries.

  • express-fileupload is a simple middleware for handling file uploads in Express applications. It allows you to easily add file upload capabilities to your Express server with minimal configuration. If you are already using Express and want a straightforward way to handle file uploads, express-fileupload is a convenient option that integrates seamlessly with your existing Express setup.

  • form-data is a library that allows you to create and manipulate form data in a way that is compatible with the multipart/form-data encoding. It is particularly useful for sending form data via HTTP requests, such as when uploading files to a server. If you need to construct and send form data programmatically, form-data is a solid choice that provides a simple API for building and managing form data.

  • multer is a middleware for handling multipart/form-data in Express applications, specifically for file uploads. It provides a simple and flexible way to handle file uploads with various storage options, including in-memory storage and disk storage. Multer is an excellent choice if you are looking for a comprehensive solution that integrates well with Express and offers advanced features for managing file uploads.

To explore how formidable compares with busboy, express-fileupload, form-data, and multer, check out the comparison: Comparing busboy vs express-fileupload vs form-data vs formidable vs multer.

Similar Npm Packages to multer

multer is a middleware for handling multipart/form-data, which is primarily used for uploading files in Node.js applications, particularly those built with Express.js. It simplifies the process of file uploads by providing a straightforward API for handling file storage, validation, and retrieval. With multer, developers can easily manage file uploads and integrate them into their applications, making it a popular choice for projects that require file handling capabilities.

While multer is a robust solution for file uploads, there are several alternatives available that also cater to file handling needs in Node.js applications. Here are a few noteworthy alternatives:

  • busboy is a lightweight and efficient library for parsing multipart/form-data. It is designed for high-performance file uploads and provides a streaming interface, making it suitable for handling large files. Busboy is particularly useful when you need fine-grained control over file uploads and want to avoid the overhead of more feature-rich libraries like multer. Its simplicity and performance make it a solid choice for applications that require efficient file parsing without additional complexity.

  • express-fileupload is a simple and easy-to-use middleware for handling file uploads in Express applications. It allows developers to quickly add file upload capabilities with minimal configuration. Express-fileupload supports various file upload features, including file size limits and file type validation, making it a convenient option for projects that need basic file upload functionality without extensive setup.

  • formidable is another popular library for parsing form data, especially file uploads in Node.js applications. It provides a comprehensive set of features for handling file uploads, including support for streaming uploads, file renaming, and progress tracking. Formidable is well-suited for applications that require more advanced file handling capabilities and want to manage file uploads with a robust and flexible API.

To see how multer compares with busboy, express-fileupload, and formidable, check out the comparison: Comparing busboy vs express-fileupload vs formidable vs multer.

Similar Npm Packages to @fastify/multipart

@fastify/multipart is a powerful and efficient plugin for the Fastify web framework that enables handling multipart/form-data, which is commonly used for file uploads. This package is designed to work seamlessly with Fastify's architecture, providing a simple and performant way to manage file uploads while maintaining high throughput and low overhead. It supports various features such as file streaming, validation, and handling of multiple files, making it an excellent choice for applications that require file upload capabilities.

While @fastify/multipart offers a robust solution for file uploads, there are several alternatives in the Node.js ecosystem that also provide similar functionality. Here are a few noteworthy options:

  • busboy is a lightweight and efficient streaming parser for multipart/form-data. It is designed to handle file uploads and can be easily integrated into any Node.js application. Busboy is particularly well-suited for applications that require a minimalistic approach to file uploads, as it provides a straightforward API for parsing incoming requests and handling file streams. Its performance and low memory footprint make it a popular choice among developers looking for a simple solution.
  • formidable is another popular library for parsing form data, especially for file uploads. It provides a more feature-rich API compared to busboy and includes support for file uploads, form fields, and progress events. Formidable is a good choice for applications that require more advanced features, such as handling different types of form data and managing file uploads with additional metadata.
  • multer is a middleware for handling multipart/form-data in Express applications. It is widely used in the Express ecosystem and provides a simple and flexible way to handle file uploads. Multer allows developers to configure storage options, file filtering, and limits on file sizes, making it a versatile choice for applications that need to manage file uploads while integrating with Express.

To see how @fastify/multipart compares with busboy, formidable, and multer, check out the comparison: Comparing @fastify/multipart vs busboy vs formidable vs multer.

README for busboy

Description

A node.js module for parsing incoming HTML form data.

Changes (breaking or otherwise) in v1.0.0 can be found here.

Requirements

Install

npm install busboy

Examples

  • Parsing (multipart) with default options:
const http = require('http');

const busboy = require('busboy');

http.createServer((req, res) => {
  if (req.method === 'POST') {
    console.log('POST request');
    const bb = busboy({ headers: req.headers });
    bb.on('file', (name, file, info) => {
      const { filename, encoding, mimeType } = info;
      console.log(
        `File [${name}]: filename: %j, encoding: %j, mimeType: %j`,
        filename,
        encoding,
        mimeType
      );
      file.on('data', (data) => {
        console.log(`File [${name}] got ${data.length} bytes`);
      }).on('close', () => {
        console.log(`File [${name}] done`);
      });
    });
    bb.on('field', (name, val, info) => {
      console.log(`Field [${name}]: value: %j`, val);
    });
    bb.on('close', () => {
      console.log('Done parsing form!');
      res.writeHead(303, { Connection: 'close', Location: '/' });
      res.end();
    });
    req.pipe(bb);
  } else if (req.method === 'GET') {
    res.writeHead(200, { Connection: 'close' });
    res.end(`
      <html>
        <head></head>
        <body>
          <form method="POST" enctype="multipart/form-data">
            <input type="file" name="filefield"><br />
            <input type="text" name="textfield"><br />
            <input type="submit">
          </form>
        </body>
      </html>
    `);
  }
}).listen(8000, () => {
  console.log('Listening for requests');
});

// Example output:
//
// Listening for requests
//   < ... form submitted ... >
// POST request
// File [filefield]: filename: "logo.jpg", encoding: "binary", mime: "image/jpeg"
// File [filefield] got 11912 bytes
// Field [textfield]: value: "testing! :-)"
// File [filefield] done
// Done parsing form!
  • Save all incoming files to disk:
const { randomFillSync } = require('crypto');
const fs = require('fs');
const http = require('http');
const os = require('os');
const path = require('path');

const busboy = require('busboy');

const random = (() => {
  const buf = Buffer.alloc(16);
  return () => randomFillSync(buf).toString('hex');
})();

http.createServer((req, res) => {
  if (req.method === 'POST') {
    const bb = busboy({ headers: req.headers });
    bb.on('file', (name, file, info) => {
      const saveTo = path.join(os.tmpdir(), `busboy-upload-${random()}`);
      file.pipe(fs.createWriteStream(saveTo));
    });
    bb.on('close', () => {
      res.writeHead(200, { 'Connection': 'close' });
      res.end(`That's all folks!`);
    });
    req.pipe(bb);
    return;
  }
  res.writeHead(404);
  res.end();
}).listen(8000, () => {
  console.log('Listening for requests');
});

API

Exports

busboy exports a single function:

( function )(< object >config) - Creates and returns a new Writable form parser stream.

  • Valid config properties:

    • headers - object - These are the HTTP headers of the incoming request, which are used by individual parsers.

    • highWaterMark - integer - highWaterMark to use for the parser stream. Default: node's stream.Writable default.

    • fileHwm - integer - highWaterMark to use for individual file streams. Default: node's stream.Readable default.

    • defCharset - string - Default character set to use when one isn't defined. Default: 'utf8'.

    • defParamCharset - string - For multipart forms, the default character set to use for values of part header parameters (e.g. filename) that are not extended parameters (that contain an explicit charset). Default: 'latin1'.

    • preservePath - boolean - If paths in filenames from file parts in a 'multipart/form-data' request shall be preserved. Default: false.

    • limits - object - Various limits on incoming data. Valid properties are:

      • fieldNameSize - integer - Max field name size (in bytes). Default: 100.

      • fieldSize - integer - Max field value size (in bytes). Default: 1048576 (1MB).

      • fields - integer - Max number of non-file fields. Default: Infinity.

      • fileSize - integer - For multipart forms, the max file size (in bytes). Default: Infinity.

      • files - integer - For multipart forms, the max number of file fields. Default: Infinity.

      • parts - integer - For multipart forms, the max number of parts (fields + files). Default: Infinity.

      • headerPairs - integer - For multipart forms, the max number of header key-value pairs to parse. Default: 2000 (same as node's http module).

This function can throw exceptions if there is something wrong with the values in config. For example, if the Content-Type in headers is missing entirely, is not a supported type, or is missing the boundary for 'multipart/form-data' requests.

(Special) Parser stream events

  • file(< string >name, < Readable >stream, < object >info) - Emitted for each new file found. name contains the form field name. stream is a Readable stream containing the file's data. No transformations/conversions (e.g. base64 to raw binary) are done on the file's data. info contains the following properties:

    • filename - string - If supplied, this contains the file's filename. WARNING: You should almost never use this value as-is (especially if you are using preservePath: true in your config) as it could contain malicious input. You are better off generating your own (safe) filenames, or at the very least using a hash of the filename.

    • encoding - string - The file's 'Content-Transfer-Encoding' value.

    • mimeType - string - The file's 'Content-Type' value.

    Note: If you listen for this event, you should always consume the stream whether you care about its contents or not (you can simply do stream.resume(); if you want to discard/skip the contents), otherwise the 'finish'/'close' event will never fire on the busboy parser stream. However, if you aren't accepting files, you can either simply not listen for the 'file' event at all or set limits.files to 0, and any/all files will be automatically skipped (these skipped files will still count towards any configured limits.files and limits.parts limits though).

    Note: If a configured limits.fileSize limit was reached for a file, stream will both have a boolean property truncated set to true (best checked at the end of the stream) and emit a 'limit' event to notify you when this happens.

  • field(< string >name, < string >value, < object >info) - Emitted for each new non-file field found. name contains the form field name. value contains the string value of the field. info contains the following properties:

    • nameTruncated - boolean - Whether name was truncated or not (due to a configured limits.fieldNameSize limit)

    • valueTruncated - boolean - Whether value was truncated or not (due to a configured limits.fieldSize limit)

    • encoding - string - The field's 'Content-Transfer-Encoding' value.

    • mimeType - string - The field's 'Content-Type' value.

  • partsLimit() - Emitted when the configured limits.parts limit has been reached. No more 'file' or 'field' events will be emitted.

  • filesLimit() - Emitted when the configured limits.files limit has been reached. No more 'file' events will be emitted.

  • fieldsLimit() - Emitted when the configured limits.fields limit has been reached. No more 'field' events will be emitted.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.