Learn the key differences between include() and require() in PHP. Discover how replacing include() with require() can improve your PHP performance, ensure critical file inclusion, and prevent silent failures in large-scale applications
Here’s a bug that has cost more than one developer an afternoon. A config file gets renamed. The app doesn’t crash. It just quietly starts behaving wrong: sessions break, a database connection never opens, prices come out as zero. You go hunting through business logic for hours, and the real culprit is a missing file that PHP swallowed with a warning you never saw.
That’s the story behind include() and require(). The two look almost identical, and people reach for whichever one their last tutorial used. But the choice matters, and it’s worth being honest about why it matters, because the common explanation is wrong.
Let’s clear one thing up first: swapping include() for require() will not make your PHP run faster. There’s no speed win hiding in there. What you get is correctness, and that’s the better prize anyway. We’ll walk through the real difference, when each one fits, and where the “faster” myth falls apart.
What Are include() and require() in PHP?
Both pull an external file into your script at the point where you call them. You use them to split code into pieces: a config file, a set of shared functions, a reusable chunk of HTML. It keeps each file small and keeps you from copy-pasting the same code everywhere.
Basic Syntax
<?php
include 'file.php';
require 'file.php';
?>Same shape. Both take a file path and drop that file’s contents in place. The one thing that separates them is what happens when the file isn’t there.
include() vs require(): The Real Difference
This is the whole story, and it comes down to error handling. Per the PHP manual, the two functions do the exact same work when the file exists. They only part ways when the file is missing or can’t be read.
Error Handling
include() emits an E_WARNING and keeps going. The rest of your script runs as if nothing happened. Handy when the file is genuinely optional, dangerous when it isn’t.
Example:
<?php
include 'non_existent_file.php';
echo "This will still run!";
?>The file is gone, but the script shrugs and prints “This will still run!”. You get a warning in the log, and if nobody’s reading the log, you get nothing.
require() does the opposite. A missing file throws a fatal error (an Error exception in PHP 8+, an E_COMPILE_ERROR before that) and stops the script cold.
Example:
<?php
require 'non_existent_file.php';
echo "This will not run!";
?>Execution halts at the require() line. “This will not run!” never prints. That’s the point: fail loud, fail now, instead of limping forward on a broken foundation.
When to Reach for require()
Use require() when the file is load-bearing. If your script can’t do its job without it, you want the hard stop.
Critical Files
Config, bootstrap, core function libraries. If any of these go missing, nothing downstream is trustworthy. Better to crash on line one than to run a hundred lines on bad assumptions.
Example:
<?php
require 'config.php'; // Including a critical configuration file
// Proceed with the rest of the script
?>No Silent Failures
This is the real payoff, and it’s the opposite of the bug we opened with. include() lets a missing dependency slip through and cause weird symptoms far from the actual cause. require() gives you an error that points straight at the problem. You spend two minutes fixing a path instead of two hours guessing.
Example:
<?php
require 'essential_functions.php'; // If this file is missing, the script will stop
?>About That “require() Is Faster” Claim
You’ll see this repeated a lot, so let’s be straight: it isn’t true. There’s no meaningful runtime speed difference between include() and require(). When the file exists, both do identical work. The PHP manual describes the difference purely as error behavior, not performance. It says nothing about one being faster, because it isn’t.
Where the confusion creeps in: because require() halts on a missing file, your server doesn’t burn time executing half-broken code, and a clear fatal error is far quicker to debug than a warning that scrolled off the screen. That’s a reliability and developer-time win, not a benchmark. If someone shows you numbers claiming raw speed, be skeptical, because the language spec doesn’t back it up.
One thing that does touch performance and correctness: the _once variants. require_once and include_once track what’s already been pulled in and skip a second inclusion of the same file. That stops “cannot redeclare function” fatals and avoids re-running a file you already loaded. Reach for those when a file might get included more than once.
When include() Is the Right Call
include() isn’t the weaker function, it’s the one for optional things. If the app should keep running when the file is absent, this is what you want.
Non-Critical Files
Think a promo banner, a footer widget, an optional template partial. If it’s missing, you’d rather serve the page without it than blank the whole screen.
Example:
<?php
include 'optional_file.php'; // It's okay if this file is missing
?>Flexible Development
While you’re building, include() can keep a page rendering even when a work-in-progress partial isn’t ready yet. Just don’t let that habit ride into production on a file that actually matters.
Dynamic Inclusion
Both functions work fine inside conditionals and loops, so you can load files based on what’s actually happening at runtime.
Conditional Inclusions
Load different code depending on a role, a setting, or user input. Notice this still uses require(), because in both branches the file is essential.
Example:
<?php
if ($user_role == 'admin') {
require 'admin_functions.php';
} else {
require 'user_functions.php';
}
?>Looping Through Files
Got a list of files to pull in? Loop them instead of writing the same line over and over.
Example:
<?php
$files = ['file1.php', 'file2.php', 'file3.php'];
foreach ($files as $file) {
include $file;
}
?>The Short Version
Pick based on how much you can afford to lose. If the file is essential, use require() (or require_once) so a missing dependency fails fast and points you at the fix. If the file is optional and the page should survive without it, use include().
Don’t choose for speed, because there’s no speed to choose. Choose for correctness, and let the rest take care of itself.