Comment extraire des sites d'actualités sans blocages : configuration de proxy et contournement de la protection

Les sites d'actualités sont parmi les ressources les plus protégées sur Internet. Cloudflare, limitation de taux, blocages par IP — tout cela rend le scraping des nouvelles un véritable défi technique. Dans ce guide, nous allons examiner comment configurer correctement un proxy pour une collecte de données stable à partir de portails d'actualités, quel type de proxy choisir pour différentes tâches et comment contourner les systèmes de protection modernes.

Pourquoi les sites d'actualités bloquent les scrapers

Les portails d'actualités sont particulièrement sensibles à la collecte automatique de données pour plusieurs raisons. Tout d'abord, le contenu est leur principal actif, qu'ils monétisent par la publicité et les abonnements. Le scraping massif permet aux concurrents de copier des matériaux et réduit le trafic unique. Deuxièmement, une forte charge provenant des bots augmente les coûts des serveurs et des CDN.

Les sites d'actualités modernes utilisent une protection à plusieurs niveaux :

• Cloudflare et similaires — vérifient JavaScript, les empreintes TLS des navigateurs, les modèles de comportement
• Limitation de taux — limitent le nombre de requêtes d'une seule IP (généralement 10-50 requêtes par minute)
• Blocage par User-Agent — bloquent les en-têtes standards des bibliothèques (Python-requests, curl)
• CAPTCHA — affichés lors d'une activité suspecte
• Géoblocages — certains portails d'actualités ne sont accessibles que depuis certains pays

Les signes typiques par lesquels les sites d'actualités détectent les scrapers : une même IP effectue de nombreuses requêtes consécutives, absence de JavaScript, ordre non standard des en-têtes HTTP, vitesse de requêtes trop rapide (un humain ne peut pas ouvrir 10 pages par seconde), absence de cookies et de referrer.

Quel type de proxy choisir pour le scraping des nouvelles

Le choix du type de proxy dépend de l'échelle de la tâche, du budget et du niveau de protection des sites cibles. Examinons trois options principales et leur applicabilité pour le scraping des nouvelles.

Proxies de centre de données pour le scraping des nouvelles

Conviennent pour le scraping de sites d'actualités sans protection sérieuse : publications régionales, blogs, petits portails d'information. Avantages : vitesse élevée (importante lors du scraping de centaines de sources), coût faible (il est possible de louer un pool de 50-100 IP), connexion stable.

Inconvénients : facilement détectables par ASN (appartenance à un centre de données), souvent déjà blacklistés par de grands sites, ne passent pas le défi Cloudflare dans 70 % des cas. Utilisez des proxies de centre de données pour le scraping massif des flux RSS, sitemap.xml, points de terminaison API ou pour la collecte de métadonnées (titres, dates de publication) sans télécharger le contenu complet.

Proxies résidentiels — la norme d'or

Les proxies résidentiels sont des adresses IP d'utilisateurs domestiques réels, fournies par des fournisseurs d'accès Internet. Pour les sites d'actualités, ils apparaissent comme des visiteurs ordinaires, ce qui est crucial lors du travail avec des ressources protégées.

Quand les proxies résidentiels sont indispensables : scraping de grands portails d'actualités (CNN, BBC, Reuters, RBC, Kommersant), sites derrière Cloudflare ou une protection similaire, collecte de données de certains pays (géotargeting), sessions longues avec authentification. Les proxies résidentiels passent les vérifications JavaScript de Cloudflare, ont une réputation IP propre, prennent en charge les sessions collantes (fixation IP pendant 10-30 minutes).

Conseil pratique : utilisez des proxies résidentiels avec rotation par temps (sessions collantes), plutôt que par requêtes. Par exemple, une IP fonctionne pendant 10 minutes, collecte 20-30 articles, puis change. Cela semble plus naturel que de changer d'IP à chaque requête.

Proxies mobiles pour des cas particuliers

