Web Scraping mit Rust: Eine Schritt-für-Schritt-Anleitung für Entwickler

Web Scraping mit Rust bezeichnet das Abrufen und Parsen von Webseiten mit der Programmiersprache Rust und ihrem Ökosystem aus Crates. Rust spricht Entwickler an, die vorhersehbare Leistung und Speichersicherheit ohne Garbage Collector wünschen. Damit eignet es sich besonders gut für Crawler, die dauerhaft oder mit hohem Volumen laufen.

Diese Anleitung ist ein praxisnaher, codeorientierter Leitfaden rund um den HTTP-Client reqwest und das Parsing-Crate scraper. Sie führt von der Projekteinrichtung und einem minimalen Abruf über CSS-Selektoren, strukturierte Datenmodelle sowie JSON- und CSV-Export bis zu Paginierung, Fehlerbehandlung mit Wiederholungsversuchen und Backoff, asynchroner Parallelität mit tokio, Proxy-Konfiguration und einer Headless-Browser-Alternative für JavaScript-lastige Websites. Jedes Beispiel ist zum Kompilieren und Ausführen ausgelegt.

DataImpulse ist ein ethischer Proxy-Anbieter mit mehr als 90 Millionen privaten, mobilen und Datacenter-IP-Adressen in 195 Ländern. Das Unternehmen nutzt ein Pay-as-you-go-Modell ab 1 Dollar pro GB mit nicht verfallendem Datenvolumen und wird für Web Scraping, Anzeigenprüfung, Preisüberwachung, Marktforschung und die Verwaltung mehrerer Konten eingesetzt.

Warum Rust für Web Scraping verwenden?

Rust eignet sich für Web Scraping, wenn Geschwindigkeit, geringer Speicherverbrauch und Zuverlässigkeit wichtiger sind als schnelles Prototyping. Die kompilierten Binärdateien laufen hardwarenah, und der Borrow Checker erkennt ganze Klassen von Nebenläufigkeitsfehlern bereits zur Kompilierzeit statt erst im Produktivbetrieb.

Diese Eigenschaften zahlen sich in einigen typischen Szenarien aus:

• Durchsatz: Ein kompilierter Rust-Crawler verarbeitet große Seitenmengen mit geringerem CPU- und Speicher-Overhead als eine interpretierte Sprache, was bei langen Jobs die Infrastrukturkosten senkt.
• Sichere Parallelität: Die Async-Laufzeit tokio ermöglicht Tausende paralleler Anfragen, während das Typsystem Race Conditions zwischen diesen Aufgaben verhindert.
• Vorhersehbarer Ressourcenverbrauch: Kein Garbage Collector bedeutet gleichmäßigere Latenzen, was Crawlern hilft, die stunden- oder tagelang laufen.

Der Kompromiss sind eine steilere Lernkurve und längere Kompilierzeiten. Rust lohnt sich daher vor allem für Projekte, die im großen Maßstab laufen, statt für einmalige Skripte. Unabhängig von der Sprache gelten dieselben Grundregeln: Beachten Sie robots.txt, begrenzen Sie Ihre Anfragerate und folgen Sie den allgemeinen Best Practices für Web Scraping, damit Ihr Crawler sich fair verhält.

Wie richtet man ein Rust-Scraping-Projekt ein?

Richten Sie ein Rust-Scraping-Projekt ein, indem Sie ein neues Cargo-Paket erstellen und die benötigten Crates in Cargo.toml deklarieren. Cargo ist das Build-Tool und der Paketmanager von Rust. Es löst also Abhängigkeiten auf und kompiliert das Projekt für Sie.

Führen Sie cargo new rust-scraper aus, um die Projektstruktur zu erstellen, und bearbeiten Sie anschließend die erzeugte Cargo.toml. Die folgenden Abhängigkeiten decken alles aus dieser Anleitung ab: HTTP, Parsing, Async, Serialisierung, CSV-Ausgabe, Streams und ergonomische Fehlerbehandlung.

[package]
name = "rust-scraper"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.12", features = ["json", "socks"] }
scraper = "0.20"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
csv = "1.3"
futures = "0.3"
anyhow = "1"
thiserror = "1"

