Guzzle

https://github.com/guzzle/guzzle
Admin
Guzzle is a PHP HTTP client library that makes it easy to send HTTP requests and integrate with web...
Tokens:165,708
Snippets:1,019
Trust Score:9
License:MIT
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Send a request with a custom HTTP method using request()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

For HTTP methods without a shortcut, pass the method name as the first argument to request(). Example uses OPTIONS.

```php
$response = $client->request('OPTIONS', 'http://httpbin.org/get');
```

--------------------------------

### Send common HTTP requests with shortcut methods

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Use named client methods for common synchronous requests: get, delete, head, patch, post, and put. Each returns a response object.

```php
$response = $client->get('http://httpbin.org/get');
$response = $client->delete('http://httpbin.org/delete');
$response = $client->head('http://httpbin.org/get');
$response = $client->patch('http://httpbin.org/patch');
$response = $client->post('http://httpbin.org/post');
$response = $client->put('http://httpbin.org/put');
```

--------------------------------

### Install Guzzle via Composer

Source: https://github.com/guzzle/guzzle/blob/8.3/README.md

Install Guzzle using Composer with the command `composer require guzzlehttp/guzzle`. This is the recommended installation method.

```bash
composer require guzzlehttp/guzzle
```

--------------------------------

### Clone Guzzle repository and install dependencies

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

Clones the Guzzle source from GitHub and installs its dependencies using Composer. Required before running the test suite.

```bash
git clone https://github.com/guzzle/guzzle.git
cd guzzle && composer install
```

--------------------------------

### Set query string parameters in the request URI

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Passes query parameters directly in the URI string when making a GET request with Guzzle.

```php
$response = $client->request('GET', 'http://httpbin.org?foo=bar');
```

--------------------------------

### Retrieve headers from a PSR-7 response

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Shows how to check if a header exists, get a single header value, and iterate over all response headers. Uses methods from Psr\Http\Message\ResponseInterface.

```php
// Check if a header exists.
if ($response->hasHeader('Content-Length')) {
    echo "It exists";
}

// Get a header from the response.
echo $response->getHeader('Content-Length')[0];

// Get all of the response headers.
foreach ($response->getHeaders() as $name => $values) {
    echo $name . ': ' . implode(', ', $values) . "\r\n";
}
```

--------------------------------

### Get status code and reason phrase from a PSR-7 response

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Retrieves the HTTP status code and reason phrase from a response object that implements Psr\Http\Message\ResponseInterface. The comments show example values (200 and OK) but the actual values depend on the response.

```php
$code = $response->getStatusCode(); // 200
$reason = $response->getReasonPhrase(); // OK
```

--------------------------------

### Example debug output from cURL verbose

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Example output produced when the 'debug' option is enabled with cURL. Shows connection details, request headers, and response headers.

```text
* About to connect() to httpbin.org port 80 (#0)
    *   Trying 107.21.213.98... * Connected to httpbin.org (107.21.213.98) port 80 (#0)
    > GET /get HTTP/1.1
    Host: httpbin.org
    User-Agent: GuzzleHttp/8

    < HTTP/1.1 200 OK
    < Access-Control-Allow-Origin: *
    < Content-Type: application/json
    < Date: Sun, 16 Feb 2014 06:50:09 GMT
    < Server: gunicorn/0.17.4
    < Content-Length: 335
    < Connection: keep-alive
    <
    * Connection #0 to host httpbin.org left intact
```

--------------------------------

### Before: Using Guzzle\Service\Inspector::fromConfig

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Original client factory using Inspector::fromConfig before the migration to Collection.

```php
use Guzzle\Service\Inspector;

class YourClient extends \Guzzle\Service\Client
{
    public static function factory($config = array())
    {
        $default = array();
        $required = array('base_url', 'username', 'api_key');
        $config = Inspector::fromConfig($config, $default, $required);

        $client = new self(
            $config->get('base_url'),
            $config->get('username'),
            $config->get('api_key')
        );
        $client->setConfig($config);

        $client->setDescription(ServiceDescription::factory(__DIR__ . DIRECTORY_SEPARATOR . 'client.json'));

        return $client;
    }
}
```

--------------------------------

### Native Functions Calls: Before and After

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the change to prefix internal native function calls with a slash to prevent method overloading. The 'Before' example uses 'curl_version()' without a slash, while the 'After' example uses '\curl_version()'.

```php
// Before:
curl_version();
```

```php
// After:
\curl_version();
```

--------------------------------

### Send a GET request with Guzzle

Source: https://github.com/guzzle/guzzle/blob/8.3/README.md

Create a Guzzle client, send a GET request to an API endpoint, and access the response status code, header, and body. The example outputs a status code of 200, a content-type header of 'application/json', and a JSON body.

