Images are an important part of many web applications. Whether you are building an e-commerce platform, blog, social media application, or admin dashboard, you need a reliable way to store and serve uploaded files.

While storing images directly on your application server may work for small projects, it can become difficult to manage as your application grows.

A better solution is Amazon S3.

Amazon S3 allows you to store images and files in cloud storage and access them from your Laravel application. Laravel provides built-in filesystem support that makes uploading files to Amazon S3 simple.

In this guide, you will learn how to store images on Amazon S3 with Laravel, configure S3 credentials, upload images, generate URLs, manage file visibility, delete files, and follow security best practices.

---

What Is Amazon S3?

Amazon S3, or Amazon Simple Storage Service, is a cloud object storage service provided by AWS.

You can use Amazon S3 to store:

• Images
• Videos
• PDF files
• Documents
• Backups
• User uploads
• Application assets

Instead of storing uploaded files directly on your Laravel server, your application uploads them to an S3 bucket.

The basic flow looks like this:

User Uploads Image
        ↓
Laravel Application
        ↓
Laravel Filesystem
        ↓
Amazon S3 Bucket
        ↓
Image URL Returned

Your Laravel application can then save the image path or URL in the database.

---

Why Use Amazon S3 With Laravel?

Using Amazon S3 for image storage provides several advantages.

Scalability

Your server does not need to store every uploaded image locally.

As your application grows, Amazon S3 can handle a large amount of storage without requiring you to manage additional disks.

Better File Management

Your application code and uploaded files are separated.

This can make deployments easier because user-uploaded files are not directly tied to one application server.

High Availability

Cloud object storage is designed for reliable storage and access to files.

Works Well With Multiple Servers

If your Laravel application runs on multiple servers, storing files on one local server can create problems.

With S3, every server can access the same file storage.

CDN Integration

You can later combine Amazon S3 with a CDN such as CloudFront to improve image delivery performance.

---

Prerequisites

Before integrating Amazon S3 with Laravel, you need:

• A Laravel application
• An AWS account
• An Amazon S3 bucket
• AWS credentials with appropriate S3 permissions

You will also need the AWS SDK package used by Laravel’s S3 filesystem driver.

---

Step 1: Install the Required S3 Package

Laravel uses Flysystem for filesystem integrations.

Install the S3 adapter if it is not already included in your project:

composer require league/flysystem-aws-s3-v3

After installation, Laravel can use the S3 filesystem disk.

---

Step 2: Create an Amazon S3 Bucket

Log in to your AWS account and create a new S3 bucket.

Choose a bucket name, for example:

my-laravel-images

You will also need to select an AWS region.

For example:

ap-south-1

Keep your selected region because Laravel needs it when connecting to the bucket.

Make sure your Laravel application and AWS configuration use the correct bucket name and region.

---

Step 3: Create AWS Credentials

Your Laravel application needs permission to access the S3 bucket.

AWS provides credentials that typically include:

AWS Access Key ID
AWS Secret Access Key

These credentials should have only the permissions required by your application.

For example, if your application only uploads and reads images from one bucket, avoid giving unnecessary administrative permissions.

A simplified permission policy may allow actions such as:

• s3:GetObject
• s3:PutObject
• s3:DeleteObject

Always follow the principle of least privilege.

---

Step 4: Configure Laravel Environment Variables

Add your S3 configuration to the .env file.

AWS_ACCESS_KEY_ID=your-access-key
AWS_SECRET_ACCESS_KEY=your-secret-key
AWS_DEFAULT_REGION=ap-south-1
AWS_BUCKET=my-laravel-images
AWS_USE_PATH_STYLE_ENDPOINT=false

If your application uses a custom S3-compatible storage provider, you may also need an endpoint configuration.

For standard Amazon S3 usage, Laravel’s default S3 configuration is usually sufficient.

Never hardcode your AWS access key or secret key directly inside your PHP files.

Keep sensitive credentials in environment variables or use a secure credential management approach.

---

Step 5: Configure the S3 Disk

Laravel stores filesystem disk configuration in:

config/filesystems.php

A typical S3 disk configuration looks like this:

's3' => [
    'driver' => 's3',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION'),
    'bucket' => env('AWS_BUCKET'),
    'url' => env('AWS_URL'),
    'endpoint' => env('AWS_ENDPOINT'),
    'use_path_style_endpoint' => env(
        'AWS_USE_PATH_STYLE_ENDPOINT',
        false
    ),
],

