GuzzleHttp is a powerful PHP library that makes it easy to send HTTP/1.1 requests and handle responses. It provides a simple interface for building HTTP requests and handling responses, allowing developers to integrate their PHP applications with web services and APIs. GuzzleHttp is designed to be both easy to use and highly customizable. It supports features such as async requests, parallel requests, middleware, and more. It also provides support for popular authentication methods and provides easy access to response data through convenient methods and interfaces.

• Installing GuzzleHttp
• Making Your First Request
• Sending GET Requests with GuzzleHttp
• Sending POST Requests with GuzzleHttp
• Handling Responses with GuzzleHttp
• Configuring GuzzleHttp
• Using GuzzleHttp Middleware
• Debugging GuzzleHttp Requests
• How Is GuzzleHttp Similar To And Different From Python Requests

In this tutorial, we’ll provide an overview of GuzzleHttp, explain why it’s useful, and show you how to get started using it in your PHP projects. We’ll cover topics such as installation, making requests, handling responses, and more. By the end of this tutorial, you should have a good understanding of how GuzzleHttp works and how to use it to interact with web services and APIs.

Installing GuzzleHttp

Before you can start using GuzzleHttp, you’ll need to install it in your project. GuzzleHttp is available via Composer, a popular PHP dependency manager.

To install GuzzleHttp via Composer, follow these steps:

1. Open a terminal or command prompt in your project’s root directory.
2. Run the following command to add GuzzleHttp as a dependency:

composer require guzzlehttp/guzzle

This will download and install the latest version of GuzzleHttp and all of its dependencies.

Once GuzzleHttp is installed, you can start using it in your project by including it in your PHP files using the following line:

use GuzzleHttp\Client;

This line will import the GuzzleHttp client class, which is the main interface for making HTTP requests with GuzzleHttp.

Making Your First Request

Now that you have GuzzleHttp installed in your project, you can start making HTTP requests. In this section, we’ll show you how to make your first request using GuzzleHttp.

To make a request with GuzzleHttp, you’ll first need to create a new instance of the GuzzleHttp\Client class. You can do this by using the following code:

$client = new \GuzzleHttp\Client();

This will create a new GuzzleHttp client instance that you can use to make requests.

To make a request, you’ll need to specify the URL you want to send the request to and the HTTP method you want to use. For example, to send a GET request to the URL “https://jsonplaceholder.typicode.com/posts“, you can use the following code:

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

This will send a GET request to the specified URL and return a response object. You can then use the response object to access the response data.

To see the response data, you can use the following code:

echo $response->getBody();

This will output the raw response data as a string. You can also use other methods of the response object to access specific parts of the response, such as the response headers or the response status code.

Sending GET Requests with GuzzleHttp

GET requests are used to retrieve data from a server. In this section, we’ll show you how to send GET requests using GuzzleHttp.

To send a GET request with GuzzleHttp, you can use the $client->get() method, as we did in the previous section. The get() method takes two arguments: the URL to send the request to and an optional array of options.

Here’s an example of sending a GET request to the URL “https://jsonplaceholder.typicode.com/posts“:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

echo $response->getBody();

This will send a GET request to the specified URL and output the response data.

You can also pass additional options to the get() method to customize the request. For example, you can pass query parameters as an array:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts', [
    'query' => [
        'userId' => 1,
    ],
]);

echo $response->getBody();

This will send a GET request to the URL “https://jsonplaceholder.typicode.com/posts” with a query parameter “userId” set to 1. The response data will be outputted to the screen. That’s how easy it is to send GET requests with GuzzleHttp! In the next section, we’ll show you how to send POST requests.

Sending POST Requests with GuzzleHttp

POST requests are used to submit data to a server. In this section, we’ll show you how to send POST requests using GuzzleHttp.

To send a POST request with GuzzleHttp, you can use the $client->post() method. The post() method takes three arguments: the URL to send the request to, an array of data to send with the request, and an optional array of options.

Here’s an example of sending a POST request to the URL “https://jsonplaceholder.typicode.com/posts” with some sample data:

$client = new \GuzzleHttp\Client();

$response = $client->post('https://jsonplaceholder.typicode.com/posts', [
    'json' => [
        'title' => 'GuzzleHttp Tutorial',
        'body' => 'Learn how to use GuzzleHttp to send HTTP requests in PHP.',
        'userId' => 1,
    ],
]);

echo $response->getBody();

This will send a POST request to the specified URL with the sample data in JSON format and output the response data.