Hier verarbeitet reqwest die Anfragen (das Feature socks aktiviert SOCKS5-Proxys, das Feature json ergänzt JSON-Hilfsfunktionen), scraper parst HTML mit CSS-Selektoren, tokio stellt die Async-Laufzeit bereit, serde und serde_json serialisieren Ihre Daten, csv schreibt Tabellen, futures liefert Stream-Kombinatoren für Parallelität und anyhow vereinfacht zusammen mit thiserror die Fehlerbehandlung. Führen Sie cargo build einmal aus, um alles herunterzuladen und zu kompilieren, bevor Sie Ihre erste Anfrage schreiben.

Wie ruft man mit reqwest und scraper eine Seite ab und parst sie?

Rufen Sie eine Seite ab, indem Sie mit reqwest eine GET-Anfrage senden und anschließend den Antworttext in scraper laden, um ihn mit CSS-Selektoren abzufragen. Das folgende Beispiel läuft asynchron auf tokio, ruft eine Seite ab und gibt den Text jedes H1-Elements aus.

use scraper::{Html, Selector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://example.com";
    let body = reqwest::get(url).await?.text().await?;

    let document = Html::parse_document(&body);
    let heading = Selector::parse("h1").unwrap();

    for element in document.select(&heading) {
        let text: String = element.text().collect();
        println!("{}", text.trim());
    }
    Ok(())
}

Der Ablauf ist immer gleich: reqwest::get gibt eine Antwort zurück, .text() liest deren Body als String, und Html::parse_document verwandelt diesen String in einen abfragbaren Baum. Der Operator ? gibt jeden Netzwerk- oder Dekodierungsfehler an main. Ein Aufruf von .text() für ein gefundenes Element sammelt dessen Textknoten, die Sie anschließend bereinigen und verwenden. Dieser Raw-HTML-Ansatz ist schnell, erfasst jedoch nur das Markup, das der Server zurückgibt, nicht Inhalte, die ein Browser erst später mit JavaScript rendern würde.

Wie wählt man Elemente mit CSS-Selektoren aus?

Wählen Sie Elemente aus, indem Sie an Selector::parse einen standardmäßigen CSS-Selektor-String übergeben, genau wie in einer Browserkonsole. Das Crate scraper unterstützt Tags, Klassen, IDs, Attributübereinstimmungen, Nachfahrenpfade und strukturelle Pseudoklassen.

use scraper::Selector;

// Match by tag
let links = Selector::parse("a").unwrap();

// Match by class
let prices = Selector::parse(".price").unwrap();

// Match by id
let main = Selector::parse("#main-content").unwrap();

// Match by attribute value
let external = Selector::parse("a[rel=\"nofollow\"]").unwrap();

// Descendant path (a title inside a product card)
let titles = Selector::parse("div.product h2.title").unwrap();

// Direct child plus pseudo-class
let first_row = Selector::parse("table > tbody > tr:first-child").unwrap();

Kompilieren Sie jeden Selektor einmal und verwenden Sie ihn wieder, statt ihn innerhalb einer Schleife zu parsen, denn das Parsing verursacht einen kleinen Aufwand. Wenn ein Selektor möglicherweise nichts findet, verwenden Sie besser .next() mit einem Fallback statt .unwrap() für das Element, damit ein fehlendes Feld nicht den gesamten Durchlauf abstürzen lässt. Die Zielseite mit dem Elementauswahlwerkzeug Ihres Browsers zu untersuchen, ist der schnellste Weg, stabile Klassennamen und Attribute für die Auswahl zu finden.

Wie exportiert man gescrapte Daten in JSON und CSV?

Exportieren Sie gescrapte Daten, indem Sie jeden Datensatz als Struct modellieren, das von serde Serialize ableitet, und anschließend einen Slice dieser Structs mit serde_json nach JSON oder mit dem Crate csv nach CSV schreiben. Ein typisiertes Modell hält Extraktion und Ausgabe synchron und macht den Code selbstdokumentierend.

Modellieren Sie zunächst den Datensatz und lesen Sie die Felder aus jedem Container-Element aus:

use scraper::{Html, Selector};
use serde::Serialize;

#[derive(Debug, Serialize)]
struct Product {
    name: String,
    price: String,
    url: String,
}

