Generating PDFs is a common requirement in modern Laravel applications. Whether you are building an invoice system, an e-commerce platform, a hospital management system, an HR application, or an admin dashboard, you may need to convert dynamic application data into downloadable or printable PDF documents.

Laravel does not include a dedicated PDF generator out of the box. However, integrating a PDF library such as Dompdf is straightforward and works well for many common use cases.

In this guide, you’ll learn how to generate PDFs in Laravel from scratch, including installation, Blade templates, dynamic database data, downloads, browser previews, storage, invoices, styling, common mistakes, and best practices.

---

What You’ll Learn

By the end of this tutorial, you’ll know how to:

• Install a Laravel PDF package
• Configure Dompdf in Laravel
• Create a PDF Blade view
• Generate a PDF from HTML
• Download a generated PDF
• Display a PDF in the browser
• Generate PDFs using database data
• Create invoices and reports
• Save PDFs to Laravel storage
• Handle images and CSS
• Avoid common PDF generation problems
• Improve PDF generation performance

---

What Is PDF Generation in Laravel?

PDF generation in Laravel means creating a Portable Document Format file dynamically from application data.

For example, imagine an application that stores customer orders in a database.

The application can retrieve an order and generate:

Customer Data
      │
      ▼
Laravel Controller
      │
      ▼
Blade PDF Template
      │
      ▼
HTML + CSS
      │
      ▼
PDF Library
      │
      ▼
Invoice.pdf

The generated PDF can then be:

• Downloaded by the user
• Displayed in the browser
• Stored on the server
• Attached to an email
• Sent to a customer
• Used as an invoice
• Used as a report or receipt

---

Why Generate PDFs in Laravel?

PDF documents are useful when application data needs to be shared, printed, archived, or presented in a standardized format.

Common examples include:

Use Case	Example
Invoices	Customer billing invoice
Receipts	Payment receipt
Reports	Sales or financial report
Certificates	Course completion certificate
Tickets	Event or appointment ticket
Statements	Account statement
Medical documents	Patient reports
Orders	Purchase order
Contracts	Generated agreements
Shipping	Delivery documents

For many business applications, generating PDFs directly from Laravel is more convenient than manually creating documents.

---

Best Laravel PDF Package

There are several approaches to generating PDFs in PHP, but Dompdf is one of the easiest options for Laravel applications.

A popular Laravel integration is:

barryvdh/laravel-dompdf

It allows you to generate a PDF from a Blade view using familiar Laravel syntax.

Why use Dompdf?

Dompdf is useful because:

• It converts HTML and CSS into PDF
• It works naturally with Blade templates
• It is easy to install
• It supports dynamic Laravel data
• It is suitable for invoices and reports
• It requires relatively little configuration

For extremely complex documents, however, other PDF engines may be more appropriate.

---

Step 1: Install the PDF Package

Open your Laravel project’s terminal and run:

composer require barryvdh/laravel-dompdf

Composer will install the package and its dependencies.

After installation, you can verify the package with:

composer show barryvdh/laravel-dompdf

Tip: Always check the package documentation and compatibility when upgrading to a newer Laravel or PHP version.

---

Step 2: Configure Dompdf

In many modern Laravel applications, the package can be used directly after installation.

If you need to publish its configuration file, run:

php artisan vendor:publish --provider="Barryvdh\DomPDF\ServiceProvider"

This typically creates:

config/dompdf.php

You can use this configuration file when you need to customize Dompdf behavior.

For example, PDF options can control features such as:

• Remote resources
• HTML parsing
• Font handling
• Temporary directories
• PDF rendering settings

---

Step 3: Create a PDF Blade View

Create a Blade file for your PDF.

For example:

resources/
└── views/
    └── pdf/
        └── invoice.blade.php

