Le proxy ne prend pas en charge le protocole requis : que faire

Vous avez configuré le proxy, lancé le script — et reçu une erreur « Protocol not supported » ou « Connection refused ». Le problème d'incompatibilité des protocoles est plus fréquent qu'on ne le pense. Nous allons examiner pourquoi cela se produit et comment résoudre le problème sans changer de fournisseur.

Quels protocoles les proxys utilisent

Avant de résoudre le problème, il est important de comprendre la différence entre les protocoles. Chacun a son domaine d'application et ses limites.

Conflits typiques :

• Selenium et Puppeteer nécessitent HTTP/HTTPS, mais vous avez SOCKS5
• Les bots Telegram fonctionnent via SOCKS5, mais le proxy ne prend en charge que HTTP
• Les clients Torrent nécessitent SOCKS5 avec UDP, mais le proxy est SOCKS4
• Les applications de jeu nécessitent UDP, mais le proxy HTTP ne le prend pas en charge

Diagnostic : déterminer le protocole du proxy

Si le fournisseur n'a pas spécifié explicitement le protocole ou si vous avez des doutes, testez le proxy vous-même.

Vérification via curl

Test du protocole HTTP :

# Proxy HTTP
curl -x http://proxy_ip:port http://httpbin.org/ip

# Avec authentification
curl -x http://user:pass@proxy_ip:port http://httpbin.org/ip

Test du protocole SOCKS5 :

# Proxy SOCKS5
curl -x socks5://proxy_ip:port http://httpbin.org/ip

# SOCKS5 avec DNS via proxy (socks5h)
curl -x socks5h://proxy_ip:port http://httpbin.org/ip

Si la commande renvoie l'adresse IP du proxy, le protocole est correctement identifié. Une erreur Connection refused ou Unsupported proxy signifie que le protocole n'est pas le bon.

Vérification via Python

import requests

proxy_ip = "proxy_ip:port"

# Test HTTP
try:
    r = requests.get("http://httpbin.org/ip", 
                     proxies={"http": f"http://{proxy_ip}"}, 
                     timeout=10)
    print(f"HTTP fonctionne : {r.json()}")
except Exception as e:
    print(f"HTTP ne fonctionne pas : {e}")

# Test SOCKS5 (nécessite pip install requests[socks])
try:
    r = requests.get("http://httpbin.org/ip", 
                     proxies={"http": f"socks5://{proxy_ip}"}, 
                     timeout=10)
    print(f"SOCKS5 fonctionne : {r.json()}")
except Exception as e:
    print(f"SOCKS5 ne fonctionne pas : {e}")

Détection automatique

Script pour parcourir les protocoles :

import requests

def detect_protocol(proxy_address):
    protocols = ["http", "https", "socks4", "socks5", "socks5h"]
    
    for proto in protocols:
        try:
            proxies = {
                "http": f"{proto}://{proxy_address}",
                "https": f"{proto}://{proxy_address}"
            }
            r = requests.get("http://httpbin.org/ip", 
                           proxies=proxies, timeout=5)
            if r.status_code == 200:
                return proto
        except:
            continue
    return None

result = detect_protocol("proxy_ip:port")
print(f"Protocole détecté : {result}")

Conversion de HTTP vers SOCKS et vice-versa

Si le proxy prend en charge un protocole différent de celui requis par votre logiciel, utilisez un convertisseur local.

Privoxy : HTTP → SOCKS

Privoxy accepte les requêtes HTTP et les dirige via un proxy SOCKS.

Installation :

# Ubuntu/Debian
sudo apt install privoxy

# macOS
brew install privoxy

# Windows — télécharger depuis le site officiel

Configuration (fichier /etc/privoxy/config) :

# Écoute sur le port local 8118 (HTTP)
listen-address 127.0.0.1:8118

# Transférer via SOCKS5 externe
forward-socks5 / socks_proxy_ip:1080 .

# Avec authentification
forward-socks5 / user:pass@socks_proxy_ip:1080 .

Votre logiciel se connecte maintenant à 127.0.0.1:8118 en HTTP, et le trafic passe par SOCKS5.

Gost : convertisseur universel

Gost est un outil puissant pour toutes les transformations de protocoles.

# Proxy HTTP en entrée → SOCKS5 en sortie
gost -L http://:8080 -F socks5://socks_proxy_ip:1080

# SOCKS5 en entrée → HTTP en sortie
gost -L socks5://:1080 -F http://http_proxy_ip:8080

