So parsen Sie Nachrichtenwebsites ohne Sperren: Proxy-Einstellungen und Umgehung von Schutzmaßnahmen

Nachrichtenwebsites gehören zu den am besten geschützten Ressourcen im Internet. Cloudflare, Ratenbegrenzung, IP-Sperren – all dies macht das Parsen von Nachrichten zu einer ernsthaften technischen Herausforderung. In diesem Leitfaden werden wir untersuchen, wie man Proxys richtig einrichtet, um Daten stabil von Nachrichtenportalen zu sammeln, welchen Proxytyp man für verschiedene Aufgaben wählen sollte und wie man moderne Schutzsysteme umgeht.

Warum Nachrichtenwebsites Parser blockieren

Nachrichtenportale sind aus mehreren Gründen besonders empfindlich gegenüber automatisierter Datensammlung. Erstens ist der Inhalt ihr Hauptvermögen, das sie durch Werbung und Abonnements monetarisieren. Massives Parsen ermöglicht es Wettbewerbern, Materialien zu kopieren und verringert die einzigartige Besucherzahl. Zweitens erhöht die hohe Last durch Bots die Kosten für Server und CDN.

Moderne Nachrichtenwebsites verwenden mehrschichtige Schutzmaßnahmen:

• Cloudflare und ähnliche Dienste – überprüfen JavaScript, TLS-Fingerabdrücke des Browsers, Verhaltensmuster
• Ratenbegrenzung – begrenzen die Anzahl der Anfragen von einer IP (normalerweise 10-50 Anfragen pro Minute)
• Blockierung nach User-Agent – sperren Standard-Header von Bibliotheken (Python-requests, curl)
• CAPTCHA – werden bei verdächtiger Aktivität angezeigt
• Geoblockierungen – einige Nachrichtenportale sind nur aus bestimmten Ländern zugänglich

Typische Anzeichen, anhand derer Nachrichtenwebsites Parser erkennen: dieselbe IP sendet viele Anfragen hintereinander, kein JavaScript, nicht standardmäßige Reihenfolge der HTTP-Header, zu schnelle Anfragespeed (ein Mensch kann nicht 10 Seiten pro Sekunde öffnen), keine Cookies und Referrer.

Welchen Proxytyp wählen für das Parsen von Nachrichten

Die Wahl des Proxytyps hängt vom Umfang der Aufgabe, dem Budget und dem Schutzgrad der Zielwebsites ab. Lassen Sie uns drei Hauptoptionen und deren Anwendbarkeit für das Parsen von Nachrichten betrachten.

Rechenzentrums-Proxys für das Parsen von Nachrichten

Eignen sich für das Parsen von Nachrichtenwebsites ohne ernsthaften Schutz: regionale Publikationen, Blogs, kleine Informationsportale. Vorteile: hohe Geschwindigkeit (wichtig beim Parsen von Hunderten von Quellen), niedrige Kosten (man kann einen Pool von 50-100 IPs mieten), stabile Verbindung.

Nachteile: leicht erkennbar durch ASN (Zugehörigkeit zu einem Rechenzentrum), oft bereits auf die schwarzen Listen großer Websites gesetzt, bestehen in 70% der Fälle nicht den Cloudflare Challenge. Verwenden Sie Rechenzentrums-Proxys für das massenhafte Parsen von RSS-Feeds, sitemap.xml, API-Endpunkten oder zum Sammeln von Metadaten (Überschriften, Veröffentlichungsdaten) ohne vollständigen Inhalt herunterzuladen.

Residential Proxys – der Goldstandard

Residential Proxys sind IP-Adressen realer Haushaltsnutzer, die von Internetanbietern bereitgestellt werden. Für Nachrichtenwebsites erscheinen sie wie gewöhnliche Besucher, was bei der Arbeit mit geschützten Ressourcen entscheidend ist.