```php
$client = new \GuzzleHttp\Client();
$response = $client->request('GET', 'https://api.example.com/users/123');

echo $response->getStatusCode(); // 200
echo $response->getHeaderLine('content-type'); // 'application/json'
echo $response->getBody(); // '{"id": 123, "name": "Ada"}'
```

--------------------------------

### After: Using Guzzle\Common\Collection::fromConfig

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Updated client factory using Collection::fromConfig after the migration.

```php
use Guzzle\Common\Collection;

class YourClient extends \Guzzle\Service\Client
{
    public static function factory($config = array())
    {
        $default = array();
        $required = array('base_url', 'username', 'api_key');
        $config = Collection::fromConfig($config, $default, $required);

        $client = new self(
            $config->get('base_url'),
            $config->get('username'),
            $config->get('api_key')
        );
        $client->setConfig($config);

        $client->setDescription(ServiceDescription::factory(__DIR__ . DIRECTORY_SEPARATOR . 'client.json'));

        return $client;
    }
}
```

--------------------------------

### Follow redirects by default and print status code

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Guzzle automatically follows redirects by default (max 5). The example requests http://github.com and prints the resulting status code, which is 200.

```php
$response = $client->request('GET', 'http://github.com');
echo $response->getStatusCode();
// 200
```

--------------------------------

### Send asynchronous requests using sendAsync() and requestAsync()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Use sendAsync() with a PSR-7 request object, or requestAsync() for methods without a named shortcut. Both return promises.

```php
use GuzzleHttp\Psr7\Request;

// Create a PSR-7 request object to send
$headers = ['X-Foo' => 'Bar'];
$body = 'Hello!';
$request = new Request('PUT', 'http://httpbin.org/put', $headers, $body);
$promise = $client->sendAsync($request);

// Or, if you don't need to pass in a request instance:
$promise = $client->requestAsync('GET', 'http://httpbin.org/get');
$promise = $client->requestAsync('OPTIONS', 'http://httpbin.org/get');
```

--------------------------------

### Install Composer via curl

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

Downloads and installs Composer, the dependency manager used to install Guzzle. Run this command in your terminal before adding Guzzle as a dependency.

```bash
# Install Composer
curl -sS https://getcomposer.org/installer | php
```

--------------------------------

### Create a Request object and send it with the client

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Build a Psr7 Request and send it via the client's send() method, optionally passing per-request options like timeout.

```php
use GuzzleHttp\Psr7\Request;

$request = new Request('PUT', 'http://httpbin.org/put');
$response = $client->send($request, ['timeout' => 2]);
```

--------------------------------

### Set query string parameters using the 'query' option as a string

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Provides the 'query' request option as a pre-formatted string instead of an array.

```php
$client->request('GET', 'http://httpbin.org', ['query' => 'foo=bar']);
```

--------------------------------

### Add Guzzle to composer.json

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

Alternative installation method: specify guzzlehttp/guzzle ^8.3 in the require section of your project's existing composer.json file.

```json
{
  "require": {
     "guzzlehttp/guzzle": "^8.3"
  }
}
```

--------------------------------

### Create a Guzzle client with base_uri and timeout

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Instantiate a GuzzleHttp\Client with default request options. The base_uri is merged with relative URIs, and timeout sets a default request timeout. Clients are immutable after creation.

```php
use GuzzleHttp\Client;

$client = new Client([
    // Base URI is used with relative requests
    'base_uri' => 'http://httpbin.org',
    // You can set any number of default request options.
    'timeout'  => 2.0,
]);
```

--------------------------------

### ServiceDescription: Commands to Operations (Before)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the old API for ServiceDescription using commands. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Service\Description\ServiceDescription;

$sd = new ServiceDescription();
$sd->getCommands();     // @returns ApiCommandInterface[]
$sd->hasCommand($name);
$sd->getCommand($name); // @returns ApiCommandInterface|null
$sd->addCommand($command); // @param ApiCommandInterface $command
```

--------------------------------

### Send asynchronous requests using named async shortcut methods

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Use the named async shortcut methods (getAsync, deleteAsync, headAsync, patchAsync, postAsync, putAsync) to send asynchronous requests. Each returns a promise that can be chained with then() calls.

```php
$promise = $client->getAsync('http://httpbin.org/get');
$promise = $client->deleteAsync('http://httpbin.org/delete');
$promise = $client->headAsync('http://httpbin.org/get');
$promise = $client->patchAsync('http://httpbin.org/patch');
$promise = $client->postAsync('http://httpbin.org/post');
$promise = $client->putAsync('http://httpbin.org/put');
```

--------------------------------

### Create Guzzle client with base_uri

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Sets up a client with a base URI for all subsequent request examples. This client is used throughout the request options documentation.

```php
$client = new GuzzleHttp\Client(['base_uri' => 'http://httpbin.org']);
```

--------------------------------

### Send concurrent requests with Promise\Utils::unwrap() and settle()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Initiate multiple async requests and wait for them concurrently. unwrap() throws if any request is rejected; settle() waits even if some fail and returns an array with 'state' and 'value' or 'reason'.

```php
use GuzzleHttp\Client;
use GuzzleHttp\Promise;

