image-size vs imageinfo: Extracting Image Dimensions in Node.js

When building backend services, build tools, or asset pipelines in Node.js, you often need to know an image's width and height without decoding the entire file. Loading a 10MB image just to read its header is wasteful. image-size and imageinfo both solve this by reading specific bytes from the file stream. However, they differ in format support, API design, and maintenance momentum. Let's compare how they handle real-world engineering tasks.

📂 Supported Formats: Broad Coverage vs Core Web Standards

image-size supports a wide array of formats, including modern web standards and some proprietary types.

• It handles JPEG, PNG, GIF, BMP, PSD, SVG, WebP, and even HEIC.
• This makes it robust for user-generated content platforms where file types vary wildly.

// image-size: Supports many formats out of the box
const sizeOf = require('image-size');

try {
  const dimensions = sizeOf('path/to/image.webp');
  console.log(dimensions.width, dimensions.height);
} catch (e) {
  console.error('Unsupported format or corrupt file');
}

imageinfo focuses on the most common web formats to keep the logic lean.

• It primarily targets JPEG, PNG, GIF, and BMP.
• If you encounter newer formats like WebP or HEIC, it may fail or return incomplete data.

// imageinfo: Focused on core formats
const imageinfo = require('imageinfo');

const info = imageinfo.checkBuffer(buffer);
if (info) {
  console.log(info.width, info.height, info.format);
} else {
  console.log('Unknown format');
}

⚡ API Style: Sync/Async Flexibility vs Buffer Focus

image-size offers both synchronous and asynchronous methods.

• You can pass a file path directly for sync operations.
• For non-blocking I/O, it provides a callback-based async API or Promise support.

// image-size: Async usage with Promises
const sizeOf = require('image-size');

sizeOf('path/to/image.png', (err, dimensions) => {
  if (err) throw err;
  console.log(`${dimensions.width}x${dimensions.height}`);
});

// Or with promises in newer versions
const dimensions = await sizeOf('path/to/image.png');

imageinfo is designed to work directly with buffers or strings.

• It does not inherently handle file paths; you must read the file yourself.
• This gives you control over I/O but adds boilerplate code for file reading.

// imageinfo: Requires manual buffer loading
const fs = require('fs');
const imageinfo = require('imageinfo');

const buffer = fs.readFileSync('path/to/image.png');
const info = imageinfo.checkBuffer(buffer);

if (info) {
  console.log(`${info.width}x${info.height}`);
}

🛡️ Error Handling: Typed Errors vs Null Returns

image-size throws exceptions when it encounters invalid files or unsupported types.

• This forces you to use try/catch blocks, ensuring errors aren't silently ignored.
• It provides specific error messages that help debug corrupt assets.

// image-size: Throws on error
try {
  const dimensions = sizeOf('corrupt.jpg');
} catch (err) {
  // Handle specific error types
  console.error('Failed to read dimensions:', err.message);
}

imageinfo typically returns null or undefined if detection fails.

• You must explicitly check the return value before accessing properties.
• This can lead to runtime errors if you forget to validate the result.

// imageinfo: Returns null on failure
const info = imageinfo.checkBuffer(buffer);

if (!info) {
  // Must manually handle failure case
  console.warn('Could not determine image info');
  return;
}

console.log(info.width);

📦 Installation and Dependencies

image-size has a few dependencies to handle different format parsers.

• This keeps the core logic modular but increases the node_modules footprint slightly.
• It is actively maintained, which means security patches are applied regularly.

# image-size: Standard install
npm install image-size

imageinfo is often a single-file module with zero dependencies.

• This makes it extremely fast to install and ideal for serverless functions where size matters.
• However, fewer dependencies mean fewer eyes on the code for security audits.

# imageinfo: Lightweight install
npm install imageinfo

🌐 Real-World Scenarios

Scenario 1: User Avatar Upload Validation

You need to ensure uploaded avatars are square and under a certain resolution.

• ✅ Best choice: image-size
• Why? Users might upload WebP or HEIC from mobile devices. image-size handles these gracefully.

// image-size: Handle diverse uploads
const dimensions = sizeOf(req.file.buffer);
if (dimensions.width !== dimensions.height) {
  return res.status(400).send('Image must be square');
}

Scenario 2: Static Site Build Optimization

You are generating srcset attributes for a blog during build time.

• ✅ Best choice: imageinfo
• Why? You control the asset pipeline, so formats are known (PNG/JPG). Speed and simplicity win.

// imageinfo: Fast build script
const buffer = fs.readFileSync(`./assets/${file}`);
const info = imageinfo.checkBuffer(buffer);
if (info) {
  generateSrcSet(info.width);
}

Scenario 3: Async Stream Processing

You are processing images from a remote URL stream without saving to disk.

• ✅ Best choice: image-size
• Why? Its async API integrates better with stream pipelines without manual buffer management.

// image-size: Stream friendly
const request = require('request');
const sizeOf = require('image-size');

request(url).on('response', function (response) {
  sizeOf(response, function (err, dimensions) {
    console.log(dimensions);
  });
});

📌 Summary Table

💡 Final Recommendation

Think in terms of format risk and integration complexity:

• Need to trust user uploads? → Use image-size. The broad format support prevents crashes when users upload unexpected file types.
• Building a controlled pipeline? → Use imageinfo. If you control the input (e.g., internal assets), the lighter weight is advantageous.
• Need async flow? → image-size has better native support for non-blocking operations.

Both libraries solve the same fundamental problem efficiently. image-size is the robust, general-purpose tool for production apps facing the open web. imageinfo is the scalpel for specific, controlled tasks where every kilobyte counts.