Lors de l'interaction avec des serveurs Web, que ce soit pour le web scraping ou le travail d'API, les en-têtes de requêtes Python sont un outil puissant mais souvent négligé. Ces en-têtes communiquent silencieusement, indiquant au serveur qui appelle, pourquoi et dans quel format les données doivent être renvoyées.
Dans ce guide, nous aborderons tout ce que vous devez savoir sur la configuration des en-têtes avec la bibliothèque de requêtes de Python, pourquoi l'ordre des en-têtes est important et comment la compréhension des en-têtes peut améliorer le succès de vos interactions Web.
Pour ceux qui découvrent la bibliothèque, vous pouvez commencer par l'installer avec les demandes d'installation pip à suivre avec ce guide.
En HTTP, les en-têtes sont des paires clé-valeur qui accompagnent chaque requête et réponse, guidant le serveur sur la façon de traiter la requête. Les en-têtes spécifient les attentes, les formats et les autorisations, jouant un rôle essentiel dans la communication serveur-client. Par exemple, les en-têtes peuvent indiquer au serveur le type d'appareil qui envoie la requête ou si le client attend une réponse JSON.
Chaque requête initie un dialogue entre le client (comme un navigateur ou une application) et le serveur, avec des en-têtes faisant office d'instructions. Les en-têtes les plus courants incluent :
Les en-têtes peuvent être facilement gérés à l'aide de la bibliothèque de requêtes de Python, vous permettant d'obtenir des en-têtes à partir d'une réponse ou de définir des en-têtes personnalisés pour adapter chaque requête.
Exemple : obtenir des en-têtes avec des requêtes Python
En Python, les requêtes pour obtenir les en-têtes peuvent être effectuées avec réponse.headers.
import requests
response = requests.get('https://httpbin.dev')
print(response.headers)
{
"Access-Control-Allow-Credentials": "true",
"Access-Control-Allow-Origin": "*",
"Content-Security-Policy": "frame-ancestors 'self' *.httpbin.dev; font-src 'self' *.httpbin.dev; default-src 'self' *.httpbin.dev; img-src 'self' *.httpbin.dev https://cdn.scrapfly.io; media-src 'self' *.httpbin.dev; script-src 'self' 'unsafe-inline' 'unsafe-eval' *.httpbin.dev; style-src 'self' 'unsafe-inline' *.httpbin.dev https://unpkg.com; frame-src 'self' *.httpbin.dev; worker-src 'self' *.httpbin.dev; connect-src 'self' *.httpbin.dev",
"Content-Type": "text/html; charset=utf-8",
"Date": "Fri, 25 Oct 2024 14:14:02 GMT",
"Permissions-Policy": "fullscreen=(self), autoplay=*, geolocation=(), camera=()",
"Referrer-Policy": "strict-origin-when-cross-origin",
"Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
"X-Content-Type-Options": "nosniff",
"X-Xss-Protection": "1; mode=block",
"Transfer-Encoding": "chunked"
}
La sortie affiche les en-têtes renvoyés par le serveur, avec des détails tels que
Exemple : Définition d'en-têtes personnalisés
Les en-têtes personnalisés, comme l'ajout d'un agent utilisateur pour l'émulation de périphérique, peuvent rendre les requêtes plus authentiques :
import requests
response = requests.get('https://httpbin.dev')
print(response.headers)
{
"Access-Control-Allow-Credentials": "true",
"Access-Control-Allow-Origin": "*",
"Content-Security-Policy": "frame-ancestors 'self' *.httpbin.dev; font-src 'self' *.httpbin.dev; default-src 'self' *.httpbin.dev; img-src 'self' *.httpbin.dev https://cdn.scrapfly.io; media-src 'self' *.httpbin.dev; script-src 'self' 'unsafe-inline' 'unsafe-eval' *.httpbin.dev; style-src 'self' 'unsafe-inline' *.httpbin.dev https://unpkg.com; frame-src 'self' *.httpbin.dev; worker-src 'self' *.httpbin.dev; connect-src 'self' *.httpbin.dev",
"Content-Type": "text/html; charset=utf-8",
"Date": "Fri, 25 Oct 2024 14:14:02 GMT",
"Permissions-Policy": "fullscreen=(self), autoplay=*, geolocation=(), camera=()",
"Referrer-Policy": "strict-origin-when-cross-origin",
"Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
"X-Content-Type-Options": "nosniff",
"X-Xss-Protection": "1; mode=block",
"Transfer-Encoding": "chunked"
}
Cette configuration permet de garantir que chaque requête apparaît comme un navigateur, réduisant ainsi le risque de déclencher des mesures anti-bot. Dans les requêtes Python, la définition des en-têtes vous permet de contrôler précisément les interactions avec le serveur.
Une question fréquente lorsque l'on travaille avec des en-têtes de requêtes Python est de savoir si les noms d'en-tête sont sensibles à la casse.
Selon la spécification HTTP/1.1, les noms d'en-tête ne sont pas sensibles à la casse, ce qui signifie que Content-Type, content-type et CONTENT-TYPE sont tous équivalents. Cependant, s'en tenir aux conventions de dénomination standard telles que Content-Type au lieu d'une casse alternative est une bonne pratique. La standardisation du format permet d'éviter toute confusion, en particulier lors de l'intégration d'API ou de systèmes tiers susceptibles d'interpréter les en-têtes différemment.
Lorsque les serveurs Web évaluent les requêtes, des détails subtils tels qu'une casse d'en-tête incohérente peuvent révéler la nature d'un client. De nombreux navigateurs et applications légitimes suivent des conventions de casse spécifiques, comme la majuscule Content-Type. Toutefois, les robots ou les scripts peuvent ne pas suivre ces conventions de manière uniforme. En analysant les requêtes avec une casse non conventionnelle, les serveurs peuvent signaler ou bloquer les robots potentiels.
En pratique, la bibliothèque de requêtes de Python gère automatiquement la normalisation de la casse pour les en-têtes lors de l'utilisation de fonctions telles que les en-têtes de définition de requêtes Python. Cela signifie que quelle que soit la façon dont vous écrivez le nom de l'en-tête, la bibliothèque le convertit dans un format standardisé, garantissant ainsi la compatibilité avec le serveur. Cependant, notez que même si les noms d'en-tête eux-mêmes ne sont pas sensibles à la casse, les valeurs d'en-tête (telles que « application/json » dans Content-Type) peuvent toujours être interprétées littéralement et doivent être formatées avec précision.
Dans la bibliothèque de requêtes de Python, vous pouvez définir des en-têtes dans tous les cas, et la bibliothèque les interprétera correctement :
headers = {'User-Agent': 'my-app/0.0.1'}
response = requests.get('https://httpbin.dev/headers', headers=headers)
print(response.json())
{
"headers": {
"Accept": ["*/*"],
"Accept-Encoding": ["gzip, deflate"],
"Host": ["httpbin.dev"],
"User-Agent": ["my-app/0.0.1"],
"X-Forwarded-For": ["45.242.24.152"],
"X-Forwarded-Host": ["httpbin.dev"],
"X-Forwarded-Port": ["443"],
"X-Forwarded-Proto": ["https"],
"X-Forwarded-Server": ["traefik-2kvlz"],
"X-Real-Ip": ["45.242.24.152"]
}}
Comme indiqué ci-dessus, les requêtes convertissent automatiquement le type de contenu en type de contenu standard. Cela démontre que la bibliothèque de requêtes de Python normalisera les noms d'en-tête pour vous, maintenant ainsi la compatibilité avec les serveurs Web quelle que soit la casse utilisée dans le code d'origine.
Dans la plupart des interactions API standard, l'ordre des en-têtes envoyés avec un appel d'en-têtes de requêtes Python n'affecte pas la fonctionnalité, car la spécification HTTP n'exige pas d'ordre spécifique pour les en-têtes. Cependant, lorsqu'il s'agit de systèmes avancés anti-bot et anti-scraping, l'ordre des en-têtes peut jouer un rôle étonnamment important pour déterminer si une demande est acceptée ou bloquée.
Les systèmes anti-bots, tels que Cloudflare, DataDome et PerimeterX, vont souvent au-delà de la simple vérification d'en-tête et analysent « l'empreinte digitale » d'une requête. Cela inclut l'ordre dans lequel les en-têtes sont envoyés. Les utilisateurs humains (via les navigateurs) envoient généralement les en-têtes dans un ordre cohérent. Par exemple, les requêtes du navigateur peuvent généralement suivre un ordre tel que User-Agent, Accept, Accept-Language, Referer, etc. En revanche, les bibliothèques d'automatisation ou les scrapers peuvent envoyer des en-têtes dans un ordre différent ou ajouter des en-têtes non standard, qui peuvent servir de signaux d'alarme pour les algorithmes de détection.
Exemple : en-têtes de navigateur et en-têtes de requêtes Python
Dans un navigateur, vous pouvez observer les en-têtes dans cet ordre :
import requests
response = requests.get('https://httpbin.dev')
print(response.headers)
{
"Access-Control-Allow-Credentials": "true",
"Access-Control-Allow-Origin": "*",
"Content-Security-Policy": "frame-ancestors 'self' *.httpbin.dev; font-src 'self' *.httpbin.dev; default-src 'self' *.httpbin.dev; img-src 'self' *.httpbin.dev https://cdn.scrapfly.io; media-src 'self' *.httpbin.dev; script-src 'self' 'unsafe-inline' 'unsafe-eval' *.httpbin.dev; style-src 'self' 'unsafe-inline' *.httpbin.dev https://unpkg.com; frame-src 'self' *.httpbin.dev; worker-src 'self' *.httpbin.dev; connect-src 'self' *.httpbin.dev",
"Content-Type": "text/html; charset=utf-8",
"Date": "Fri, 25 Oct 2024 14:14:02 GMT",
"Permissions-Policy": "fullscreen=(self), autoplay=*, geolocation=(), camera=()",
"Referrer-Policy": "strict-origin-when-cross-origin",
"Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
"X-Content-Type-Options": "nosniff",
"X-Xss-Protection": "1; mode=block",
"Transfer-Encoding": "chunked"
}
Avec la bibliothèque de requêtes de Python, les en-têtes peuvent être légèrement différents :
headers = {'User-Agent': 'my-app/0.0.1'}
response = requests.get('https://httpbin.dev/headers', headers=headers)
print(response.json())
{
"headers": {
"Accept": ["*/*"],
"Accept-Encoding": ["gzip, deflate"],
"Host": ["httpbin.dev"],
"User-Agent": ["my-app/0.0.1"],
"X-Forwarded-For": ["45.242.24.152"],
"X-Forwarded-Host": ["httpbin.dev"],
"X-Forwarded-Port": ["443"],
"X-Forwarded-Proto": ["https"],
"X-Forwarded-Server": ["traefik-2kvlz"],
"X-Real-Ip": ["45.242.24.152"]
}}
Cette légère différence dans l'ordre des en-têtes peut laisser entendre aux systèmes anti-bot que la requête pourrait être automatisée, surtout si elle est combinée avec d'autres signaux, tels que le format User-Agent ou des en-têtes manquants.
En analysant cet ordre, les systèmes de détection avancés peuvent identifier des modèles souvent associés à des scripts automatisés ou à des robots. Lorsqu'une requête ne correspond pas à l'ordre habituel, le serveur peut supposer qu'elle provient d'un bot, ce qui peut entraîner des requêtes bloquées ou des défis captcha.
Lors de la configuration des en-têtes de requêtes Python pour imiter les requêtes du navigateur, il est utile de savoir quels en-têtes sont standard dans la plupart des navigateurs Web. Ces en-têtes informent le serveur sur les capacités et les préférences du client, rendant la demande plus légitime.
Les en-têtes standard imitent le comportement du navigateur, augmentant ainsi le succès des requêtes. Les en-têtes clés incluent :
Pour garantir que les requêtes imitent de vrais navigateurs :
Outils de développement de navigateur :
Outils proxy :
Exemple : imiter les en-têtes en Python
import requests
response = requests.get('https://httpbin.dev')
print(response.headers)
{
"Access-Control-Allow-Credentials": "true",
"Access-Control-Allow-Origin": "*",
"Content-Security-Policy": "frame-ancestors 'self' *.httpbin.dev; font-src 'self' *.httpbin.dev; default-src 'self' *.httpbin.dev; img-src 'self' *.httpbin.dev https://cdn.scrapfly.io; media-src 'self' *.httpbin.dev; script-src 'self' 'unsafe-inline' 'unsafe-eval' *.httpbin.dev; style-src 'self' 'unsafe-inline' *.httpbin.dev https://unpkg.com; frame-src 'self' *.httpbin.dev; worker-src 'self' *.httpbin.dev; connect-src 'self' *.httpbin.dev",
"Content-Type": "text/html; charset=utf-8",
"Date": "Fri, 25 Oct 2024 14:14:02 GMT",
"Permissions-Policy": "fullscreen=(self), autoplay=*, geolocation=(), camera=()",
"Referrer-Policy": "strict-origin-when-cross-origin",
"Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
"X-Content-Type-Options": "nosniff",
"X-Xss-Protection": "1; mode=block",
"Transfer-Encoding": "chunked"
}
Cette requête utilise des en-têtes de type navigateur pour rendre l'interaction plus naturelle. En observant les en-têtes et l'ordre des en-têtes à partir des outils du navigateur, vous pouvez les personnaliser en Python pour rendre votre demande aussi proche que possible d'une requête réelle du navigateur.
La chaîne User-Agent joue un rôle crucial dans la façon dont les serveurs répondent aux requêtes. Il identifie l'application, le système d'exploitation et l'appareil à l'origine de la demande, permettant aux serveurs d'adapter leurs réponses en conséquence.
Les chaînes User-Agent sont généralement générées par le navigateur lui-même et peuvent varier en fonction de la version du navigateur, du système d'exploitation et même de la configuration matérielle.
Vous pouvez en savoir plus sur la façon d'utiliser efficacement les agents utilisateurs pour le Web Scraping dans notre article dédié :
(https://scrapfly.io/blog/user-agent-header-in-web-scraping/)
Lors de l'utilisation des en-têtes de requêtes Python avec des requêtes POST, les en-têtes jouent un rôle essentiel dans la façon dont le serveur interprète les données envoyées par le client. Les requêtes POST sont généralement utilisées pour envoyer des données à un serveur afin de créer, mettre à jour ou modifier des ressources, nécessitant souvent des en-têtes supplémentaires pour clarifier la structure, le format et l'objectif des données.
Content-Type : Indique le format de données, tel que application/json pour les données JSON, application/x-www-form-urlencoded pour les soumissions de formulaires ou multipart/form-data pour fichiers. En définissant cela correctement, vous garantissez que le serveur analyse vos données comme prévu.
User-Agent : Identifie l'application client, ce qui facilite l'accès à l'API et les politiques de limite de débit.
Autorisation : nécessaire aux points de terminaison sécurisés pour authentifier les demandes, souvent à l'aide de jetons ou d'informations d'identification.
Accepter : Spécifie le format de réponse souhaité (par exemple, application/json), facilitant une gestion cohérente des données et un traitement des erreurs.
Exemple d'utilisation des en-têtes pour les requêtes POST
Pour envoyer des données au format JSON, vous définissez généralement l'en-tête Content-Type sur application/json et transmettez les données au format JSON. Voici un exemple avec des requêtes Python en-têtes de publication pour envoyer une charge utile JSON :
headers = {'User-Agent': 'my-app/0.0.1'}
response = requests.get('https://httpbin.dev/headers', headers=headers)
print(response.json())
{
"headers": {
"Accept": ["*/*"],
"Accept-Encoding": ["gzip, deflate"],
"Host": ["httpbin.dev"],
"User-Agent": ["my-app/0.0.1"],
"X-Forwarded-For": ["45.242.24.152"],
"X-Forwarded-Host": ["httpbin.dev"],
"X-Forwarded-Port": ["443"],
"X-Forwarded-Proto": ["https"],
"X-Forwarded-Server": ["traefik-2kvlz"],
"X-Real-Ip": ["45.242.24.152"]
}}
L'utilisation des en-têtes de publication des requêtes Python de cette manière garantit que le serveur traite correctement vos données et peut empêcher le blocage de la requête.
Lorsqu'un serveur attend du trafic provenant d'utilisateurs réels, il peut vérifier certains en-têtes spécifiques au navigateur qui sont généralement envoyés uniquement par les navigateurs Web réels. Ces en-têtes permettent d'identifier et de différencier les navigateurs des scripts automatisés, ce qui est particulièrement important lors de la navigation dans les protections anti-bots sur certains sites. En configurant les en-têtes de requêtes Python pour imiter ces modèles spécifiques au navigateur, vous pouvez donner à vos requêtes une apparence plus humaine, augmentant souvent les chances de réussite des requêtes.
DNT (Do Not Track) : Informe le serveur de la préférence de suivi de l'utilisateur (1 signifie "ne pas suivre"), rendant la demande plus semblable à celle d'un navigateur.
Sec-Fetch-Site : affiche la relation d'origine, avec des valeurs telles que même origine, intersite et aucun, aidant à imiter le contexte de navigation authentique.
Sec-Fetch-Mode : définit l'objectif de la requête, tel que la navigation pour le chargement des pages, ce qui le rend utile pour reproduire le comportement typique du navigateur.
Sec-Fetch-Dest : Indique le type de contenu (document, image, script), utile pour imiter des demandes de ressources spécifiques.
Exemple d'en-têtes spécifiques au navigateur dans les requêtes Python :
Définissez des en-têtes spécifiques au navigateur lorsque vous effectuez des requêtes à l'aide de la bibliothèque de requêtes en Python.
import requests
response = requests.get('https://httpbin.dev')
print(response.headers)
{
"Access-Control-Allow-Credentials": "true",
"Access-Control-Allow-Origin": "*",
"Content-Security-Policy": "frame-ancestors 'self' *.httpbin.dev; font-src 'self' *.httpbin.dev; default-src 'self' *.httpbin.dev; img-src 'self' *.httpbin.dev https://cdn.scrapfly.io; media-src 'self' *.httpbin.dev; script-src 'self' 'unsafe-inline' 'unsafe-eval' *.httpbin.dev; style-src 'self' 'unsafe-inline' *.httpbin.dev https://unpkg.com; frame-src 'self' *.httpbin.dev; worker-src 'self' *.httpbin.dev; connect-src 'self' *.httpbin.dev",
"Content-Type": "text/html; charset=utf-8",
"Date": "Fri, 25 Oct 2024 14:14:02 GMT",
"Permissions-Policy": "fullscreen=(self), autoplay=*, geolocation=(), camera=()",
"Referrer-Policy": "strict-origin-when-cross-origin",
"Strict-Transport-Security": "max-age=31536000; includeSubDomains; preload",
"X-Content-Type-Options": "nosniff",
"X-Xss-Protection": "1; mode=block",
"Transfer-Encoding": "chunked"
}
En incluant ces en-têtes, vous pouvez rendre votre demande plus proche de celles généralement envoyées par les navigateurs, réduisant ainsi la probabilité d'être signalée comme un robot ou de rencontrer des restrictions d'accès.
Détection anti-bot : les en-têtes spécifiques au navigateur aident les requêtes à ressembler au trafic utilisateur normal, ce qui rend plus difficile pour les systèmes anti-bot de les signaler.
Compatibilité améliorée : Certains sites proposent des réponses différentes pour les requêtes de type navigateur, ce qui rend ces en-têtes utiles pour les sites qui restreignent le trafic non-navigateur.
Authenticité des demandes : imiter le comportement du navigateur avec ces en-têtes peut augmenter les taux de réussite des demandes en réduisant les risques de blocage.
Lorsque vous travaillez avec des en-têtes de requêtes Python, il est essentiel d'utiliser des en-têtes valides et correctement formatés. De nombreux serveurs surveillent activement les en-têtes entrants pour détecter les demandes inhabituelles ou incomplètes. Les requêtes avec des en-têtes invalides ou manquants (comme un User-Agent manquant, un Content-Type mal défini ou des en-têtes contradictoires) sont des signaux courants de trafic automatisé ou suspect et peuvent conduire à un blocage immédiat.
Par exemple, les en-têtes qui se contredisent, comme mélanger Accept : text/html avec Content-Type : application/json, peuvent amener le serveur à rejeter votre demande, car cette combinaison ne correspond pas au comportement typique du navigateur.
De plus, certains sites Web utilisent des outils anti-bots basés sur l'IA pour examiner les en-têtes et identifier les incohérences de type robot. Il est préférable de tester les en-têtes pour détecter les problèmes potentiels sur une plate-forme contrôlée.
Ces conseils pratiques pour définir les en-têtes, comme l'utilisation de User-Agent, faire correspondre le type de contenu et éviter les en-têtes excessifs, aident à réduire la détection et à minimiser le blocage des requêtes.
Prendre ces précautions lors de la définition des en-têtes peut améliorer considérablement le taux de réussite de vos demandes et vous aider à contourner efficacement les blocages potentiels.
Bien que les requêtes soient une puissante bibliothèque client HTTP, ce n'est pas un excellent outil de scraping car il est difficile à mettre à l'échelle et facile à identifier et à bloquer.
ScrapFly fournit des API de scraping Web, de capture d'écran et d'extraction pour la collecte de données à grande échelle.
Pour conclure ce guide, voici les réponses à quelques questions fréquemment posées sur les en-têtes de requêtes Python.
Les en-têtes transmettent des informations supplémentaires à chaque demande, telles que le type de données attendues, les informations sur le client et les détails de l'autorisation. Ils sont essentiels pour communiquer les préférences et garantir que les serveurs traitent correctement les demandes.
Les en-têtes peuvent aider à contourner la détection anti-bot, à authentifier les demandes et à garantir le format de données correct dans les réponses. La personnalisation des en-têtes pour qu'ils ressemblent à des requêtes réelles du navigateur est particulièrement utile pour récupérer et accéder aux API restreintes.
À l'aide des outils de développement de navigateur, vous pouvez inspecter les en-têtes envoyés avec chaque requête adressée à un site Web. Copier ces en-têtes dans vos requêtes Python peut aider votre requête à imiter le trafic du navigateur.
Travailler avec les en-têtes de requêtes Python est essentiel à la fois pour le web scraping et les interactions API. Comprendre comment définir, obtenir et manipuler les en-têtes peut vous aider à créer des requêtes plus efficaces et plus fiables. Que vous traitiez des requêtes GET ou POST, imitez les en-têtes du navigateur ou essayiez d'éviter la détection, la façon dont vous gérez les en-têtes peut faire ou défaire votre succès de scraping.
En suivant les meilleures pratiques, telles que l'utilisation d'en-têtes standard, la définition de valeurs appropriées pour les requêtes POST et la garantie de l'ordre des en-têtes, vos requêtes seront mieux équipées pour naviguer dans le paysage complexe des services Web modernes.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Introduction aux outils de détection SSL
Classement des plateformes de trading de cryptomonnaies
Comment supprimer des éléments de tableau en JavaScript
Pièces sous-évaluées à thésauriser en 2024
Comment utiliser la fonction dict en Python
Quel est le format du caj
Utilisation du contacteur AC
Quelle est la différence entre j2ee et springboot
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
