Upload CSV files and import to Database using Laravel PHP

CSV (Comma-Separated Values) files are one of the most popular formats for storing and transferring data between applications. Whether you're importing customer information, employee records, products, inventory, or student details, CSV files provide a quick and efficient way to move large amounts of data into a database.

Laravel, one of the most popular PHP frameworks, makes importing CSV files simple and secure. With its powerful validation system, Eloquent ORM, and built-in file handling capabilities, developers can create a reliable CSV import feature with minimal effort.

In this tutorial, you'll learn how to upload a CSV file and import its data into a MySQL database using Laravel. This guide is beginner-friendly and follows Laravel best practices, making it suitable for both new and experienced developers.

 

Why Use CSV Import in Laravel?

Many businesses work with Excel or CSV files every day. Instead of entering records manually, importing CSV files saves time and reduces errors.

Some common use cases include:

• Importing customer information

• Uploading employee records

• Managing product catalogs

• Student admission data

• Vendor information

• Sales reports

• Inventory management

• Contact lists

Laravel provides an excellent foundation for building these import systems because it offers secure file uploads, validation, database abstraction, and clean code architecture.

 

Benefits of Importing CSV Files in Laravel

Using Laravel for CSV imports offers several advantages:

Faster Data Entry

Instead of manually adding hundreds or thousands of records, users can upload a single CSV file to import all the data within seconds.

Improved Accuracy

CSV import minimizes human errors that typically occur during manual data entry.

Better Productivity

Businesses can update large datasets quickly, allowing employees to focus on more important tasks.

Easy Validation

Laravel allows you to validate uploaded files and imported data before saving it into the database.

Secure File Handling

Laravel protects your application through request validation and secure file upload mechanisms.

 

Prerequisites

Before starting the project, ensure your system has the following installed:

• PHP 8.x or later

• Composer

• Laravel 10 or Laravel 11

• MySQL Database

• Apache or Nginx

• Visual Studio Code (or any code editor)

You should also have basic knowledge of:

• PHP

• Laravel

• MySQL

• HTML Forms

 

Step 1: Create a New Laravel Project

First, create a fresh Laravel application using Composer.

composer create-project laravel/laravel csv-import

 

Navigate to the project directory:

cd csv-import

 

Start the development server:

php artisan serve

 

Visit:

http://127.0.0.1:8000

 

Your Laravel application is now ready.

 

Step 2: Configure Database Connection

Open the .env file and update your database credentials.

DB_CONNECTION=mysql

DB_HOST=127.0.0.1

DB_PORT=3306

DB_DATABASE=csv_import

DB_USERNAME=root

DB_PASSWORD=

 

After updating the database configuration, clear the configuration cache.

php artisan config:clear

 

Laravel will now connect to your MySQL database.

 

Step 3: Create Migration

Generate a migration for storing users (or any data you want to import).

php artisan make:migration create_users_table

 

Update the migration file.

Schema::create('users', function (Blueprint $table) {

    $table->id();

    $table->string('name');

    $table->string('email')->unique();

    $table->string('phone');

    $table->timestamps();

});

 

Run the migration.

php artisan migrate

 

The table will now be created in your database.

 

Step 4: Create Model

Generate the model.

php artisan make:model User

 

Open the User model and define the fillable fields.

protected $fillable = [

    'name',

    'email',

    'phone'

];

 

This allows Laravel to perform mass assignment safely while importing records.

 

Step 5: Create Controller

Generate a controller.

php artisan make:controller CSVImportController

 

Inside the controller, create methods for displaying the upload page and importing CSV data.

public function index()

{

    return view('import');

}

 

Another method will be used later to process the uploaded CSV file.

Keeping upload logic inside a dedicated controller makes your application organized and easier to maintain.

 

Step 6: Create Routes

Open the routes/web.php file and add the following routes.

use App\Http\Controllers\CSVImportController;

 

Route::get('/import',[CSVImportController::class,'index']);

 

Route::post('/import',

[CSVImportController::class,'store']);

 

The GET route displays the upload form, while the POST route processes the uploaded CSV file.

 

Step 7: Create the Upload Form

Inside the resources/views folder, create a file named:

import.blade.php

 

Add the following HTML form.

<form action="/import"

method="POST"

enctype="multipart/form-data">

 

@csrf

 

<input type="file" name="csv_file">

 

<button type="submit">

Upload CSV

</button>

 

</form>

 

The multipart/form-data attribute is required because the form uploads a file.

Laravel also requires the @csrf directive to protect against cross-site request forgery (CSRF) attacks.

 

Step 8: Validate the Uploaded CSV File

Before importing data into the database, always validate the uploaded file. Validation prevents users from uploading unsupported file types and helps maintain data integrity.