$client = new Client(['base_uri' => 'http://httpbin.org/']);

// Initiate each request but do not block
$promises = [
    'image' => $client->getAsync('/image'),
    'png'   => $client->getAsync('/image/png'),
    'jpeg'  => $client->getAsync('/image/jpeg'),
    'webp'  => $client->getAsync('/image/webp')
];

// Wait for the requests to complete; throws if any request is rejected.
$responses = Promise\Utils::unwrap($promises);

// You can access each response using the key of the promise
echo $responses['image']->getHeader('Content-Length')[0];
echo $responses['png']->getHeader('Content-Length')[0];

// Wait for the requests to complete, even if some of them fail
$responses = Promise\Utils::settle($promises)->wait();

// Values returned above are wrapped in an array with "state" (either fulfilled or rejected),
// plus "value" for fulfilled responses or "reason" for rejected requests.
echo $responses['image']['state']; // returns "fulfilled"
echo $responses['image']['value']->getHeader('Content-Length')[0];
echo $responses['png']['value']->getHeader('Content-Length')[0];
```

--------------------------------

### Use Pool with a closure that returns promises

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Alternative Pool usage where the generator yields closures that receive merged request options and return a response or promise.

```php
$client = new Client();

$requests = function ($total) use ($client) {
    $uri = 'http://127.0.0.1:8126/guzzle-server/perf';
    for ($i = 0; $i < $total; $i++) {
        yield function (array $options) use ($client, $uri) {
            return $client->getAsync($uri, $options);
        };
    }
};

$pool = new Pool($client, $requests(100));
```

--------------------------------

### Require Composer's autoloader

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

After installing Guzzle, include Composer's autoloader in your PHP script to load all dependencies automatically.

```php
require 'vendor/autoload.php';
```

--------------------------------

### Set query string parameters using the 'query' option as an array

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Uses the 'query' request option with an array; Guzzle formats it with PHP's http_build_query function.

```php
$client->request('GET', 'http://httpbin.org', [
    'query' => ['foo' => 'bar']
]);
```

--------------------------------

### ServiceDescription: Commands to Operations (After)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the new API for ServiceDescription using operations. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Service\Description\ServiceDescription;

$sd = new ServiceDescription();
$sd->getOperations();           // @returns OperationInterface[]
$sd->hasOperation($name);
$sd->getOperation($name);       // @returns OperationInterface|null
$sd->addOperation($operation);  // @param OperationInterface $operation
```

--------------------------------

### Send an indeterminate number of requests with GuzzleHttp\Pool

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Use Pool with a generator yielding Request objects to send many requests concurrently. Configure concurrency and callbacks for fulfilled and rejected responses.

```php
use GuzzleHttp\Client;
use GuzzleHttp\Pool;
use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\ResponseInterface;

$client = new Client();

$requests = function ($total) {
    $uri = 'http://127.0.0.1:8126/guzzle-server/perf';
    for ($i = 0; $i < $total; $i++) {
        yield new Request('GET', $uri);
    }
};

$pool = new Pool($client, $requests(100), [
    'concurrency' => 5,
    'fulfilled' => function (ResponseInterface $response, $index, PromiseInterface $aggregate) {
        // this is delivered each successful response
    },
    'rejected' => function ($reason, $index, PromiseInterface $aggregate) {
        // this is delivered each failed request
    },
]);

// Initiate the transfers and create a promise
$promise = $pool->promise();

// Force the pool of requests to complete.
$promise->wait();
```

--------------------------------

### URL default path before change

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Before 3.2, URLs had a default path of '/' when no path was specified. This example shows the old behavior.

```php
$request = $client->get('http://www.foo.com');
echo $request->getUrl();
// >> http://www.foo.com/
```

--------------------------------

### Use base_uri with relative and absolute request URIs

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Shows how the client combines base_uri with relative URIs. A leading slash replaces the base path, while a relative path appends to it. Absolute URIs override the base.

```php
// Create a client with a base URI
$client = new GuzzleHttp\Client(['base_uri' => 'https://foo.com/api/']);
// Send a request to https://foo.com/api/test
$response = $client->request('GET', 'test');
// Send a request to https://foo.com/root
$response = $client->request('GET', '/root');
```

--------------------------------

### Require Guzzle with Composer

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