fn parse_products(html: &str) -> Vec<Product> {
    let document = Html::parse_document(html);
    let card = Selector::parse("div.product").unwrap();
    let name_sel = Selector::parse("h2.title").unwrap();
    let price_sel = Selector::parse("span.price").unwrap();
    let link_sel = Selector::parse("a").unwrap();

    let mut products = Vec::new();
    for card_el in document.select(&card) {
        let name = card_el
            .select(&name_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let price = card_el
            .select(&price_sel)
            .next()
            .map(|e| e.text().collect::<String>().trim().to_string())
            .unwrap_or_default();
        let url = card_el
            .select(&link_sel)
            .next()
            .and_then(|e| e.value().attr("href"))
            .unwrap_or_default()
            .to_string();

        products.push(Product { name, price, url });
    }
    products
}

Da Product ableitetSerialize, versorgt dieselbe Struct ohne zusätzlichen Aufwand beide Exporter:

use std::fs::File;
use std::io::Write;

fn export_json(products: &[Product]) -> anyhow::Result<()> {
    let json = serde_json::to_string_pretty(products)?;
    let mut file = File::create("products.json")?;
    file.write_all(json.as_bytes())?;
    Ok(())
}

fn export_csv(products: &[Product]) -> anyhow::Result<()> {
    let mut writer = csv::Writer::from_path("products.csv")?;
    for product in products {
        writer.serialize(product)?;
    }
    writer.flush()?;
    Ok(())
}

Die Funktion to_string_pretty von serde_json erzeugt gut lesbares JSON, und die Funktion serialize des Crates csv ordnet jede Struct einer Zeile mit einer aus den Feldnamen abgeleiteten Kopfzeile zu. Ein typisiertes Modell für Scraping, JSON und CSV wiederzuverwenden, macht eine Rust-Pipeline bei Änderungen an der Zielseite leicht wartbar.

Wie scrapet man mehrere Seiten mit einer Paginierungsschleife?

Scrapen Sie mehrere Seiten, indem Sie über Seitennummern oder eine URL für die nächste Seite iterieren und einen einzigen reqwest-Client wiederverwenden, damit Verbindungen über Anfragen hinweg gebündelt werden. Erstellen Sie jede URL, rufen Sie sie ab, parsen Sie sie mit der Funktion aus dem vorherigen Abschnitt und stoppen Sie, sobald eine Seite keine Ergebnisse zurückgibt.

use scraper::Html;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let mut all_products = Vec::new();

    for page in 1..=10 {
        let url = format!("https://example.com/products?page={}", page);
        let body = client.get(&url).send().await?.text().await?;
        let products = parse_products(&body);

        // Stop when a page returns no results
        if products.is_empty() {
            break;
        }
        all_products.extend(products);

        // Pause between requests to stay polite
        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
    }

    println!("Collected {} products", all_products.len());
    Ok(())
}

Wenn Sie den Client einmalig mit reqwest::Client::new() außerhalb der Schleife erstellen, kann er TCP-Verbindungen wiederverwenden. Das ist deutlich schneller als ein neuer Client pro Anfrage. Die Prüfung auf leere Ergebnisse beendet die Schleife beim Erreichen der letzten Seite auf natürliche Weise, und die kurze Pause verteilt die Anfragen, damit Sie den Server nicht überlasten. Bei Websites mit einem Link zur nächsten Seite statt nummerierter Seiten extrahieren Sie in jeder Iteration das href des entsprechenden Ankers und folgen ihm, bis der Link verschwindet.

Wie behandelt man Fehler und Wiederholungsversuche mit Backoff?

Behandeln Sie Fehler, indem Ihre Abruffunktionen einen typisierten Fehler zurückgeben, und wiederholen Sie vorübergehende Fehlschläge mit exponentiellem Backoff. Netzwerke laufen in Timeouts und Server geben temporäre Statuscodes zurück. Ein robuster Scraper behandelt einen einzelnen Fehler daher als erwartbar statt als fatal.

Mit dem Crate thiserror können Sie ein kompaktes Fehler-Enum definieren, das automatisch aus einem reqwest-Fehler konvertiert wird:

use thiserror::Error;

