Upload Files in Express with Multer and Store Them in S3 (2026)

Express’s Multer middleware, when combined with AWS S3, turns a common web development task into a surprisingly robust file-handling system. The most counterintuitive aspect is realizing that S3 isn’t just a dumping ground for files; it’s a fully distributed object store with its own versioning, access control, and even event triggers, all of which can be leveraged before your Express app even finishes processing the request.

Let’s see this in action. Imagine a simple Express route designed to accept a file upload and save it directly to an S3 bucket.

const express = require('express');
const multer = require('multer');
const AWS = require('aws-sdk');
const fs = require('fs');
const path = require('path');

const app = express();
const port = 3000;

// Configure AWS SDK
AWS.config.update({
    accessKeyId: 'YOUR_ACCESS_KEY_ID',
    secretAccessKey: 'YOUR_SECRET_ACCESS_KEY',
    region: 'us-east-1' // e.g., us-east-1
});

const s3 = new AWS.S3();
const bucketName = 'your-unique-bucket-name';

// Configure Multer
// Multer storage configuration for S3
const storage = multerS3({
    s3: s3,
    bucket: bucketName,
    acl: 'public-read', // Or 'private' depending on your needs
    key: function (req, file, cb) {
        // Generate a unique filename
        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
        cb(null, 'uploads/' + file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
    }
});

const upload = multer({ storage: storage });

app.post('/upload', upload.single('myFile'), (req, res) => {
    if (!req.file) {
        return res.status(400).send('No file uploaded.');
    }

    // req.file contains information about the uploaded file
    // including its location on S3 if using multerS3
    const s3Location = req.file.location;
    const s3Key = req.file.key;

    console.log(`File uploaded successfully to S3: ${s3Location}`);
    res.send({
        message: 'File uploaded successfully!',
        url: s3Location,
        key: s3Key
    });
});

app.listen(port, () => {
    console.log(`Server listening on port ${port}`);
});

In this setup, multer handles the incoming multipart/form-data request. Instead of saving the file to the server’s local disk, we’ve configured multerS3 (a specific storage engine for Multer) to directly stream the file content to your designated S3 bucket. The storage configuration defines where and how the file is saved. The bucket is self-explanatory, acl sets permissions, and the key function generates the unique path and filename within your S3 bucket, prepending uploads/ to organize files.

The upload.single('myFile') middleware intercepts requests to /upload and looks for a file field named myFile. If found, it processes the upload. Crucially, when multerS3 is used, req.file doesn’t just contain local filesystem details; it gets populated with S3-specific metadata like location (the full URL to the file) and key (the object’s path within the bucket). Your Express route then simply receives confirmation and the S3 URL.

The primary problem this architecture solves is decoupling file storage from your application server. Instead of your server’s disk filling up or needing complex file management, S3 acts as a highly scalable, durable, and cost-effective storage backend. This means your Express application can remain stateless and focus on its core logic, while S3 handles the heavy lifting of storing and serving potentially vast amounts of user-generated content. You gain durability (S3 is designed for 99.999999999% durability) and scalability without needing to manage file servers yourself.

The most overlooked aspect of this integration is how S3’s event-driven capabilities can be triggered by these uploads. For instance, you can configure S3 to trigger AWS Lambda functions automatically when a new object is created. This means you could have a Lambda function resize an uploaded image, scan it for malware, or update a database record, all without your Express server needing to poll for changes or initiate further actions. This is achieved by setting up "Event Notifications" on your S3 bucket, specifying the event type (e.g., s3:ObjectCreated:*) and the destination (e.g., a Lambda function ARN).

The next logical step after mastering direct S3 uploads is to implement more granular control over file access, perhaps using pre-signed URLs for temporary, secure downloads.