You can also pass additional options to the post() method to customize the request. For example, you can set the content type of the request:

$client = new \GuzzleHttp\Client();

$response = $client->post('https://jsonplaceholder.typicode.com/posts', [
    'json' => [
        'title' => 'GuzzleHttp Tutorial',
        'body' => 'Learn how to use GuzzleHttp to send HTTP requests in PHP.',
        'userId' => 1,
    ],
    'headers' => [
        'Content-Type' => 'application/json',
    ],
]);

echo $response->getBody();

This will send a POST request to the URL “https://jsonplaceholder.typicode.com/posts” with the sample data in JSON format and a “Content-Type” header set to “application/json”. The response data will be outputted to the screen.

Handling Responses with GuzzleHttp

After making a request with GuzzleHttp, you’ll receive a response object that contains the response data. In this section, we’ll show you how to handle responses in GuzzleHttp.

The response object returned by GuzzleHttp has many useful methods to access different parts of the response, such as the response status code, response headers, and response body.

Here’s an example of how to get the response status code:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

$status_code = $response->getStatusCode();

echo $status_code;

This will send a GET request to the specified URL and output the response status code.

You can also get the response headers using the getHeaders() method:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

$headers = $response->getHeaders();

echo '<pre>';
print_r($headers);
echo '</pre>';

This will send a GET request to the specified URL and output the response headers in a human-readable format.

To get the response body, you can use the getBody() method:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

$body = $response->getBody();

echo $body;

This will send a GET request to the specified URL and output the response body.

You can also use the json() method to parse the response body as JSON:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

$data = $response->json();

echo '<pre>';
print_r($data);
echo '</pre>';

This will send a GET request to the specified URL, parse the response body as JSON, and output the data in a human-readable format.

Configuring GuzzleHttp

GuzzleHttp can be configured using an instance of GuzzleHttp\Client. The Client constructor takes an optional array of configuration options.

Here are some common configuration options that can be used with GuzzleHttp:

• base_uri: The base URI that is used for all requests made with the client. This can be useful if you’re making requests to the same API and don’t want to repeat the base URI for every request.

$client = new \GuzzleHttp\Client([
    'base_uri' => 'https://jsonplaceholder.typicode.com/',
]);

• timeout: The maximum amount of time to wait for a response from the server.

$client = new \GuzzleHttp\Client([
    'timeout' => 5.0, // 5 seconds
]);

• http_errors: Whether or not to throw an exception for HTTP protocol errors (e.g., 404 Not Found, 500 Internal Server Error).

$client = new \GuzzleHttp\Client([
    'http_errors' => false,
]);

• verify: Whether or not to verify the SSL certificate of the server. If you’re making requests to a server with a self-signed certificate, you’ll need to set this to false.

$client = new \GuzzleHttp\Client([
    'verify' => false,
]);

• headers: An array of headers to include with every request made with the client.

$client = new \GuzzleHttp\Client([
    'headers' => [
        'User-Agent' => 'My App/1.0',
    ],
]);

You can also set configuration options on a per-request basis by passing an array of options as the third argument to the request method:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts', [
    'timeout' => 5.0, // 5 seconds
]);

echo $response->getBody();

This will send a GET request to the specified URL with a timeout of 5 seconds and output the response data.

Using GuzzleHttp Middleware

Middleware is a powerful feature in GuzzleHttp that allows you to modify requests and responses before they are sent and received. Middleware is essentially a series of callables that are executed in sequence, with each callable modifying the request or response in some way.

Here’s an example of using middleware to modify the response body by adding a prefix to it:

$client = new \GuzzleHttp\Client();

$prefix = 'PREFIX: ';

$modifyResponse = function ($response) use ($prefix) {
    $body = $response->getBody();
    $response = $response->withBody(\GuzzleHttp\Psr7\stream_for($prefix . $body));
    return $response;
};

$stack = \GuzzleHttp\HandlerStack::create();
$stack->push(\GuzzleHttp\Middleware::mapResponse($modifyResponse));

$client = new \GuzzleHttp\Client(['handler' => $stack]);

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

echo $response->getBody();

This will send a GET request to the specified URL and modify the response body by adding the prefix ‘PREFIX: ‘ to it.

In the example above, we created a new callable $modifyResponse that modifies the response by adding the prefix to the body. We then created a new instance of GuzzleHttp\HandlerStack and pushed our callable onto the stack using GuzzleHttp\Middleware::mapResponse. Finally, we passed the handler stack to the GuzzleHttp\Client constructor.

