Requetes HTTP en Python avec la bibliotheque Requests : POST, authentification et proxies

Introduction

La communication HTTP est au coeur de presque toutes les applications modernes. Que vous construisiez une API, consommiez des services web tiers, ou automatisiez des taches sur Internet, la maitrise des requetes HTTP est essentielle pour tout developpeur Python.

La bibliotheque requests est devenue la reference en Python pour effectuer des requetes HTTP. Creee par Kenneth Reitz, elle se distingue par sa simplicite d’utilisation et son API elegante qui rend le travail avec HTTP intuitif et agreable. Contrairement aux modules natifs comme urllib, requests abstrait les complexites du protocole HTTP tout en offrant un controle total lorsque necessaire.

Dans cet article complet, nous explorerons les fonctionnalites avancees de la bibliotheque requests :

• Requetes POST : envoi de donnees form-encoded et JSON
• Upload de fichiers : transfert de fichiers vers des serveurs
• Lecture des reponses : analyse des donnees retournees
• Authentification : HTTP Basic, Digest et methodes personnalisees
• Proxies : routage des requetes via des serveurs intermediaires

Avant de commencer, assurez-vous d’avoir installe la bibliotheque :

pip install requests

Requetes POST

La bibliotheque requests fournit une fonctionnalite puissante pour envoyer des requetes POST avec des donnees form-encoded. C’est la methode la plus courante pour soumettre des formulaires web ou envoyer des donnees structurees a une API.

Envoi de donnees form-encoded

import requests

# Donnees a envoyer
payload = {'username': 'john_doe', 'email': 'john@example.com'}

# Envoi de la requete POST
response = requests.post('https://httpbin.org/post', data=payload)

# Analyse de la reponse
print(f"URL: {response.url}")
print(f"Status: {response.status_code}")
print(f"Historique: {response.history}")

Lorsque vous utilisez le parametre data avec un dictionnaire, requests encode automatiquement les donnees au format application/x-www-form-urlencoded.

Envoi de donnees JSON

Pour les APIs modernes, vous souhaiterez souvent envoyer des donnees au format JSON :

import requests

payload = {
    'user': {
        'name': 'John Doe',
        'email': 'john@example.com'
    },
    'preferences': ['python', 'web-dev']
}

# Utilisation du parametre json (automatiquement serialise)
response = requests.post('https://httpbin.org/post', json=payload)

# Le header Content-Type est automatiquement defini a application/json
print(response.request.headers['Content-Type'])

Difference entre data et json

Parametre	Content-Type	Encodage
data=dict	application/x-www-form-urlencoded	Form encoding
json=dict	application/json	JSON serialization
data=str	text/plain	Aucun (envoye tel quel)

Envoi de fichiers

La bibliotheque requests permet d’envoyer des fichiers facilement via des requetes POST multipart. Cette fonctionnalite est essentielle pour les uploads d’images, documents ou autres ressources.

Upload simple

import requests

# Ouverture du fichier en mode binaire
with open('document.pdf', 'rb') as f:
    files = {'file': f}
    response = requests.post('https://httpbin.org/post', files=files)

print(response.json())

Upload avec metadonnees

Pour un controle plus fin, vous pouvez specifier le nom du fichier, son type MIME et des headers personnalises :

import requests

files = {
    'document': (
        'rapport_2024.xlsx',                    # Nom du fichier
        open('data/report.xlsx', 'rb'),         # Contenu du fichier
        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',  # Type MIME
        {'X-Custom-Header': 'valeur'}           # Headers optionnels
    )
}

response = requests.post('https://api.example.com/upload', files=files)

Upload multiple

import requests

files = [
    ('images', ('photo1.jpg', open('photo1.jpg', 'rb'), 'image/jpeg')),
    ('images', ('photo2.jpg', open('photo2.jpg', 'rb'), 'image/jpeg')),
    ('images', ('photo3.jpg', open('photo3.jpg', 'rb'), 'image/jpeg')),
]

response = requests.post('https://api.example.com/gallery', files=files)