A simple PDF template could look like this:

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">

    <title>Invoice</title>

    <style>
        body {
            font-family: DejaVu Sans, sans-serif;
            font-size: 14px;
            color: #333;
        }

        .header {
            text-align: center;
            margin-bottom: 30px;
        }

        .invoice-details {
            margin-bottom: 20px;
        }

        table {
            width: 100%;
            border-collapse: collapse;
        }

        th,
        td {
            border: 1px solid #ddd;
            padding: 10px;
            text-align: left;
        }

        th {
            background: #f5f5f5;
        }

        .total {
            text-align: right;
            font-weight: bold;
            margin-top: 20px;
        }
    </style>
</head>

<body>

    <div class="header">
        <h1>Invoice</h1>
        <p>Invoice #{{ $invoice->id }}</p>
    </div>

    <div class="invoice-details">
        <strong>Customer:</strong>
        {{ $invoice->customer_name }}

        <br>

        <strong>Date:</strong>
        {{ $invoice->created_at->format('d M Y') }}
    </div>

    <table>
        <thead>
            <tr>
                <th>Product</th>
                <th>Quantity</th>
                <th>Price</th>
                <th>Total</th>
            </tr>
        </thead>

        <tbody>
            @foreach ($invoice->items as $item)
                <tr>
                    <td>{{ $item->product_name }}</td>
                    <td>{{ $item->quantity }}</td>
                    <td>{{ number_format($item->price, 2) }}</td>
                    <td>
                        {{ number_format($item->quantity * $item->price, 2) }}
                    </td>
                </tr>
            @endforeach
        </tbody>
    </table>

    <div class="total">
        Total:
        {{ number_format($invoice->total, 2) }}
    </div>

</body>
</html>

This template is simply a Blade view containing HTML and CSS.

The PDF library converts that HTML into a PDF document.

---

Step 4: Create a PDF Controller

Create a controller if you don’t already have one:

php artisan make:controller InvoiceController

Then import the PDF facade:

use Barryvdh\DomPDF\Facade\Pdf;

Your controller can contain:

<?php

namespace App\Http\Controllers;

use App\Models\Invoice;
use Barryvdh\DomPDF\Facade\Pdf;

class InvoiceController extends Controller
{
    public function download($id)
    {
        $invoice = Invoice::with('items')->findOrFail($id);

        $pdf = Pdf::loadView('pdf.invoice', [
            'invoice' => $invoice
        ]);

        return $pdf->download(
            'invoice-' . $invoice->id . '.pdf'
        );
    }
}

Let’s break down the important part:

$pdf = Pdf::loadView('pdf.invoice', [
    'invoice' => $invoice
]);

loadView() loads the Blade template and passes data to it.

Then:

return $pdf->download('invoice-' . $invoice->id . '.pdf');

tells Laravel to return the generated PDF as a downloadable file.

---

Step 5: Create a Route

Add a route to:

routes/web.php

For example:

use App\Http\Controllers\InvoiceController;

Route::get(
    '/invoices/{id}/download',
    [InvoiceController::class, 'download']
)->name('invoices.download');

Now you can access:

/invoices/123/download

The controller retrieves invoice 123, renders the Blade template, converts it to PDF, and downloads the file.

---

How Laravel PDF Generation Works

The complete process looks like this:

┌─────────────────────┐
│     User Request    │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│   Laravel Route     │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│     Controller      │
│                     │
│ Fetch Database Data │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│    Blade View       │
│                     │
│ HTML + CSS + Data   │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│    PDF Library      │
│       Dompdf        │
└──────────┬──────────┘
           │
           ▼
┌─────────────────────┐
│     PDF Document    │
└─────────────────────┘

This architecture keeps the data retrieval, presentation, and PDF rendering relatively easy to understand.

---

How to Display a PDF in the Browser

You don’t always want users to download a PDF.

Sometimes you want to open it directly in the browser.

Instead of:

return $pdf->download('invoice.pdf');

use:

return $pdf->stream('invoice.pdf');

For example:

public function preview($id)
{
    $invoice = Invoice::with('items')->findOrFail($id);

    $pdf = Pdf::loadView('pdf.invoice', [
        'invoice' => $invoice
    ]);

    return $pdf->stream(
        'invoice-' . $invoice->id . '.pdf'
    );
}