Adds guzzlehttp/guzzle version ^8.3 as a dependency to your project using Composer's command-line interface.

```bash
composer require guzzlehttp/guzzle:^8.3
```

--------------------------------

### Handle promise fulfillment and rejection with then()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Chain then() calls on the promise returned by requestAsync(). The fulfillment callback receives a ResponseInterface, and the rejection callback receives a reason (often a TransferException).

```php
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\TransferException;

$promise = $client->requestAsync('GET', 'http://httpbin.org/get');
$promise->then(
    function (ResponseInterface $res) {
        echo $res->getStatusCode();
    },
    function ($reason) {
        if ($reason instanceof TransferException) {
            echo $reason->getMessage();
        }
    }
);
```

--------------------------------

### Batch requests with GuzzleHttp\Pool::batch()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Sends a fixed set of requests concurrently, blocks until all settle, and returns an array of responses or rejection reasons in the same order as the requests. Accepts the same options as the Pool constructor (concurrency, options, fulfilled, rejected). Not suited for very large or indeterminate numbers of requests because it keeps every request and response in memory.

```php
use GuzzleHttp\Client;
use GuzzleHttp\Pool;
use GuzzleHttp\Psr7\Request;
use Psr\Http\Message\ResponseInterface;

$client = new Client();

$requests = [
    new Request('GET', 'http://httpbin.org/get'),
    new Request('GET', 'http://httpbin.org/status/500'),
];

$results = Pool::batch($client, $requests, ['concurrency' => 5]);

foreach ($results as $index => $result) {
    if ($result instanceof ResponseInterface) {
        echo $index . ': ' . $result->getStatusCode() . "\n";
    } else {
        // The transfer failed; $result is the rejection reason, usually an exception.
        echo $index . ': failed' . "\n";
    }
}
```

--------------------------------

### Client request methods: 3.0 vs 4.0

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

In 4.0, calling get() or post() sends the request and returns the response directly. To mirror 3.0 behavior, use createRequest() and send().

```php
// 3.0
$request = $client->get('/');
$response = $request->send();

// 4.0
$response = $client->get('/');

// or, to mirror the previous behavior
$request = $client->createRequest('GET', '/');
$response = $client->send($request);
```

--------------------------------

### Replacement for deprecated command.headers and command.response_body

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Use command.request_options with headers and save_as to replace the deprecated options. This is the recommended approach.

```php
$command = $client->getCommand('foo', array(
    'command.request_options' => array(
        'headers' => array('Test' => '123'),
        'save_as' => '/path/to/file'
    )
));
```

--------------------------------

### Log Middleware: Usage with MessageFormatter

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/middleware.md

Example of pushing Middleware::log() onto a handler stack. Uses a PSR-3 logger and a MessageFormatter with the DEBUG preset and 'debug' log level.

```php
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\MessageFormatter;
use GuzzleHttp\Middleware;

// $logger is any Psr\Log\LoggerInterface implementation.
$stack = HandlerStack::create();
$stack->push(Middleware::log($logger, new MessageFormatter(MessageFormatter::DEBUG), 'debug'));

$client = new Client(['handler' => $stack]);
$client->request('GET', 'https://example.com');
```

--------------------------------

### ExponentialBackoffPlugin to BackoffPlugin (Before)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the old class and usage for ExponentialBackoffPlugin. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Http\Plugin\ExponentialBackoffPlugin;

$backoffPlugin = new ExponentialBackoffPlugin($maxRetries, array_merge(
        ExponentialBackoffPlugin::getDefaultFailureCodes(), array(429)
    ));

$client->addSubscriber($backoffPlugin);
```

--------------------------------

### LogPlugin and Log Namespace Change (Before)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the old namespace and usage for LogPlugin and ClosureLogAdapter. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Common\Log\ClosureLogAdapter;
use Guzzle\Http\Plugin\LogPlugin;

/** @var \Guzzle\Http\Client */
$client;

// $verbosity is an integer indicating desired message verbosity level
$client->addSubscriber(new LogPlugin(new ClosureLogAdapter(function($m) { echo $m; }, $verbosity = LogPlugin::LOG_VERBOSE);
```

--------------------------------

### ExponentialBackoffPlugin to BackoffPlugin (After)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the new class and usage for BackoffPlugin. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Plugin\Backoff\BackoffPlugin;
use Guzzle\Plugin\Backoff\HttpBackoffStrategy;

// Use convenient factory method instead -- see implementation for ideas of what
// you can do with chaining backoff strategies
$backoffPlugin = BackoffPlugin::getExponentialBackoff($maxRetries, array_merge(
        HttpBackoffStrategy::getDefaultFailureCodes(), array(429)
    ));
