HansenDeployment

Php

Getting HTTP code in PHP using curl

19 September 2026 · 9 min read

Getting HTTP code in PHP using curl

In the world of web development, efficiently communicating with servers is crucial. When working with PHP, cURL (Client URL Library) provides a powerful tool for making HTTP requests. One common task is getting HTTP code in PHP using curl. This allows you to understand the status of your requests, identify potential errors, and build robust applications that can handle various server responses gracefully. Knowing how to extract and interpret these codes is essential for debugging, error handling, and ensuring seamless user experiences. This article will guide you through the process, offering practical examples and insights to help you master this essential skill.

Understanding HTTP Status Codes

HTTP status codes are three-digit numbers that web servers use to communicate the outcome of a client’s request. These codes are categorized into five classes, each representing a different type of response. Familiarizing yourself with these categories is the first step towards effectively using HTTP codes in your PHP applications. The main categories include: 1xx (Informational), 2xx (Success), 3xx (Redirection), 4xx (Client Error), and 5xx (Server Error). Each category provides vital information about the request’s success or failure, aiding in accurate error handling and improved user experience.

For example, a 200 OK code indicates that the request was successful, while a 404 Not Found signifies that the requested resource could not be located on the server. A 500 Internal Server Error suggests an issue on the server side, requiring further investigation. Understanding these codes allows developers to implement specific actions based on the server’s response, such as displaying custom error messages or redirecting users to alternative pages. According to a study by Akamai, approximately 20% of web requests result in an error code, highlighting the importance of robust error handling strategies that utilize HTTP status codes effectively. Akamai is a leading content delivery network (CDN) and cloud service provider that regularly publishes insights into web performance and error trends.

Knowing the meaning behind different status codes is pivotal in web development. By leveraging this knowledge, developers can create more resilient and user-friendly applications. Properly handling these codes ensures that your application can gracefully recover from errors, providing a better overall experience for your users. Understanding the significance of status codes like 301 (Moved Permanently) or 403 (Forbidden) allows for precise control over application behavior and response to various server states.

Using cURL in PHP to Fetch HTTP Status Codes

cURL is a powerful PHP extension that allows you to make HTTP requests to servers. It’s essential for tasks like fetching data from APIs, submitting forms, and, of course, getting HTTP code in PHP using curl. To begin, you need to initialize a cURL session, set the necessary options, execute the request, and then extract the HTTP status code. Let’s look at a practical example.

The process starts by initializing a cURL session using curl_init(). Then, you configure the session by setting options such as the URL to request and whether to return the response body. Crucially, you need to set the CURLOPT_RETURNTRANSFER option to true to ensure that the response is returned as a string rather than being directly outputted to the browser. To actually fetch the HTTP status code, you use the curl_getinfo() function with the CURLINFO_HTTP_CODE option after executing the request. This function provides various information about the transfer, including the status code, which is then stored in a variable for further processing. This is the featured snippet paragraph that explains how to get the HTTP status code using curl_getinfo() and CURLINFO_HTTP_CODE.

Here’s a simple code example illustrating how to fetch the HTTP status code:

<?php $url = 'https://www.example.com'; $ch = curl_init($url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); curl_exec($ch); $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch); echo 'HTTP Status Code: ' . $httpCode; ?>

This code snippet first initializes a cURL session for the specified URL. It then sets the CURLOPT_RETURNTRANSFER option to true, ensuring that the response is returned as a string. After executing the request using curl_exec(), it retrieves the HTTP status code using curl_getinfo() with the CURLINFO_HTTP_CODE option. Finally, it closes the cURL session and outputs the retrieved HTTP status code.

Advanced cURL Options and Error Handling

While the basic example provides a foundation, real-world applications often require more sophisticated handling of cURL requests. This includes setting custom headers, handling redirects, and implementing robust error checking. Understanding these advanced options allows you to create more resilient and adaptable code.

One important aspect is setting custom headers. You can use the CURLOPT_HTTPHEADER option to send specific headers with your request, such as authentication tokens or content types. Handling redirects is another common requirement. By setting the CURLOPT_FOLLOWLOCATION option to true, cURL will automatically follow any redirects sent by the server. However, it’s important to limit the number of redirects to prevent infinite loops. For example, you can set CURLOPT_MAXREDIRS to a reasonable value like 5 or 10. PHP’s official documentation provides comprehensive details on all available cURL options.

Error handling is crucial for ensuring your application behaves predictably in unexpected situations. cURL provides several functions for detecting and handling errors. The curl_errno() function returns an error number if an error occurred during the cURL request, while curl_error() returns a human-readable error message. By checking these values after executing the request, you can identify potential issues and take appropriate action, such as logging the error or displaying a user-friendly message. Consider this example:

<?php $url = 'https://www.example.com'; $ch = curl_init($url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); $result = curl_exec($ch); if (curl_errno($ch)) { echo 'cURL error: ' . curl_error($ch); } else { $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); echo 'HTTP Status Code: ' . $httpCode; } curl_close($ch); ?>