The browser will attempt to display the PDF using its built-in PDF viewer.

---

Download vs Stream

The two most common PDF responses are:

Method	Purpose
download()	Downloads the PDF
stream()	Displays the PDF in the browser

Download

return $pdf->download('invoice.pdf');

Use this when the user should save the document.

Browser Preview

return $pdf->stream('invoice.pdf');

Use this when the user should preview or print the document.

---

Generating a PDF From Database Data

One of the biggest advantages of Laravel PDF generation is the ability to create documents using real database records.

For example, suppose your application has:

Invoice
 ├── Customer
 ├── Invoice Items
 ├── Tax
 ├── Discount
 └── Total

You can retrieve the complete invoice:

$invoice = Invoice::with([
    'customer',
    'items'
])->findOrFail($id);

Then pass it to the PDF:

$pdf = Pdf::loadView('pdf.invoice', compact('invoice'));

return $pdf->download(
    'invoice-' . $invoice->id . '.pdf'
);

Inside Blade:

<h2>{{ $invoice->customer->name }}</h2>

@foreach ($invoice->items as $item)
    <p>
        {{ $item->product_name }}
        -
        {{ $item->quantity }}
    </p>
@endforeach

This approach is useful for:

• E-commerce invoices
• Hospital reports
• Booking confirmations
• Employee payslips
• Sales reports
• Customer statements

---

Creating a Simple Laravel Invoice PDF

A professional invoice generally contains:

┌──────────────────────────────────────────┐
│                COMPANY LOGO              │
│              Company Name                │
│                                          │
│ Invoice #: INV-1001     Date: 22 Aug 2026│
├──────────────────────────────────────────┤
│ Bill To: Customer Name                   │
│ Email: customer@example.com              │
├──────────────────────────────────────────┤
│ Product       Qty      Price       Total │
│ Product A      2       ₹500       ₹1,000 │
│ Product B      1       ₹800         ₹800 │
├──────────────────────────────────────────┤
│                         Subtotal ₹1,800  │
│                         Tax      ₹324    │
│                         Total    ₹2,124  │
└──────────────────────────────────────────┘

A Blade implementation could look like:

<table>
    <thead>
        <tr>
            <th>Product</th>
            <th>Qty</th>
            <th>Price</th>
            <th>Total</th>
        </tr>
    </thead>

    <tbody>
        @foreach ($invoice->items as $item)
            <tr>
                <td>{{ $item->product_name }}</td>
                <td>{{ $item->quantity }}</td>
                <td>₹{{ number_format($item->price, 2) }}</td>
                <td>
                    ₹{{ number_format(
                        $item->quantity * $item->price,
                        2
                    ) }}
                </td>
            </tr>
        @endforeach
    </tbody>
</table>

Keep PDF templates simple. PDF rendering engines do not support every modern CSS feature available in browsers.

---

Adding a Logo to a Laravel PDF

Images are frequently used in invoices, certificates, receipts, and reports.

For example:

<img
    src="{{ public_path('images/logo.png') }}"
    width="150"
    alt="Company Logo"
>

Using a filesystem path can be more reliable than depending on an external URL.

For example:

$logo = public_path('images/logo.png');

Then:

<img src="{{ $logo }}" width="150">

When working with images, make sure the PDF renderer can access the file.

---

Using CSS in Laravel PDF Templates

Basic CSS works well with Dompdf.

For example:

<style>
    body {
        font-family: DejaVu Sans, sans-serif;
        font-size: 12px;
    }

    .invoice-title {
        font-size: 24px;
        font-weight: bold;
    }

    .text-right {
        text-align: right;
    }

    .border {
        border: 1px solid #ddd;
    }
</style>

However, avoid assuming that every CSS feature supported by Chrome will work exactly the same way in a PDF engine.

For predictable results, prefer:

• Tables
• Basic margins
• Padding
• Borders
• Font sizes
• Text alignment
• Simple positioning

Be cautious with:

