Skip to content

Bibliothèque Python Requests : guide complet des requêtes HTTP en Python

Soren Atelier
Name
Soren Atelier

Updated on

Effectuer des requêtes HTTP en Python avec le module intégré urllib est notoirement complexe et verbeux. Vous devez encoder manuellement les paramètres, manipuler des objets de réponse via plusieurs appels de méthode et écrire des dizaines de lignes de code répétitif juste pour envoyer une simple requête API. Cette complexité ralentit le développement et rend votre code plus difficile à maintenir.

La bibliothèque Python requests élimine cette frustration en fournissant une API élégante et agréable à utiliser pour la communication HTTP. Que vous consommiez des API REST, fassiez du scraping de sites web, uploadiez des fichiers ou construisiez des scripts d’automatisation, requests rend les opérations HTTP intuitives et simples en quelques lignes de code.

Dans ce guide complet, vous apprendrez tout, des requêtes GET et POST de base aux fonctionnalités avancées comme l’authentification, les sessions, la gestion des erreurs et des modèles d’intégration d’API concrets.

📚

    Installer la bibliothèque Python Requests

    La bibliothèque requests ne fait pas partie de la bibliothèque standard de Python : vous devez donc l’installer séparément avec pip :

    pip install requests

    Pour les utilisateurs conda :

    conda install requests

    Une fois installée, vous pouvez l’importer dans vos scripts Python :

    import requests

    Pour vérifier l’installation et consulter la version :

    import requests
print(requests.__version__)

    Effectuer des requêtes GET avec Python Requests

    Les requêtes GET sont la méthode HTTP la plus courante : elles servent à récupérer des données depuis des serveurs. La bibliothèque requests rend les requêtes GET extrêmement simples.

    Requête GET de base

    Voici comment effectuer une requête GET basique :

    import requests
 
response = requests.get('https://api.github.com')
print(response.status_code)  # 200
print(response.text)  # Response body as string

    Requête GET avec paramètres de requête (query parameters)

    Au lieu de construire manuellement des URL avec une query string, utilisez le paramètre params :

    import requests
 
# Method 1: Using params dictionary
params = {
    'q': 'python requests',
    'sort': 'stars',
    'order': 'desc'
}
response = requests.get('https://api.github.com/search/repositories', params=params)
 
# The URL is automatically constructed:
# https://api.github.com/search/repositories?q=python+requests&sort=stars&order=desc
 
print(response.url)  # View the constructed URL
data = response.json()  # Parse JSON response

    Requête GET avec en-têtes personnalisés

    De nombreuses API exigent des en-têtes personnalisés pour l’authentification ou la négociation de contenu :

    import requests
 
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept': 'application/json',
    'Accept-Language': 'en-US,en;q=0.9'
}
 
response = requests.get('https://api.example.com/data', headers=headers)
print(response.json())

    Effectuer des requêtes POST en Python

    Les requêtes POST envoient des données à un serveur ; elles sont couramment utilisées pour les soumissions de formulaires et les opérations d’API.

    Requête POST avec des données de formulaire

    Pour envoyer des données encodées comme un formulaire (comme des soumissions de formulaires HTML) :

    import requests
 
# Send form data
data = {
    'username': 'john_doe',
    'password': 'secret123',
    'remember_me': True
}
 
response = requests.post('https://example.com/login', data=data)
print(response.status_code)

    Requête POST avec une charge utile JSON

    Les API REST modernes attendent généralement des charges utiles JSON. La bibliothèque requests gère automatiquement la sérialisation JSON :

    import requests
 
# Method 1: Using json parameter (recommended)
payload = {
    'name': 'New Project',
    'description': 'A test project',
    'tags': ['python', 'api']
}
 
response = requests.post('https://api.example.com/projects', json=payload)
 
# Method 2: Manual JSON encoding
import json
headers = {'Content-Type': 'application/json'}
response = requests.post(
    'https://api.example.com/projects',
    data=json.dumps(payload),
    headers=headers
)

    Requête POST avec des fichiers

    Uploadez des fichiers avec le paramètre files :

    import requests
 
# Upload a single file
files = {'file': open('report.pdf', 'rb')}
response = requests.post('https://example.com/upload', files=files)
 
# Upload multiple files
files = {
    'file1': open('document.pdf', 'rb'),
    'file2': open('image.jpg', 'rb')
}
response = requests.post('https://example.com/upload', files=files)
 