$client->addSubscriber($backoffPlugin);
```

--------------------------------

### Disable redirects with 'allow_redirects' => false

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Sets 'allow_redirects' to false to disable redirect following. The request to http://github.com returns a 301 status code instead of following the redirect.

```php
$response = $client->request('GET', 'http://github.com', [
    'allow_redirects' => false
]);
echo $response->getStatusCode();
// 301
```

--------------------------------

### XML Service Description (Before)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Original XML format for Guzzle service descriptions, using <command> elements with method, uri, doc, and param attributes. Includes commands for list_groups, search_groups, create_group, delete_group, get_group, and update_group.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<client>
    <commands>
        <!-- Groups -->
        <command name="list_groups" method="GET" uri="groups.json">
            <doc>Get a list of groups</doc>
        </command>
        <command name="search_groups" method="GET" uri='search.json?query="{{query}} type:group"'>
            <doc>Uses a search query to get a list of groups</doc>
            <param name="query" type="string" required="true" />
        </command>
        <command name="create_group" method="POST" uri="groups.json">
            <doc>Create a group</doc>
            <param name="data" type="array" location="body" filters="json_encode" doc="Group JSON"/>
            <param name="Content-Type" location="header" static="application/json"/>
        </command>
        <command name="delete_group" method="DELETE" uri="groups/{{id}}.json">
            <doc>Delete a group by ID</doc>
            <param name="id" type="integer" required="true"/>
        </command>
        <command name="get_group" method="GET" uri="groups/{{id}}.json">
            <param name="id" type="integer" required="true"/>
        </command>
        <command name="update_group" method="PUT" uri="groups/{{id}}.json">
            <doc>Update a group</doc>
            <param name="id" type="integer" required="true"/>
            <param name="data" type="array" location="body" filters="json_encode" doc="Group JSON"/>
            <param name="Content-Type" location="header" static="application/json"/>
        </command>
    </commands>
</client>
```

--------------------------------

### LogPlugin and Log Namespace Change (After)

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the new namespace and usage for LogPlugin and ClosureLogAdapter. Use this as a reference when migrating from Guzzle 2.8 to 3.0.

```php
use Guzzle\Log\ClosureLogAdapter;
use Guzzle\Log\MessageFormatter;
use Guzzle\Plugin\Log\LogPlugin;

/** @var \Guzzle\Http\Client */
$client;

// $format is a string indicating desired message format -- @see MessageFormatter
$client->addSubscriber(new LogPlugin(new ClosureLogAdapter(function($m) { echo $m; }, $format = MessageFormatter::DEBUG_FORMAT);
```

--------------------------------

### Send a PSR-7 request with Client::send()

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/guzzle-and-psr-7.md

Creates a PSR-7 Request and sends it using Guzzle's Client::send() method. The request uses the GET method and a URL of https://example.com/api.

```php
use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Request;

$client = new Client();
$request = new Request('GET', 'https://example.com/api');
$response = $client->send($request);
```

--------------------------------

### Run Guzzle unit tests with PHPUnit

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/overview.md

Executes Guzzle's unit test suite using PHPUnit. Note that integration tests for HTTP handlers require Node.js ^20.19 || ^22.13 || >=24 available as 'node'.

```bash
vendor/bin/phpunit
```

--------------------------------

### Access response body as string or stream

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/quick-start.md

Retrieves the response body using getBody(). The body can be used as a string, cast to a string, or used as a stream-like object. Shows implicit and explicit casting, reading a specific number of bytes, and reading the remaining contents.

```php
$body = $response->getBody();
// Implicitly cast the body to a string and echo it
echo $body;
// Explicitly cast the body to a string
$stringBody = (string) $body;
// Read 10 bytes from the body
$tenBytes = $body->read(10);
// Read the remaining contents of the body as a string
$remainingBytes = $body->getContents();
```

--------------------------------

### Deprecated command.headers and command.response_body usage

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the old way of setting command headers and response body, which is deprecated. Use command.request_options instead.

```php
$command = $client->getCommand('foo', array(
    'command.headers' => array('Test' => '123'),
    'command.response_body' => '/path/to/file'
));
```

--------------------------------

### POST body field and file

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Use the PostBodyInterface to set fields and add files. Requires a request created with a standard MessageFactoryInterface.

```php
$request = $client->createRequest('POST', '/');
$request->getBody()->setField('foo', 'bar');
$request->getBody()->addFile(new PostFile('file_key', fopen('/path/to/content', 'r')));
```

--------------------------------

### Enable default redirects with allow_redirects => true

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Uses the default redirect behavior (max 5 redirects) by omitting the option. The example follows redirects and prints the final status code, which is 200.

```php
$res = $client->request('GET', '/redirect/3');
echo $res->getStatusCode();
// 200
```

--------------------------------

### Add event listener with on() instead of addListener()

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the migration from addListener() to the on() method. The 4.x listener receives an additional $name argument.