• Complex flexbox layouts
• CSS Grid
• Advanced animations
• JavaScript-dependent UI
• Browser-specific CSS

---

Setting PDF Page Size and Orientation

You can customize the paper size and orientation.

For example:

$pdf = Pdf::loadView('pdf.invoice', compact('invoice'))
    ->setPaper('a4', 'portrait');

For landscape documents:

$pdf = Pdf::loadView('pdf.report', compact('report'))
    ->setPaper('a4', 'landscape');

This is particularly useful for wide reports and data tables.

---

Common PDF Page Sizes

Size	Common Usage
A4	Invoices, reports, business documents
Letter	US business documents
A5	Smaller documents
Custom	Tickets, labels, specialized documents

For most business applications, A4 portrait is a practical default.

---

Saving a Laravel PDF to Storage

Sometimes you don’t want to generate the PDF every time a user requests it.

You may want to generate it once and save it.

For example:

$pdf = Pdf::loadView(
    'pdf.invoice',
    compact('invoice')
);

$pdf->save(
    storage_path(
        'app/public/invoices/invoice-' . $invoice->id . '.pdf'
    )
);

You can also use Laravel’s filesystem abstraction for more flexible storage strategies.

This becomes particularly useful when storing PDFs on:

• Local disk
• Amazon S3
• DigitalOcean Spaces
• Other cloud storage services

---

Sending a Generated PDF by Email

A common Laravel use case is attaching a generated invoice to an email.

For example:

$pdf = Pdf::loadView(
    'pdf.invoice',
    compact('invoice')
);

return $pdf->output();

The generated binary output can be attached through a Laravel Mailable.

Conceptually:

Order Completed
      │
      ▼
Generate Invoice PDF
      │
      ▼
Attach PDF to Email
      │
      ▼
Send to Customer

This is useful for:

• Order confirmations
• Payment receipts
• Booking confirmations
• Monthly statements
• Subscription invoices

---

Generating PDFs in Laravel Queues

Generating a large number of PDFs inside a normal HTTP request can slow down your application.

For example, imagine an admin exports 10,000 invoices.

Doing everything in a single request can cause:

Browser Request
      │
      ▼
Generate 10,000 PDFs
      │
      ▼
Long Processing Time
      │
      ▼
Timeout / Slow Response

A better architecture is:

Admin Requests Export
        │
        ▼
Create Queue Job
        │
        ▼
Background Worker
        │
        ├── Generate PDF
        ├── Save PDF
        └── Update Status
        │
        ▼
Notify User

Laravel queues are a strong option for heavy PDF generation workloads.

---

Example: PDF Generation Using a Service Class

As an application grows, it is better not to put all PDF logic inside controllers.

For example:

namespace App\Services;

use Barryvdh\DomPDF\Facade\Pdf;

class InvoicePdfService
{
    public function generate($invoice)
    {
        return Pdf::loadView(
            'pdf.invoice',
            compact('invoice')
        );
    }
}

The controller can then remain focused on the HTTP request:

public function download($id, InvoicePdfService $pdfService)
{
    $invoice = Invoice::with('items')
        ->findOrFail($id);

    $pdf = $pdfService->generate($invoice);

    return $pdf->download(
        'invoice-' . $invoice->id . '.pdf'
    );
}

This separation makes the application easier to maintain and test.

---

Common Mistakes When Generating PDFs in Laravel

1. Using Unsupported CSS

A design may look perfect in Chrome but break when converted to PDF.

Solution

Use PDF-friendly HTML and CSS and test the generated document regularly.

---

2. Using Incorrect Image Paths

A logo may appear in the browser but disappear from the generated PDF.

Solution

Use accessible filesystem paths when appropriate:

<img src="{{ public_path('images/logo.png') }}">

---

3. Generating Huge PDFs During HTTP Requests

Generating thousands of records synchronously can cause timeouts.

Solution

Use Laravel queues for large exports.

---

4. Loading Too Much Database Data

Avoid retrieving thousands of unnecessary records before rendering a PDF.