# Upload file with additional form data
files = {'file': open('data.csv', 'rb')}
data = {'description': 'Monthly report', 'category': 'finance'}
response = requests.post('https://example.com/upload', files=files, data=data)

    Autres méthodes HTTP : PUT, PATCH, DELETE

    La bibliothèque requests prend en charge toutes les méthodes HTTP standard :

    import requests
 
# PUT - Replace entire resource
data = {'name': 'Updated Name', 'status': 'active'}
response = requests.put('https://api.example.com/users/123', json=data)
 
# PATCH - Partially update resource
data = {'status': 'inactive'}
response = requests.patch('https://api.example.com/users/123', json=data)
 
# DELETE - Remove resource
response = requests.delete('https://api.example.com/users/123')
print(response.status_code)  # 204 No Content
 
# HEAD - Get headers only (no response body)
response = requests.head('https://example.com')
print(response.headers)
 
# OPTIONS - Get supported methods
response = requests.options('https://api.example.com/users')
print(response.headers.get('Allow'))

    Comprendre l’objet Response

    L’objet Response contient toutes les informations sur la réponse du serveur :

    import requests
 
response = requests.get('https://api.github.com/users/github')
 
# Status code
print(response.status_code)  # 200, 404, 500, etc.
 
# Response body as string
print(response.text)
 
# Response body as JSON (for JSON APIs)
data = response.json()
print(data['login'])
 
# Raw binary content (for images, files)
image_data = response.content
with open('profile.jpg', 'wb') as f:
    f.write(image_data)
 
# Response headers
print(response.headers)
print(response.headers['Content-Type'])
 
# Encoding
print(response.encoding)  # 'utf-8'
 
# Request information
print(response.request.headers)
print(response.request.url)
 
# Check if request was successful
if response.ok:  # True if status_code < 400
    print("Success!")

    Travailler avec les en-têtes (headers) de requête

    Les en-têtes transportent des métadonnées importantes à propos de la requête.

    Définir des en-têtes personnalisés

    import requests
 
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'Accept-Encoding': 'gzip, deflate',
    'Connection': 'keep-alive',
    'Custom-Header': 'custom-value'
}
 
response = requests.get('https://api.example.com', headers=headers)

    Accéder aux en-têtes de réponse

    import requests
 
response = requests.get('https://api.github.com')
 
# Dictionary-like access
print(response.headers['Content-Type'])
print(response.headers.get('X-RateLimit-Remaining'))
 
# Case-insensitive access
print(response.headers['content-type'])  # Works!
 
# Iterate all headers
for key, value in response.headers.items():
    print(f"{key}: {value}")

    Authentification avec Python Requests

    La bibliothèque requests prend en charge plusieurs mécanismes d’authentification.

    Authentification Basic

    import requests
from requests.auth import HTTPBasicAuth
 
# Method 1: Using auth parameter (recommended)
response = requests.get(
    'https://api.example.com/protected',
    auth=('username', 'password')
)
 
# Method 2: Explicit HTTPBasicAuth
response = requests.get(
    'https://api.example.com/protected',
    auth=HTTPBasicAuth('username', 'password')
)
 
# Method 3: Manual header (not recommended)
import base64
credentials = base64.b64encode(b'username:password').decode('utf-8')
headers = {'Authorization': f'Basic {credentials}'}
response = requests.get('https://api.example.com/protected', headers=headers)

    Authentification Bearer Token

    Courante pour les tokens JWT et OAuth 2.0 :

    import requests
 
token = 'your_access_token_here'
headers = {'Authorization': f'Bearer {token}'}
 
response = requests.get('https://api.example.com/user', headers=headers)

    Authentification par clé API (API Key)

    import requests
 
# Method 1: Query parameter
params = {'api_key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', params=params)
 
# Method 2: Custom header
headers = {'X-API-Key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', headers=headers)

    Authentification OAuth 2.0

    Pour OAuth 2.0, utilisez la bibliothèque requests-oauthlib :

    from requests_oauthlib import OAuth2Session
 
client_id = 'your_client_id'
client_secret = 'your_client_secret'
token_url = 'https://oauth.example.com/token'
 
oauth = OAuth2Session(client_id)
token = oauth.fetch_token(token_url, client_secret=client_secret)
 
# Make authenticated requests
response = oauth.get('https://api.example.com/protected')

    Sessions pour des connexions persistantes

    Les sessions conservent les cookies, le pooling de connexions et la configuration à travers plusieurs requêtes :

    import requests
 
