Hello Developers, File uploads are the backbone of many modern applications—whether you're building a social media platform that stores profile pictures, an e-commerce app that uploads product images, or a backend service that processes PDFs, documents, audio, and more.
In the Node.js ecosystem, no library has become as reliable and developer-friendly as Multer for handling file uploads. As of 2025, Multer remains the industry standard for working with multipart/form-data, the encoding type used when uploading files from forms.
This guide will walk you through file uploads from scratch: understanding how Multer works, configuring storage, handling single/multiple uploads, validation, error handling, folder structure, best practices, and real-world patterns used in production apps.
Let’s break it down in a simple and easy ways
What is Multer and Why It’s Still Popular in 2025?
Multer is a Node.js middleware that helps you handle file uploads in Express applications.
Think of Multer as a traffic controller between your frontend and backend:
Your client uploads a file through HTML form or frontend (React/Angular/Vue).
The form sends data as multipart/form-data.
Multer extracts the file from the request and saves it.
You receive file information on the backend (path, size, file name, etc.)
Why Multer Still Matters in 2025
Fast and reliable
Zero dependencies on databases
Easy-to-configure storage engines
Works with cloud storage like AWS S3, Cloudinary, Firebase
Well documented and battle-tested
Lightweight and flexible
Setting Up File Uploads in Node.js Using Multer (2025 Guide)
Let’s build a complete file upload system using the latest patterns.
Step 1: Install Dependencies
npm init -y
npm install express multer dotenv cors
Packages:
express – backend framework
multer – handles file uploads
dotenv – load env variables
cors – allow cross-origin requests
Step 2: Basic Project Structure
project/
│-- uploads/
│-- server.js
│-- middleware/
│ └── upload.js
│-- routes/
│ └── uploadRoutes.js
│-- controllers/
│ └── uploadController.js
│-- .env
Step 3: Configure Multer Storage
Multer gives you two main ways to save files:
DiskStorage (save files locally)
MemoryStorage (buffer files, used before uploading to cloud storage)
In most apps, we start with DiskStorage.
middleware/upload.js
const multer = require("multer");
const path = require("path");
// Storage engine
const storage = multer.diskStorage({
destination: (req, file, cb) => {
cb(null, "uploads/");
},
filename: (req, file, cb) => {
const uniqueName = Date.now() + "-" + file.originalname;
cb(null, uniqueName);
}
});
// File filter (validation)
const fileFilter = (req, file, cb) => {
const allowedTypes = /jpeg|jpg|png|pdf/;
const extName = allowedTypes.test(path.extname(file.originalname).toLowerCase());
if (extName) {
cb(null, true);
} else {
cb("Error: Only images or PDF files allowed!");
}
};
// Upload middleware
const upload = multer({
storage: storage,
limits: { fileSize: 5 * 1024 * 1024 }, // 5MB limit
fileFilter: fileFilter
});
module.exports = upload;
What this does:
Stores files inside the uploads folder
Renames files with a unique timestamp
Validates file types (JPEG, PNG, PDF)
Applies 5MB size limit
Handles upload errors gracefully
Step 4: Create Upload Controller
// controllers/uploadController.js
exports.uploadSingleFile = (req, res) => {
if (!req.file) {
return res.status(400).json({ message: "No file uploaded" });
}
res.json({
message: "File uploaded successfully",
file: req.file
});
};
exports.uploadMultipleFiles = (req, res) => {
if (!req.files || req.files.length === 0) {
return res.status(400).json({ message: "No files uploaded" });
}
res.json({
message: "Files uploaded successfully",
files: req.files
});
};
Step 5: Create Upload Routes
// routes/uploadRoutes.js
const express = require("express");
const router = express.Router();
const upload = require("../middleware/upload");
const uploadController = require("../controllers/uploadController");
// Single file upload
router.post("/single", upload.single("file"), uploadController.uploadSingleFile);
// Multiple files upload
router.post("/multiple", upload.array("files", 5), uploadController.uploadMultipleFiles);
module.exports = router;
Now you can upload:
1 file → /single
Up to 5 files → /multiple
Step 6: Setup Express Server
// server.js
const express = require("express");
const cors = require("cors");
const uploadRoutes = require("./routes/uploadRoutes");
const app = express();
app.use(cors());
app.use(express.json());
app.use("/uploads", express.static("uploads")); // Make folder public
app.use("/api/upload", uploadRoutes);
app.listen(5000, () => {
console.log("Server running on port 5000");
});
And It's Done!
Your server can now upload files easily.
How to Upload Files from Frontend (2025 Edition)
HTML Form Example:
<form action="http://localhost:5000/api/upload/single" enctype="multipart/form-data" method="POST">
<input type="file" name="file" />
<button type="submit">Upload</button>
</form>
React Example:
const formData = new FormData();
formData.append("file", selectedFile);
axios.post("http://localhost:5000/api/upload/single", formData);
Saving Files to Cloud Storage (2025 Standard)
In production apps, developers rarely store files locally.
Preferred cloud options:
Cloudinary (recommended for images)
AWS S3 (best for scalable file storage)
Firebase Storage
Supabase Storage
DigitalOcean Spaces
Multer’s MemoryStorage is perfect for cloud uploads:
const upload = multer({ storage: multer.memoryStorage() });
After that, you upload the buffer to your cloud provider.
Handling Multer Errors
router.post("/single", (req, res) => {
upload.single("file")(req, res, function (err) {
if (err instanceof multer.MulterError) {
return res.status(400).json({ message: err.message });
} else if (err) {
return res.status(400).json({ message: err });
}
res.json({ message: "Upload successful", file: req.file });
});
});
Best Practices for File Uploads in 2025
Limit file size (always)
Validate file types
Sanitize file names
Avoid storing sensitive files publicly
Don’t store large files in your DB
Use cloud storage for scalability
Use rate limiting to prevent abuse
Never trust user-uploaded file paths
Real-World Use Cases
Here are examples of where Multer shines:
Profile picture upload
Resume/CV uploads
Product images in e-commerce
PDF reports
Blog cover images
Image compression and resizing
Upload image → Optimise → Save to Cloud
Multer integrates very well with processing libraries like Sharp (for resizing).
Conclustion
Handling file uploads in Node.js can feel confusing at first, but with Multer, the entire process becomes simple and efficient. In 2025, Multer continues to be the most recommended solution due to its flexibility, stability, and ease of integration.You now have a complete, production-ready setup:
Single & multiple file uploads
Storage engine configuration
File validation
Error handling
Public folder access
No comments:
Post a Comment