```php
// 3.x
$request->getEventDispatcher()->addListener('foo', function (Event $event) { /* ... */ } );
// 4.x
$request->getEmitter()->on('foo', function (Event $event, $name) { /* ... */ } );
```

--------------------------------

### Wrap third-party SPL exceptions in middleware

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/contributing/exception-guidelines.md

When calling PSR-17 factories or PSR-7 parsers that may throw the global \InvalidArgumentException, catch the global type and rethrow as BadResponseException when a response exists. This example wraps a redirect URI creation failure.

```php
try {
    $uri = $uriFactory->createUri($location);
} catch (\InvalidArgumentException $e) { // global type: also catches Guzzle's
    throw new BadResponseException("Redirect URI, {$location}, is invalid", $request, $response, $e);
}
```

--------------------------------

### get_group

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Get a ticket. This operation is defined in the service description and can be called by the client.

```APIDOC
## GET groups/{id}.json

### Description
Get a ticket.

### Method
GET

### Endpoint
groups/{id}.json

### Parameters
#### Path Parameters
- **id** (integer) - Required - Group to get by ID

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### list_groups

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Get a list of groups. This operation is defined in the service description and can be called by the client.

```APIDOC
## GET groups.json

### Description
Get a list of groups.

### Method
GET

### Endpoint
groups.json

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### search_groups

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Uses a search query to get a list of groups. This operation is defined in the service description and can be called by the client.

```APIDOC
## GET search.json?query="{query} type:group"

### Description
Uses a search query to get a list of groups.

### Method
GET

### Endpoint
search.json?query="{query} type:group"

### Parameters
#### Query Parameters
- **query** (string) - Required - Zendesk Search Query

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### Send async request with requestAsync and then

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/faq.md

Use $client->requestAsync() to send a GET request asynchronously and chain then() to handle the fulfilled response or rejected reason. The rejection reason is often a Guzzle exception, but custom handlers can reject with other values.

```php
$promise = $client->requestAsync('GET', 'http://httpbin.org/get');
$promise->then(function ($response) {
    echo 'Got a response! ' . $response->getStatusCode();
}, function ($reason) {
    // The rejection reason is often a Guzzle exception, but custom handlers can
    // reject with other values.
});
```

--------------------------------

### URL default path after change

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

After 3.2, URLs no longer have a default path of '/'. This example shows the new behavior.

```php
$request = $client->get('http://www.foo.com');
echo $request->getUrl();
// >> http://www.foo.com
```

--------------------------------

### Guzzle v5: Listen to 'before' event and mutate request

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows the old event-based approach in Guzzle v5, where the 'before' event is used to mutate the request by setting a header. Relies on mutable HTTP messages.

```php
use GuzzleHttp\Event\BeforeEvent;
$client = new GuzzleHttp\Client();
// Get the emitter and listen to the before event.
$client->getEmitter()->on('before', function (BeforeEvent $e) {
    // Guzzle v5 events relied on mutation
    $e->getRequest()->setHeader('X-Foo', 'Bar');
});
```

--------------------------------

### Set SSL verification behavior with 'verify' option

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Controls SSL certificate verification for a request. Set to true to use the system's CA bundle (default), false to disable verification (insecure), or a string path to a custom CA bundle. The example shows all three forms.

```php
// Use the system's CA bundle (this is the default setting)
$client->request('GET', '/', ['verify' => true]);

// Use a custom SSL certificate on disk.
$client->request('GET', '/', ['verify' => '/path/to/cert.pem']);

// Disable validation entirely (don't do this!).
$client->request('GET', '/', ['verify' => false]);
```

--------------------------------

### SetCookie constructor validation examples

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows valid and invalid constructor arrays for SetCookie in Guzzle 8.0. Invalid field values now throw InvalidArgumentException instead of being coerced.

```php
// Valid:
new SetCookie([
    'Name' => 'foo',
    'Value' => 'bar',
    'Domain' => 'example.com',
    'Secure' => true,
]);
```

```php
// Invalid in 8.0:
new SetCookie([
    'Name' => false,
    'Value' => 'bar',
]);
```

--------------------------------

### Set stream_factory with GuzzleHttp\Psr7\HttpFactory

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Use this option to supply a PSR-17 stream factory when Guzzle creates request and response body streams. The example sets the factory on a per-request basis with a POST body. Guzzle only checks that the value implements Psr\Http\Message\StreamFactoryInterface; it does not validate the streams it returns, so the factory must produce streams that behave like the default GuzzleHttp\Psr7\Stream.

```php
$factory = new \GuzzleHttp\Psr7\HttpFactory();