Laravel will use these values when you select the s3 disk.

If you change configuration values in a production environment using cached configuration, clear or rebuild the configuration cache as appropriate.

For example:

php artisan config:clear

Or:

php artisan config:cache

---

Step 6: Create an Image Upload Form

Let’s create a simple form for uploading an image.

<form
    action="/upload-image"
    method="POST"
    enctype="multipart/form-data"
>
    @csrf

    <input
        type="file"
        name="image"
        accept="image/*"
    >

    <button type="submit">
        Upload Image
    </button>
</form>

The important part is:

enctype="multipart/form-data"

Without it, the browser will not correctly send the uploaded file.

---

Step 7: Create the Upload Route

Add a route to handle the request.

use App\Http\Controllers\ImageController;
use Illuminate\Support\Facades\Route;

Route::post(
    '/upload-image',
    [ImageController::class, 'store']
);

---

Step 8: Validate the Uploaded Image

Before uploading any file, validate it.

public function store(Request $request)
{
    $request->validate([
        'image' => [
            'required',
            'image',
            'mimes:jpg,jpeg,png,webp',
            'max:5120',
        ],
    ]);

    // Upload image
}

This validation ensures that:

• An image was uploaded
• The uploaded file is treated as an image
• Only allowed file types are accepted
• The file size does not exceed the configured limit

Here:

5120 KB = 5 MB

Validation is important for both security and storage management.

---

Step 9: Upload an Image to Amazon S3

Laravel provides a simple way to upload files using the store() method.

use Illuminate\Http\Request;

public function store(Request $request)
{
    $request->validate([
        'image' => [
            'required',
            'image',
            'mimes:jpg,jpeg,png,webp',
            'max:5120',
        ],
    ]);

    $path = $request
        ->file('image')
        ->store('images', 's3');

    return response()->json([
        'message' => 'Image uploaded successfully.',
        'path' => $path,
    ]);
}

The uploaded file will be stored inside:

images/

in your configured S3 bucket.

Laravel automatically generates a unique filename.

The returned value may look similar to:

images/a8b2c3d4-image.jpg

This path can be stored in your database.

---

Using storeAs() to Set a Custom File Name

Sometimes you may want to control the file name.

Laravel provides storeAs().

$filename = time() . '-' .
    $request->file('image')->getClientOriginalName();

$path = $request
    ->file('image')
    ->storeAs(
        'images',
        $filename,
        's3'
    );

However, using the original filename alone is generally not recommended because different users may upload files with the same name.

A safer approach is to generate a unique name.

use Illuminate\Support\Str;

$filename = Str::uuid() . '.' .
    $request->file('image')->extension();

$path = $request
    ->file('image')
    ->storeAs(
        'images',
        $filename,
        's3'
    );

This produces unique filenames such as:

images/9a4f2c7b-xxxx-xxxx.jpg

---

Using Storage::putFile()

You can also upload files using Laravel’s Storage facade.

use Illuminate\Support\Facades\Storage;

$path = Storage::disk('s3')
    ->putFile(
        'images',
        $request->file('image')
    );

This explicitly tells Laravel to use the s3 disk.

You can then return the path:

return response()->json([
    'path' => $path,
]);

---

How to Get the Image URL From Amazon S3

After uploading the image, you often need a URL to display it.

Laravel provides:

Storage::disk('s3')->url($path);

Example:

use Illuminate\Support\Facades\Storage;

$url = Storage::disk('s3')->url(
    'images/example.jpg'
);

You can return it in an API response:

return response()->json([
    'image_url' => $url,
]);

If the object is accessible through the configured public URL, the generated URL can be used directly in your frontend.

---

Store the S3 Image Path in the Database

A common approach is to store only the file path instead of the complete URL.

For example:

images/products/abc123.jpg

Your database migration might contain:

$table->string('image_path')->nullable();

Then save the path:

$path = $request
    ->file('image')
    ->store('products', 's3');

$product->image_path = $path;

$product->save();

Later, generate the URL dynamically:

Storage::disk('s3')
    ->url($product->image_path);

This is often more flexible than permanently storing a full URL because the storage domain or CDN configuration can change later.

---

Displaying an S3 Image in Laravel Blade

Suppose your database stores:

images/products/product.jpg

You can generate the URL in Blade:

<img
    src="{{ Storage::disk('s3')->url($product->image_path) }}"
    alt="{{ $product->name }}"
>

A cleaner approach is to create an accessor in your model.