Wann Residential Proxys erforderlich sind: Parsen großer Nachrichtenportale (CNN, BBC, Reuters, RBK, Kommersant), Websites hinter Cloudflare oder ähnlichem Schutz, Datensammlung aus bestimmten Ländern (Geotargeting), längere Sitzungen mit Authentifizierung. Residential Proxys bestehen die JavaScript-Überprüfungen von Cloudflare, haben einen sauberen IP-Ruf und unterstützen Sticky Sessions (Fixierung der IP für 10-30 Minuten).

Praktischer Tipp: Verwenden Sie Residential Proxys mit zeitlicher Rotation (Sticky Sessions) und nicht nach Anfragen. Zum Beispiel funktioniert eine IP 10 Minuten, sammelt 20-30 Artikel und wechselt dann. Das sieht natürlicher aus als der Wechsel der IP bei jeder Anfrage.

Mobile Proxys für besondere Fälle

Mobile Proxys verwenden IPs von Mobilfunkanbietern (MTS, Beeline, Tele2). Sie genießen maximales Vertrauen, da Millionen von Menschen mobile Internetdienste zum Lesen von Nachrichten nutzen. Verwenden Sie sie für das Parsen von mobilen Versionen von Nachrichtenwebsites (die oft einen vereinfachten Schutz haben), Websites mit extrem strengen Schutzmaßnahmen, AMP-Seiten von Google News.

Besonderheit von mobilen Proxys: Die IP ändert sich oft automatisch (Mobilfunkanbieter verwenden CGNAT), eine IP kann gleichzeitig von Hunderten von Nutzern verwendet werden, was eine Blockierung sinnlos macht. Nachteil – hohe Kosten, daher sollten sie gezielt eingesetzt werden, nur für die am stärksten geschützten Ziele.

Umgehung von Cloudflare und anderen Anti-Bot-Systemen

Cloudflare ist der Hauptfeind von Parsern auf Nachrichtenwebsites. Etwa 40% der großen Nachrichtenportale verwenden Cloudflare zum Schutz vor Bots. Standardbibliotheken (requests, urllib) bestehen nicht die Überprüfung, da Cloudflare den TLS-Fingerabdruck, die Ausführung von JavaScript, die Reihenfolge der HTTP-Header und Verhaltensmuster analysiert.

Strategien zur Umgehung von Cloudflare

1. Headless-Browser (Selenium, Playwright, Puppeteer)

Emulieren einen echten Browser mit der Ausführung von JavaScript. Cloudflare sieht den korrekten TLS-Fingerabdruck von Chrome/Firefox und lässt die Anfrage durch. Nachteile: langsam (2-5 Sekunden pro Seite), benötigt viele Ressourcen (RAM, CPU).

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

# Proxy für Selenium einrichten
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')

# Warten auf das Laden von JavaScript
driver.implicitly_wait(10)
html = driver.page_source
driver.quit()

2. Bibliotheken mit TLS-Fingerprinting (curl_cffi, tls-client)

Imitieren den TLS-Fingerabdruck eines echten Browsers, ohne einen Headless-Browser zu starten. Arbeiten 10-20 Mal schneller als Selenium, führen jedoch kein JavaScript aus. Eignen sich für Websites mit grundlegender Cloudflare-Überprüfung (ohne JS-Challenge).

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'  # Imitation des TLS-Fingerabdrucks von Chrome 110
)

print(response.text)

3. Cloudflare-Umgehungsdienste (scraperapi, scrapingbee)

Kostenpflichtige APIs, die automatisch Cloudflare umgehen. Sie senden die URL, sie geben das fertige HTML zurück. Vorteile: keine technischen Details zu verstehen, automatische Proxy-Rotation, CAPTCHA-Verarbeitung. Nachteile: teuer bei großen Volumina (ab 50 $/Monat für 100K Anfragen).

Korrekte HTTP-Header

Selbst mit Proxys ist es wichtig, korrekte Header zu senden, da die Website den Bot anhand eines nicht standardmäßigen User-Agents oder des Fehlens von Accept-Language erkennen kann.

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': 'de-DE,de;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'
}

Aktualisieren Sie regelmäßig den User-Agent – verwenden Sie aktuelle Versionen von Browsern. Überprüfen Sie Ihren Fingerabdruck auf Websites wie whoer.net oder browserleaks.com.