Les proxies mobiles utilisent des IP d'opérateurs mobiles (MTS, Beeline, Tele2). Ils ont la confiance maximale, car des millions de personnes utilisent Internet mobile pour lire des nouvelles. Utilisez-les pour le scraping des versions mobiles des sites d'actualités (qui ont souvent une protection simplifiée), des sites avec une protection extrêmement stricte, des pages AMP de Google News.

Particularité des proxies mobiles : l'IP change souvent automatiquement (les opérateurs mobiles utilisent CGNAT), une seule IP peut être partagée par des centaines d'utilisateurs simultanément, ce qui rend le blocage inutile. Inconvénient — prix élevé, donc utilisez-les de manière ciblée, uniquement pour les objectifs les plus protégés.

Contourner Cloudflare et d'autres systèmes anti-bot

Cloudflare est le principal ennemi des scrapers de sites d'actualités. Environ 40 % des grands portails d'actualités utilisent Cloudflare pour se protéger contre les bots. Les bibliothèques standard (requests, urllib) ne passent pas la vérification, car Cloudflare analyse l'empreinte TLS, l'exécution de JavaScript, l'ordre des en-têtes HTTP, les modèles de comportement.

Stratégies pour contourner Cloudflare

1. Navigateurs sans tête (Selenium, Playwright, Puppeteer)

Émulent un véritable navigateur avec exécution de JavaScript. Cloudflare voit une empreinte TLS correcte de Chrome/Firefox et laisse passer la requête. Inconvénients : lent (2-5 secondes par page), nécessite beaucoup de ressources (RAM, CPU).

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Configuration du proxy pour Selenium
chrome_options = Options()
chrome_options.add_argument('--proxy-server=http://username:password@proxy.example.com:8080')
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-blink-features=AutomationControlled')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://news-site.com/article')

# Attendre le chargement de JavaScript
driver.implicitly_wait(10)
html = driver.page_source
driver.quit()

2. Bibliothèques avec empreinte TLS (curl_cffi, tls-client)

Imite l'empreinte TLS d'un véritable navigateur sans exécuter de navigateur sans tête. Fonctionnent 10 à 20 fois plus vite que Selenium, mais n'exécutent pas JavaScript. Conviennent pour les sites avec une vérification de base de Cloudflare (sans défi JS).

from curl_cffi import requests

proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

response = requests.get(
    'https://news-site.com/article',
    proxies=proxies,
    impersonate='chrome110'  # Imiter l'empreinte TLS de Chrome 110
)

print(response.text)

3. Services de contournement de Cloudflare (scraperapi, scrapingbee)

API payantes qui contournent automatiquement Cloudflare. Vous envoyez l'URL, ils renvoient le HTML prêt. Avantages : pas besoin de se soucier des détails techniques, rotation automatique des proxies, traitement des CAPTCHA. Inconvénients : coûteux pour de gros volumes (à partir de 50 $/mois pour 100K requêtes).

En-têtes HTTP corrects

Même avec des proxies, il est important d'envoyer des en-têtes corrects, sinon le site détectera le bot par un User-Agent non standard ou l'absence d'Accept-Language.

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Accept-Language': 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7',
    'Accept-Encoding': 'gzip, deflate, br',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1',
    'Sec-Fetch-Dest': 'document',
    'Sec-Fetch-Mode': 'navigate',
    'Sec-Fetch-Site': 'none',
    'Cache-Control': 'max-age=0'
}

Mettez périodiquement à jour le User-Agent — utilisez les versions actuelles des navigateurs. Vous pouvez vérifier votre empreinte sur des sites comme whoer.net ou browserleaks.com.

Configuration de la rotation IP et gestion des requêtes

Une bonne rotation des proxies est la clé d'un scraping stable sans blocages. Les sites d'actualités suivent la fréquence des requêtes d'une seule IP, et dépasser la limite entraîne un bannissement temporaire ou permanent.

Types de rotation des proxies

Rotation par requêtes — chaque requête passe par une nouvelle IP. Convient pour le scraping rapide d'un grand nombre de sites différents, minimise le risque de bannissement par fréquence de requêtes. Inconvénients : ne convient pas pour les sites avec des sessions (cookies, authentification), peut sembler suspect pour certaines protections.

