How to Get Response Headers Using file_get_contents in PHP

Learn how to retrieve HTTP response headers using file_get_contents() in PHP. A simple and lightweight alternative to cURL for inspecting headers.

When working with APIs or external resources in PHP, sometimes you need to inspect the HTTP response headers — not just the content. While cURL is commonly used for this, you can also retrieve headers using the built-in file_get_contents() function with the right stream context.

In this post, we learn the effective way to get response headers, while using PHP file_get_contents() function.

Using $http_response_header PHP variable to Get Response Headers

We use file_get_contents() to fetch the content from a URL. But with some configuration, you can also access the response headers.

Here’s how you can do it:

<?php
$url = "https://example.com";

// Create a stream context
$options = [
    "http" => [
        "method" => "GET",
        "header" => "User-Agent: PHP\r\n"
    ]
];
$context = stream_context_create($options);

// Fetch the content
$response = file_get_contents($url, false, $context);

// Display the content
echo $response;

// Get the response headers
print_r($http_response_header);
?>

Explanation

  • We used stream_context_create() to define HTTP request options, like headers or methods.
  • The $http_response_header is a special PHP variable automatically populated when using file_get_contents() with an HTTP context.
  • It contains the raw headers returned by the server as an indexed array.

Example Output

When you run the above script, $http_response_header might contain something like:

Array
(
    [0] => HTTP/1.1 200 OK
    [1] => Content-Type: text/html; charset=UTF-8
    [2] => Date: Wed, 25 Jun 2025 10:30:00 GMT
    ...
)

Checking Specific Headers

You can loop through the headers to extract specific values:

foreach ($http_response_header as $header) {
    if (stripos($header, "Content-Type:") !== false) {
        echo "Content-Type Header: $header";
    }
}

Use Cases

We can use this method for various purpose as follows:

  • Verifying HTTP status codes
  • Checking content type or caching headers
  • Basic debugging of server responses without using cURL

Conclusion

While file_get_contents() is often seen as a simple way to read data from URLs, it’s surprisingly powerful when paired with stream contexts. For lightweight HTTP requests where you don’t need advanced control, it’s a quick alternative to cURL — and retrieving headers is straightforward using $http_response_header.

How to Find YouTube Video ID from Any YouTube URL

Learn how to extract the YouTube video ID from different types of YouTube URLs using simple methods and regex examples. Ideal for developers and marketers.

YouTube has so many types of URLs to embed the video on your site. Sometimes it’s difficult to find a single regular expression to parse all type of YouTube URL and retrieve the video ID from it.

To retrieve the video ID from the YouTube URL, use this function,

function getVideoID($url) {
    $pattern = '#^(?:https?://)?(?:www\.)?(?:youtu\.be/|youtube\.com(?:/embed/|/v/|/watch\?v=|/watch\?.+&v=))([\w-]{11})(?:.+)?$#x';
    preg_match($pattern, $url, $matches);
    return (isset($matches[1])) ? $matches[1] : false;
}

Regular Expression explanation is as follows,

$pattern = '#^(?:https?://)?';    # Either http or https.
$pattern .= '(?:www\.)?';         #  Optional, www subdomain.
$pattern .= '(?:';                #  Group host alternatives:
$pattern .=   'youtu\.be/';       #    Either youtu.be,
$pattern .=   '|youtube\.com';    #    or youtube.com
$pattern .=   '(?:';              #    Group path alternatives:
$pattern .=     '/embed/';        #      Either /embed/,
$pattern .=     '|/v/';           #      or /v/,
$pattern .=     '|/watch\?v=';    #      or /watch?v=,    
$pattern .=     '|/watch\?.+&v='; #      or /watch?other_param&v=
$pattern .=   ')';                #    End path alternatives.
$pattern .= ')';                  #  End host alternatives.
$pattern .= '([\w-]{11})';        # Youtube video ids with standard length of 11 chars.
$pattern .= '(?:.+)?$#x';         # Optional other ending URL parameters.

SPF Records for Outgoing Email: What They Are & Why They Matter

Learn what an SPF record is, why it’s essential for email deliverability, and how to configure it properly for sending outgoing emails from your domain.

When users mark messages as spam from a domain, mailbox providers can accurately identify that domain as a potential source of spam – if it has a valid SPF (Sender Policy Framework) records. SPF helps distinguish legitimate senders from spoofed ones. Conversely, if spoofed emails are flagged, SPF enables providers to maintain the domain’s reputation and ensure legitimate mail flows smoothly. Clearly, using SPF helps enhance the accuracy of spam filtering and protect email reputation.

Understand Why SPF Records Often Fails with PHP’s mail()

PHP developers frequently rely on the mail() function for sending emails. However, this approach skips SMTP authentication, making outgoing emails prone to being caught by SPF checks. What’s more, SPF only evaluates the envelope sender (the “Return-Path” header), not the “From” address users actually see. You can read about this at http://www.openspf.org/FAQ/Envelope_from_scope.

In many cases, the envelope sender defaults to the server or localhost, even when the “From” header appears to come from your domain. SPF checks then focus on the envelope sender—if it lacks a proper SPF records, the email may result in a soft fail. Gmail, for instance, might label this as a “best guess record,” which can be incorrect and hurt deliverability.

How to Fix SPF Records Soft-Fail Issues

Here are two effective solutions:

Switch to an SMTP-based mailer

Use libraries like PHPMailer to send emails via SMTP. This allows setting the envelope sender to match the “From” address, enabling proper SPF alignment.

Use sendmail parameters with PHP’s mail()

If refactoring the code is too extensive, you can still adjust the envelope sender using PHP’s mail() function with the -f or -F options in the additional parameters, for example:

mail("user@example.com",  "test subject",  "test message",  $headers,  "-F 'Example  Envelope-sender' -f returnpath@example.com");

This ensures the envelope sender matches your domain – making SPF checks pass correctly.

Conclusion

In essence, SPF plays a vital role in email deliverability and domain reputation. But to leverage it effectively, you must ensure emails send with the correct envelope sender. For PHP developers, the most reliable approach is using SMTP-based mailing; alternatively, configuring the envelope address via sendmail parameters can help bridge the gap without major code changes.