#[derive(Error, Debug)]
enum ScrapeError {
    #[error("request failed: {0}")]
    Request(#[from] reqwest::Error),

    #[error("unexpected status code: {0}")]
    Status(reqwest::StatusCode),

    #[error("selector matched no elements")]
    Empty,
}

async fn fetch_page(client: &reqwest::Client, url: &str) -> Result<String, ScrapeError> {
    let response = client.get(url).send().await?;
    if !response.status().is_success() {
        return Err(ScrapeError::Status(response.status()));
    }
    Ok(response.text().await?)
}

Das Attribut #[from] bewirkt, dass ein reqwest-Fehler automatisch in ScrapeError::Request über den ?-Operator umgewandelt wird. Ergänzend zu typisierten Fehlern kapseln Sie die Anfrage in eine Wiederholungsschleife, deren Wartezeit nach jedem Versuch wächst:

use std::time::Duration;

async fn fetch_with_backoff(client: &reqwest::Client, url: &str) -> anyhow::Result<String> {
    let max_attempts = 5;
    for attempt in 1..=max_attempts {
        match client.get(url).send().await {
            Ok(resp) if resp.status().is_success() => {
                return Ok(resp.text().await?);
            }
            Ok(resp) => {
                eprintln!("attempt {attempt}: status {}", resp.status());
            }
            Err(err) => {
                eprintln!("attempt {attempt}: {err}");
            }
        }
        // Exponential backoff: 0.5s, 1s, 2s, 4s, 8s
        let backoff = Duration::from_millis(500 * 2u64.pow(attempt - 1));
        tokio::time::sleep(backoff).await;
    }
    anyhow::bail!("giving up on {url} after {max_attempts} attempts")
}

Exponentieller Backoff (hier 0.5s, 1s, 2s, 4s, 8s) gibt einem rate-limitierten oder kurzzeitig überlasteten Server Zeit zur Erholung, statt ihn weiter mit Anfragen zu belasten. Noch wirkungsvoller ist die Kombination von Wiederholungsversuchen mit rotierenden Proxys: Eine auf einer IP blockierte oder gedrosselte Anfrage kann beim nächsten Versuch über eine andere Exit-IP erfolgreich sein.

Wie führt man mit tokio parallele Anfragen aus?

Führen Sie parallele Anfragen aus, indem Sie Ihre URL-Liste in einen Async-Stream umwandeln und buffer_unordered anwenden. Dadurch wird begrenzt, wie viele Anfragen gleichzeitig ausgeführt werden. Dies ist der größte Performance-Hebel eines Rust-Scrapers, und tokio zusammen mit dem Crate futures macht ihn sicher nutzbar.

use futures::stream::{self, StreamExt};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::new();
    let urls: Vec<String> = (1..=50)
        .map(|n| format!("https://example.com/item/{}", n))
        .collect();

    let bodies = stream::iter(urls)
        .map(|url| {
            let client = client.clone();
            async move {
                let text = client.get(&url).send().await?.text().await?;
                Ok::<_, reqwest::Error>((url, text))
            }
        })
        .buffer_unordered(10); // at most 10 requests in flight

    bodies
        .for_each(|result| async {
            match result {
                Ok((url, body)) => println!("{}: {} bytes", url, body.len()),
                Err(err) => eprintln!("error: {}", err),
            }
        })
        .await;

    Ok(())
}

Hier wandelt stream::iter die URL-Liste in einen Stream um, .map startet eine Async-Anfrage pro URL, und buffer_unordered(10) lässt höchstens zehn parallel laufen und liefert Ergebnisse, sobald sie fertig sind. Den Client je Aufgabe zu klonen, ist günstig, weil ein reqwest Client ein Arc um einen gemeinsamen Verbindungspool ist. Passen Sie das Parallelitätslimit so an, dass Geschwindigkeit und Belastung der Zielseite im Gleichgewicht sind: Zehn bis zwanzig ist ein sinnvoller Ausgangspunkt, und ein Proxy-Pool verteilt Anfragen bei höherer Parallelität auf viele IPs.

Wie leitet man Rust-Scraping-Traffic über einen Proxy?

Leiten Sie Traffic über einen Proxy, indem Sie einen reqwest-Client mit reqwest::Proxy erstellen und Gateway sowie Zugangsdaten mit .basic_auth verknüpfen. Anfragen über rotierende IPs zu senden, verteilt die Last, erreicht geografisch spezifische Inhalte und verringert die Wahrscheinlichkeit einer Rate-Limitierung. Rotierende IPs gehören zu den wirksamsten Techniken für Scraping ohne blockiert zu werden.