Rotation par temps (sessions collantes) — une IP est utilisée pendant un temps fixe (5-30 minutes), puis change. Convient pour le scraping d'un seul portail d'actualités avec de nombreuses pages, conserve les cookies et les sessions, ressemble au comportement d'un utilisateur réel. Recommandé pour la plupart des tâches de scraping d'actualités.

Rotation par géolocalisation — changement d'IP provenant de différents pays/villes. Utilisé pour le scraping de contenu géodépendant (nouvelles régionales), contournement des géoblocages.

Fréquence optimale des requêtes

Même avec une rotation des proxies, il ne faut pas faire des requêtes trop fréquemment. Intervalles sûrs pour différents types de sites :

• Grands portails d'actualités (RBC, Kommersant, Vedomosti) — 2-5 secondes entre les requêtes d'une seule IP
• Sites moyens — 1-3 secondes
• Petits blogs et publications régionales — 0.5-1 seconde

Ajoutez des délais aléatoires (randomization) pour que le modèle de requêtes semble naturel :

import time
import random

def fetch_article(url, proxies):
    response = requests.get(url, proxies=proxies, headers=headers)
    
    # Délai aléatoire de 2 à 5 secondes
    delay = random.uniform(2, 5)
    time.sleep(delay)
    
    return response.text

Exemple de rotation de proxies d'un pool

Si vous avez une liste de proxies, vous pouvez réaliser une simple rotation manuellement :

import itertools
import requests

# Pool de proxies
proxy_list = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

# Créer un itérateur infini
proxy_pool = itertools.cycle(proxy_list)

def get_next_proxy():
    proxy = next(proxy_pool)
    return {'http': proxy, 'https': proxy}

# Utilisation
urls = ['https://news1.com/article', 'https://news2.com/article']

for url in urls:
    proxies = get_next_proxy()
    response = requests.get(url, proxies=proxies, headers=headers)
    print(f'Fetched {url} via {proxies["http"]}')

Exemples de code : Python + Scrapy + proxy

Scrapy est un framework professionnel pour le scraping qui prend en charge nativement les proxies, le middleware, la rotation et le traitement des erreurs. Examinons un exemple complet d'un scraper de site d'actualités avec rotation de proxy.

Installation des dépendances

pip install scrapy scrapy-rotating-proxies

Configuration de Scrapy avec proxy (settings.py)

# settings.py

# Activer le middleware pour la rotation des proxies
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

DOWNLOADER_MIDDLEWARES = {
    'rotating_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_proxies.middlewares.BanDetectionMiddleware': 620,
}

# Paramètres pour contourner les blocages
CONCURRENT_REQUESTS = 8  # Pas plus de 8 requêtes simultanées
DOWNLOAD_DELAY = 2  # Délai de 2 secondes entre les requêtes
RANDOMIZE_DOWNLOAD_DELAY = True  # Délai aléatoire

# User-Agent
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'

# Tentatives de répétition en cas d'erreurs
RETRY_TIMES = 3
RETRY_HTTP_CODES = [500, 502, 503, 504, 408, 429]

Spider pour le scraping des nouvelles

# news_spider.py

import scrapy
from datetime import datetime

class NewsSpider(scrapy.Spider):
    name = 'news_parser'
    
    # Liste des sites d'actualités à scraper
    start_urls = [
        'https://example-news.com/latest',
    ]
    
    def parse(self, response):
        # Scraper la liste des articles sur la page d'accueil
        articles = response.css('article.news-item')
        
        for article in articles:
            article_url = article.css('a.title::attr(href)').get()
            
            if article_url:
                # Aller à la page de l'article
                yield response.follow(article_url, callback=self.parse_article)
    
    def parse_article(self, response):
        # Extraire les données de l'article
        yield {
            'url': response.url,
            'title': response.css('h1.article-title::text').get(),
            'date': response.css('time.published::attr(datetime)').get(),
            'author': response.css('span.author::text').get(),
            'text': ' '.join(response.css('div.article-body p::text').getall()),
            'tags': response.css('a.tag::text').getall(),
            'scraped_at': datetime.now().isoformat(),
        }