use Illuminate\Support\Facades\Storage;

public function getImageUrlAttribute(): ?string
{
    if (! $this->image_path) {
        return null;
    }

    return Storage::disk('s3')
        ->url($this->image_path);
}

Now you can use:

$product->image_url

In Blade:

<img
    src="{{ $product->image_url }}"
    alt="{{ $product->name }}"
>

This keeps storage-related logic out of your views.

---

Uploading Public Images

If your images are intended to be publicly accessible, you may upload them with public visibility.

$path = $request
    ->file('image')
    ->storePublicly(
        'images',
        's3'
    );

You can also use Storage:

Storage::disk('s3')->put(
    'images/example.jpg',
    file_get_contents(
        $request->file('image')
    ),
    'public'
);

Be careful with public visibility.

Public access may be appropriate for:

• Product images
• Blog images
• Public profile images

It is generally not appropriate for:

• Private documents
• User identification files
• Financial records
• Sensitive uploads

---

Private Images and Temporary URLs

For private files, you should avoid exposing a permanent public URL.

Laravel can generate a temporary URL for supported storage drivers such as S3.

use Illuminate\Support\Facades\Storage;

$url = Storage::disk('s3')->temporaryUrl(
    $path,
    now()->addMinutes(10)
);

The generated URL expires after the specified time.

This is useful for:

• Private documents
• Paid content
• User-specific files
• Sensitive reports

For example:

return response()->json([
    'download_url' => Storage::disk('s3')
        ->temporaryUrl(
            $document->path,
            now()->addMinutes(5)
        ),
]);

This allows the user temporary access without making the object permanently public.

---

Uploading Images to a Specific S3 Folder

You can organize images into folders by passing a path.

For example:

$path = $request
    ->file('image')
    ->store(
        'products/images',
        's3'
    );

The structure in S3 will look like:

products/
    images/
        image-1.jpg
        image-2.jpg

For user profile images:

$path = $request
    ->file('image')
    ->store(
        'users/' . auth()->id(),
        's3'
    );

This can make file organization easier.

---

Updating an Existing Image

When a user uploads a new image, you may want to delete the old one.

For example:

use Illuminate\Support\Facades\Storage;

if ($product->image_path) {

    Storage::disk('s3')->delete(
        $product->image_path
    );
}

$path = $request
    ->file('image')
    ->store(
        'products',
        's3'
    );

$product->update([
    'image_path' => $path,
]);

However, there is an important consideration.

If you delete the old image first and the new upload fails, your product may no longer have an image.

A safer flow is:

Upload New Image
        ↓
Save New Path
        ↓
Confirm Success
        ↓
Delete Old Image

Example:

$newPath = $request
    ->file('image')
    ->store(
        'products',
        's3'
    );

$oldPath = $product->image_path;

$product->update([
    'image_path' => $newPath,
]);

if ($oldPath) {
    Storage::disk('s3')->delete($oldPath);
}

For more critical workflows, consider additional error handling or cleanup strategies.

---

Deleting an Image From Amazon S3

Laravel makes deleting an S3 object simple.

use Illuminate\Support\Facades\Storage;

Storage::disk('s3')->delete(
    $product->image_path
);

You can delete multiple files:

Storage::disk('s3')->delete([
    'images/one.jpg',
    'images/two.jpg',
]);

After successfully deleting the object, you may also update or remove the related database record.

---

A Complete Laravel S3 Image Upload Example

Here is a complete controller example.

<?php

namespace App\Http\Controllers;

use App\Models\Product;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class ProductImageController extends Controller
{
    public function store(Request $request)
    {
        $request->validate([
            'image' => [
                'required',
                'image',
                'mimes:jpg,jpeg,png,webp',
                'max:5120',
            ],
        ]);

        $path = $request
            ->file('image')
            ->store('products', 's3');

        $url = Storage::disk('s3')
            ->url($path);

        return response()->json([
            'message' => 'Image uploaded successfully.',
            'path' => $path,
            'url' => $url,
        ]);
    }
}

The complete upload process is:

User Selects Image
        ↓
Laravel Request
        ↓
Validate File
        ↓
Upload to S3
        ↓
Receive File Path
        ↓
Save Path in Database
        ↓
Generate URL When Needed

---

Using Laravel Validation for Secure Image Uploads

Never trust the original filename or client-provided metadata alone.

Validate uploaded files before storing them.

A good starting point is:

