Proxy en PHP : cURL et Guzzle HTTP Client

```html

Si vous écrivez un scraper, automatisez la collecte de données ou contournez les restrictions IP — un proxy en PHP est indispensable. Dans ce guide, nous allons examiner deux outils principaux : l'extension intégrée cURL et la bibliothèque populaire Guzzle HTTP Client — avec des exemples de code prêts à l'emploi que vous pouvez utiliser immédiatement dans votre projet.

Pourquoi utiliser un proxy dans les projets PHP

PHP reste l'un des langages les plus répandus pour l'automatisation côté serveur, et les tâches nécessitant des proxies se présentent constamment. Voici les principaux scénarios où un proxy est indispensable :

Scraping de sites et marketplaces — Wildberries, Ozon, Avito, AliExpress bloquent les IP après quelques dizaines de requêtes. Les proxies permettent de répartir la charge entre différentes adresses et d'éviter les erreurs 403/429.
Collecte de données à partir de ressources géodépendantes — les prix, les résultats des moteurs de recherche, le contenu peuvent varier selon le pays. Les proxies avec la géolocalisation souhaitée résolvent ce problème.
Contourner la limitation de taux — de nombreuses API limitent le nombre de requêtes depuis une seule IP. La rotation des proxies permet de contourner ces limites.
Tester le contenu géodépendant — vérifier à quoi ressemble un site pour les utilisateurs de différents pays sans quitter le bureau.
Anonymous lors de l'automatisation — masquer l'IP réelle du serveur lors de requêtes massives vers des ressources externes.
Surveillance des concurrents — collecte régulière des prix, de l'assortiment, des promotions sur les sites des concurrents sans risque d'être banni.

En PHP, pour les requêtes HTTP, on utilise le plus souvent deux outils : l'extension intégrée cURL et la bibliothèque Guzzle HTTP Client. Les deux prennent en charge les proxies HTTP, HTTPS, SOCKS4 et SOCKS5 — examinons chacun en détail.

Quel type de proxy choisir pour PHP

Avant d'écrire du code, il est important de comprendre quel type de proxy convient à votre tâche. Différents types ont des caractéristiques variées en termes de vitesse, de fiabilité et de degré d'anonymat.

Type de proxy	Vitesse	Anonymat	Meilleur pour
Proxies de centre de données	Très élevée	Moyenne	Scraping sans systèmes anti-bot stricts, requêtes API
Proxies résidentiels	Moyenne	Élevée	Scraping de sites protégés, marketplaces, données géographiques
Proxies mobiles	Moyenne	Maximale	Sites avec une protection anti-bot stricte, réseaux sociaux

Pour la plupart des tâches de scraping de données sur des marketplaces comme Wildberries ou Ozon, le choix optimal sera les proxies résidentiels — leurs IP appartiennent à de véritables utilisateurs domestiques, ce qui rend les requêtes pratiquement indiscernables du trafic de navigateur normal. Les proxies de centre de données conviennent là où la vitesse est plus importante que la discrétion, et où la protection est faible.

Les trois types de proxies prennent en charge les protocoles HTTP/HTTPS et SOCKS5, donc en termes de code — la configuration est la même. La seule différence réside dans la chaîne de connexion.

Proxy dans cURL : configuration de base

L'extension cURL est disponible dans PHP par défaut et est le moyen standard d'effectuer des requêtes HTTP sur le serveur. Pour connecter un proxy, deux options principales sont utilisées : CURLOPT_PROXY et CURLOPT_PROXYTYPE.

Proxy HTTP sans authentification

<?php

$ch = curl_init();

curl_setopt_array($ch, [
    CURLOPT_URL            => 'https://httpbin.org/ip',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => true,
    CURLOPT_TIMEOUT        => 30,

    // Indiquer l'adresse du proxy
    CURLOPT_PROXY          => '185.199.100.1:8080',

    // Type de proxy : HTTP (par défaut)
    CURLOPT_PROXYTYPE      => CURLPROXY_HTTP,
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Code HTTP : $httpCode\n";
echo $response;

Ici, CURLOPT_PROXY prend une chaîne au format host:port. Pour le trafic HTTPS via un proxy HTTP, cURL utilise automatiquement la méthode CONNECT — le tunneling, donc le contenu de la requête reste chiffré.

Options utiles de cURL pour travailler avec des proxies

Option	Description
`CURLOPT_PROXY`	Adresse du serveur proxy (host:port)
`CURLOPT_PROXYTYPE`	Type : CURLPROXY_HTTP, CURLPROXY_SOCKS4, CURLPROXY_SOCKS5
`CURLOPT_PROXYUSERPWD`	Nom d'utilisateur et mot de passe au format user:password
`CURLOPT_HTTPPROXYTUNNEL`	Activer le tunneling via HTTP CONNECT
`CURLOPT_SSL_VERIFYPEER`	Vérification du certificat SSL (false — désactiver)
`CURLOPT_TIMEOUT`	Délai d'attente de la requête en secondes
`CURLOPT_CONNECTTIMEOUT`	Délai d'attente de connexion au proxy

Authentification et SOCKS5 dans cURL

La plupart des proxies commerciaux nécessitent une authentification par nom d'utilisateur et mot de passe. De plus, SOCKS5 est le protocole préféré lorsque l'anonymat complet est nécessaire, car il n'ajoute pas d'en-têtes comme X-Forwarded-For qui pourraient révéler l'utilisation d'un proxy.

Proxy HTTP avec nom d'utilisateur et mot de passe

<?php

$proxyHost = '185.199.100.1';
$proxyPort = '8080';
$proxyUser = 'your_login';
$proxyPass = 'your_password';

$ch = curl_init();

curl_setopt_array($ch, [
    CURLOPT_URL            => 'https://httpbin.org/ip',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,
    CURLOPT_CONNECTTIMEOUT => 10,

    // Proxy avec authentification
    CURLOPT_PROXY          => "$proxyHost:$proxyPort",
    CURLOPT_PROXYTYPE      => CURLPROXY_HTTP,
    CURLOPT_PROXYUSERPWD   => "$proxyUser:$proxyPass",

    // Tunneling pour HTTPS
    CURLOPT_HTTPPROXYTUNNEL => true,

    // En-têtes de navigateur pour masquer
    CURLOPT_USERAGENT      => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    CURLOPT_HTTPHEADER     => [
        'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language: ru-RU,ru;q=0.9,en;q=0.8',
    ],
]);

$response = curl_exec($ch);

if (curl_errno($ch)) {
    echo 'Erreur cURL : ' . curl_error($ch);
} else {
    echo $response;
}

curl_close($ch);

Proxy SOCKS5 dans cURL

<?php

$ch = curl_init();

curl_setopt_array($ch, [
    CURLOPT_URL            => 'https://httpbin.org/ip',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 30,

    CURLOPT_PROXY          => '185.199.100.1:1080',

    // SOCKS5 avec résolution DNS via le proxy (recommandé !)
    CURLOPT_PROXYTYPE      => CURLPROXY_SOCKS5_HOSTNAME,

    // Authentification (si nécessaire)
    CURLOPT_PROXYUSERPWD   => 'login:password',
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;

💡 Important : SOCKS5 vs SOCKS5_HOSTNAME

Utilisez CURLPROXY_SOCKS5_HOSTNAME au lieu de CURLPROXY_SOCKS5. La différence est que lors de l'utilisation de SOCKS5_HOSTNAME, les requêtes DNS passent également par le proxy, ce qui empêche les fuites DNS et augmente l'anonymat. Avec SOCKS5 normal, la résolution DNS se fait localement — cela peut révéler votre IP réelle.

Rotation des proxies dans cURL

Un seul proxy sera rapidement bloqué lors de requêtes massives. La bonne stratégie consiste à avoir un pool de proxies et à les alterner. Voici une implémentation simple mais efficace :

<?php

class ProxyRotator
{
    private array $proxies;
    private int $currentIndex = 0;

    public function __construct(array $proxies)
    {
        $this->proxies = $proxies;
        shuffle($this->proxies); // Mélanger pour un ordre aléatoire
    }

    /**
     * Obtenir le prochain proxy du pool
     */
    public function getNext(): string
    {
        $proxy = $this->proxies[$this->currentIndex];
        $this->currentIndex = ($this->currentIndex + 1) % count($this->proxies);
        return $proxy;
    }

    /**
     * Obtenir un proxy aléatoire
     */
    public function getRandom(): string
    {
        return $this->proxies[array_rand($this->proxies)];
    }
}

// Liste des proxies au format login:password@host:port
$proxyList = [
    'user1:[email protected]:8080',
    'user2:[email protected]:8080',
    'user3:[email protected]:8080',
    'user4:[email protected]:8080',
];

$rotator = new ProxyRotator($proxyList);

/**
 * Fonction de requête avec sélection automatique du proxy
 */
function fetchWithProxy(string $url, ProxyRotator $rotator): ?string
{
    $proxyStr = $rotator->getNext();

    // Analyser la chaîne du proxy
    preg_match('/^(.+):(.+)@(.+):(\d+)$/', $proxyStr, $m);
    [, $user, $pass, $host, $port] = $m;

    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL            => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 20,
        CURLOPT_CONNECTTIMEOUT => 8,
        CURLOPT_PROXY          => "$host:$port",
        CURLOPT_PROXYTYPE      => CURLPROXY_HTTP,
        CURLOPT_PROXYUSERPWD   => "$user:$pass",
        CURLOPT_USERAGENT      => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
        CURLOPT_SSL_VERIFYPEER => false,
    ]);

    $response = curl_exec($ch);
    $error    = curl_error($ch);
    curl_close($ch);

    if ($error) {
        error_log("Proxy $host:$port inaccessible : $error");
        return null;
    }

    return $response;
}

// Exemple : scraper 10 pages avec rotation des proxies
$urls = [
    'https://example.com/page/1',
    'https://example.com/page/2',
    'https://example.com/page/3',
    // ...
];

foreach ($urls as $url) {
    $html = fetchWithProxy($url, $rotator);
    if ($html) {
        echo "Reçu : " . strlen($html) . " octets\n";
    }
    usleep(500000); // Pause de 0.5 sec entre les requêtes
}

Notez le usleep(500000) — la pause entre les requêtes est critique. Même avec la rotation des proxies, des requêtes trop fréquentes peuvent entraîner un blocage en raison de modèles de comportement. L'intervalle recommandé est de 500 ms à 2 secondes selon le site.

Proxy dans Guzzle HTTP Client : configuration de base

Guzzle est une puissante bibliothèque PHP pour les requêtes HTTP, utilisée dans la plupart des frameworks PHP modernes (Laravel, Symfony). Elle offre une API plus conviviale et lisible par rapport à cURL brut, prend en charge les requêtes asynchrones, le middleware et un traitement d'erreurs pratique.

Installation via Composer

composer require guzzlehttp/guzzle

Proxy HTTP sans authentification

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

$client = new Client([
    // URL de base (optionnel)
    'base_uri' => 'https://httpbin.org',

    // Paramètres par défaut pour toutes les requêtes
    'timeout'  => 30,
    'connect_timeout' => 10,

    // Proxy pour toutes les requêtes du client
    'proxy' => 'http://185.199.100.1:8080',
]);

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

echo $response->getStatusCode() . "\n";  // 200
echo $response->getBody() . "\n";        // {"origin": "185.199.100.1"}

Dans Guzzle, le proxy est défini via l'option proxy au format URL. C'est plus intuitif que dans cURL. Le proxy peut être défini au niveau du client (pour toutes les requêtes) ou pour chaque requête individuellement.

Proxy HTTP avec authentification

<?php

use GuzzleHttp\Client;

$login    = 'your_login';
$password = 'your_password';
$host     = '185.199.100.1';
$port     = '8080';

$client = new Client([
    'timeout' => 30,
]);

// Proxy avec authentification passé au format URL
$response = $client->get('https://httpbin.org/ip', [
    'proxy' => "http://$login:$password@$host:$port",
    'headers' => [
        'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Accept'     => 'text/html,application/xhtml+xml,application/xml;q=0.9',
    ],
]);

echo $response->getBody();

Le format de l'URL du proxy dans Guzzle est : scheme://user:password@host:port. Pour un proxy HTTP, utilisez http://, pour SOCKS5 — socks5://.

Travail avancé avec Guzzle : délais d'attente, en-têtes, SOCKS5

Examinons des scénarios plus complexes : différents proxies pour HTTP et HTTPS, SOCKS5, désactivation de la vérification SSL et configuration des en-têtes pour imiter un navigateur.

Différents proxies pour HTTP et HTTPS

<?php

use GuzzleHttp\Client;

$client = new Client([
    'timeout' => 30,
    'proxy'   => [
        // Proxy pour les requêtes HTTP
        'http'  => 'http://login:[email protected]:8080',
        // Proxy pour les requêtes HTTPS
        'https' => 'http://login:[email protected]:8080',
        // Exceptions — ces hôtes passent sans proxy
        'no'    => ['localhost', '127.0.0.1', '.internal.corp'],
    ],
]);

SOCKS5 dans Guzzle

<?php

use GuzzleHttp\Client;

// Pour SOCKS5 dans Guzzle, un package supplémentaire est nécessaire
// composer require clue/socks-react (ou utilisez le gestionnaire cURL)

$client = new Client([
    'timeout' => 30,
    'proxy'   => 'socks5://login:[email protected]:1080',
    'curl'    => [
        CURLOPT_PROXYTYPE => CURLPROXY_SOCKS5_HOSTNAME,
    ],
]);

$response = $client->get('https://httpbin.org/ip');
echo $response->getBody();

Configuration complète avec en-têtes de navigateur

<?php

use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;

$client = new Client([
    'timeout'         => 30,
    'connect_timeout' => 10,
    'verify'          => false, // Désactiver la vérification SSL (pour le débogage)
    'allow_redirects' => [
        'max'       => 5,
        'strict'    => false,
        'referer'   => true,
        'protocols' => ['http', 'https'],
    ],
    'headers' => [
        'User-Agent'      => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
        'Accept'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Accept-Language' => 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7',
        'Accept-Encoding' => 'gzip, deflate, br',
        'Cache-Control'   => 'no-cache',
        'Connection'      => 'keep-alive',
    ],
]);

$response = $client->get('https://example.com/catalog', [
    'proxy' => 'http://login:[email protected]:8080',
]);

$statusCode = $response->getStatusCode();
$body       = (string) $response->getBody();

echo "Statut : $statusCode, Taille : " . strlen($body) . " octets\n";

⚠️ À propos de verify => false

Désactiver la vérification SSL ('verify' => false) est acceptable uniquement lors du débogage ou lors de l'utilisation de services internes. Dans le code de production, assurez-vous de toujours garder la vérification SSL activée, sinon vous êtes vulnérable aux attaques de type man-in-the-middle.

Rotation des proxies dans Guzzle

Dans Guzzle, la rotation peut être facilement mise en œuvre via un middleware — une couche intermédiaire qui intercepte chaque requête et y ajoute un proxy. C'est plus élégant que de passer le proxy manuellement dans chaque appel.

<?php

use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use Psr\Http\Message\RequestInterface;

/**
 * Middleware pour la rotation automatique des proxies
 */
function proxyRotationMiddleware(array $proxies): callable
{
    $index = 0;
    $total = count($proxies);

    return Middleware::mapRequest(
        function (RequestInterface $request) use ($proxies, &$index, $total) {
            $proxy = $proxies[$index % $total];
            $index++;

            // Ajouter le proxy dans les attributs de la requête
            // (passer via options dans le gestionnaire)
            return $request->withHeader('X-Selected-Proxy', $proxy);
        }
    );
}

// Liste des proxies
$proxies = [
    'http://user1:[email protected]:8080',
    'http://user2:[email protected]:8080',
    'http://user3:[email protected]:8080',
];

// Variante simple : classe d'enveloppement autour de Guzzle avec rotation
class GuzzleWithRotation
{
    private Client $client;
    private array $proxies;
    private int $index = 0;

    public function __construct(array $proxies, array $clientConfig = [])
    {
        $this->proxies = $proxies;
        $this->client  = new Client($clientConfig);
    }

    public function get(string $url, array $options = []): \GuzzleHttp\Psr7\Response
    {
        $options['proxy'] = $this->proxies[$this->index % count($this->proxies)];
        $this->index++;

        return $this->client->get($url, $options);
    }

    public function post(string $url, array $options = []): \GuzzleHttp\Psr7\Response
    {
        $options['proxy'] = $this->proxies[$this->index % count($this->proxies)];
        $this->index++;

        return $this->client->post($url, $options);
    }
}

// Utilisation
$guzzle = new GuzzleWithRotation($proxies, [
    'timeout' => 30,
    'headers' => [
        'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
    ],
]);

$urls = [
    'https://example.com/product/1',
    'https://example.com/product/2',
    'https://example.com/product/3',
];

foreach ($urls as $url) {
    try {
        $response = $guzzle->get($url);
        echo "OK [{$response->getStatusCode()}]: $url\n";
        sleep(1);
    } catch (\Exception $e) {
        echo "Erreur : " . $e->getMessage() . "\n";
    }
}

Gestion des erreurs et débogage

Lors de l'utilisation de proxies, les erreurs sont inévitables : le proxy peut être inaccessible, répondre lentement, ou le site cible peut renvoyer une erreur. Il est important de gérer correctement toutes ces situations.

Gestion des erreurs dans cURL

<?php

function fetchWithErrorHandling(string $url, string $proxy): array
{
    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL            => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 20,
        CURLOPT_CONNECTTIMEOUT => 8,
        CURLOPT_PROXY          => $proxy,
        CURLOPT_PROXYTYPE      => CURLPROXY_HTTP,
    ]);

    $body     = curl_exec($ch);
    $errno    = curl_errno($ch);
    $error    = curl_error($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $totalTime = curl_getinfo($ch, CURLINFO_TOTAL_TIME);
    curl_close($ch);

    // Codes d'erreur cURL pour les proxies
    $proxyErrors = [
        CURLE_COULDNT_CONNECT    => 'Impossible de se connecter au proxy',
        CURLE_OPERATION_TIMEDOUT => 'Délai d'attente de connexion au proxy',
        CURLE_RECV_ERROR         => 'Erreur de réception des données',
        CURLE_SSL_CONNECT_ERROR  => 'Erreur SSL via le proxy',
    ];

    if ($errno) {
        $message = $proxyErrors[$errno] ?? "Erreur cURL #$errno : $error";
        return ['success' => false, 'error' => $message, 'code' => $errno];
    }

    if ($httpCode >= 400) {
        return ['success' => false, 'error' => "HTTP $httpCode", 'code' => $httpCode];
    }

    return [
        'success' => true,
        'body'    => $body,
        'code'    => $httpCode,
        'time'    => round($totalTime, 3),
    ];
}

// Utilisation avec des tentatives répétées
function fetchWithRetry(string $url, array $proxies, int $maxRetries = 3): ?string
{
    foreach ($proxies as $proxy) {
        for ($attempt = 1; $attempt <= $maxRetries; $attempt++) {
            $result = fetchWithErrorHandling($url, $proxy);

            if ($result['success']) {
                echo "Succès via $proxy (tentative $attempt, {$result['time']}s)\n";
                return $result['body'];
            }

            echo "Erreur via $proxy : {$result['error']}\n";

            if ($attempt < $maxRetries) {
                sleep(2); // Pause avant de réessayer
            }
        }
    }

    return null; // Tous les proxies ont échoué
}

Gestion des erreurs dans Guzzle

<?php

use GuzzleHttp\Client;
use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\ServerException;
use GuzzleHttp\Exception\ClientException;

$client = new Client(['timeout' => 30]);

$proxies = [
    'http://user1:[email protected]:8080',
    'http://user2:[email protected]:8080',
];

function fetchGuzzleWithFallback(Client $client, string $url, array $proxies): ?string
{
    foreach ($proxies as $proxy) {
        try {
            $response = $client->get($url, [
                'proxy'   => $proxy,
                'timeout' => 20,
            ]);

            return (string) $response->getBody();

        } catch (ConnectException $e) {
            // Proxy inaccessible ou délai d'attente de connexion
            echo "Proxy inaccessible ($proxy) : " . $e->getMessage() . "\n";

        } catch (ClientException $e) {
            // HTTP 4xx — erreur client (403, 404, 429)
            $code = $e->getResponse()->getStatusCode();
            echo "HTTP $code pour $url via $proxy\n";

            if ($code === 429) {
                echo "Limite de taux — pause de 5 secondes\n";
                sleep(5);
            }

        } catch (ServerException $e) {
            // HTTP 5xx — erreur serveur
            echo "Erreur serveur : " . $e->getResponse()->getStatusCode() . "\n";

        } catch (RequestException $e) {
            // Autres erreurs de requête
            echo "Erreur de requête : " . $e->getMessage() . "\n";
        }
    }

    return null;
}

cURL vs Guzzle : que choisir

Les deux outils fonctionnent très bien avec des proxies, mais ont des points forts différents. Voici une comparaison sur des critères clés :

Critère	cURL	Guzzle
Installation	✅ Intégré dans PHP	⚠️ Nécessite Composer
Lisibilité du code	⚠️ Beaucoup d'options, verbeux	✅ API propre et pratique
Performance	✅ Un peu plus rapide (pas d'enveloppements)	✅ Comparable, supporte l'asynchrone
Requêtes asynchrones	⚠️ curl_multi (compliqué)	✅ Support intégré
Middleware / hooks	❌ Non	✅ HandlerStack, Middleware
Support SOCKS5	✅ Natif	✅ Via le gestionnaire cURL
Gestion des erreurs	⚠️ Codes d'erreur manuels	✅ Exceptions avec types
Intégration dans Laravel/Symfony	⚠️ Manuellement	✅ Support natif
Convient pour	Scripts simples, sans dépendances	Projets sur frameworks, logique complexe

Recommandation : Si vous écrivez un script simple ou travaillez sur un hébergement sans Composer — utilisez cURL. Pour des projets sur Laravel, Symfony ou toute application PHP moderne — Guzzle sera beaucoup plus pratique et offrira plus de possibilités d'évolutivité.

🚀 Liste de contrôle rapide avant le lancement

✅ Vérifiez que le proxy fonctionne : curl -x http://login:pass@host:port https://httpbin.org/ip
✅ Définissez des délais d'attente : timeout et connect_timeout
✅ Ajoutez un User-Agent réaliste
✅ Implémentez des pauses entre les requêtes (minimum 500 ms)
✅ Prévoyez la gestion des erreurs et un fallback vers un autre proxy
✅ Pour SOCKS5, utilisez CURLPROXY_SOCKS5_HOSTNAME (pas SOCKS5)
✅ Ne désactivez pas la vérification SSL en production

Conclusion

La configuration d'un proxy en PHP n'est pas compliquée si vous connaissez les bonnes options et formats. Pour les tâches de base, c'est suffisant d'utiliser cURL avec CURLOPT_PROXY et CURLOPT_PROXYUSERPWD. Pour les projets sur des frameworks, Guzzle offre une API plus conviviale, des exceptions typées et un support middleware pour la rotation des proxies.

Les principes clés pour un fonctionnement fiable : utilisez SOCKS5 avec résolution DNS via le proxy (CURLPROXY_SOCKS5_HOSTNAME), définissez toujours des délais d'attente, ajoutez des pauses entre les requêtes et implémentez la rotation des proxies pour des tâches à grande échelle. La gestion des erreurs avec un fallback vers un autre proxy est un élément essentiel de tout code de production.

Bonne chance avec vos projets PHP et l'utilisation des proxies !

Configuration de proxy en PHP avec cURL et Guzzle HTTP Client : guide complet avec des exemples de code

Pourquoi utiliser un proxy dans les projets PHP

Quel type de proxy choisir pour PHP

Proxy dans cURL : configuration de base

Proxy HTTP sans authentification

Options utiles de cURL pour travailler avec des proxies

Authentification et SOCKS5 dans cURL

Proxy HTTP avec nom d'utilisateur et mot de passe

Proxy SOCKS5 dans cURL

Rotation des proxies dans cURL

Proxy dans Guzzle HTTP Client : configuration de base

Installation via Composer

Proxy HTTP sans authentification

Proxy HTTP avec authentification

Travail avancé avec Guzzle : délais d'attente, en-têtes, SOCKS5

Différents proxies pour HTTP et HTTPS

SOCKS5 dans Guzzle

Configuration complète avec en-têtes de navigateur

Rotation des proxies dans Guzzle

Gestion des erreurs et débogage

Gestion des erreurs dans cURL

Gestion des erreurs dans Guzzle

cURL vs Guzzle : que choisir

Conclusion