Lancer le scraper

# Sauvegarde en JSON
scrapy crawl news_parser -o news_data.json

# Sauvegarde en CSV
scrapy crawl news_parser -o news_data.csv

Scraper simple avec requests + BeautifulSoup

Si une logique complexe n'est pas nécessaire, vous pouvez utiliser la combinaison requests + BeautifulSoup :

import requests
from bs4 import BeautifulSoup
import time
import random

# Configuration du proxy
proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

def parse_news_article(url):
    try:
        response = requests.get(url, proxies=proxies, headers=headers, timeout=10)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # Extraction des données (les sélecteurs dépendent du site)
        title = soup.find('h1', class_='article-title').text.strip()
        date = soup.find('time', class_='published')['datetime']
        text = ' '.join([p.text for p in soup.find_all('p', class_='article-text')])
        
        return {
            'url': url,
            'title': title,
            'date': date,
            'text': text
        }
    
    except Exception as e:
        print(f'Erreur lors du scraping de {url}: {e}')
        return None

# Scraping de la liste des articles
urls = [
    'https://news-site.com/article-1',
    'https://news-site.com/article-2',
]

for url in urls:
    article_data = parse_news_article(url)
    if article_data:
        print(article_data)
    
    # Délai entre les requêtes
    time.sleep(random.uniform(2, 4))

Erreurs courantes lors du scraping des nouvelles

Même avec une configuration correcte des proxies, les scrapers reçoivent souvent des blocages en raison d'erreurs techniques. Examinons les problèmes les plus fréquents et leurs solutions.

Erreur 1 : Fréquence de requêtes trop élevée

Symptômes : HTTP 429 (Trop de requêtes), bannissements temporaires d'IP, CAPTCHA. Cause : le scraper effectue 10-50 requêtes par seconde à partir d'une seule IP. Solution : ajoutez des délais (time.sleep()), utilisez DOWNLOAD_DELAY dans Scrapy, limitez CONCURRENT_REQUESTS.

Erreur 2 : Utilisation d'un seul proxy pour toutes les requêtes

Symptômes : le proxy est rapidement banni, même avec des délais. Cause : une seule IP effectue des centaines de requêtes sur un même site. Solution : utilisez un pool de proxies avec rotation, pour les grands sites — au moins 10-20 proxies, pour les sessions collantes changez d'IP toutes les 10-15 minutes.

Erreur 3 : Ignorer les cookies

De nombreux sites d'actualités définissent des cookies lors de la première visite et vérifient leur présence lors des requêtes suivantes. L'absence de cookies est un signe de bot. Solution : utilisez requests.Session() pour sauvegarder automatiquement les cookies, dans Scrapy activez COOKIES_ENABLED = True.

import requests

session = requests.Session()
session.proxies = {'http': 'http://proxy.com:8080', 'https': 'http://proxy.com:8080'}

# Première requête — obtenir les cookies
response1 = session.get('https://news-site.com')

# Les requêtes suivantes envoient automatiquement les cookies
response2 = session.get('https://news-site.com/article')

Erreur 4 : Mauvaise gestion des redirections

Les sites d'actualités utilisent souvent des redirections (301, 302) pour les versions mobiles, les sous-domaines régionaux, les pages AMP. Si le scraper ne suit pas les redirections, il obtient une page vide. Solution : dans requests, c'est activé par défaut (allow_redirects=True), vérifiez l'URL finale via response.url.

Erreur 5 : Scraping de contenu dynamique sans JavaScript

De nombreux sites d'actualités modernes chargent le contenu via JavaScript (React, Vue). La bibliothèque requests obtient un squelette HTML vide sans articles. Solution : utilisez Selenium/Playwright pour exécuter JavaScript, vérifiez le réseau dans DevTools — il se peut que les données soient chargées via une API (vous pouvez scraper directement le JSON).

Mise à l'échelle : scraping de centaines de sources