# Avec authentification aux deux extrémités
gost -L http://local_user:local_pass@:8080 \
     -F socks5://remote_user:remote_pass@proxy_ip:1080

Convertisseur Python

Convertisseur minimaliste pour les tâches simples :

# pip install pproxy
# HTTP en entrée, SOCKS5 en sortie
pproxy -l http://:8080 -r socks5://proxy_ip:1080

# SOCKS5 en entrée, HTTP en sortie  
pproxy -l socks5://:1080 -r http://proxy_ip:8080

Configuration de tunnels locaux

Parfois, la conversion ne suffit pas — un tunnel complet est nécessaire.

Tunnel SSH via proxy HTTP

Si vous disposez d'un serveur SSH et d'un proxy HTTP, vous pouvez créer un SOCKS5 :

# Créer un SOCKS5 sur localhost:1080 via proxy HTTP
ssh -D 1080 -o ProxyCommand="nc -X connect -x http_proxy:8080 %h %p" user@ssh_server

Stunnel pour HTTPS

Si vous avez besoin d'un proxy HTTPS mais que vous n'avez qu'un proxy HTTP :

# stunnel.conf
[https-proxy]
client = yes
accept = 127.0.0.1:8443
connect = http_proxy_ip:8080
protocol = connect
protocolHost = target_host:443

Configuration du logiciel pour le protocole disponible

Il est parfois plus simple d'adapter le logiciel au protocole disponible que de convertir.

Selenium avec différents protocoles

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Proxy HTTP (méthode standard)
options = Options()
options.add_argument('--proxy-server=http://proxy_ip:8080')

# Proxy SOCKS5
options.add_argument('--proxy-server=socks5://proxy_ip:1080')

# Pour Firefox avec SOCKS5
from selenium.webdriver.firefox.options import Options as FirefoxOptions
profile = webdriver.FirefoxProfile()
profile.set_preference("network.proxy.type", 1)
profile.set_preference("network.proxy.socks", "proxy_ip")
profile.set_preference("network.proxy.socks_port", 1080)
profile.set_preference("network.proxy.socks_version", 5)

aiohttp avec SOCKS

# pip install aiohttp-socks
import aiohttp
from aiohttp_socks import ProxyConnector

async def fetch_with_socks():
    connector = ProxyConnector.from_url('socks5://proxy_ip:1080')
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get('http://httpbin.org/ip') as response:
            return await response.json()

Bots Telegram via HTTP

Si la bibliothèque Telegram nécessite SOCKS5, mais que vous avez HTTP :

# python-telegram-bot avec proxy HTTP
from telegram.ext import ApplicationBuilder

application = (
    ApplicationBuilder()
    .token("YOUR_TOKEN")
    .proxy_url("http://proxy_ip:8080")  # Fonctionne avec HTTP
    .build()
)

Conseil : De nombreuses bibliothèques modernes prennent en charge les deux protocoles. Vérifiez la documentation — il suffit peut-être de changer le schéma d'URL de socks5:// à http://.

Comment choisir un proxy avec le protocole requis

Pour éviter les problèmes de protocole, déterminez les exigences à l'avance.

Matrice de compatibilité

Ce qu'il faut vérifier lors du choix d'un fournisseur

• Liste des protocoles pris en charge — doit être explicitement indiqué
• Possibilité de commutation — certains fournisseurs donnent accès à une seule IP via différents ports/protocoles
• Prise en charge UDP pour SOCKS5 — tous les proxys SOCKS5 ne prennent pas en charge UDP
• Documentation de configuration — exemples pour différents langages et outils

Les proxys résidentiels prennent généralement en charge HTTP/HTTPS et SOCKS5 simultanément, ce qui élimine la plupart des problèmes de compatibilité. Les proxys de centre de données sont plus souvent limités à HTTP/HTTPS.

Check-list avant l'achat

1. Déterminez quel protocole votre logiciel nécessite
2. Vérifiez si UDP est nécessaire (jeux, torrents, VoIP)
3. Confirmez auprès du fournisseur la prise en charge du protocole requis
4. Demandez un accès de test pour vérifier la compatibilité
5. Préparez un plan B — un convertisseur local

Conclusion

L'incompatibilité des protocoles est un problème résoluble. Dans la plupart des cas, un convertisseur local comme Privoxy ou Gost suffit. Pour les projets à long terme, il est plus rentable de choisir immédiatement un proxy prenant en charge le protocole requis.

Pour les tâches nécessitant une flexibilité dans le choix du protocole, les proxys résidentiels avec accès multiprotocole sont adaptés — plus d'informations sur proxycove.com.