$request->validate([
    'image' => [
        'required',
        'image',
        'mimes:jpg,jpeg,png,webp',
        'max:5120',
    ],
]);

Depending on your application, you may also want to validate image dimensions.

For example:

'image' => [
    'required',
    'image',
    'max:5120',
    'dimensions:min_width=200,min_height=200',
],

Set limits based on your application’s actual requirements.

---

Common Problems When Using Amazon S3 With Laravel

Access Denied Error

An AccessDenied error usually means your AWS credentials or IAM permissions are not correctly configured.

Check:

• Access key
• Secret key
• IAM permissions
• Bucket policy
• Object permissions

Make sure the application has permission to perform the required S3 actions.

---

Wrong AWS Region

If your bucket is created in one AWS region but Laravel is configured to use another, requests may fail.

Check:

AWS_DEFAULT_REGION=ap-south-1

Make sure it matches the bucket’s configured region.

---

Image URL Does Not Open

The object may be private, the generated URL may not match your bucket configuration, or public access may be intentionally blocked.

For private files, use a temporary URL instead of trying to expose a public object URL.

---

File Is Uploaded but Not Found

Check the exact path returned by Laravel.

For example:

$path = $request
    ->file('image')
    ->store('images', 's3');

The returned path should be used when retrieving or deleting the file.

Do not manually guess the filename or folder path.

---

Best Practices for Laravel and Amazon S3

1. Store Paths Instead of Full URLs

Prefer:

products/abc123.jpg

instead of permanently storing:

https://example-bucket.s3.amazonaws.com/products/abc123.jpg

You can generate the URL dynamically.

This gives you more flexibility if you later change domains or add a CDN.

---

2. Validate Every Upload

Always validate:

• File type
• File size
• Image dimensions when needed

Do not allow unrestricted file uploads.

---

3. Use Unique File Names

Avoid relying only on the original filename.

Generate unique names or let Laravel generate them automatically.

---

4. Keep AWS Credentials Secure

Never commit your .env file containing real AWS credentials to Git.

Also avoid exposing access keys in frontend JavaScript.

For production environments running on AWS infrastructure, consider using managed identity or role-based credentials where appropriate instead of long-lived credentials.

---

5. Use Private Storage for Sensitive Files

Do not make every S3 object public.

Use private objects and temporary URLs for sensitive content.

---

6. Delete Unused Images

When users replace or delete records, remove unused images where appropriate.

This helps prevent unnecessary storage costs and orphaned files.

---

7. Consider Direct Browser Uploads for Large Files

For large uploads, sending the file through your Laravel server may not always be ideal.

A common architecture is:

Browser
   ↓
Request Temporary Upload Permission
   ↓
Laravel Application
   ↓
Generate Signed Upload Request
   ↓
Browser Uploads Directly to S3

This can reduce load on your Laravel application servers.

---

Frequently Asked Questions

How do I upload an image to Amazon S3 in Laravel?

You can use Laravel’s filesystem methods:

$path = $request
    ->file('image')
    ->store('images', 's3');

Laravel uploads the file to the configured S3 disk and returns the stored path.

---

Where do I configure Amazon S3 in Laravel?

Configure your AWS credentials in the .env file and use the s3 disk configuration in config/filesystems.php.

---

How do I get an S3 image URL in Laravel?

Use:

Storage::disk('s3')->url($path);

For private files, consider using:

Storage::disk('s3')->temporaryUrl(
    $path,
    now()->addMinutes(10)
);

---

Should I store the S3 URL or path in the database?

In many cases, storing the path is more flexible.

For example:

products/product-image.jpg

You can generate the current URL dynamically when needed.

---

Can Laravel delete files from Amazon S3?

Yes.

Storage::disk('s3')->delete($path);

Laravel will send the delete request through the configured S3 filesystem disk.

---

Conclusion

Using Amazon S3 with Laravel is a reliable way to manage images and other uploaded files as your application grows.

Laravel’s filesystem abstraction makes the process straightforward:

Configure S3
    ↓
Validate Image
    ↓
Upload Using Laravel Storage
    ↓
Save File Path
    ↓
Generate URL When Needed

For most applications, a simple upload looks like this:

$path = $request
    ->file('image')
    ->store('images', 's3');

The important part is not just uploading the file. You should also validate uploads, protect AWS credentials, use appropriate file visibility, store paths cleanly, and delete unused files.

By following these Laravel S3 best practices, you can build a scalable and secure file upload system for your Laravel application.