đ·ïž The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
title: "Web scraping HTTP en Python avec Fetcher et FetcherSession" description: "Envoyez des requĂȘtes HTTP synchrones ou asynchrones avec imitation de navigateur, cookies, proxies et sessions rĂ©utilisables. Extrayez les donnĂ©es des rĂ©ponses avec Scrapling."
RequĂȘtes HTTP {#http-requests}
Fetcher envoie des requĂȘtes HTTP rapides et lĂ©gĂšres grĂące Ă curl_cffi, une bibliothĂšque performante qui propose de nombreuses options pour Ă©viter la dĂ©tection.
!!! success "Avant de commencer"
1. Lisez [Les bases des fetchers](../fetching/choosing.md) pour comprendre lâ[objet Response](../fetching/choosing.md#response-object) et choisir un fetcher.
2. Lisez [Rechercher des éléments](../parsing/selection.md) pour savoir comment trouver et extraire des éléments de [Selector](../parsing/main_classes.md#selector)/[Response](../fetching/choosing.md#response-object).
3. Lisez [Classes principales](../parsing/main_classes.md) pour connaßtre les propriétés et méthodes de [Selector](../parsing/main_classes.md#selector) dont hérite [Response](../fetching/choosing.md#response-object).
Utilisation de base {#basic-usage}
La principale façon dâimporter ce fetcher est la mĂȘme que pour les autres :
from scrapling.fetchers import Fetcher
Consultez la configuration du parser ici.
Arguments communs {#shared-arguments}
Toutes les mĂ©thodes de requĂȘte partagent ces arguments :
- url : URL cible.
- stealthy_headers : gĂ©nĂšre et ajoute des en-tĂȘtes de navigateur rĂ©el, dont un referer Google. ActivĂ© par dĂ©faut.
- follow_redirects : contrÎle les redirections. La valeur par défaut est
"safe": suit les redirections, mais refuse celles vers des IP internes ou privĂ©es pour protĂ©ger contre le SSRF. UtilisezTruepour les suivre sans restriction, ouFalsepour les dĂ©sactiver. - timeout : dĂ©lai maximal en secondes pour terminer chaque requĂȘte. 30 secondes par dĂ©faut.
- retries : nombre maximal de tentatives lorsquâune requĂȘte Ă©choue, premiĂšre tentative comprise. 3 par dĂ©faut.
- retry_delay : secondes dâattente entre les tentatives. 1 seconde par dĂ©faut.
- impersonate : imite lâempreinte TLS dâun navigateur. Accepte une chaĂźne ou une liste, comme
"chrome110","firefox102"ou"safari15_5"pour des versions prĂ©cises. Utilisez"chrome","firefox","safari"ou"edge"pour la derniĂšre version disponible. Les requĂȘtes semblent ainsi venir dâun vrai navigateur au niveau TLS. Avec une liste, une option est choisie au hasard pour chaque requĂȘte. Par dĂ©faut, utilise la derniĂšre version de Chrome disponible. - http3 : utilise HTTP/3. False par dĂ©faut. Peut poser problĂšme avec
impersonate. - cookies : cookies de la requĂȘte. Accepte un dictionnaire
nameâvalueou une liste de dictionnaires. - proxy : proxy utilisĂ© pour acheminer tout le trafic HTTP et HTTPS de cette requĂȘte. Le format est
http://username:password@localhost:8030. - proxy_auth : authentification HTTP Basic du proxy, sous forme de tuple (nom dâutilisateur, mot de passe).
- proxies : dictionnaire de proxies au format
{"http": proxy_url, "https": proxy_url}. - proxy_rotator : objet
ProxyRotatorpour changer automatiquement de proxy. Ne peut pas ĂȘtre combinĂ© avecproxyouproxies. - headers : en-tĂȘtes de la requĂȘte. Ils peuvent remplacer ceux gĂ©nĂ©rĂ©s par
stealthy_headers. - max_redirects : nombre maximal de redirections. 30 par défaut. Utilisez -1 pour ne pas limiter.
- verify : indique si les certificats HTTPS doivent ĂȘtre vĂ©rifiĂ©s. True par dĂ©faut.
- cert : tuple des noms de fichiers (certificat, clé) pour le certificat client.
- selector_config : dictionnaire de rĂ©glages du parser pour crĂ©er lâobjet
Selector/Responsefinal.
!!! note "Notes"
1. Les navigateurs disponibles pour lâimitation sont (`"edge"`, `"chrome"`, `"chrome_android"`, `"safari"`, `"safari_beta"`, `"safari_ios"`, `"safari_ios_beta"`, `"firefox"`, `"tor"`).<br/>
2. Les navigateurs et leurs versions apparaissent dans lâautocomplĂ©tion de lâargument et sont actualisĂ©s Ă chaque mise Ă jour de `curl_cffi`.<br/>
3. Si `impersonate` ou `stealthy_headers` est activĂ©, les fetchers gĂ©nĂšrent des en-tĂȘtes rĂ©els correspondant Ă la version du navigateur utilisĂ©e.
Pour dâautres rĂ©glages, vous pouvez passer Ă chaque mĂ©thode les arguments acceptĂ©s par curl_cffi quâelle ne gĂšre pas dĂ©jĂ .
Encodage du texte {#text-encoding}
Si une page qui nâutilise pas UTF-8 affiche des caractĂšres incorrects, passez default_encoding="shift_jis", ou lâencodage rĂ©el de la page, avec la requĂȘte. Il sera utilisĂ© si lâen-tĂȘte Content-Type ne prĂ©cise pas dâencodage. Il ne remplace pas lâencodage fourni par le serveur.
Si le serveur indique un mauvais encodage, vous pouvez imposer le bon avec selector_config={"encoding": "shift_jis"}.
Méthodes HTTP {#http-methods}
Chaque méthode a ses propres arguments, comme params pour GET et data/json pour POST, PUT et DELETE.
Voici quelques exemples :
Les méthodes
OPTIONSetHEADne sont pas disponibles.
GET {#get}
from scrapling.fetchers import Fetcher
# Basic GET
page = Fetcher.get('https://example.com')
page = Fetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = Fetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
# With parameters
page = Fetcher.get('https://example.com/search', params={'q': 'query'})
# With headers
page = Fetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
# Basic HTTP authentication
page = Fetcher.get("https://example.com", auth=("my_user", "password123"))
# Browser impersonation
page = Fetcher.get('https://example.com', impersonate='chrome')
# HTTP/3 support
page = Fetcher.get('https://example.com', http3=True)
Pour les requĂȘtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic GET
page = await AsyncFetcher.get('https://example.com')
page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', stealthy_headers=True)
page = await AsyncFetcher.get('https://scrapling.requestcatcher.com/get', proxy='http://username:password@localhost:8030')
# With parameters
page = await AsyncFetcher.get('https://example.com/search', params={'q': 'query'})
# With headers
page = await AsyncFetcher.get('https://example.com', headers={'User-Agent': 'Custom/1.0'})
# Basic HTTP authentication
page = await AsyncFetcher.get("https://example.com", auth=("my_user", "password123"))
# Browser impersonation
page = await AsyncFetcher.get('https://example.com', impersonate='chrome110')
# HTTP/3 support
page = await AsyncFetcher.get('https://example.com', http3=True)
Dans tous les cas, page est un Response, qui est aussi un Selector. Vous pouvez lâutiliser directement :
page.css('.something.something')
page = Fetcher.get('https://api.github.com/events')
>>> page.json()
[{'id': '<redacted>',
'type': 'PushEvent',
'actor': {'id': '<redacted>',
'login': '<redacted>',
'display_login': '<redacted>',
'gravatar_id': '',
'url': 'https://api.github.com/users/<redacted>',
'avatar_url': 'https://avatars.githubusercontent.com/u/<redacted>'},
'repo': {'id': '<redacted>',
...
POST {#post}
from scrapling.fetchers import Fetcher
# Basic POST
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, params={'q': 'query'})
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
page = Fetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
# Another example of form-encoded data
page = Fetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
# JSON data
page = Fetcher.post('https://example.com/api', json={'key': 'value'})
Pour les requĂȘtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic POST
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, stealthy_headers=True)
page = await AsyncFetcher.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'}, proxy='http://username:password@localhost:8030', impersonate="chrome")
# Another example of form-encoded data
page = await AsyncFetcher.post('https://example.com/submit', data={'username': 'user', 'password': 'pass'}, http3=True)
# JSON data
page = await AsyncFetcher.post('https://example.com/api', json={'key': 'value'})
PUT {#put}
from scrapling.fetchers import Fetcher
# Basic PUT
page = Fetcher.put('https://example.com/update', data={'status': 'updated'})
page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
page = Fetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
# Another example of form-encoded data
page = Fetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
Pour les requĂȘtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
# Basic PUT
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'})
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, stealthy_headers=True, impersonate="chrome")
page = await AsyncFetcher.put('https://example.com/update', data={'status': 'updated'}, proxy='http://username:password@localhost:8030')
# Another example of form-encoded data
page = await AsyncFetcher.put("https://scrapling.requestcatcher.com/put", data={'key': ['value1', 'value2']})
DELETE {#delete}
from scrapling.fetchers import Fetcher
page = Fetcher.delete('https://example.com/resource/123')
page = Fetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
page = Fetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
Pour les requĂȘtes asynchrones, un petit ajustement suffit :
from scrapling.fetchers import AsyncFetcher
page = await AsyncFetcher.delete('https://example.com/resource/123')
page = await AsyncFetcher.delete('https://example.com/resource/123', stealthy_headers=True, impersonate="chrome")
page = await AsyncFetcher.delete('https://example.com/resource/123', proxy='http://username:password@localhost:8030')
Gestion des sessions {#session-management}
Utilisez FetcherSession pour envoyer plusieurs requĂȘtes avec la mĂȘme configuration. Elle fonctionne en code synchrone et asynchrone : elle dĂ©tecte le mode utilisĂ© et adapte la session sans nĂ©cessiter une autre importation.
FetcherSession accepte presque tous les arguments des mĂ©thodes de requĂȘte. Vous pouvez dĂ©finir des rĂ©glages pour toute la session, puis les modifier pour une requĂȘte prĂ©cise, comme dans les exemples suivants.
from scrapling.fetchers import FetcherSession
# Create a session with default configuration
with FetcherSession(
impersonate='chrome',
http3=True,
stealthy_headers=True,
timeout=30,
retries=3
) as session:
# Make multiple requests with the same settings and the same cookies
page1 = session.get('https://scrapling.requestcatcher.com/get')
page2 = session.post('https://scrapling.requestcatcher.com/post', data={'key': 'value'})
page3 = session.get('https://api.github.com/events')
# All requests share the same session and connection pool
Vous pouvez aussi utiliser ProxyRotator avec FetcherSession pour changer automatiquement de proxy entre les requĂȘtes :
from scrapling.fetchers import FetcherSession, ProxyRotator
rotator = ProxyRotator([
'http://proxy1:8080',
'http://proxy2:8080',
'http://proxy3:8080',
])
with FetcherSession(proxy_rotator=rotator, impersonate='chrome') as session:
# Each request automatically uses the next proxy in rotation
page1 = session.get('https://example.com/page1')
page2 = session.get('https://example.com/page2')
# You can check which proxy was used via the response metadata
print(page1.meta['proxy'])
Pour une requĂȘte prĂ©cise, remplacez le proxy ou le rotateur de la session en passant proxy= Ă la mĂ©thode :
with FetcherSession(proxy='http://default-proxy:8080') as session:
# Uses the session proxy
page1 = session.get('https://example.com/page1')
# Override the proxy for this specific request
page2 = session.get('https://example.com/page2', proxy='http://special-proxy:9090')
Un exemple asynchrone :
async with FetcherSession(impersonate='firefox', http3=True) as session:
# All standard HTTP methods available
response = await session.get('https://example.com')
response = await session.post('https://scrapling.requestcatcher.com/post', json={'data': 'value'})
response = await session.put('https://scrapling.requestcatcher.com/put', data={'update': 'info'})
response = await session.delete('https://scrapling.requestcatcher.com/delete')
Ou, mieux encore :
import asyncio
from scrapling.fetchers import FetcherSession
# Async session usage
async with FetcherSession(impersonate="safari") as session:
urls = ['https://example.com/page1', 'https://example.com/page2']
tasks = [
session.get(url) for url in urls
]
pages = await asyncio.gather(*tasks)
Fetcher utilise FetcherSession pour crĂ©er une session temporaire Ă chaque requĂȘte.
Avantages des sessions {#session-benefits}
- Plus rapides : 10 fois plus rapides que la crĂ©ation dâune session par requĂȘte.
- Cookies persistants : gestion automatique des cookies entre les requĂȘtes.
- Moins de ressources : meilleure utilisation de la mĂ©moire et du processeur pour plusieurs requĂȘtes.
- Configuration centralisée : un seul endroit pour gérer les réglages.
Exemples {#examples}
Des exemples complets pour débuter en web scraping.
RequĂȘte HTTP simple {#basic-http-request}
from scrapling.fetchers import Fetcher
# Make a request
page = Fetcher.get('https://example.com')
# Check the status
if page.status == 200:
# Extract title
title = page.css('title::text').get()
print(f"Page title: {title}")
# Extract all links
links = page.css('a::attr(href)').getall()
print(f"Found {len(links)} links")
Extraire des produits {#product-scraping}
from scrapling.fetchers import Fetcher
def scrape_products():
page = Fetcher.get('https://example.com/products')
# Find all product elements
products = page.css('.product')
results = []
for product in products:
results.append({
'title': product.css('.title::text').get(),
'price': product.css('.price::text').re_first(r'\d+\.\d{2}'),
'description': product.css('.description::text').get(),
'in_stock': product.has_class('in-stock')
})
return results
Télécharger des fichiers {#downloading-files}
from scrapling.fetchers import Fetcher
page = Fetcher.get('https://raw.githubusercontent.com/D4Vinci/Scrapling/main/docs/assets/main_cover.png')
with open(file='main_cover.png', mode='wb') as f:
f.write(page.body)
Parcourir les pages de résultats {#pagination-handling}
from scrapling.fetchers import Fetcher
def scrape_all_pages():
base_url = 'https://example.com/products?page={}'
page_num = 1
all_products = []
while True:
# Get current page
page = Fetcher.get(base_url.format(page_num))
# Find products
products = page.css('.product')
if not products:
break
# Process products
for product in products:
all_products.append({
'name': product.css('.name::text').get(),
'price': product.css('.price::text').get()
})
# Next page
page_num += 1
return all_products
Envoyer des formulaires {#form-submission}
from scrapling.fetchers import Fetcher
# Submit login form
response = Fetcher.post(
'https://example.com/login',
data={
'username': '[email protected]',
'password': 'password123'
}
)
# Check login success
if response.status == 200:
# Extract user info
user_name = response.css('.user-name::text').get()
print(f"Logged in as: {user_name}")
Extraire des tableaux {#table-extraction}
from scrapling.fetchers import Fetcher
def extract_table():
page = Fetcher.get('https://example.com/data')
# Find table
table = page.css('table')[0]
# Extract headers
headers = [
th.text for th in table.css('thead th')
]
# Extract rows
rows = []
for row in table.css('tbody tr'):
cells = [td.text for td in row.css('td')]
rows.append(dict(zip(headers, cells)))
return rows
Menu de navigation {#navigation-menu}
from scrapling.fetchers import Fetcher
def extract_menu():
page = Fetcher.get('https://example.com')
# Find navigation
nav = page.css('nav')[0]
menu = {}
for item in nav.css('li'):
links = item.css('a')
if links:
link = links[0]
menu[link.text] = {
'url': link['href'],
'has_submenu': bool(item.css('.submenu'))
}
return menu
Quand utiliser chaque option {#when-to-use}
Utilisez Fetcher si vous :
- Avez besoin de requĂȘtes HTTP rapides.
- Voulez limiter lâutilisation des ressources.
- Nâavez pas besoin dâexĂ©cuter JavaScript, car les donnĂ©es sont accessibles par requĂȘtes HTTP.
- Avez besoin dâĂ©viter certaines dĂ©tections, par exemple si le site est protĂ©gĂ© mais nâutilise pas de dĂ©fis JavaScript.
Utilisez FetcherSession si vous :
- Envoyez plusieurs requĂȘtes au mĂȘme site ou Ă des sites diffĂ©rents.
- Devez conserver des cookies ou une authentification entre les requĂȘtes.
- Voulez réutiliser les connexions pour améliorer les performances.
- Devez garder les mĂȘmes rĂ©glages entre les requĂȘtes.
- Travaillez avec des API qui nécessitent un état de session.
Utilisez dâautres fetchers si vous :
- Devez automatiser un navigateur.
- Avez besoin dâoptions avancĂ©es pour Ă©viter la dĂ©tection de bots.
- Devez exécuter JavaScript ou interagir avec du contenu dynamique.