use reqwest::Proxy;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Authenticated gateway; rotates the exit IP on each request
    let proxy = Proxy::all("http://gw.dataimpulse.com:823")?
        .basic_auth("login", "password");

    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(std::time::Duration::from_secs(30))
        .build()?;

    let body = client
        .get("https://httpbin.org/ip")
        .send()
        .await?
        .text()
        .await?;

    println!("{}", body);
    Ok(())
}

Ersetzen Sie login und password durch Ihre Zugangsdaten und passen Sie den Port für das benötigte Netzwerk an. Wenn der Proxy Ihre Anfrage mit Status 407 ablehnt, sind fast immer fehlende oder falsche Zugangsdaten die Ursache. Die Anleitung zu HTTP-Fehler 407 sowie der Leitfaden zur Proxy-Authentifizierung erläutern die Behebung. DataImpulse bietet Residential-Proxys, Datacenter-Proxys und mobile Proxys über HTTP, HTTPS und SOCKS5, mit rotierenden und Sticky Sessions. Länder-Targeting ist enthalten, während Targeting nach Bundesstaat, Stadt, ZIP und ASN kostenpflichtige Zusatzoptionen sind.

Wie scrapet man JavaScript-lastige Seiten, und wann ist Rust die richtige Wahl?

Scrapen Sie JavaScript-lastige Seiten mit einem echten Headless-Browser, denn reqwest und scraper sehen nur das Raw-HTML des Servers und führen keine Skripte aus. Wenn Inhalte erst nach clientseitigem Rendering erscheinen, verwenden Sie ein Browser-Automatisierungs-Crate wie thirtyfour, das das WebDriver-Protokoll spricht, oder chromiumoxide, das Chrome über das DevTools Protocol steuert.

use thirtyfour::prelude::*;

#[tokio::main]
async fn main() -> WebDriverResult<()> {
    let caps = DesiredCapabilities::chrome();
    let driver = WebDriver::new("http://localhost:9515", caps).await?;

    driver.goto("https://example.com").await?;

    // Wait for client-side content to render, then read it
    let heading = driver.find(By::Css("h1")).await?;
    println!("{}", heading.text().await?);

    driver.quit().await?;
    Ok(())
}

Das Beispiel mit thirtyfour verbindet sich mit einem laufenden chromedriver, lädt eine Seite, wartet auf ein gerendertes Element und liest dessen Text. Dieser Ansatz ist deutlich aufwendiger als ein einfacher HTTP-Abruf. Nutzen Sie ihn daher nur für Seiten, die ihn wirklich benötigen, und behalten Sie für alles andere den schnellen reqwest-Pfad bei. Eine genauere Betrachtung dieses Kompromisses finden Sie in den Anleitungen zu dynamischen Webseiten scrapen und Web Scraping mit JavaScript. Die folgende Tabelle fasst zusammen, wie die wichtigsten Crates zusammenspielen:

Bei der Sprachwahl sollten Sie Rust wählen, wenn Sie dauerhafte hohe Leistung und geringen Ressourcenverbrauch im großen Maßstab benötigen, und Python, wenn Ihnen schnelle Entwicklung und ein breiteres Scraping-Ökosystem wie Scrapy und Playwright wichtiger sind. Häufig werden Extraktionsregeln zunächst in Python prototypisiert und der leistungskritische Teil nach Rust portiert, sobald die Logik stabil ist und das Volumen wächst. Für welche Sprache Sie sich auch entscheiden: Die Netzwerkschicht ist genauso wichtig wie der Parser, und ethisch beschaffte Proxys halten große Jobs zuverlässig am Laufen.

Häufig gestellte Fragen

Weiterführende Anleitungen

• Web Scraping mit JavaScript
• Dynamische Webseiten scrapen
• Best Practices für Web Scraping

Zuverlässig scrapen mit ethischen Proxys

Sobald Ihr Rust-Scraper sauber abruft, parst und exportiert, sorgt ein zuverlässiges Proxy-Netzwerk dafür, dass er im großen Maßstab weiterläuft. DataImpulse bietet ethisch beschaffte IPs im Pay-as-you-go-Modell ab 1 Dollar pro GB mit nicht verfallendem Datenvolumen. So können Sie ein Konto erstellen und Ihre ersten Anfragen in wenigen Minuten weiterleiten.