Lorsque vous devez scraper non pas un seul site d'actualités, mais des centaines de sources simultanément (agrégateurs d'actualités, surveillance des médias), une architecture évolutive est nécessaire.

Scraping distribué avec Scrapy Cloud

Scrapy Cloud (des créateurs de Scrapy) permet de lancer des scrapers dans le cloud avec une mise à l'échelle automatique. Avantages : pas besoin de serveurs propres, rotation automatique des proxies, surveillance et journaux. Coût : à partir de 9 $/mois pour le plan de base.

Queues de tâches (Celery + Redis)

Pour un déploiement autonome, utilisez Celery — un système de tâches distribuées. Architecture : Redis stocke la file d'attente des URL à scraper, plusieurs workers (serveurs) prennent des tâches dans la file d'attente et scrappent en parallèle, chaque worker utilise son propre pool de proxies.

# tasks.py

from celery import Celery
import requests

app = Celery('news_parser', broker='redis://localhost:6379/0')

@app.task
def parse_article(url, proxy):
    proxies = {'http': proxy, 'https': proxy}
    response = requests.get(url, proxies=proxies, timeout=10)
    # Scraping et sauvegarde des données
    return response.text

# Ajout de tâches dans la file d'attente
urls = ['https://news1.com/article', 'https://news2.com/article']
proxies = ['http://proxy1.com:8080', 'http://proxy2.com:8080']

for url in urls:
    proxy = random.choice(proxies)
    parse_article.delay(url, proxy)  # Exécution asynchrone

Surveillance et gestion des erreurs

Lors du scraping à grande échelle, la surveillance est cruciale : combien d'URL ont été traitées, combien d'erreurs, quels proxies ont été bannis. Utilisez Sentry pour suivre les erreurs Python, Grafana + Prometheus pour les métriques (requêtes par seconde, temps de réponse), journalisation dans ELK Stack (Elasticsearch, Logstash, Kibana).

Optimisation des coûts des proxies

Lors du scraping de centaines de sources, les coûts des proxies peuvent atteindre des milliers de dollars par mois. Stratégies d'optimisation : utilisez des proxies de centre de données pour des sites simples (RSS, API), des proxies résidentiels uniquement pour des sites protégés, mettez en cache les données — ne scrapez pas le même article deux fois, scrapez aux heures creuses (la nuit, la charge sur les sites est plus faible, moins de risque de bannissement).

Exemple : pour scraper 500 sites d'actualités, vous pouvez utiliser 80 % de proxies de centre de données (pour RSS et sites simples) et 20 % de proxies résidentiels (pour les 100 portails protégés). Cela réduira les coûts de 3 à 5 fois.

Conclusion

Le scraping des sites d'actualités est une tâche techniquement complexe qui nécessite un choix approprié de proxies, une configuration de rotation et un contournement des systèmes anti-bot. Les principales conclusions de l'article : pour les portails d'actualités protégés (Cloudflare, limitation de taux stricte), utilisez des proxies résidentiels avec des sessions collantes, pour le scraping massif de centaines de sources, les proxies de centre de données avec une rotation rapide conviennent, ajoutez toujours des délais entre les requêtes (2-5 secondes) et des en-têtes HTTP corrects, pour contourner Cloudflare, utilisez des navigateurs sans tête (Selenium, Playwright) ou des bibliothèques avec empreinte TLS.

Lors de la mise à l'échelle, utilisez des systèmes distribués (Celery, Scrapy Cloud) et surveillez les erreurs. N'oubliez pas que le scraping doit être éthique — respectez le robots.txt, ne créez pas de charge excessive sur les serveurs et respectez les droits d'auteur sur le contenu.

Si vous prévoyez de scraper de grands portails d'actualités avec une protection Cloudflare, nous vous recommandons d'utiliser des proxies résidentiels — ils offrent un niveau de confiance élevé et un risque minimal de blocages. Pour des tâches où la vitesse et le volume de données sont importants (scraping RSS, points de terminaison API), des proxies de centre de données conviendront.