A curl command beside Python Requests code with checks for destination, headers, payload and response behavior

Pour convertir curl en Python, associez l’URL, la méthode, les en-têtes et le corps de la commande à un appel Requests, puis comparez ce que le serveur reçoit. Partez de l’exemple en deux versions ci-dessous et choisissez explicitement le comportement face aux redirections.

Une réponse réussie ne prouve pas à elle seule l’équivalence. Notre test en localhost a montré que des traductions pourtant directes pouvaient modifier les octets du JSON, l’encodage des formulaires et le comportement des redirections, même quand le code semblait correct.


Points clés

  • Notre instantané en localhost portait sur six scénarios de test, chacun répété trois fois par client.
  • Le test comprenait 36 exécutions initiales de clients, hors requêtes de suivi des redirections.
  • Le scénario de requête répétée a conservé l’ordre des paramètres et les clés en double.
  • Le scénario JSON a conservé les données, mais modifié les octets du corps.
  • Le scénario de formulaire a transformé une espace littérale en signe plus.
  • Le scénario de redirection a produit une seule requête avec curl et deux avec Requests.

Comment convertir curl en Python avec Requests ?

Traduisez une requête à la fois, en gardant sa destination et ses entrées bien visibles. Cet exemple GET envoie des paramètres de requête répétés et un en-tête personnalisé à un point de terminaison d’écho public ; n’y utilisez que des données synthétiques.

python -m pip install requests
curl --silent --show-error 'https://httpbin.org/get?tag=a&tag=b&page=2' -H 'X-Test: 1'
import requests

response = requests.get(
    'https://httpbin.org/get',
    params=[('tag', 'a'), ('tag', 'b'), ('page', '2')],
    headers={'X-Test': '1'},
    allow_redirects=False,
    timeout=(5, 20),
)
response.raise_for_status()
print(response.status_code)
print(response.json()['args'])

Lorsque le point de terminaison répond normalement, attendez-vous au statut 200 et à des arguments équivalents à {'page': '2', 'tag': ['a', 'b']}. L’ordre d’affichage du dictionnaire n’a pas d’importance ici ; les valeurs répétées, si.

Le guide de démarrage de Requests documente les paramètres de requête, les en-têtes et la gestion des réponses. Pour votre propre point de terminaison, remplacez d’abord l’URL, puis modifiez une seule entrée à la fois afin que les échecs restent faciles à isoler.


Quelles correspondances entre options curl et Python comptent le plus ?

Faites correspondre le sens de la requête, pas seulement l’écriture des options. Le manuel de curl et la référence de l’API Requests décrivent les options qui sous-tendent cette liste de contrôle de conversion.

Entrée curl Équivalent Requests Point de vérification
-X POST requests.post(…) ou request(‘POST’, …) Vérifiez la méthode réellement utilisée, y compris celles qu’impliquent les options de corps.
Requête dans l’URL ou -G params= Conservez les clés en double et l’ordre lorsqu’ils sont requis.
-H headers= Conservez les valeurs requises.
-b ‘name=value’ cookies= Un fichier de cookies demande un traitement distinct.
-u pour l’authentification Basic auth=(username, password) Ne supposez pas que tous les schémas d’authentification sont de type Basic.
En-tête Authorization: Bearer headers={‘Authorization’: …} Lisez le jeton depuis une source de secrets.
-d ou –data-raw data= ou json= Choisissez selon le format du corps et les exigences sur les octets.
-F files=, éventuellement data= Vérifiez les noms de fichiers et de champs.
-L allow_redirects=True Définissez explicitement la politique de redirection.
-x proxies= Conservez le schéma du proxy et le routage.

La traduction des options n’est pas toujours univoque. Traitez les options inhabituelles de signature, de certificat, de DNS et de protocole comme des points de revue distincts. Utilisez notre guide des en-têtes curl pour identifier quels en-têtes de la source comptent.


Comment préserver le JSON, les formulaires et les envois de fichiers ?

Utilisez json= pour du JSON structuré, data= pour des champs de formulaire ou des octets de corps exacts, et files= pour les envois multipart. Ces interfaces sont documentées dans les exemples de corps et d’envoi de Requests.

Une requête POST peut aussi comporter des paramètres de requête. Cet exemple garde la requête séparée du corps JSON et lit un jeton Bearer dans l’environnement. Définissez API_URL avec votre point de terminaison autorisé et API_TOKEN via votre mécanisme habituel de gestion des secrets avant de l’exécuter.