Lecture des reponses

La bibliotheque requests fournit plusieurs facons d’acceder aux donnees retournees par le serveur, adaptees a differents types de contenu.

Proprietes de la reponse

import requests

response = requests.post('https://httpbin.org/post', data={'key': 'value'})

# Informations de base
print(f"Status Code: {response.status_code}")      # 200
print(f"OK: {response.ok}")                        # True si 200-299
print(f"Headers: {response.headers}")              # Headers de reponse
print(f"Encoding: {response.encoding}")            # Encodage detecte

# Contenu
print(f"Text: {response.text}")                    # Contenu texte
print(f"JSON: {response.json()}")                  # Parse JSON automatique
print(f"Binary: {response.content}")               # Contenu binaire (bytes)

Gestion des erreurs HTTP

import requests

response = requests.post('https://api.example.com/data', json={'key': 'value'})

# Lever une exception si erreur HTTP
response.raise_for_status()

# Ou verifier manuellement
if response.status_code == 201:
    print("Ressource creee avec succes")
elif response.status_code == 400:
    print(f"Erreur de validation: {response.json().get('error')}")
elif response.status_code >= 500:
    print("Erreur serveur, reessayez plus tard")

Telechargement de fichiers volumineux

Pour les fichiers volumineux, utilisez le streaming pour eviter de charger tout en memoire :

import requests

response = requests.get('https://example.com/large-file.zip', stream=True)

with open('fichier.zip', 'wb') as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

Authentification

La bibliotheque requests supporte plusieurs methodes d’authentification HTTP, de la plus simple a la plus personnalisee.

HTTP Basic Auth

La methode la plus simple, ou les identifiants sont encodes en Base64 :

import requests
from requests.auth import HTTPBasicAuth

# Methode explicite
response = requests.get(
    'https://api.example.com/private',
    auth=HTTPBasicAuth('username', 'password')
)

# Raccourci avec tuple
response = requests.get(
    'https://api.example.com/private',
    auth=('username', 'password')
)

HTTP Digest Auth

Plus securisee que Basic Auth, elle ne transmet pas le mot de passe en clair :

from requests.auth import HTTPDigestAuth

response = requests.get(
    'https://api.example.com/secure',
    auth=HTTPDigestAuth('user', 'password')
)

Token Bearer (OAuth2)

Pour les APIs modernes utilisant des tokens JWT ou OAuth :

import requests

token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

headers = {
    'Authorization': f'Bearer {token}'
}

response = requests.get('https://api.example.com/me', headers=headers)

Authentification personnalisee

Pour des besoins specifiques, creez votre propre classe d’authentification :

from requests.auth import AuthBase

class APIKeyAuth(AuthBase):
    """Authentification par cle API dans le header"""

    def __init__(self, api_key):
        self.api_key = api_key

    def __call__(self, request):
        request.headers['X-API-Key'] = self.api_key
        request.headers['X-Request-ID'] = str(uuid.uuid4())
        return request

# Utilisation
response = requests.get(
    'https://api.example.com/data',
    auth=APIKeyAuth('ma-cle-secrete')
)

Utilisation de proxies

La bibliotheque requests permet de router vos requetes via des serveurs proxy HTTP, HTTPS ou SOCKS. C’est utile pour le debugging, l’anonymisation ou l’acces a des ressources restreintes.

Configuration de base

import requests

proxies = {
    'http': 'http://proxy.example.com:8080',
    'https': 'http://proxy.example.com:8080'
}

response = requests.get('https://api.example.com/data', proxies=proxies)

Proxy avec authentification

proxies = {
    'http': 'http://user:password@proxy.example.com:8080',
    'https': 'http://user:password@proxy.example.com:8080'
}

response = requests.get('https://api.example.com/data', proxies=proxies)

Proxy SOCKS

Pour utiliser des proxies SOCKS (comme Tor), installez d’abord le support :

pip install requests[socks]

import requests

proxies = {
    'http': 'socks5://127.0.0.1:9050',
    'https': 'socks5://127.0.0.1:9050'
}