$client->request('POST', '/post', [
    'body' => 'payload',
    'stream_factory' => $factory,
]);
```

--------------------------------

### Normalize HTTP method to uppercase for Guzzle 8

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Guzzle 8 preserves method casing and treats methods case-sensitively. Use uppercase standard methods like 'GET' to ensure built-in behavior; lowercase methods are no longer normalized.

```php
$client->request('GET', 'https://example.com');
```

--------------------------------

### Redirects: allow_redirects option

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Shows how to configure redirects in Guzzle 4.0 using the 'allow_redirects' request option. The first example enables standard redirects with a default maximum of 5 redirects; the second enables strict redirects with a custom maximum of 5.

```php
// Standard redirects with a default of a max of 5 redirects
$request = $client->createRequest('GET', '/', ['allow_redirects' => true]);

// Strict redirects with a custom number of redirects
$request = $client->createRequest('GET', '/', [
    'allow_redirects' => ['max' => 5, 'strict' => true]
]);
```

--------------------------------

### Header values must be strings in Guzzle 8

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

In Guzzle 8, header values passed through the 'headers' request option must be strings or non-empty arrays of strings. The first example shows the 7.x behavior that is no longer accepted, and the second shows the required 8.0 format.

```php
// 7.x, no longer accepted in 8.0
$client->request('GET', '/', [
    'headers' => ['Api-Version' => 1],
]);
```

```php
// 8.0
$client->request('GET', '/', [
    'headers' => ['Api-Version' => '1'],
]);
```

--------------------------------

### Create and use a HandlerStack with push and unshift

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/middleware.md

Builds a handler stack with a chosen handler, pushes three middleware that echo letters, then unshifts one that echoes '0'. The client request outputs 'ABC' after pushes and '0ABC' after unshift.

```php
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use GuzzleHttp\Utils;
use Psr\Http\Message\RequestInterface;

$stack = new HandlerStack();
$stack->setHandler(Utils::chooseHandler());

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'A';
    return $r;
}));

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'B';
    return $r;
}));

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'C';
    return $r;
}));

$client->request('GET', 'http://httpbin.org/');
// echoes 'ABC';

$stack->unshift(Middleware::mapRequest(function (RequestInterface $r) {
    echo '0';
    return $r;
}));

$client = new Client(['handler' => $stack]);
$client->request('GET', 'http://httpbin.org/');
// echoes '0ABC';
```

--------------------------------

### Per-request handler option: Guzzle 7 deprecated vs Guzzle 8 rejection

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Guzzle 8 rejects the per-request 'handler' option with InvalidArgumentException before a transfer starts. Configure the handler when creating the client, or use a separate client instance for requests that need a different handler.

```php
// Guzzle 7 (deprecated, used the request-level handler)
$client->request('GET', '/status', ['handler' => $mockHandler]);
```

```php
// Guzzle 8
$client = new Client(['handler' => HandlerStack::create($mockHandler)]);
$client->request('GET', '/status');
```

--------------------------------

### Set a proxy for all protocols

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Pass a string to specify a proxy for all protocols. The default is none.

```php
$client->request('GET', '/', ['proxy' => 'http://localhost:8125']);
```

--------------------------------

### update_group

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Update a group. This operation is defined in the service description and can be called by the client.

```APIDOC
## PUT groups/{id}.json

### Description
Update a group.

### Method
PUT

### Endpoint
groups/{id}.json

### Parameters
#### Path Parameters
- **id** (integer) - Required - Group to update by ID

#### Request Body
- **data** (array) - Required - Group JSON

#### Headers
- **Content-Type** (string) - static: application/json

### Request Example
{
  "data": {}
}

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### create_group

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Create a group. This operation is defined in the service description and can be called by the client.

```APIDOC
## POST groups.json

### Description
Create a group.

### Method
POST

### Endpoint
groups.json

### Parameters
#### Request Body
- **data** (array) - Required - Group JSON

#### Headers
- **Content-Type** (string) - static: application/json

### Request Example
{
  "data": {}
}

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### Adding middleware to a client via HandlerStack

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/middleware.md

Shows how to create a HandlerStack with a CurlHandler and push the add_header middleware onto it, then pass the stack to a new Client. This composes the middleware into the client's handler.

```php
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\Client;

$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(add_header('X-Foo', 'bar'));
$client = new Client(['handler' => $stack]);
```

--------------------------------

### delete_group

Source: https://github.com/guzzle/guzzle/blob/8.3/UPGRADING.md

Delete a group by ID. This operation is defined in the service description and can be called by the client.

```APIDOC
## DELETE groups/{id}.json

### Description
Delete a group by ID.

### Method
DELETE

### Endpoint
groups/{id}.json

### Parameters
#### Path Parameters
- **id** (integer) - Required - Group to delete by ID

### Response
#### Success Response (200)
- No response schema provided in the source.