import os
import requests

response = requests.post(
    os.environ['API_URL'],
    params=[('mode', 'validate')],
    headers={'Authorization': 'Bearer ' + os.environ['API_TOKEN']},
    json={'name': 'a', 'n': 1},
    allow_redirects=False,
    timeout=(5, 20),
)
response.raise_for_status()
print(response.status_code)

Pour les corps signés, sérialisez une seule fois et signez exactement les octets que vous envoyez. Notre scénario JSON a modifié les espaces pendant la traduction. Une sérialisation compacte reproduit le corps d’origine de ce scénario, mais elle ne peut pas reconstituer des espaces ou un ordre de clés arbitraires d’origine.

import json
import os
import requests

body = json.dumps({'name': 'a', 'n': 1}, separators=(',', ':')).encode('utf-8')
response = requests.post(
    os.environ['API_URL'],
    data=body,
    headers={'Content-Type': 'application/json'},
    allow_redirects=False,
    timeout=(5, 20),
)
response.raise_for_status()

Pour des champs de formulaire répétés, utilisez data=[('k', '1'), ('k', '2'), ('x', 'a b')]. Dans notre test, cela a encodé l’espace en +, alors que l’entrée littérale -d de curl conservait une espace. L’option –data-urlencode de curl encode les valeurs des champs, mais un décodage équivalent n’établit toujours pas que les octets sont identiques.

Pour les envois de fichiers, laissez le client construire la frontière multipart. Cet exemple autonome utilise un contenu de fichier synthétique ; comparez le contenu des fichiers et les noms des champs séparément de l’enveloppe multipart.

import os
import requests

response = requests.post(
    os.environ['API_URL'],
    data={'label': 'example'},
    files={'file': ('sample.txt', b'hello\n', 'text/plain')},
    allow_redirects=False,
    timeout=(5, 20),
)
response.raise_for_status()

Comment copier une requête du navigateur en toute sécurité ?

Ne capturez qu’une requête autorisée, puis supprimez les secrets avant de la partager. Dans Chrome DevTools, ouvrez Network, faites un clic droit sur la requête et choisissez Copy > Copy as cURL, comme l’indique la référence Network de Chrome.

Inspectez le texte avant d’exécuter quoi que ce soit. Les guillemets du shell relèvent de la syntaxe de la commande, pas forcément de la charge utile. Vérifiez les guillemets imbriqués, les retours à la ligne avec continuation et les références à des variables par rapport au shell utilisé pour la capture.

Déplacez les valeurs d’autorisation et de session vers un stockage de secrets. Conservez les en-têtes applicatifs requis, mais examinez les en-têtes Host, Content-Length et ceux propres au navigateur avant de les copier. Retirez les en-têtes douteux un par un et refaites le test ; tout supprimer d’un coup masque la valeur qui comptait.

Notez l’heure de la capture et l’opération visée. Une requête copiée est un instantané : l’expiration de la session ou un changement d’état de l’application peut l’invalider. La traduction n’équivaut pas à une émulation du navigateur et ne reproduit pas une interaction entière.


Quand utiliser un convertisseur ou une autre approche ?

Utilisez la conversion manuelle pour le code que vous allez maintenir, et un convertisseur pour une première traduction que vous pouvez inspecter. Conservez curl lorsque la préservation de son comportement compte plus que l’usage d’un client HTTP natif Python.

Approche Utilisez X lorsque… Évitez X lorsque…
Conversion manuelle vers Requests Utilisez la conversion manuelle vers Requests lorsque vous avez besoin d’un code lisible et maintenu. Évitez la conversion manuelle vers Requests lorsqu’un comportement inhabituel de curl reste sans équivalent.
curlconverter Utilisez curlconverter lorsque vous voulez une traduction de départ. Évitez curlconverter lorsque vous ne pouvez pas relire le code généré ni protéger les identifiants.
Conserver curl via subprocess Utilisez subprocess lorsque le comportement existant de curl est essentiel. Évitez subprocess lorsque le contenu de la commande n’est pas fiable ou que du Python natif est exigé.

Le site officiel de curlconverter indique que la conversion s’effectue dans votre navigateur. Cette affirmation vaut pour ce site, pas pour tous les convertisseurs de curl vers Python. Son dépôt officiel documente ce chemin en ligne de commande :

