How to Generate PDFs from Laravel Blade Without Running Chromium
Build a production-ready invoice from an existing Blade view, understand how local assets reach the renderer, and decide when managed Chromium is the right tradeoff.
Managed PDF infrastructure for Laravel
Laravel PDFs
without running
Chromium.
Render your existing Blade views with images, fonts, and CSS handled automatically—without installing Chromium, Node.js, Docker, browser workers, or exposing private assets.
Keep your Blade views
No Chromium or Docker
Unlimited on paid plans
InvoiceController.php
1 use BladePDF\Laravel\Facades\BladePDF;
2
3 public function download(Invoice $invoice)
4 {
5 return BladePDF::fromView('invoices.template', [
6 'invoice' => $invoice,
7 'company' => Auth::user()->company,
8 ])
9 ->format('A4')
10 ->withHeader('partials.header')
11 ->withFooter('partials.footer')
12 ->showBackground()
13 ->render()
14 ->response('invoice-' . $invoice->number . '.pdf');
15 }Laravel-native workflow
From Blade view to Laravel response.
fromView()
Existing Blade views
Render normal view names with the application data you already pass from Laravel.
public/ + storage/
Local document assets
Resolve local CSS, images, fonts, JavaScript, SVG, and nested stylesheet dependencies.
response() + download()
Laravel delivery
Return inline responses or Unicode-safe downloads directly from controllers.
storePdf()->async()
Queues and webhooks
Submit stored background renders and handle completion through signed events.
Why BladePDF exists
PDF rendering is easy. Operating Chromium is not.
A browser that works on a laptop becomes an infrastructure problem in production. BladePDF runs that layer so your application only has to render Blade.
$
composer require bladepdf/laravel
Install and patch browsers
Chromium, Node.js, system libraries, and security updates become production dependencies.
Recover from memory and crashes
Long-lived browser processes need memory limits, health checks, restarts, and retry logic.
Build queues and scale workers
Traffic bursts require queue capacity, worker replicas, monitoring, and careful concurrency.
Make private assets reachable
Local logos, fonts, and CSS are invisible to a remote or containerized browser unless you expose or package them.
One integration for every document your Laravel app ships
Invoices
Receipts
Statements
Analytics reports
Account exports
Event tickets
Shipping labels
Certificates
Contracts
Proposals
Invoices
Receipts
Statements
Analytics reports
Account exports
Event tickets
Shipping labels
Certificates
Contracts
Proposals
The managed alternative
Keep Blade. Hand off the browser stack.
Your Laravel app renders the view. BladePDF operates the Chromium, asset transfer, queue, security controls, storage, and delivery around it.
Managed Chromium
Generate browser-quality PDFs without installing, patching, monitoring, or restarting Chromium on your application servers.
Keep existing Blade views
Reuse the invoices, reports, certificates, and exports already in your codebase instead of adopting another template system.
Private assets, handled automatically
Local images, CSS, and fonts are uploaded and rewritten for each render. Nothing needs a public URL. See the asset pipeline →
Isolated, guarded renders
Each job receives a fresh browser context with network request controls, hard timeouts, and memory limits applied by the rendering service.
Managed queues and capacity
Short bursts wait in a plan-sized queue. Add concurrency when you need more PDFs rendering at once, not when you cross a document quota.
Laravel-native delivery
Render from controllers, services, or jobs, then download, stream, save, or return the PDF with familiar Laravel response helpers.
Cloud Blade templates
Save drafts and publish centralized document templates, then ship layout changes instantly without redeploying your Laravel application. See cloud workflows →
Stored PDFs and render history
Keep selected outputs for re-download, delivery, and audit workflows, with request metadata and signed download URLs attached.
Signed async delivery
Receive HMAC-signed pdf.rendered and pdf.failed events with retries and a delivery log.
Data security
Your documents are not our dataset.
HTML, context data, request-scoped assets, and non-stored PDFs are deleted right after the render finishes. PDFs are retained only when you explicitly enable storage. Read the data-retention details.
Automatic asset pipeline
Keep local assets private.
BladePDF makes them render.
Use {{ asset('...') }},
{{ url('...') }}, or absolute paths in Blade.
BladePDF discovers referenced images, CSS, and fonts, uploads them for the request, and rewrites their URLs before rendering. No public CDN or manual asset bundle required.
resources/views/invoices/show.blade.php
Your Blade template
1 <html>
2 <head>
3 <link rel="stylesheet" href="{{ asset('css/invoice.css') }}" />
4 <link rel="stylesheet" href="https://cdn.example.com/pdf/base.css" />
5 </head>
6 <body>
7 <header class="invoice-header">
8 <img src="{{ asset('img/logo.svg') }}" />
9 <h1>{{ $invoice->number }}</h1>
10 <img src="{{ url('storage/qrcodes/' . $invoice->id . '.png') }}" />
11 </header>
12
13 <main>
14 @foreach($invoice->items as $item)
15 @include('invoices.line-item', ['item' => $item])
16 @endforeach
17 </main>
18
19 <style> @font-face { src: url('/fonts/Inter.woff2'); } </style>
20 </body>
21 </html>1. Scan template
Parse Blade output for asset references like asset(), url(), inline @font-face url(), and absolute paths.
2. Upload referenced assets
Referenced files are uploaded from your app for the current render request so CSS, images, and fonts are reachable by the PDF engine.
3. Render with resolved URLs
Every reference is resolved before rendering so fonts, images, and styles are available when PDF generation starts.
Supported assets
Images
PNG · SVG · JPG
CSS
Tailwind · Plain CSS
Fonts
WOFF2 · OTF · TTF
JS bundles
Optional
Without BladePDF
- ✕ Manually host assets at publicly reachable URLs
- ✕ Build your own upload + URL rewrite workflow
- ✕ Convert relative references before rendering
- ✕ Debug missing fonts and broken image links
With BladePDF
- ✓Keep using
asset()andurl() - ✓ Referenced files upload automatically during generation
- ✓ Asset URLs are resolved before rendering begins
- ✓ Same Blade template style your team already uses
Managed document workflows
Manage what happens
before and after the render.
Keep local views in Laravel, or centralize reusable document templates in BladePDF. Publish design changes without a deploy, retain selected outputs, and continue workflows through signed events.
InvoiceController.php
// Rendered from a template you manage in BladePDF
$result = BladePDF::fromTemplate('invoice.standard', [
'invoice' => $invoice->toArray(),
])
->reference($invoice->uuid)
->storePdf()
->render();
$url = $result->storedPdfUrl();
Your app sends a template id and JSON context. BladePDF compiles the published template, renders it, and returns a local result object with the PDF bytes and, when stored, a signed PDF URL.
Cloud Blade templates
Separate drafts from the published version, reuse layouts across applications, and deploy a document update instantly without shipping Laravel code.
Hosted assets & storage
Upload logos, fonts, and CSS once and reference them with asset:///logo.png. Swap per-tenant assets at render time with overrideAsset().
Signed webhooks
Subscribe to pdf.rendered and pdf.failed. Every delivery is HMAC-signed, retried on failure, and visible in a delivery log.
Store & retrieve PDFs
Add storePdf() when you need re-download, delivery, or an exact audit copy. Retrieve it through a signed URL or an async webhook payload.
Dedicated storage on every plan
Templates and hosted assets live in your workspace storage. Paid plans scale up as your document library grows.
Free
100 MB
Starter
5 GB
Growth
15 GB
Scale
50 GB
How it works
Your app owns the template. BladePDF owns the rendering.
Three steps replace a browser installation, a worker fleet, and a custom asset-delivery path.
1
Install via Composer
$ composer require
bladepdf/laravel
Add the Laravel integration and an API key. No Node.js, Chromium, or Docker image joins your deployment.
2
Design in Blade
<div class="invoice">
@foreach($items as $i)
{{ $i->name }}
@endforeach
</div>
Keep normal Blade data, components, CSS, local images, and fonts inside your Laravel project.
3
Render through BladePDF
BladePDF::fromView('invoices.template',
$data)
->render()
->response('invoice.pdf');
BladePDF resolves assets, runs the isolated browser job, and returns, stores, or delivers the finished PDF.
Live example
Ship invoices, reports, tickets, labels — anything.
Pick a template type to see how BladePDF handles real-world documents. Switch between Blade source and the rendered PDF instantly.
invoices/template.blade.php
INVOICE
#INV-2026-0042
From
Acme Corp
221B Market St, SF
To
Wayne Ent.
1007 Mountain Dr
| Item | Qty | Total |
|---|---|---|
| SaaS License | 1 | $299 |
| Support Plan | 1 | $99 |
| Setup | 1 | $150 |
| Training | 4h | $400 |
Thanks for your business
Total
$948
Other runtimes
Need BladePDF from another service?
BladePDF is Laravel-first. When a PHP or Node.js service owns the HTML, use the same managed rendering platform through an official SDK or the REST API.
Composer
Generic PHP SDK
Framework-agnostic rendering, secure local assets, fluent PDF options, and asynchronous delivery.
Explore the PHP SDKnpm
Node.js / TypeScript SDK
Typed rendering with Buffer, streams, atomic file delivery, and automatic local asset discovery.
Explore the Node.js SDKHTTP
REST API
Send multipart render requests from any server-side language without adopting an SDK.
Read the REST API docsPractical guides
PDF guides for real applications.
Start with a Laravel invoice, build a Node.js PDF pipeline, or troubleshoot Browsershot in production. Each guide includes code and deployment details.
Generate PDFs in Node.js with BladePDF
Build an EJS invoice with local CSS and images, save the PDF, then return it from Express, Fastify or Next.js. Includes the runnable TypeScript project, its generated PDF and a React template example.
Laravel Browsershot in production
See what it takes to run Browsershot reliably in production—from Chromium and Docker to queue capacity, memory, assets, security, and persistent browsers.
Pricing
Pay for capacity, not every PDF.
Paid plans include unlimited generations within fair use. Choose how many PDFs can render at the same time, then let the managed queue absorb short bursts.
01 / ACTIVE CAPACITY
One slot means one active render
Concurrency is the number of PDFs that can render at the same time. Add slots when simultaneous workloads need more throughput.
02 / BURST HANDLING
The queue smooths traffic spikes
When every slot is busy, requests wait in your plan's managed queue and start as soon as capacity becomes available.
03 / PREDICTABLE COST
Document count does not set the bill
On paid plans, a large report does not consume a larger generation allowance than a one-page invoice. Normal size, time, storage, and bandwidth limits still apply.
Free
$0
/month
Prove the managed workflow inside a real Laravel app before moving production volume.
Start Free
200 generations per month
Best-effort concurrency, up to 1 render at a time
Cloud templates, hosted assets & webhooks
100 MB template & asset storage
Blade template support
No JavaScript or external asset fetching
Most popular
Starter
$9
/month
For production apps with a steady PDF workload and occasional queued bursts.
Get API Key
Unlimited generations within fair use
1 concurrent generation
Cloud templates, hosted assets & webhooks
5 GB template & asset storage
JavaScript execution and external asset fetching
Use in controllers, jobs, or queues
Growth
$24
/month
For SaaS products that need several PDFs rendering at the same time.
Choose Growth
Unlimited generations within fair use
3 concurrent generations
Cloud templates, hosted assets & webhooks
15 GB template & asset storage
Better throughput for bursts
Fits queued and multi-tenant workloads
Scale
$59
/month
For busy Laravel applications with sustained parallel generation and larger bursts.
Choose Scale
Unlimited generations within fair use
8 concurrent generations
Cloud templates, hosted assets & webhooks
50 GB template & asset storage
Built for operational simplicity
Supports heavier report and export workloads
Standard payload, bandwidth, queue and render-time limits apply to paid plans. View all plan limits.
Self-hosted vs managed
The code is the easy part.
Browsershot, Puppeteer, and Playwright give you browser control. BladePDF is for teams that want the Blade workflow without operating the browser platform behind it.
Operational responsibility
Self-hosted Chromium
BladePDF
Chromium installation
Install Chrome and system dependencies
Nothing to install
Docker
Build and maintain browser images
Not required
Browser updates
Test and deploy them yourself
Managed by BladePDF
Worker scaling
Add processes, servers, or replicas
Increase managed concurrency
Memory tuning
Set limits and watch browser processes
Resource limits and recovery managed
Queue management
Build capacity, retries, and timeouts
Managed queues per plan
Local assets
Expose URLs or build an upload path
Automatic discovery, upload, and rewrite
Browser crashes
Detect, restart, and retry
Browser recovery handled by the service
Monitoring
Build logs, metrics, and alerting
Render history, timings, and failure logs
Render security
Design isolation and network controls
Isolated contexts and request guards
FAQ
What Laravel teams ask before switching.
Why use BladePDF instead of Browsershot, Puppeteer, or Spatie Laravel PDF?
Use BladePDF when you want to keep the familiar Blade workflow without operating Chromium yourself. Browsershot, Puppeteer, and self-hosted Spatie drivers give you lower-level browser control; BladePDF manages browser installation and updates, render isolation, queues, capacity, asset transfer, logs, storage, and async delivery.
Do I need Chromium, Node.js, or Docker in production?
No. Your Laravel application sends the rendered view and its assets to BladePDF. The managed rendering service runs Chromium, so your deployment does not need a browser binary, Node.js runtime, Docker image, or browser worker.
Can I use my existing Blade templates?
Yes. That is one of the main benefits. BladePDF is designed so you can render PDFs from the Blade templates already living in your Laravel project.
Can BladePDF render images and fonts that are not public?
Yes. The Laravel package discovers local images, stylesheets, fonts, and nested CSS references, uploads them for the render request, and rewrites their URLs. You do not need to expose private assets through a public bucket or CDN.
Can I manage templates in the dashboard instead of my codebase?
Yes. You can author Blade templates directly in the BladePDF dashboard, save drafts, and publish when ready, then render them from Laravel with
fromTemplate('invoice.standard', $context)->render(). Because the published version lives in BladePDF, you can update a document's design without shipping a code deploy. You can still keep rendering local views with fromView() whenever you prefer.Can I store reusable assets like logos and fonts?
Yes. Upload logos, fonts, and stylesheets once and reference them from any published template with
asset:///. Every plan includes dedicated storage for your templates and assets — 100 MB on Free, and 5 GB, 15 GB, or 50 GB on paid plans. You can also override a stored asset for a single render with overrideAsset(), which is handy for per-tenant logos.Do you support webhooks?
Yes. Add a webhook endpoint in the dashboard for account-wide render notifications, or attach a per-request callback to async renders with
webhook(). BladePDF sends signed pdf.rendered and pdf.failed events, verifies them with an HMAC signature, retries failed deliveries, and records every attempt in a delivery log.What does concurrency mean?
Concurrency is how many PDFs your plan can render at the same time. When every slot is busy, new requests wait in your plan's queue; increasing concurrency reduces waiting during sustained parallel workloads.
Do paid plans limit the number of PDFs?
Paid plans do not meter a monthly document count. Pricing follows the concurrency level you need, while normal queue, payload, render-time, PDF-size, storage, bandwidth, and fair-use limits still apply.
When should I choose a self-hosted renderer instead?
Choose self-hosting when offline rendering, strict data locality, or low-level browser control matters more than operational simplicity. Choose BladePDF when the goal is reliable production PDF generation without making your Laravel infrastructure responsible for running browsers.
Is this suitable for invoices, reports, and certificates?
Yes. BladePDF is a great fit for invoices, financial statements, account exports, reports, proposals, shipping documents, receipts, and certificate-style PDFs.
Keep the Blade views.
Retire the browser stack.
Move Chromium, local asset transfer, queues, capacity, storage, and async delivery out of your Laravel deployment.
$ composer require bladepdf/laravel