Einrichtung der IP-Rotation und Anfragenmanagement

Die richtige Rotation von Proxys ist der Schlüssel zu stabilem Parsen ohne Sperren. Nachrichtenwebsites verfolgen die Häufigkeit von Anfragen von einer IP, und das Überschreiten des Limits führt zu einer vorübergehenden oder dauerhaften Sperre.

Arten der Proxy-Rotation

Rotation nach Anfragen – jede Anfrage erfolgt über eine neue IP. Eignet sich für schnelles Parsen einer großen Anzahl unterschiedlicher Websites, minimiert das Risiko einer Sperre aufgrund der Anfragehäufigkeit. Nachteile: nicht geeignet für Websites mit Sitzungen (Cookies, Authentifizierung), kann für einige Schutzmaßnahmen verdächtig erscheinen.

Rotation nach Zeit (Sticky Sessions) – eine IP wird für eine feste Zeit (5-30 Minuten) verwendet und wechselt dann. Eignet sich für das Parsen eines Nachrichtenportals mit vielen Seiten, bewahrt Cookies und Sitzungen, sieht aus wie das Verhalten eines echten Nutzers. Empfohlen für die meisten Aufgaben beim Parsen von Nachrichten.

Rotation nach Geolokation – Wechsel der IP aus verschiedenen Ländern/Städten. Wird verwendet, um geobezogene Inhalte (regionale Nachrichten) zu parsen und Geoblockierungen zu umgehen.

Optimale Anfragerate

Selbst mit Proxy-Rotation sollten Anfragen nicht zu häufig gestellt werden. Sichere Intervalle für verschiedene Arten von Websites:

• Große Nachrichtenportale (RBK, Kommersant, Vedomosti) – 2-5 Sekunden zwischen Anfragen von einer IP
• Mittlere Websites – 1-3 Sekunden
• Kleine Blogs und regionale Publikationen – 0.5-1 Sekunde

Fügen Sie zufällige Verzögerungen (Randomisierung) hinzu, damit das Anfrage-Muster natürlich aussieht:

import time
import random

def fetch_article(url, proxies):
    response = requests.get(url, proxies=proxies, headers=headers)
    
    # Zufällige Verzögerung von 2 bis 5 Sekunden
    delay = random.uniform(2, 5)
    time.sleep(delay)
    
    return response.text

Beispiel für Proxy-Rotation aus einem Pool

Wenn Sie eine Liste von Proxys haben, können Sie eine einfache Rotation manuell implementieren:

import itertools
import requests

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

# Erstellen eines unendlichen Iterators
proxy_pool = itertools.cycle(proxy_list)

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

# Verwendung
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"]}')

Codebeispiele: Python + Scrapy + Proxys

Scrapy ist ein professionelles Framework für das Parsen, das von Haus aus Proxys, Middleware, Rotation und Fehlerbehandlung unterstützt. Lassen Sie uns ein vollständiges Beispiel eines Parsers für eine Nachrichtenwebsite mit Proxy-Rotation betrachten.

Installation der Abhängigkeiten

pip install scrapy scrapy-rotating-proxies

Scrapy mit Proxys einrichten (settings.py)

# settings.py

# Middleware für die Proxy-Rotation aktivieren
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,
}

# Einstellungen zur Umgehung von Sperren
CONCURRENT_REQUESTS = 8  # Maximal 8 gleichzeitige Anfragen
DOWNLOAD_DELAY = 2  # Verzögerung von 2 Sekunden zwischen Anfragen
RANDOMIZE_DOWNLOAD_DELAY = True  # Zufällige Verzögerung

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

# Wiederholungsversuche bei Fehlern
RETRY_TIMES = 3
RETRY_HTTP_CODES = [500, 502, 503, 504, 408, 429]

Spider zum Parsen von Nachrichten

# news_spider.py

import scrapy
from datetime import datetime

