This comprehensive tutorial will walk you through everything you need to know about handling file uploads in Laravel. From uploading images and PDFs to securing file storage and building reusable upload systems, this guide is designed to make you confident in managing files in Laravel applications.
Table of contents [Show]
File uploads are one of the most common and essential features in modern web applications. Whether you’re building a blog that lets users upload profile pictures, an e-commerce system where admins upload product images, or a document management system where files like PDFs and Word docs are shared—file handling is unavoidable.
Laravel, being a modern PHP framework, provides a robust and secure way to handle file uploads. With built-in features for validation, storage abstraction, and easy retrieval, developers can implement clean and flexible file handling in their applications.
Before diving into Laravel-specific details, let’s understand why file uploads matter:
composer create-project laravel/laravel file-upload-demo
cd file-upload-demo
php artisan serve
For this demo, create a database called file_uploads and update your .env file.
DB_DATABASE=file_uploads
DB_USERNAME=root
DB_PASSWORD=
Laravel comes with a storage folder for handling files. To make uploaded files accessible publicly, run:
php artisan storage:link
We’ll create a migration for storing uploaded files metadata.
php artisan make:migration create_files_table --create=files
// database/migrations/xxxx_xx_xx_create_files_table.php
public function up()
{
Schema::create('files', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('path');
$table->string('type')->nullable();
$table->timestamps();
});
}
php artisan migrate
php artisan make:model File
// app/Models/File.php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class File extends Model
{
protected $fillable = ['name', 'path', 'type'];
}
php artisan make:controller FileController
// app/Http/Controllers/FileController.php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Models\File;
class FileController extends Controller
{
public function index()
{
$files = File::all();
return view('files.index', compact('files'));
}
public function store(Request $request)
{
$request->validate([
'file' => 'required|mimes:jpg,jpeg,png,pdf|max:2048'
]);
$uploadedFile = $request->file('file');
$filename = time().'_'.$uploadedFile->getClientOriginalName();
$path = $uploadedFile->storeAs('uploads', $filename, 'public');
File::create([
'name' => $filename,
'path' => $path,
'type' => $uploadedFile->getClientMimeType()
]);
return back()->with('success', 'File uploaded successfully.');
}
}
// routes/web.php
use App\Http\Controllers\FileController;
Route::get('files', [FileController::class, 'index'])->name('files.index');
Route::post('files', [FileController::class, 'store'])->name('files.store');
<!-- resources/views/files/index.blade.php -->
<!DOCTYPE html>
<html>
<head>
<title>File Upload Demo</title>
</head>
<body>
@if(session('success'))
<p >{{ session('success') }}</p>
@endif
<form action="{{ route('files.store') }}" method="POST" enctype="multipart/form-data">
@csrf
<input type="file" name="file" required>
<button type="submit">Upload</button>
</form>
<h2>Uploaded Files</h2>
<ul>
@foreach($files as $file)
<li>
<a href="{{ asset('storage/'.$file->path) }}" target="_blank">
{{ $file->name }}
</a>
</li>
@endforeach
</ul>
</body>
</html>Laravel provides robust validation rules to ensure uploaded files meet requirements:
mimes:jpg,jpeg,png,pdf → restricts file typemax:2048 → restricts size to 2MBrequired → ensures a file is uploadedExample:
$request->validate([
'file' => 'required|mimes:jpg,jpeg,png,pdf|max:2048'
]);
To upload multiple files, simply add the multiple attribute to your input:
<input type="file" name="files[]" multiple>
foreach ($request->file('files') as $uploadedFile) {
$filename = time().'_'.$uploadedFile->getClientOriginalName();
$path = $uploadedFile->storeAs('uploads', $filename, 'public');
File::create([
'name' => $filename,
'path' => $path,
'type' => $uploadedFile->getClientMimeType()
]);
}
Laravel supports local, public, and cloud storage like Amazon S3 and Google Drive. Configure in config/filesystems.php.
| Disk | Description | Use Case |
|---|---|---|
| local | Stores files in storage/app | Private application data |
| public | Stores files in storage/app/public | Accessible files (images, documents) |
| s3 | Amazon S3 bucket storage | Cloud file hosting |
public if they’re not meant to be accessed directly.
return response()->download(storage_path('app/public/'.$file->path));
Storage::disk('public')->delete($file->path);
$file->delete();
File uploads are a powerful feature in Laravel applications. With its built-in validation, storage abstraction, and secure handling, Laravel makes it easy to implement everything from simple image uploads to advanced document management systems.
By following this tutorial, you now know how to upload, validate, store, and manage files (images, PDFs, and more) in Laravel. With practice, you can extend this knowledge to build professional file handling systems that serve real-world needs.
This article is a comprehensive tutorial on using the Prohibited Validation Rules in Laravel. You will learn how to apply prohibited, prohibited_if, and prohibited_unless with clear explanations, real-life scenarios, and code examples. This guide is perfect for developers who want to master advanced validation techniques in Laravel applications.
This detailed tutorial explores request validation in Laravel controllers. You’ll learn multiple techniques—basic controller validation, using form request classes, custom rules, conditional validation, error handling, localization, and best practices. With practical examples, code snippets, and structured explanations, this article is designed for beginners to advance learner.
This guide teaches you how to deploy Laravel applications to production servers. From preparing your environment and configuring Nginx or Apache, to database migrations, caching, performance optimization, CI/CD pipelines, and security practices—this article covers everything step by step.It’s suitable for both beginners and advanced developers who want to ship stable, secure & scalable app.