#### Response Example
No response example provided in the source.
```

--------------------------------

### Name middleware and add before/after or remove by name

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/middleware.md

Shows how to name middleware for targeted insertion: push a named middleware, add another before it, add one after it, and remove by name. Uses mapRequest to modify request headers.

```php
use Psr\Http\Message\RequestInterface;
use GuzzleHttp\Middleware;

// Add a middleware with a name
$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Foo', 'Bar');
}), 'add_foo');

// Add a middleware before a named middleware (unshift before).
$stack->before('add_foo', Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Baz', 'Qux');
}), 'add_baz');

// Add a middleware after a named middleware (pushed after).
$stack->after('add_baz', Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Lorem', 'Ipsum');
}), 'add_lorem');

// Remove a middleware by name
$stack->remove('add_foo');
```

--------------------------------

### MessageFormatter: Preset and custom template

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/middleware.md

Shows creating a MessageFormatter with the SHORT preset or a custom template string. The custom template uses placeholders like {method}, {uri}, and {code}.

```php
// Use a preset...
$formatter = new MessageFormatter(MessageFormatter::SHORT);
// ...or supply a custom template.
$formatter = new MessageFormatter('{method} {uri} {code}');
```

--------------------------------

### Use headers as default client options

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Headers may be added as default options when creating a client. They are only applied if the request does not already contain the specific header. This applies to requests passed to send()/sendAsync() and requests created by the client (e.g., request() and requestAsync()).

```php
$client = new GuzzleHttp\Client(['headers' => ['X-Foo' => 'Bar']]);

// Will send a request with the X-Foo header.
$client->request('GET', '/get');

// Sets the X-Foo header to "test", which prevents the default header
// from being applied.
$client->request('GET', '/get', ['headers' => ['X-Foo' => 'test']]);

// Will disable adding in default headers.
$client->request('GET', '/get', ['headers' => null]);

// Will not overwrite the X-Foo header because it is in the message.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request);

// Will overwrite the X-Foo header with the request option provided in the
// send method.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request, ['headers' => ['X-Foo' => 'overwrite']]);
```

--------------------------------

### Set client certificate with password using cert option

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Specifies a client-side certificate file and its password as an array. The first element is the path, the second is the password. A null password is treated as omitted. PEM is the default format.

```php
$client->request('GET', '/', ['cert' => ['/path/server.pem', 'password']]);
```

--------------------------------

### Get a cookie by name and access its properties

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/cookies.md

Retrieve a cookie by its exact name using getCookieByName, then access its value, domain, and expiration timestamp.

```php
$cookie = $jar->getCookieByName('some_cookie');

$cookie->getValue(); // 'foo'
$cookie->getDomain(); // 'example.org'
$cookie->getExpires(); // expiration date as a Unix timestamp
```

--------------------------------

### cert

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Specifies the path to a client-side certificate file, optionally with a password. PEM is the default format; use cert_type to specify another format.

```APIDOC
## cert

### Description
Set to a string to specify the path to a file containing a client side certificate. PEM is the default certificate format. If a password is required, then set to an array containing the path to the certificate file in the first array element followed by the password required for the certificate in the second array element. A `null` password is treated the same as omitting it. Use [`cert_type`](#cert_type) to specify another supported certificate format.

### Types
- string
- array

### Default
None

### Constant
`GuzzleHttp\RequestOptions::CERT`

### Example
```php
$client->request('GET', '/', ['cert' => ['/path/server.pem', 'password']]);
```

> [!NOTE]
> TLS client certificate options remain active during redirects. See [Cross-Origin Redirects](#cross-origin-redirects) for details.
```

--------------------------------

### ssl_key

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Specifies the path to a file containing a private SSL key. PEM is the default format; if a password is required, provide an array with the path and password. Use ssl_key_type to specify another supported key format.

```APIDOC
## ssl_key

### Description
Specify the path to a file containing a private SSL key. PEM is the default private key format. If a password is required, set to an array containing the path to the SSL key in the first element followed by the password in the second element. A `null` password is treated the same as omitting it.

### Types
- string
- array

### Default
None

### Constant
`GuzzleHttp\RequestOptions::SSL_KEY`

### Notes
- With the stream handler, `cert` and `ssl_key` must use the same passphrase when both options specify one because PHP streams expose only one SSL context passphrase.
- TLS client key options remain active during redirects. See Cross-Origin Redirects for details.
```

--------------------------------

### Set sink to a file path string

Source: https://github.com/guzzle/guzzle/blob/8.3/docs/request-options.md

Pass a string to specify the path to a file that will store the contents of the response body. Guzzle opens the file and owns that stream.

```php
$client->request('GET', '/stream/20', ['sink' => '/path/to/file']);
```
Tokens:
Raw