class NewsSpider(scrapy.Spider):
    name = 'news_parser'
    
    # Liste der Nachrichtenwebsites zum Parsen
    start_urls = [
        'https://example-news.com/latest',
    ]
    
    def parse(self, response):
        # Parsen der Artikelliste auf der Hauptseite
        articles = response.css('article.news-item')
        
        for article in articles:
            article_url = article.css('a.title::attr(href)').get()
            
            if article_url:
                # Gehe zur Artikelseite
                yield response.follow(article_url, callback=self.parse_article)
    
    def parse_article(self, response):
        # Extrahieren der Artikeldaten
        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(),
        }

Parser starten

# Speichern in JSON
scrapy crawl news_parser -o news_data.json

# Speichern in CSV
scrapy crawl news_parser -o news_data.csv

Einfacher Parser mit requests + BeautifulSoup

Wenn keine komplexe Logik erforderlich ist, kann die Kombination requests + BeautifulSoup verwendet werden:

import requests
from bs4 import BeautifulSoup
import time
import random

# Proxy einrichten
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')
        
        # Daten extrahieren (Selektoren hängen von der Website ab)
        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'Fehler beim Parsen von {url}: {e}')
        return None

# Parsen der Artikelliste
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)
    
    # Verzögerung zwischen Anfragen
    time.sleep(random.uniform(2, 4))

Typische Fehler beim Parsen von Nachrichten

Selbst mit der richtigen Proxy-Einrichtung erhalten Parser häufig Sperren aufgrund technischer Fehler. Lassen Sie uns die häufigsten Probleme und deren Lösungen untersuchen.

Fehler 1: Zu hohe Anfragerate

Symptome: HTTP 429 (Zu viele Anfragen), vorübergehende IP-Sperren, CAPTCHA. Grund: Der Parser macht 10-50 Anfragen pro Sekunde von einer IP. Lösung: Fügen Sie Verzögerungen hinzu (time.sleep()), verwenden Sie DOWNLOAD_DELAY in Scrapy, begrenzen Sie CONCURRENT_REQUESTS.

Fehler 2: Verwendung eines Proxys für alle Anfragen

Symptome: Proxy wird schnell gesperrt, selbst mit Verzögerungen. Grund: Eine IP macht Hunderte von Anfragen an eine Website. Lösung: Verwenden Sie einen Proxy-Pool mit Rotation, für große Websites – mindestens 10-20 Proxys, für Sticky Sessions wechseln Sie die IP alle 10-15 Minuten.

Fehler 3: Ignorieren von Cookies

Viele Nachrichtenwebsites setzen Cookies beim ersten Besuch und überprüfen deren Vorhandensein bei nachfolgenden Anfragen. Fehlende Cookies sind ein Zeichen für einen Bot. Lösung: Verwenden Sie requests.Session() für das automatische Speichern von Cookies, aktivieren Sie in Scrapy COOKIES_ENABLED = True.

import requests

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

# Erste Anfrage – Cookies erhalten
response1 = session.get('https://news-site.com')

# Nachfolgende Anfragen senden automatisch Cookies
response2 = session.get('https://news-site.com/article')

Fehler 4: Falsche Verarbeitung von Weiterleitungen

Nachrichtenwebsites verwenden häufig Weiterleitungen (301, 302) für mobile Versionen, regionale Subdomains, AMP-Seiten. Wenn der Parser den Weiterleitungen nicht folgt, erhält er eine leere Seite. Lösung: In requests ist dies standardmäßig aktiviert (allow_redirects=True), überprüfen Sie die endgültige URL über response.url.

Fehler 5: Parsen von dynamischen Inhalten ohne JavaScript

Viele moderne Nachrichtenwebsites laden Inhalte über JavaScript (React, Vue). Die Bibliothek requests erhält ein leeres HTML-Skelett ohne Artikel. Lösung: Verwenden Sie Selenium/Playwright zur Ausführung von JavaScript, überprüfen Sie das Netzwerk in den Entwicklertools – möglicherweise werden die Daten über eine API geladen (kann direkt JSON geparst werden).

Skalierung: Parsen von Hunderten von Quellen

