Image Metadata and Dimension Detection: exif-parser vs image-size vs image-type vs imageinfo

When handling image uploads or processing assets in Node.js, you often need to know three things: what format is it, how big is it, and what metadata does it contain? The packages exif-parser, image-size, image-type, and imageinfo address these needs, but they solve different parts of the puzzle. Let's compare how they handle detection, performance, and API design.

📏 Getting Image Dimensions

image-size is the dedicated tool for reading width and height. It supports many formats (PNG, JPEG, GIF, SVG, etc.) and works with buffers or file paths.

import sizeOf from 'image-size';

const dimensions = sizeOf('images/batch/folder/image.png');
console.log(dimensions.width, dimensions.height);
// Output: 100 100

imageinfo also provides dimensions but uses a callback-based API typical of older Node.js libraries. It returns an object with width, height, and type.

import imageinfo from 'imageinfo';

const buffer = fs.readFileSync('image.png');
const info = imageinfo(buffer);

if (info.valid) {
  console.log(info.width, info.height);
}

exif-parser does not provide general image dimensions. It focuses strictly on EXIF data. If the EXIF data contains pixel dimensions, you can read them, but this is not reliable for all images.

// exif-parser: No direct dimension API
// You must parse EXIF tags which may or may not exist
const parser = require('exif-parser').create(buffer);
const tags = parser.parse();
// tags.tags.PixelXDimension might exist, but don't count on it

image-type does not provide dimensions. It only identifies the file format.

// image-type: No dimension support
// Only returns file type info

🔍 Detecting File Type

image-type is the most reliable for checking the actual file signature (magic numbers). It ignores file extensions, which is critical for security.

import imageType from 'image-type';

const buffer = fs.readFileSync('mystery-file');
const type = imageType(buffer);

if (type) {
  console.log(type.ext, type.mime);
  // Output: 'png', 'image/png'
}

image-size infers the type internally to determine dimensions but does not expose a clean type-detection API as its primary feature. You can access the type property from the result.

import sizeOf from 'image-size';

const dimensions = sizeOf('image.jpg');
console.log(dimensions.type);
// Output: 'jpg'

imageinfo returns the format type alongside dimensions in its result object.

import imageinfo from 'imageinfo';

const info = imageinfo(buffer);
console.log(info.format); 
// Output: 'PNG' or 'JPEG'

exif-parser does not detect file types. It assumes the input is a JPEG or TIFF containing EXIF data. Passing a PNG will result in empty or failed parsing.

// exif-parser: Assumes JPEG/TIFF
// No type detection mechanism
const parser = require('exif-parser').create(pngBuffer);
const result = parser.parse(); 
// Result will likely be empty or invalid

📷 Reading EXIF Metadata

exif-parser is the only package in this list designed specifically for EXIF data. It exposes tags like orientation, GPS, ISO, and shutter speed.

import exif from 'exif-parser';

const parser = exif.create(buffer);
parser.parse((err, result) => {
  if (err) throw err;
  console.log(result.tags.Make); // Camera brand
  console.log(result.tags.Orientation); // For auto-rotate
});

image-size does not read EXIF metadata. It stops after finding the dimension markers.

// image-size: No EXIF support
const dimensions = sizeOf('image.jpg');
// dimensions object has no EXIF tags

image-type does not read EXIF metadata. It only reads the file header signature.

// image-type: No EXIF support
const type = imageType(buffer);
// Returns only ext and mime

imageinfo does not read EXIF metadata. It focuses on basic structural info like size and format.

// imageinfo: No EXIF support
const info = imageinfo(buffer);
// No tags or metadata properties available

🌊 Stream Support

image-size supports streams, which is useful for large files where loading the whole buffer into memory is expensive.

import sizeOf from 'image-size';
import fs from 'fs';

const stream = fs.createReadStream('large-image.png');
sizeOf(stream, (err, dimensions) => {
  console.log(dimensions.width);
});

image-type also supports streams, allowing type detection without waiting for the full download.

import imageType from 'image-type';
import fs from 'fs';

const stream = fs.createReadStream('upload');
const type = await imageType.stream(stream);
console.log(type?.ext);

exif-parser works primarily with buffers. While you can pipe data into it, the API is designed around having the binary data available to parse tags.

// exif-parser: Buffer focused
const parser = exif.create(buffer);
// Stream support is not a primary feature

imageinfo expects a buffer. It does not have built-in stream handling.

// imageinfo: Buffer only
const info = imageinfo(buffer);
// Must read file fully before calling

⚠️ Maintenance and Status

image-size is actively maintained and widely used in production ecosystems. It receives updates for new formats and bug fixes.

image-type is also actively maintained and considered the standard for file type detection in the Node.js ecosystem.

exif-parser is stable but sees less frequent updates. It remains the go-to for pure JS EXIF parsing without native dependencies.

imageinfo is deprecated or effectively unmaintained. It has not seen significant updates in years. Using it introduces risk for security and compatibility.

📊 Summary Table

💡 The Big Picture

These tools are not direct competitors; they are complementary pieces of an image processing pipeline.

image-type should be your first line of defense. Use it to validate uploads before doing anything else. It ensures a file claiming to be a JPEG is actually a JPEG.

image-size is your standard for dimensions. Use it when you need to enforce aspect ratios or calculate storage needs. Its stream support makes it safe for large files.

exif-parser is your specialist for metadata. Use it when you need to auto-rotate images based on orientation tags or extract GPS data for mapping features.

imageinfo should be avoided. Its functionality is split better between image-size and image-type, both of which are more modern and reliable.

Final Thought: For a robust image upload handler, combine image-type (for security), image-size (for validation), and exif-parser (for orientation correction). Do not rely on a single legacy package to do it all.