# Create a session
session = requests.Session()
 
# Set headers for all requests in this session
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})
 
# Login and session maintains cookies
login_data = {'username': 'john', 'password': 'secret'}
session.post('https://example.com/login', data=login_data)
 
# Subsequent requests use the session cookies
response1 = session.get('https://example.com/dashboard')
response2 = session.get('https://example.com/profile')
 
# Close the session
session.close()

    Session avec authentification

    import requests
 
session = requests.Session()
session.auth = ('username', 'password')
 
# All requests in this session use the authentication
response1 = session.get('https://api.example.com/users')
response2 = session.get('https://api.example.com/posts')

    Session avec context manager

    import requests
 
with requests.Session() as session:
    session.headers.update({'Authorization': 'Bearer token123'})
 
    response1 = session.get('https://api.example.com/data')
    response2 = session.post('https://api.example.com/data', json={'key': 'value'})
 
# Session automatically closed after with block

    Stratégies de timeout et de retry

    Définissez toujours des timeouts pour éviter que les requêtes ne restent bloquées indéfiniment.

    Définir des timeouts

    import requests
 
# Single timeout value (applies to both connect and read)
response = requests.get('https://api.example.com', timeout=5)
 
# Separate connect and read timeouts
response = requests.get('https://api.example.com', timeout=(3, 10))
# 3 seconds to establish connection, 10 seconds to read response
 
# No timeout (dangerous - may hang forever)
response = requests.get('https://api.example.com', timeout=None)

    Mettre en place une logique de retry

    import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry
 
# Configure retry strategy
retry_strategy = Retry(
    total=3,  # Total number of retries
    backoff_factor=1,  # Wait 1, 2, 4 seconds between retries
    status_forcelist=[429, 500, 502, 503, 504],  # Retry on these status codes
    allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]
)
 
adapter = HTTPAdapter(max_retries=retry_strategy)
session = requests.Session()
session.mount("http://", adapter)
session.mount("https://", adapter)
 
# Requests will automatically retry on failure
response = session.get('https://api.example.com/data')

    Gestion des erreurs dans Python Requests

    Une gestion robuste des erreurs est cruciale pour les applications en production.

    Gérer les exceptions courantes

    import requests
from requests.exceptions import (
    ConnectionError,
    Timeout,
    HTTPError,
    RequestException
)
 
try:
    response = requests.get('https://api.example.com/data', timeout=5)
    response.raise_for_status()  # Raises HTTPError for 4xx/5xx status codes
    data = response.json()
 
except ConnectionError:
    print("Failed to connect to the server")
 
except Timeout:
    print("Request timed out")
 
except HTTPError as e:
    print(f"HTTP error occurred: {e}")
    print(f"Status code: {e.response.status_code}")
 
except RequestException as e:
    # Catches all requests exceptions
    print(f"An error occurred: {e}")
 
except ValueError:
    # JSON decoding error
    print("Invalid JSON response")

    Vérifier les codes de statut

    import requests
 
response = requests.get('https://api.example.com/data')
 
# Method 1: Manual check
if response.status_code == 200:
    data = response.json()
elif response.status_code == 404:
    print("Resource not found")
elif response.status_code >= 500:
    print("Server error")
 
# Method 2: Using raise_for_status()
try:
    response.raise_for_status()
    data = response.json()
except requests.exceptions.HTTPError as e:
    if response.status_code == 404:
        print("Resource not found")
    elif response.status_code == 401:
        print("Authentication required")
    else:
        print(f"HTTP error: {e}")
 
# Method 3: Using response.ok
if response.ok:  # True if status_code < 400
    data = response.json()
else:
    print(f"Request failed with status {response.status_code}")

    Vérification SSL et certificats

    Par défaut, requests vérifie les certificats SSL :

    import requests
 
# Default behavior - verify SSL certificate
response = requests.get('https://api.example.com')
 
# Disable SSL verification (not recommended for production)
response = requests.get('https://example.com', verify=False)
 
# Suppress the InsecureRequestWarning
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
response = requests.get('https://example.com', verify=False)
 
# Use custom CA bundle
response = requests.get('https://example.com', verify='/path/to/ca_bundle.crt')
 
# Client-side certificates
response = requests.get(
    'https://example.com',
    cert=('/path/to/client.crt', '/path/to/client.key')
)

    Utiliser des proxys avec Python Requests

    Configurez des serveurs proxy pour les requêtes :

    import requests
 