Instead of loading everything:

$orders = Order::all();

use a filtered query:

$orders = Order::whereBetween('created_at', [
    $startDate,
    $endDate
])->get();

For very large datasets, consider chunking or queued processing.

---

5. Ignoring PDF Security

A PDF endpoint should not allow users to access arbitrary documents.

Avoid routes like:

/invoice/{id}

without authorization checks.

Use Laravel authorization policies or other access-control mechanisms:

$this->authorize('view', $invoice);

This is especially important when invoices contain customer, financial, medical, or other private information.

---

Best Practices for Laravel PDF Generation

1. Keep PDF Views Separate

Instead of using your normal website Blade template, create dedicated PDF views:

resources/views/
├── layouts/
├── pages/
└── pdf/
    ├── invoice.blade.php
    ├── receipt.blade.php
    └── report.blade.php

This keeps PDF-specific styling isolated.

2. Keep Templates Simple

Use predictable HTML and CSS rather than trying to reproduce an entire web application inside a PDF.

3. Reuse PDF Components

If multiple PDFs share a header or footer, create reusable Blade partials:

@include('pdf.partials.header')

4. Validate User Input

If users control report filters, validate dates, IDs, sorting parameters, and other inputs before generating the document.

5. Authorize PDF Access

Make sure users can only access documents they are permitted to view.

6. Use Queues for Heavy Jobs

Large PDF generation should generally happen asynchronously.

7. Test Multiple Pages

Don’t test only one-page invoices.

Test documents containing:

• Long tables
• Multiple pages
• Long customer names
• Large descriptions
• Missing images
• Different fonts
• Different amounts

---

Dompdf vs Other PDF Generation Approaches

Dompdf is convenient, but it isn’t the only option.

Approach	Best For	Complexity
Dompdf	Invoices and simple reports	Low
mPDF	More advanced HTML/CSS PDFs	Medium
TCPDF	Detailed PDF generation	Medium
Headless Chrome	Browser-like HTML rendering	Higher
wkhtmltopdf	HTML-to-PDF workflows	Medium

When should you use Dompdf?

Choose Dompdf when you need:

• Simple invoices
• Receipts
• Basic reports
• Certificates
• Standard business documents
• Easy Laravel integration

For highly complex web layouts, a browser-based PDF solution can provide better rendering fidelity.

---

Laravel PDF Generation: Recommended Architecture

For a small application:

Controller
    │
    ▼
Blade View
    │
    ▼
PDF Library
    │
    ▼
PDF Response

For a larger application:

Controller
    │
    ▼
Service Class
    │
    ▼
Database / Repository
    │
    ▼
Blade PDF Template
    │
    ▼
PDF Generator
    │
    ├── Download
    ├── Storage
    └── Email

For high-volume PDF generation:

User
 │
 ▼
Laravel API
 │
 ▼
Queue Job
 │
 ▼
PDF Service
 │
 ▼
PDF Generator
 │
 ├── Cloud Storage
 └── Notification

The second and third approaches are usually more suitable as an application grows.

---

Real-World Example: Generating a Booking Confirmation PDF

Suppose you’re building a booking platform.

After a customer successfully books an appointment, your Laravel application could generate a confirmation PDF containing:

Booking Confirmation

Customer: John Doe
Booking ID: BK-10245
Service: Consultation
Date: 25 August 2026
Time: 10:30 AM
Provider: Example Clinic

Status: Confirmed

The flow would be:

Booking Created
      │
      ▼
Retrieve Booking
      │
      ▼
Render Booking Blade View
      │
      ▼
Generate PDF
      │
      ├──────► Download
      │
      ├──────► Store
      │
      └──────► Email

This same architecture can be adapted for invoices, receipts, reports, certificates, and other business documents.

---

Performance Tips for Laravel PDF Generation

PDF generation can become CPU- and memory-intensive when documents are large.

Consider these techniques:

Limit Database Queries

Retrieve only the data required by the document.

Eager Load Relationships