npm install --global curlconverter
curlconverter --language python 'https://httpbin.org/get'

Exécuter curl depuis Python est une approche différente. Conformément à la documentation du module subprocess de Python, utilisez une liste d’arguments fixe et évitez l’évaluation par le shell. Relisez tout de même chaque argument et chaque destination.

import subprocess

result = subprocess.run(
    ['curl', '--silent', '--show-error', '--fail',
     '--max-time', '20', 'https://httpbin.org/get'],
    check=True,
    capture_output=True,
    text=True,
    timeout=25,
)
print(result.stdout)

Comment vérifier que la conversion est équivalente ?

Utilisez la vérification d’équivalence de requête en 4 couches pour distinguer la concordance des entrées applicatives, celle des octets et celle du comportement de la réponse. Décidez quelles propriétés votre point de terminaison exige avant d’accepter une conversion.

Votre requête Python est-elle vraiment identique à la commande curl ?

  • Couche 1, destination et méthode : comparez la méthode, le chemin et les paires de la requête dans l’ordre.
  • Couche 2, en-têtes et authentification : comparez les valeurs d’en-têtes choisies et l’emplacement des identifiants sans journaliser les secrets.
  • Couche 3, charge utile : comparez la longueur du corps brut, son SHA-256 et l’égalité de la charge utile analysée.
  • Couche 4, transport et réponse : comparez le statut, l’URL finale et le nombre de sauts de redirection.

Lors de notre test du 15 octobre 2026, un serveur HTTP de journalisation lié à 127.0.0.1 a reçu six scénarios, chacun exécuté trois fois avec chaque client. Cela représente 36 exécutions initiales, les requêtes de suivi des redirections étant comptées à part. Les résultats se sont répétés de façon constante sur les trois exécutions.

Source : DataImpulse, CURL vs PYTHON REQUESTS EQUIVALENCE TEST, 15 octobre 2026, 16:12 UTC. L’environnement Linux utilisait curl 8.5.0, Python 3.12.3 et Requests 2.34.2. Il s’agit d’un instantané en localhost, pas d’un benchmark.

Scénario Concordance sémantique Concordance des octets Concordance des redirections Explication
Requête répétée Oui Oui, requête Non testée Les paires de tuples ont conservé tag=a, tag=b et page=2.
En-tête personnalisé et cookie Oui Oui, valeurs choisies Non testée X-Test et le cookie synthétique concordaient.
En-tête Bearer Oui Oui, valeur choisie Non testée La valeur d’autorisation synthétique concordait.
POST JSON Oui Non Non testée Des espaces ajoutés ont modifié le hash du corps.
Champs de formulaire répétés Mêmes champs décodés Non Non testée Une espace littérale est devenue +.
Redirection 302 Requête initiale uniquement Non établie pour la chaîne Non curl a fait une requête ; Requests en a fait deux.

Les concordances d’octets ci-dessus portent sur les champs nommés, pas sur les messages complets tels qu’ils circulent sur le réseau. Le User-Agent différait entre les clients. L’instantané ne permet pas d’établir la compatibilité avec des API externes, le comportement TLS, les performances d’un proxy ni des taux de réussite généralisés.

Pour votre propre vérification reproductible, conservez les commandes nettoyées, le code du serveur et les versions des paquets. Journalisez les quatre couches séparément. Répétez le scénario de redirection avec les deux clients configurés pour s’arrêter, puis avec les deux configurés pour suivre ; ce sont des étapes de validation complémentaires, pas des résultats mesurés supplémentaires rapportés ici.


Pourquoi le code converti échoue-t-il ou renvoie-t-il des résultats différents ?