# Requete via le reseau Tor
response = requests.get('https://check.torproject.org', proxies=proxies)

Variables d’environnement

Vous pouvez aussi configurer les proxies via des variables d’environnement :

export HTTP_PROXY="http://proxy.example.com:8080"
export HTTPS_PROXY="http://proxy.example.com:8080"
export NO_PROXY="localhost,127.0.0.1,.local"

# Requests utilisera automatiquement les proxies de l'environnement
response = requests.get('https://api.example.com/data')

Bonnes Pratiques

Voici les recommandations essentielles pour utiliser requests de maniere professionnelle :

Utilisez des sessions pour les requetes multiples

import requests

# Session reutilise les connexions TCP et les cookies
session = requests.Session()
session.headers.update({'Authorization': 'Bearer token'})

# Toutes les requetes partagent la configuration
response1 = session.get('https://api.example.com/users')
response2 = session.get('https://api.example.com/orders')

Definissez toujours un timeout

# Evitez les requetes qui bloquent indefiniment
response = requests.get(
    'https://api.example.com/data',
    timeout=(3.05, 27)  # (connect timeout, read timeout)
)

Gerez les erreurs correctement

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError

try:
    response = requests.get('https://api.example.com/data', timeout=10)
    response.raise_for_status()
    data = response.json()
except Timeout:
    print("La requete a expire")
except ConnectionError:
    print("Impossible de se connecter au serveur")
except RequestException as e:
    print(f"Erreur HTTP: {e}")

Utilisez des retry pour la resilience

from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

session = requests.Session()
retry = Retry(total=3, backoff_factor=0.5, status_forcelist=[500, 502, 503, 504])
adapter = HTTPAdapter(max_retries=retry)
session.mount('http://', adapter)
session.mount('https://', adapter)

Pieges Courants

Evitez ces erreurs frequentes lors de l’utilisation de requests :

Ne pas fermer les fichiers

# MAUVAIS - le fichier reste ouvert
files = {'file': open('data.txt', 'rb')}
requests.post(url, files=files)

# BON - utiliser with pour fermer automatiquement
with open('data.txt', 'rb') as f:
    files = {'file': f}
    requests.post(url, files=files)

Oublier de verifier le status code

# MAUVAIS - suppose que tout s'est bien passe
response = requests.post(url, json=data)
result = response.json()

# BON - verifier avant de traiter
response = requests.post(url, json=data)
if response.ok:
    result = response.json()
else:
    print(f"Erreur {response.status_code}: {response.text}")

Melanger data et json

# MAUVAIS - json sera ignore
response = requests.post(url, data={'a': 1}, json={'b': 2})

# BON - utiliser l'un OU l'autre
response = requests.post(url, json={'a': 1, 'b': 2})

Ignorer les timeouts

# MAUVAIS - peut bloquer indefiniment
response = requests.get('https://slow-api.com/data')

# BON - toujours definir un timeout
response = requests.get('https://slow-api.com/data', timeout=30)

Conclusion

La bibliotheque requests est un outil indispensable pour tout developpeur Python travaillant avec des APIs et des services web. Dans cet article, nous avons couvert :

• Requetes POST : envoi de donnees form-encoded et JSON avec les parametres data et json
• Upload de fichiers : transfert de fichiers simples et multiples avec metadonnees
• Lecture des reponses : acces aux differentes proprietes de la reponse (status, headers, contenu)
• Authentification : Basic Auth, Digest Auth, Bearer tokens et authentification personnalisee
• Proxies : configuration de proxies HTTP, HTTPS et SOCKS

En suivant les bonnes pratiques presentees (sessions, timeouts, gestion d’erreurs) et en evitant les pieges courants, vous serez en mesure de construire des applications robustes et performantes.

Ressources complementaires

Pour approfondir vos connaissances :

• Documentation officielle Requests
• HTTPBIN - Service de test pour les requetes HTTP
• Requests-HTML - Extension pour le parsing HTML