Instead of triggering repeated queries:

$invoice = Invoice::with([
    'customer',
    'items'
])->findOrFail($id);

Reduce Image Size

Large images can significantly increase PDF memory usage.

Use appropriately sized images rather than uploading a multi-megapixel image for a small logo.

Queue Large Jobs

For bulk exports, move processing to a queue worker.

Cache Reusable Documents

If a document rarely changes, storing the generated PDF can avoid unnecessary regeneration.

---

Security Considerations

PDF generation should also be treated as an application security concern.

Never assume that because a document is a PDF it is automatically safe.

Important considerations include:

• Authorize document access
• Validate route parameters
• Validate report filters
• Escape dynamic content in Blade
• Avoid exposing private storage paths
• Restrict access to sensitive documents
• Use signed URLs when appropriate
• Protect generated files containing personal or financial information

For example, avoid exposing sensitive files through predictable public URLs when authorization is required.

---

Testing Laravel PDF Generation

PDF functionality should be tested like any other important application feature.

For example, test that:

GET /invoices/1/download
        │
        ▼
HTTP 200
        │
        ▼
Content-Type: application/pdf

You can also test:

• Unauthorized users
• Missing invoices
• Empty invoice items
• Large invoices
• Multiple pages
• Invalid IDs
• Missing images
• Different user roles

For critical business documents, automated tests can help prevent unexpected regressions.

---

Frequently Asked Questions

1. How do I generate a PDF in Laravel?

A common approach is to install the barryvdh/laravel-dompdf package, create a Blade template, load that view with Pdf::loadView(), and return the result using download() or stream().

Example:

$pdf = Pdf::loadView(
    'pdf.invoice',
    compact('invoice')
);

return $pdf->download('invoice.pdf');

---

2. Can Laravel generate PDFs from Blade templates?

Yes. Blade templates are particularly convenient for PDF generation because you can use Laravel variables, loops, conditionals, and reusable Blade components or partials.

For example:

<h1>Invoice #{{ $invoice->id }}</h1>

@foreach ($invoice->items as $item)
    <p>{{ $item->product_name }}</p>
@endforeach

---

3. How can I download a PDF in Laravel?

Use the download() method:

return $pdf->download('invoice.pdf');

This tells the browser to download the generated document.

---

4. How can I preview a PDF in Laravel?

Use the stream() method:

return $pdf->stream('invoice.pdf');

This allows compatible browsers to display the PDF instead of immediately downloading it.

---

5. Can Laravel generate PDFs from database data?

Yes. Retrieve the required model and relationships, pass the data to a Blade PDF template, and render the template with a PDF library.

This is commonly used for invoices, receipts, reports, certificates, and booking documents.

---

6. Can I save generated Laravel PDFs to storage?

Yes. Generated PDFs can be saved to local storage or integrated with cloud storage such as Amazon S3 or compatible object-storage services.

This is useful when PDFs need to be accessed later without regenerating them.

---

7. What is the best PDF package for Laravel?

There isn’t one universal best package.

Dompdf is a good starting point for simple HTML-to-PDF requirements. For complex layouts or browser-level HTML/CSS compatibility, other approaches such as mPDF or headless browser solutions may be more appropriate.

The right choice depends on document complexity, performance requirements, CSS support, and deployment environment.

---

Key Takeaways

• Laravel PDF generation is useful for invoices, reports, receipts, certificates, and business documents.
• Dompdf provides a straightforward HTML-to-PDF workflow for many Laravel applications.
• Use dedicated Blade templates for PDF documents.
• download() is useful for downloading PDFs.
• stream() is useful for browser previews.
• Use filesystem paths carefully when loading images.
• Keep PDF HTML and CSS simple and predictable.
• Use eager loading and efficient database queries for dynamic documents.
• Move large PDF generation tasks to Laravel queues.
• Protect PDF routes with proper authorization.
• Store frequently accessed generated PDFs when regeneration is unnecessary.
• Test PDFs with large datasets and multi-page content, not only simple examples.