Repérez la première couche qui diffère avant de modifier plusieurs paramètres. Commencez par exécuter la commande d’origine et la requête convertie à peu de temps d’intervalle, avec les mêmes entrées autorisées.

  • Authentification : vérifiez l’expiration des identifiants, leur portée et l’état de session requis. N’affichez jamais les jetons lorsque vous diagnostiquez une erreur 401 ou 403.
  • Redirections : inspectez la réponse initiale avant de comparer le contenu final. Notre scénario a révélé immédiatement des comportements par défaut différents.
  • Encodage : comparez les octets lorsque des signatures ou des charges utiles exactes comptent ; comparez les champs décodés lorsque c’est le sens applicatif qui compte.
  • Erreurs HTTP : inspectez le statut et un extrait nettoyé de la réponse. Requests propose raise_for_status() pour gérer les statuts HTTP en échec.
  • Délais d’attente : définissez explicitement les valeurs de connexion et de lecture. Elles ne constituent pas une échéance sur le temps total écoulé.
  • TLS : corrigez les problèmes de confiance du certificat ou de nom d’hôte. Désactiver la vérification crée un risque d’interception.
  • Streaming : consommez la réponse de façon délibérée et fermez-la ; utilisez un gestionnaire de contexte autour des téléchargements en flux.

Le guide de démarrage de Requests traite de la gestion des statuts, tandis que l’usage avancé explique les délais d’attente, la vérification des certificats et le streaming. Diagnostiquez l’échec avant d’ajouter des nouvelles tentatives, surtout pour les opérations qui modifient l’état du serveur.


Comment intégrer des proxies dans une requête convertie ?

Traduisez le routage une fois que la conversion directe fonctionne. Gardez l’authentification du proxy séparée du jeton Bearer ou des cookies de la destination.

import os
import requests

proxy_url = os.environ['PROXY_URL']
response = requests.get(
    os.environ['API_URL'],
    proxies={'http': proxy_url, 'https': proxy_url},
    allow_redirects=False,
    timeout=(5, 20),
)
response.raise_for_status()
print(response.status_code)

Requests documente les URL de proxy, l’authentification de proxy intégrée et les paramètres de proxy d’environnement dans sa documentation sur les proxies. Inspectez le routage de l’environnement lorsque les résultats diffèrent. SOCKS exige des dépendances optionnelles ; préservez le comportement DNS voulu en plus de l’adresse du proxy.

Utilisez le guide de configuration d’un proxy avec curl pour relire la commande source et le tutoriel sur les proxies avec Python Requests pour le code de destination. Une fois les vérifications d’équivalence passées, le guide du routage avec Python et le guide du routage avec curl proposent des étapes suivantes facultatives.


Questions fréquentes

Comment convertir une commande curl en Python Requests ?

Séparez la requête curl en destination, méthode, en-têtes et charge utile, puis traduisez chaque élément. Comparez ce que le serveur observe avant de vous fier au résultat ; une exécution réussie ne suffit pas à elle seule.

Comment les options curl pour le JSON, les formulaires et les envois correspondent-elles à Python ?

Choisissez json= pour les objets JSON, data= pour les champs de formulaire ou les octets exacts, et files= pour les envois multipart. Pour les requêtes sensibles aux octets, conservez le corps d’origine et vérifiez son hash plutôt que de supposer que la sérialisation le préserve.

Comment préserver en toute sécurité les en-têtes, les cookies et l’authentification Bearer ?

Dressez l’inventaire des valeurs requises et chargez les vrais secrets à l’exécution. Utilisez des valeurs de remplacement synthétiques lorsque vous partagez des exemples, et évitez de journaliser les identifiants de la destination comme ceux du proxy.

Pourquoi le Python converti peut-il se comporter différemment de la commande curl d’origine ?

Notre instantané a mis en évidence des différences de sérialisation du corps et de gestion des redirections. Vérifiez la requête et la réponse initiales avant d’attribuer une sortie différente au service distant.

Comment traduire les paramètres de proxy de curl dans Requests ?

Reportez le point de terminaison du proxy dans le dictionnaire proxies et conservez son schéma. Vérifiez le routage de l’environnement et l’authentification du proxy séparément de l’authentification applicative avant de comparer les résultats.

Un JSON analysé identique prouve-t-il qu’une conversion est correcte ?

Cela prouve seulement que les charges utiles comparées se décodent en les mêmes données. Notre scénario JSON présentait pourtant des hashs de corps différents, ce qui compte lorsque la validation dépend des octets exacts.


Besoin d’un routage par proxy une fois votre conversion fonctionnelle ?

Commencez par le guide de configuration de Requests avec DataImpulse si votre flux de travail autorisé nécessite un routage par proxy. DataImpulse n’est ni une API de scraping, ni un service géré de déblocage, ni un VPN ; la justesse des requêtes et la gestion des réponses restent à la charge de votre code.

Dernière mise à jour : 15 octobre 2026.


Share article: