Skip to content

đŸ•·ïž 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

18.8 KB
Raw Blame

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. Utilisez True pour les suivre sans restriction, ou False pour 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→value ou 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 ProxyRotator pour changer automatiquement de proxy. Ne peut pas ĂȘtre combinĂ© avec proxy ou proxies.
  • 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/Response final.

!!! 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 OPTIONS et HEAD ne 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.