You can also use middleware to modify requests in a similar way. Here’s an example of adding a header to every request using middleware:

$client = new \GuzzleHttp\Client();

$addHeader = function ($request) {
    return $request->withHeader('X-My-Header', 'My Value');
};

$stack = \GuzzleHttp\HandlerStack::create();
$stack->push(\GuzzleHttp\Middleware::mapRequest($addHeader));

$client = new \GuzzleHttp\Client(['handler' => $stack]);

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

echo $response->getBody();

This will send a GET request to the specified URL with an additional header ‘X-My-Header: My Value’.

Debugging GuzzleHttp Requests

GuzzleHttp provides a number of ways to debug requests and responses. Here are some techniques that you can use:

1. Enable Debug Logging: You can enable debug logging by passing the debug option to the client constructor. This will output detailed debugging information to the console.

$client = new \GuzzleHttp\Client([
    'debug' => true,
]);

2. Inspect Requests and Responses: You can inspect the request and response objects by dumping them to the console. Here’s an example:

$client = new \GuzzleHttp\Client();

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

var_dump($response);

This will output the response object to the console, which you can use to inspect the response headers, status code, and body.

3. Use the Request and Response Handlers: GuzzleHttp provides a request and response handler that you can use to intercept and modify the request and response objects. Here’s an example of using the request handler to log requests:

$logRequests = function ($request) {
    error_log($request->getMethod() . ' ' . (string)$request->getUri());
    return $request;
};

$stack = \GuzzleHttp\HandlerStack::create();
$stack->push(\GuzzleHttp\Middleware::mapRequest($logRequests));

$client = new \GuzzleHttp\Client(['handler' => $stack]);

$response = $client->get('https://jsonplaceholder.typicode.com/posts');

This will send a GET request to the specified URL and log the request method and URL to the error log.

4. Use a Proxy Server: You can use a proxy server to intercept and inspect requests and responses. Here’s an example of using the http_proxy option to specify a proxy server:

$client = new \GuzzleHttp\Client([
    'http_proxy' => 'http://localhost:8888',
]);

This will send all requests through the specified proxy server, which you can then use to inspect the request and response objects.

How Is GuzzleHttp Similar To And Different From Python Requests

GuzzleHttp and Python Requests are both popular HTTP clients that make it easy to send HTTP requests and handle HTTP responses. Here are some of the similarities and differences between the two libraries:

Similarities:

1. Both libraries are easy to use and require only a few lines of code to make an HTTP request.
2. Both libraries support HTTP methods such as GET, POST, PUT, DELETE, etc.
3. Both libraries support various types of authentication, including Basic Authentication, OAuth, and Bearer Tokens.
4. Both libraries allow you to specify headers and query parameters.

Differences:

1. GuzzleHttp is a PHP library, while Requests is a Python library.
2. GuzzleHttp has built-in support for middleware, which allows you to modify requests and responses before they are sent and received. Requests does not have built-in middleware support, but it is possible to use external libraries to achieve similar functionality.
3. GuzzleHttp requires PHP 7.1 or later, while Requests requires Python 2.7, 3.4, or later.
4. GuzzleHttp uses the PSR-7 HTTP message interface, while Requests uses its own custom HTTP message format.
5. GuzzleHttp has built-in support for asynchronous requests using the Promises interface, while Requests does not have built-in support for asynchronous requests.
6. GuzzleHttp has built-in support for exception handling and error reporting, while Requests requires you to handle exceptions manually.

In summary, both GuzzleHttp and Python Requests are great libraries for sending HTTP requests and handling HTTP responses. They are both easy to use and have similar features, but they differ in their implementation details and language-specific features.

• Guzzle, PHP HTTP client — Guzzle Documentation (docs.guzzlephp.org)
• What Is GuzzleHttp And How To Use It – vegibit (vegibit.com)
• How to use Guzzle for sending HTTP Requests and (www.youtube.com)
• How to use Guzzle – Artisans Web (artisansweb.net)
• How to use Guzzle HTTP Client in simple PHP? – Stack (stackoverflow.com)
• GitHub – guzzle/guzzle: Guzzle, an extensible PHP (github.com)
• PHP: Using Guzzle to make URL GET and POST Requests (davescripts.com)
• Consuming REST API in PHP Using Guzzle | by Cloudways (medium.com)
• Laravel 10 Guzzle HTTP Client Get Request Example (www.laravelia.com)
• Laravel 8 Guzzle HTTP GET & POST Example – Tuts (www.tutsmake.com)
• Posts – laravelcode.com (www.laravelcode.com)