Inside the store() method of your controller, add validation:

$request->validate([

    'csv_file' => 'required|mimes:csv,txt|max:2048'

]);

 

This validation ensures that:

• A file is selected before submission.

• Only .csv and .txt file formats are accepted.

• The uploaded file size does not exceed the specified limit.

If validation fails, Laravel automatically redirects the user back to the upload page and displays the validation errors.

Validating user uploads is an important security practice because it protects your application from invalid or potentially harmful files.

 

Read CSV File and Import Data into MySQL Database Using Laravel

In Part 1, we created the Laravel project, configured the database, created the migration and model, added routes, built the upload form, and validated the uploaded CSV file.

Now it's time to process the uploaded CSV file and save the records into the MySQL database.

 

Step 9: Read the Uploaded CSV File

After validating the uploaded file, retrieve it from the request.

$file = $request->file('csv_file');

Laravel stores the uploaded file temporarily, allowing you to access its path before processing it.

Next, open the CSV file using PHP's built-in fopen() function.

$handle = fopen($file->getRealPath(), "r");

The getRealPath() method returns the temporary file location on the server.

Using fopen() enables Laravel to read the CSV file one row at a time, which is memory-efficient even for moderately large files.

 

Step 10: Skip the CSV Header Row

Most CSV files contain column headings such as:

Name,Email,Phone

Since these are not actual records, skip the first row before importing the data.

fgetcsv($handle);

This reads and ignores the first row, ensuring only the data rows are inserted into the database.

 

Step 11: Loop Through the CSV Records

Now read every row in the CSV file.

while (($row = fgetcsv($handle, 1000, ",")) !== FALSE) {

 

}

The fgetcsv() function converts each row into an array.

For example, a CSV row like:

John Doe,john@example.com,9876543210

becomes

$row[0] // John Doe

$row[1] // john@example.com

$row[2] // 9876543210

This makes it easy to insert values into the database.

 

Step 12: Insert Records into the Database

Inside the loop, create a new record using Laravel's Eloquent model.

User::create([

    'name'  => $row[0],

    'email' => $row[1],

    'phone' => $row[2]

]);

Because we already defined the $fillable property in the model, Laravel allows mass assignment safely.

Each row from the CSV file is inserted into the database as a new record.

 

Complete CSV Import Method

Below is a simple example of the complete store() method.

public function store(Request $request)

{

    $request->validate([

        'csv_file' => 'required|mimes:csv,txt'

    ]);

 

    $file = $request->file('csv_file');

 

    $handle = fopen($file->getRealPath(), 'r');

 

    fgetcsv($handle);

 

    while (($row = fgetcsv($handle, 1000, ",")) !== FALSE) {

 

        User::create([

            'name' => $row[0],

            'email' => $row[1],

            'phone' => $row[2]

        ]);

    }

 

    fclose($handle);

 

    return back()->with('success','CSV Imported Successfully');

}

This method is suitable for small and medium-sized CSV files.

 

Display Success Message

After importing the data, show a confirmation message.

In your Blade file:

@if(session('success'))

 

<div class="alert alert-success">

{{ session('success') }}

</div>

 

@endif

This provides immediate feedback to the user that the import was successful.

 

Prevent Duplicate Records

One common challenge during CSV imports is duplicate data. If users upload the same CSV file multiple times, duplicate records may be inserted into the database.

Laravel provides an elegant solution using updateOrCreate().

User::updateOrCreate(

 

[

'email'=>$row[1]

],

 

[

'name'=>$row[0],

'phone'=>$row[2]

]

 

);

This checks whether the email already exists.

• If it exists, Laravel updates the existing record.

• If it doesn't exist, Laravel creates a new one.

This approach keeps your database clean and avoids duplicate entries.

 

Validate Individual CSV Rows

Sometimes a CSV file contains incomplete or invalid data.

For example:

• Missing email address

• Empty name

• Invalid phone number

Before inserting a row, verify that the required fields are available.

Example:

if(empty($row[0]) || empty($row[1])){

 

continue;

 

}

Using continue skips invalid rows without stopping the import process.

This makes your application more reliable when handling user-uploaded files.

 

Handle Import Errors Gracefully

Unexpected issues such as malformed CSV files or database errors can interrupt the import process.

Wrap your import logic inside a try...catch block.

try{

 

// Import Code

 

}

 

catch(Exception $e){

 

return back()->with('error',$e->getMessage());

 

}

This ensures that errors are handled gracefully and meaningful messages are displayed to users instead of a blank error page.

 

Optimize Performance for Large CSV Files

When importing thousands of records, performance becomes important.

Here are some best practices:

Increase Execution Time

Large files may take longer to process.

set_time_limit(300);

This allows the script to run for up to five minutes.

 

Increase Memory Limit

ini_set('memory_limit','512M');

This prevents memory exhaustion during large imports.

 

Use Chunk Processing

Instead of loading the entire CSV file into memory, process it row by row or in small batches.

Chunk processing reduces memory usage and improves stability.

 

Insert Records in Bulk

Rather than inserting one row at a time, collect multiple rows into an array and insert them together.

Bulk inserts significantly improve performance for large datasets.

 

Queue Heavy Imports

If users frequently upload CSV files containing tens of thousands of records, consider using Laravel Queues.

Queues allow the import to run in the background without making users wait for the request to finish.

This improves the overall user experience and keeps your application responsive.

 

Security Best Practices

CSV imports involve user-uploaded files, so security should always be a priority.

Follow these recommendations:

• Accept only CSV or TXT file formats.

• Validate all uploaded files.

• Limit maximum upload size.

• Skip invalid rows instead of crashing the import.

• Escape unexpected characters when necessary.

• Validate email addresses before insertion.

• Use Laravel validation rules consistently.

• Never trust user-uploaded data without verification.

These practices help protect your application from invalid data and potential security risks.

 

Common Mistakes to Avoid

Many beginners encounter issues while implementing CSV imports.

Avoid these common mistakes:

• Forgetting to skip the CSV header row.

• Missing the @csrf token in the upload form.

• Not defining $fillable in the model.

• Importing duplicate records.

• Ignoring validation before insertion.

• Uploading Excel files without proper conversion to CSV.

• Not closing the file using fclose().

• Processing extremely large files without chunking or queues.

• Assuming every CSV file follows the same column order.

• Not providing user-friendly success or error messages.

By avoiding these mistakes, you'll build a more reliable and maintainable import feature.

 

Conclusion

Importing CSV files into a MySQL database using Laravel is a practical feature that saves time and improves productivity for businesses handling large amounts of data.

With Laravel's validation, Eloquent ORM, and file handling capabilities, you can create a secure and efficient import system with minimal code. By validating uploaded files, skipping invalid records, preventing duplicate entries, and optimizing performance for large datasets, your application can handle real-world import requirements confidently.

Whether you're building a CRM, inventory management system, HR portal, school management application, or eCommerce platform, a well-designed CSV import feature enhances usability and streamlines data management. Following Laravel best practices ensures your import process remains scalable, secure, and easy to maintain as your application grows.

FAQ

Frequently Asked Questions (FAQs)

1. How do I upload a CSV file in Laravel?

Uploading a CSV file in Laravel is simple. Create a form with the multipart/form-data attribute, validate the uploaded file using Laravel's validation rules, and process it in a controller. Laravel's file handling features make uploading secure and efficient.

 

2. How can I import CSV data into a MySQL database using Laravel?

You can import CSV data by reading the uploaded file with PHP's fgetcsv() function or using a package like Laravel Excel. Loop through each row, validate the data, and insert it into the database using Laravel's Eloquent ORM.

 

3. Can Laravel import large CSV files?

Yes. Laravel can handle large CSV files by increasing the execution time and memory limit, processing records in chunks, or using Laravel Queues for background processing. These methods improve performance and prevent server timeouts.

 

4. How do I prevent duplicate records while importing CSV files?

Laravel provides methods like updateOrCreate() and firstOrCreate() to prevent duplicate records. You can check unique fields such as email, product code, or customer ID before inserting data into the database.

 

5. Which file formats can Laravel import?

Laravel can import CSV, TXT, Excel (.xlsx), and other file formats depending on the libraries used. CSV is the most common because it is lightweight, easy to process, and supported by most applications.

 

6. Why should I validate CSV files before importing?

Validation ensures that only valid and safe data enters your database. It helps prevent incorrect file formats, missing fields, duplicate records, and invalid values that could affect your application's performance and data integrity.

 

7. Can I import Excel files directly in Laravel?

Yes. By using the Laravel Excel package (Maatwebsite Excel), you can import Excel files such as .xlsx and .xls directly without converting them into CSV format.

 

8. What is the best package for CSV and Excel imports in Laravel?

The most popular package is Laravel Excel (Maatwebsite Excel). It provides advanced features such as chunk reading, queued imports, validation, exporting data, and support for Excel and CSV file formats.

 

9. How do I display a success message after importing a CSV file?

After completing the import, redirect the user back with a success session message.

Example:

return back()->with('success', 'CSV Imported Successfully');

You can display this message in your Blade template using Laravel's session helper.

 

10. How can I skip empty rows while importing CSV files?

Before inserting each record, check whether the required columns contain data. If a row is empty or incomplete, use the continue statement to skip it and proceed with the next record.