# HTTP and HTTPS proxies
proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
 
response = requests.get('https://api.example.com', proxies=proxies)
 
# SOCKS proxy (requires requests[socks])
proxies = {
    'http': 'socks5://user:pass@host:port',
    'https': 'socks5://user:pass@host:port'
}
 
# Use environment variables
# Set HTTP_PROXY and HTTPS_PROXY environment variables
response = requests.get('https://api.example.com')  # Automatically uses env proxies
 
# Disable proxies
response = requests.get('https://api.example.com', proxies={'http': None, 'https': None})

    Comparaison des bibliothèques HTTP Python

    Voici comment la bibliothèque requests se compare aux alternatives :

    Fonctionnalitérequestsurllibhttpxaiohttp
    Facilité d’utilisationExcellente (API Pythonic)Mauvaise (verbeuse)ExcellenteBonne
    Support asyncNonNonOuiOui
    Support HTTP/2NonNonOuiNon
    Gestion de sessionIntégréeManuelleIntégréeIntégrée
    Gestion JSONAutomatiqueManuelleAutomatiqueAutomatique
    Connection PoolingOuiNonOuiOui
    Bibliothèque standardNon (pip install)OuiNon (pip install)Non (pip install)
    DocumentationExcellenteBonneExcellenteBonne
    PerformanceBonneCorrecteExcellenteExcellente (async)
    SSL/TLSSupport completSupport completSupport completSupport complet
    Meilleur cas d’usageHTTP synchrone, usage généralScripts simples, sans dépendancesHTTP sync/async moderneAsync haute performance

    Quand utiliser chacune :

    • requests : choix par défaut pour la plupart des opérations HTTP synchrones. Idéal pour le scraping web, la consommation d’API et les tâches HTTP générales.
    • urllib : uniquement lorsque vous ne pouvez pas installer de packages externes (exigence « bibliothèque standard »).
    • httpx : lorsque vous avez besoin de HTTP/2 ou que vous voulez une API moderne compatible requests avec des capacités async.
    • aiohttp : pour des applications asynchrones haute performance gérant de nombreuses requêtes concurrentes.

    Limitation de débit (rate limiting) et scraping respectueux

    Lors du scraping de sites web ou d’appels à des API, mettez en place une limitation de débit :

    import requests
import time
from datetime import datetime
 
class RateLimitedSession:
    def __init__(self, requests_per_second=1):
        self.session = requests.Session()
        self.min_interval = 1.0 / requests_per_second
        self.last_request_time = 0
 
    def get(self, url, **kwargs):
        # Wait if necessary
        elapsed = time.time() - self.last_request_time
        if elapsed < self.min_interval:
            time.sleep(self.min_interval - elapsed)
 
        # Make request
        response = self.session.get(url, **kwargs)
        self.last_request_time = time.time()
        return response
 
# Use rate-limited session
session = RateLimitedSession(requests_per_second=2)  # 2 requests per second
 
urls = ['https://api.example.com/item/1', 'https://api.example.com/item/2']
for url in urls:
    response = session.get(url)
    print(f"{datetime.now()}: {response.status_code}")

    Respecter robots.txt

    import requests
from urllib.robotparser import RobotFileParser
 
def can_fetch(url, user_agent='MyBot'):
    """Check if URL can be scraped according to robots.txt"""
    rp = RobotFileParser()
    robots_url = f"{url.split('/')[0]}//{url.split('/')[2]}/robots.txt"
    rp.set_url(robots_url)
    rp.read()
    return rp.can_fetch(user_agent, url)
 
url = 'https://example.com/page'
if can_fetch(url):
    response = requests.get(url)
else:
    print("Scraping not allowed by robots.txt")

    Exemples concrets et cas d’usage

    Exemple 1 : Consommer une API REST

    import requests
 
class GitHubAPI:
    def __init__(self, token=None):
        self.base_url = 'https://api.github.com'
        self.session = requests.Session()
        if token:
            self.session.headers.update({'Authorization': f'token {token}'})
 
    def get_user(self, username):
        """Get user information"""
        response = self.session.get(f'{self.base_url}/users/{username}')
        response.raise_for_status()
        return response.json()
 
    def search_repositories(self, query, sort='stars', limit=10):
        """Search repositories"""
        params = {'q': query, 'sort': sort, 'per_page': limit}
        response = self.session.get(f'{self.base_url}/search/repositories', params=params)
        response.raise_for_status()
        return response.json()['items']
 
    def create_issue(self, owner, repo, title, body):
        """Create an issue in a repository"""
        url = f'{self.base_url}/repos/{owner}/{repo}/issues'
        data = {'title': title, 'body': body}
        response = self.session.post(url, json=data)
        response.raise_for_status()
        return response.json()
 