Wenn Sie nicht nur eine Nachrichtenwebsite, sondern Hunderte von Quellen gleichzeitig parsen müssen (Nachrichtenaggregatoren, Medienüberwachung), ist eine skalierbare Architektur erforderlich.

Verteiltes Parsen mit Scrapy Cloud

Scrapy Cloud (von den Machern von Scrapy) ermöglicht das Ausführen von Parsern in der Cloud mit automatischer Skalierung. Vorteile: keine eigenen Server erforderlich, automatische Proxy-Rotation, Überwachung und Protokollierung. Kosten: ab 9 $/Monat für den Basisplan.

Aufgabenwarteschlangen (Celery + Redis)

Für die eigenständige Bereitstellung verwenden Sie Celery – ein System für verteilte Aufgaben. Architektur: Redis speichert die Warteschlange von URLs zum Parsen, mehrere Worker (Server) nehmen Aufgaben aus der Warteschlange und parsen parallel, jeder Worker verwendet seinen eigenen Proxy-Pool.

# 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)
    # Parsen und Speichern von Daten
    return response.text

# Aufgaben zur Warteschlange hinzufügen
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)  # Asynchrone Ausführung

Überwachung und Fehlerbehandlung

Bei massivem Parsen ist die Überwachung entscheidend: wie viele URLs verarbeitet wurden, wie viele Fehler aufgetreten sind, welche Proxys gesperrt wurden. Verwenden Sie Sentry zur Überwachung von Python-Fehlern, Grafana + Prometheus für Metriken (Anfragen pro Sekunde, Antwortzeiten), Protokollierung im ELK-Stack (Elasticsearch, Logstash, Kibana).

Optimierung der Proxy-Kosten

Beim Parsen von Hunderten von Quellen können die Kosten für Proxys Tausende von Dollar pro Monat erreichen. Optimierungsstrategien: Verwenden Sie Rechenzentrums-Proxys für einfache Websites (RSS, API), Residential Proxys nur für geschützte, cachen Sie Daten – parsen Sie denselben Artikel nicht zweimal, parsen Sie in Nebenzeiten (nachts ist die Last auf Websites geringer, geringeres Risiko einer Sperre).

Beispiel: Für das Parsen von 500 Nachrichtenwebsites können Sie 80% Rechenzentrums-Proxys (für RSS und einfache Websites) und 20% Residential Proxys (für die Top-100 geschützten Portale) verwenden. Dies reduziert die Kosten um das 3-5-fache.

Fazit

Das Parsen von Nachrichtenwebsites ist eine technisch anspruchsvolle Aufgabe, die die richtige Auswahl von Proxys, die Einrichtung von Rotation und die Umgehung von Anti-Bot-Systemen erfordert. Die wichtigsten Erkenntnisse aus dem Artikel: Verwenden Sie für geschützte Nachrichtenportale (Cloudflare, strenge Ratenbegrenzung) Residential Proxys mit Sticky Sessions, für das massenhafte Parsen von Hunderten von Quellen eignen sich Rechenzentrums-Proxys mit schneller Rotation, fügen Sie unbedingt Verzögerungen zwischen Anfragen (2-5 Sekunden) und korrekte HTTP-Header hinzu, verwenden Sie zur Umgehung von Cloudflare Headless-Browser (Selenium, Playwright) oder Bibliotheken mit TLS-Fingerprinting.

Bei der Skalierung verwenden Sie verteilte Systeme (Celery, Scrapy Cloud) und überwachen Sie Fehler. Denken Sie daran, dass das Parsen ethisch sein sollte – halten Sie sich an die robots.txt, erzeugen Sie keine übermäßige Last auf Servern und respektieren Sie die Urheberrechte an Inhalten.

Wenn Sie planen, große Nachrichtenportale mit Cloudflare-Schutz zu parsen, empfehlen wir die Verwendung von Residential Proxys – sie bieten ein hohes Maß an Vertrauen und minimales Risiko von Sperren. Für Aufgaben, bei denen Geschwindigkeit und Datenvolumen wichtig sind (Parsen von RSS, API-Endpunkten), sind Rechenzentrums-Proxys geeignet.