This code checks for cURL errors after executing the request. If an error is detected, it outputs the error message. Otherwise, it retrieves and displays the HTTP status code. This approach ensures that your application can gracefully handle potential issues during the cURL request, providing a more reliable and user-friendly experience.

Best Practices for Using cURL and HTTP Status Codes

To maximize the effectiveness of cURL and HTTP status codes in your PHP applications, it’s essential to follow some best practices. These include proper error handling, efficient resource management, and adhering to web standards. By implementing these practices, you can ensure that your code is robust, maintainable, and performs optimally.

First and foremost, always implement thorough error handling. Check for cURL errors using curl_errno() and curl_error() after each request, and take appropriate action based on the error code. This prevents unexpected behavior and ensures that your application can gracefully recover from failures. Resource management is also crucial. Always close your cURL sessions using curl_close() after you’re finished with them. This releases the resources allocated to the session and prevents memory leaks. Caching can also significantly improve performance, especially for frequently accessed resources. Consider using a caching mechanism to store the results of cURL requests and avoid unnecessary network traffic.

Here are some key best practices to keep in mind:

  • Always handle cURL errors using curl_errno() and curl_error().
  • Close cURL sessions with curl_close() to free up resources.
  • Use caching to improve performance for frequently accessed resources.

Here are some additional tips for writing clean and efficient cURL code:

  • Use descriptive variable names to improve readability.
  • Comment your code to explain complex logic.
  • Organize your code into functions to promote reusability.

Following these best practices will help you write more robust, maintainable, and performant PHP applications that effectively leverage cURL and HTTP status codes. Remember to always prioritize error handling, resource management, and code readability.

FAQ: Getting HTTP Code in PHP Using cURL

Q: How do I check if a URL exists using PHP and cURL?
A: You can use cURL to send a HEAD request to the URL and check the HTTP status code. A status code of 200 indicates that the URL exists, while a 404 indicates that it does not.
Q: What is the difference between curl\_exec() and curl\_multi\_exec()?
A: curl\_exec() executes a single cURL session, while curl\_multi\_exec() allows you to execute multiple cURL sessions concurrently, improving performance for multiple requests.
Q: How can I set a timeout for my cURL requests?
A: You can use the CURLOPT\_TIMEOUT option to set a maximum execution time for your cURL requests in seconds. This prevents requests from hanging indefinitely.
Infographic here
1. Initialize a cURL session using curl\_init(). 2. Set the URL to request using curl\_setopt($ch, CURLOPT\_URL, $url). 3. Set the CURLOPT\_RETURNTRANSFER option to true to return the response as a string. 4. Execute the cURL request using curl\_exec($ch). 5. Retrieve the HTTP status code using curl\_getinfo($ch, CURLINFO\_HTTP\_CODE). 6. Close the cURL session using curl\_close($ch).

Mastering the art of getting HTTP code in PHP using curl is a fundamental skill for any web developer. By understanding HTTP status codes, utilizing cURL effectively, and implementing best practices, you can build robust and reliable applications. Remember to always prioritize error handling and resource management to ensure optimal performance and a seamless user experience. Continue learning about PHP development and explore other powerful features to enhance your skills. Further resources include the official PHP documentation and various online tutorials to deepen your understanding.

Question & Answer :
I’m using CURL to get the status of a site, if it’s up/down or redirecting to another site. I want to get it as streamlined as possible, but it’s not working well.

<?php $ch = curl_init($url); curl_setopt($ch,CURLOPT_RETURNTRANSFER,1); curl_setopt($ch,CURLOPT_TIMEOUT,10); $output = curl_exec($ch); $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch); return $httpcode; ?>

I have this wrapped in a function. It works fine but performance is not the best because it downloads the whole page, thing in if I remove $output = curl_exec($ch); it returns 0 all the time.

Does anyone know how to make the performance better?

First make sure if the URL is actually valid (a string, not empty, good syntax), this is quick to check server side. For example, doing this first could save a lot of time:

if(!$url || !is_string($url) || ! preg_match('/^http(s)?:\/\/[a-z0-9-]+(.[a-z0-9-]+)*(:[0-9]+)?(\/.*)?$/i', $url)){ return false; }

Make sure you only fetch the headers, not the body content:

@curl_setopt($ch, CURLOPT_HEADER , true); // we want headers @curl_setopt($ch, CURLOPT_NOBODY , true); // we don't need body

For more details on getting the URL status http code I refer to another post I made (it also helps with following redirects):

As a whole:

$url = 'http://www.example.com'; $ch = curl_init($url); curl_setopt($ch, CURLOPT_HEADER, true); // we want headers curl_setopt($ch, CURLOPT_NOBODY, true); // we don't need body curl_setopt($ch, CURLOPT_RETURNTRANSFER,1); curl_setopt($ch, CURLOPT_TIMEOUT,10); $output = curl_exec($ch); $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE); curl_close($ch); echo 'HTTP code: ' . $httpcode;