# Usage
api = GitHubAPI(token='your_github_token')
user = api.get_user('torvalds')
print(f"Name: {user['name']}, Followers: {user['followers']}")
 
repos = api.search_repositories('python requests', limit=5)
for repo in repos:
    print(f"{repo['full_name']}: {repo['stargazers_count']} stars")

    Exemple 2 : Télécharger des fichiers avec progression

    import requests
from tqdm import tqdm
 
def download_file(url, filename):
    """Download file with progress bar"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
 
    total_size = int(response.headers.get('content-length', 0))
 
    with open(filename, 'wb') as f, tqdm(
        desc=filename,
        total=total_size,
        unit='B',
        unit_scale=True,
        unit_divisor=1024,
    ) as progress_bar:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
            progress_bar.update(len(chunk))
 
# Download a file
download_file('https://example.com/large-file.zip', 'downloaded.zip')

    Exemple 3 : Web scraping avec gestion d’erreurs

    import requests
from bs4 import BeautifulSoup
import time
 
def scrape_articles(base_url, max_pages=5):
    """Scrape article titles from a news website"""
    session = requests.Session()
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    })
 
    articles = []
 
    for page in range(1, max_pages + 1):
        try:
            url = f"{base_url}?page={page}"
            response = session.get(url, timeout=10)
            response.raise_for_status()
 
            soup = BeautifulSoup(response.content, 'html.parser')
            titles = soup.find_all('h2', class_='article-title')
 
            for title in titles:
                articles.append({
                    'title': title.text.strip(),
                    'url': title.find('a')['href'] if title.find('a') else None
                })
 
            print(f"Scraped page {page}: {len(titles)} articles")
            time.sleep(1)  # Rate limiting
 
        except requests.exceptions.RequestException as e:
            print(f"Error scraping page {page}: {e}")
            continue
 
    return articles
 
# Usage
articles = scrape_articles('https://news.example.com/articles', max_pages=3)
print(f"Total articles collected: {len(articles)}")

    Exemple 4 : Intégration d’API avec pagination

    import requests
 
def fetch_all_items(api_url, headers=None):
    """Fetch all items from a paginated API"""
    items = []
    page = 1
 
    while True:
        try:
            params = {'page': page, 'per_page': 100}
            response = requests.get(api_url, params=params, headers=headers, timeout=10)
            response.raise_for_status()
 
            data = response.json()
 
            if not data:  # No more items
                break
 
            items.extend(data)
            print(f"Fetched page {page}: {len(data)} items")
 
            page += 1
 
            # Check for pagination in headers
            if 'Link' in response.headers:
                links = response.headers['Link']
                if 'rel="next"' not in links:
                    break
 
        except requests.exceptions.RequestException as e:
            print(f"Error fetching page {page}: {e}")
            break
 
    return items
 
# Usage
all_items = fetch_all_items('https://api.example.com/items')
print(f"Total items: {len(all_items)}")

    Tester des API dans Jupyter avec RunCell

    Lors du développement et des tests d’intégrations d’API, RunCell (opens in a new tab) fournit un environnement d’agent piloté par IA directement dans les notebooks Jupyter. Au lieu de déboguer manuellement les requêtes HTTP et les réponses, l’agent intelligent de RunCell peut vous aider à :

    • Construire et tester automatiquement des requêtes API avec la bonne authentification
    • Déboguer en temps réel le parsing des réponses et la gestion des erreurs
    • Générer des extraits de code pour des patterns HTTP courants
    • Valider les réponses d’API par rapport à des schémas attendus
    • Itérer rapidement sur des transformations de données à partir de réponses d’API

    C’est particulièrement utile avec des API complexes nécessitant plusieurs étapes d’authentification, la gestion de la pagination ou une logique de parsing de données sophistiquée. RunCell accélère le workflow de développement en réduisant les allers-retours liés au test manuel des requêtes HTTP.

    FAQ

    À quoi sert la bibliothèque Python requests ?

    La bibliothèque Python requests sert à effectuer des requêtes HTTP vers des serveurs web et des API. Elle simplifie des tâches comme récupérer des pages web, consommer des API REST, envoyer des données de formulaire, uploader des fichiers et gérer l’authentification. C’est la bibliothèque HTTP la plus populaire en Python grâce à son API intuitive et son ensemble de fonctionnalités complet.

    Comment installer la bibliothèque Python requests ?

    Installez la bibliothèque requests avec pip : pip install requests. Pour les environnements conda, utilisez conda install requests. Une fois installée, importez-la avec import requests dans votre code Python. La bibliothèque ne fait pas partie de la bibliothèque standard de Python : l’installation est donc nécessaire.

    Quelle est la différence entre requests.get() et requests.post() ?

    requests.get() récupère des données depuis un serveur sans rien modifier ; elle est généralement utilisée pour obtenir des pages web ou des données d’API. requests.post() envoie des données au serveur pour créer ou mettre à jour des ressources ; elle est couramment utilisée pour des soumissions de formulaires, des uploads de fichiers ou des opérations d’API qui modifient l’état côté serveur. Les requêtes GET passent les paramètres dans l’URL, tandis que les requêtes POST envoient les données dans le corps de la requête.

    Comment gérer les erreurs avec la bibliothèque Python requests ?

    Utilisez des blocs try-except pour intercepter les exceptions de requêtes : ConnectionError pour les problèmes réseau, Timeout pour les réponses lentes, HTTPError pour les codes 4xx/5xx et RequestException comme capture générale. Appelez response.raise_for_status() après chaque requête pour lever automatiquement une HTTPError en cas d’échec. Définissez toujours des timeouts afin d’éviter que les requêtes ne restent bloquées indéfiniment.

    Comment envoyer des données JSON avec Python requests ?

    Utilisez le paramètre json dans requests : requests.post(url, json=data). La bibliothèque sérialise automatiquement les dictionnaires Python en JSON et définit l’en-tête Content-Type: application/json. Pour parser des réponses JSON, utilisez response.json(), qui désérialise le corps de réponse JSON en dictionnaire Python.

    Dois-je utiliser requests ou urllib en Python ?

    Utilisez la bibliothèque requests pour la plupart des opérations HTTP. Elle offre une API plus propre, une gestion automatique du JSON, une gestion de session intégrée et une meilleure gestion des erreurs que urllib. N’utilisez urllib que lorsque vous ne pouvez pas installer de packages externes et devez vous appuyer uniquement sur la bibliothèque standard de Python. Pour des applications modernes nécessitant HTTP/2 ou l’async, envisagez httpx comme alternative.

    Comment ajouter l’authentification à Python requests ?

    Pour l’authentification Basic, utilisez requests.get(url, auth=('username', 'password')). Pour les Bearer tokens (JWT, OAuth), ajoutez un en-tête Authorization : headers = {'Authorization': f'Bearer {token}'}. Pour les clés API, ajoutez-les soit en paramètres de requête via le dictionnaire params, soit dans des en-têtes personnalisés comme 'X-API-Key'. Les sessions peuvent conserver l’authentification sur plusieurs requêtes.

    Que sont les sessions dans Python requests et quand les utiliser ?

    Les sessions conservent la configuration (en-têtes, cookies, authentification) à travers plusieurs requêtes vers le même serveur. Utilisez des sessions lorsque vous effectuez plusieurs requêtes vers une API, lorsque vous devez maintenir un état de connexion via des cookies ou lorsque vous voulez réutiliser des connexions TCP pour de meilleures performances. Créez une session avec session = requests.Session() et utilisez session.get() à la place de requests.get().

    Conclusion

    La bibliothèque Python requests est un outil indispensable pour la communication HTTP en Python. Son API élégante transforme des opérations HTTP complexes en code simple et lisible. Des requêtes GET de base aux fonctionnalités avancées comme l’authentification, les sessions, les uploads de fichiers et la gestion des erreurs, requests fournit tout ce dont vous avez besoin pour des interactions HTTP robustes.

    En maîtrisant les patterns et bonnes pratiques de ce guide — définir des timeouts, implémenter une logique de retry, gérer les erreurs proprement et respecter les limites de débit — vous construirez des applications fiables qui communiquent efficacement avec des services web et des API. Que vous consommiez des API REST, fassiez du scraping de sites web ou construisiez des outils d’automatisation, la bibliothèque requests rend les opérations HTTP simples et maintenables.

    📚