Zum Inhalt springen
Zurück zum Blog

Web-Scraping mit Rust: Schritt-für-Schritt-Anleitung mit funktionierendem Code

Mihai MaximZuletzt aktualisiert am 21 min read
Web-Scraping mit Rust: Schritt-für-Schritt-Anleitung mit funktionierendem Code

Beim Web-Scraping mit Rust kommen im Wesentlichen drei Crates zum Einsatz: „reqwest“ sendet die HTTP-Anfragen, „scraper“ analysiert den HTML-Code mithilfe von CSS-Selektoren und „tokio“ führt alles asynchron aus. Sie werden einen Scraper von Anfang bis Ende erstellen. Er sammelt alle Bücher auf books.toscrape.com, einem öffentlichen Übungskatalog, folgt der Paginierung, ruft Seiten parallel unter Einhaltung von „polite limits“ ab, wiederholt fehlgeschlagene Anfragen und schreibt die Ergebnisse in CSV- und JSON-Dateien. Anschließend werden Sie eine mit JavaScript gerenderte Seite (quotes.toscrape.com/js/) auf drei Arten bearbeiten: durch Auslesen des eingebetteten JSON, durch Rendern in Headless Chrome und durch Aufruf einer Scraping-API über denselben reqwest-Client.

Der Code ist auf die in der folgenden Tabelle aufgeführten Crate-Versionen ausgerichtet, einschließlich der Funktionsänderungen in reqwest 0.13, die viele ältere Tutorials unbrauchbar machen.

Das Wichtigste auf einen Blick

  • Verwenden Sie reqwest 0.13 für HTTP, scraper 0.29 für das Parsen und tokio für asynchrone Vorgänge. Aktivieren Sie die query Feature, bevor Sie .query().
  • Erstellen Sie einen Client und verwenden Sie ihn wieder. Erstellen Sie Ihre Selektoren einmalig, nicht innerhalb einer Schleife.
  • Parsen Sie HTML in einer regulären synchronen Funktion, da scraper::Html nicht über eine .await in einer gestarteten Aufgabe aufrechterhalten werden.
  • Folgen Sie dem „Weiter“-Link für die Paginierung, begrenzen Sie die Parallelität mit buffer_unorderedund wiederholen Sie 429- und 5xx-Antworten mit Backoff.
  • Bei JavaScript-Seiten sollten Sie zunächst den rohen HTML-Code überprüfen, dann nach eingebettetem JSON suchen und erst danach auf einen Headless-Browser oder eine verwaltete API zurückgreifen.

Eignet sich Rust für Web-Scraping?

Ja, Rust eignet sich gut für Scraper, die über einen langen Zeitraum laufen oder viele Seiten abrufen. Es benötigt wenig Speicher, verarbeitet mit Tokio viele gleichzeitige Anfragen effizient und wird zu einer einzigen Binärdatei kompiliert, die sich leicht bereitstellen lässt. Python ist für einmalige Skripte schneller und verfügt über ausgereiftere Browser-Tools, daher hängt die richtige Wahl von der jeweiligen Aufgabe ab.

Entscheiden Sie sich für Rust, wenn:

  • Der Scraper kontinuierlich, nach einem Zeitplan oder über Tausende von Seiten hinweg läuft.
  • Sie möchten, dass der Compiler Typfehler und fehlende Felder bereits vor der Produktionsumgebung erkennt.
  • Sie auf kleinen Servern oder in Containern bereitstellen und eine einzige, in sich geschlossene Binärdatei wünschen.

Entscheiden Sie sich für Python, wenn:

  • Sie ein Prototyp entwickeln, eine Website erkunden oder ein einmaliges Skript schreiben. Unser Leitfaden zum Web-Scraping mit Python behandelt diesen Ansatz.
  • Sie umfangreiche Browser-Automatisierung oder eine spezialisierte Bibliothek benötigen, für die es noch kein Äquivalent in Rust gibt.

Viele Teams gehen so vor: Sie erkunden eine Website zunächst in Python und verlagern den lang andauernden Crawling-Vorgang dann auf Rust, sobald die Selektoren stabil sind.

Welche Rust-Crates benötigen Sie für das Web-Scraping?

Du benötigst einen HTTP-Client, einen HTML-Parser und eine asynchrone Laufzeitumgebung. „reqwest“, „scraper“ und „tokio“ decken diese drei Aufgaben für die meisten Projekte ab, und einige Hilfs-Crates kümmern sich um URLs, die Ausgabe und Parallelität.

Aufgabe

Crate

Version geprüft im November 2026

Anwendungsbereich

HTTP-Client (asynchron)

reqwest

0.13.5

Standardwahl für die meisten Scraper

HTTP-Client (synchron, klein)

ureq

3.5.1

Einfache Skripte ohne asynchrone Laufzeitumgebung

Asynchrone Laufzeitumgebung

tokio

1.54.1

Erforderlich für asynchrone Anfragen

HTML-Parsing mit CSS-Selektoren

Scraper

0.29.0

Standardauswahl für das Parsen

Leichtere oder Streaming-Parser

tl, lol_html

0.7.8, 3.0.3

Reine Geschwindigkeit oder Streaming-Umschreibungen mit weniger Komfortfunktionen

Älterer Parser

select

0.6.1

Nur bestehender Code, geringe Aktivität

Serialisierung

serde, serde_json

1.0.229, 1.0.154

Strukturen in JSON und zurück

CSV-Ausgabe

csv

1.4.0

Schreibt Serde-Strukturen als Zeilen

URLs

url

2.5.8

Url::join für relative Links

Hilfsfunktionen für Parallelität

Futures

0.3.34

buffer_unordered für begrenzte Parallelität

Ratenbegrenzung (optional)

Regler

0.10.4

Konstante Token-Bucket-Grenzwerte

Headless Chrome (synchron)

headless_chrome

1.0.22

Einfachste Möglichkeit, JavaScript darzustellen

Headless Chrome (asynchron)

chromiumoxide

0.9.1

Asynchrone Steuerung über das Chrome DevTools-Protokoll

WebDriver

fantoccini, thirtyfour

0.22.1, 0.38.1

Browser-Automatisierung über Chromedriver oder Geckodriver

Crawler-Framework

Spider

2.53.9

Crawling der gesamten Website anstelle einer benutzerdefinierten Schleife

Einige Crates im neuen Code überspringen. „kuchiki“ 0.8.1 wird nicht mehr gepflegt (kuchikiki ist der gepflegte Fork), und „soup“ 0.5.1 sowie „voyager“ 0.2.1 wurden seit Jahren nicht mehr aktualisiert.

So richtest du ein Projekt für Web-Scraping mit Rust ein

Die Einrichtung erfolgt in vier Schritten: Toolchain installieren, überprüfen, ein Projekt erstellen und die Crates hinzufügen.

  1. Installiere Rust mit rustup. Unter macOS und Linux erfolgt die Installation über einen einzigen Shell-Befehl. Unter Windows lade die Datei herunter und führe sie aus rustup-init.exe.
  2. Überprüfen Sie, ob der Compiler und Cargo in Ihrem Pfad enthalten sind:
rustc --version
cargo --version
  1. Erstellen Sie ein neues Binärprojekt:
cargo new rust-scraper
cd rust-scraper
  1. Fügen Sie die Crates mit den in dieser Anleitung verwendeten Features hinzu:
cargo add reqwest --features query
cargo add tokio --features full
cargo add serde --features derive
cargo add scraper serde_json url csv futures anyhow

Sie benötigen die query Feature für den Abschnitt zur Scraper-API, aber wenn Sie es jetzt aktivieren, ersparen Sie sich später einen verwirrenden Kompilierungsfehler. Ihr Cargo.toml sollten am Ende einen „dependencies“-Block wie diesen haben:

[dependencies]
anyhow = "1.0.104"
csv = "1.4.0"
futures = "0.3.34"
reqwest = { version = "0.13.5", features = ["query"] }
scraper = "0.29.0"
serde = { version = "1.0.229", features = ["derive"] }
serde_json = "1.0.154"
tokio = { version = "1.54.1", features = ["full"] }
url = "2.5.8"

Was hat sich in reqwest 0.13 geändert?

reqwest 0.13 hat mehrere Standardeinstellungen und Funktionsnamen geändert, sodass Code, der für 0.11 oder 0.12 geschrieben wurde, nach dem Upgrade oft nicht mehr kompiliert werden kann. Hier sind die Änderungen, auf die du am ehesten stoßen wirst, sowie die jeweiligen Fehlermeldungen:

  • rustls ist nun das Standard-TLS-Backend. Du benötigst kein Feature-Flag mehr, um rustls zu nutzen. Wenn du ausdrücklich das native TLS der Plattform benötigst, aktiviere native-tls.
  • Die rustls-tls Feature wurde umbenannt in rustlsumbenannt. Cargo bricht mit der Meldung „Das Paket hängt von reqwest mit dem Feature rustls-tls , reqwest verfügt nicht über diese Funktion.“ Entfernen Sie die Funktion, da rustls bereits die Standardeinstellung ist.
  • .query() und .form() sind nun Opt-in-Funktionen. Ohne sie meldet der Compiler den Fehler E0599: „Keine Methode namens query für die Struktur RequestBuilder.“ Aktivieren Sie query oder form in Cargo.toml.
  • reqwest::blocking benötigt weiterhin die blocking Funktion. Ohne diese Funktion erhalten Sie die Meldung „konnte nicht gefunden werden blocking in reqwest."

Die vollständige Liste findest du im reqwest-Changelog.

So sendest du deine erste HTTP-Anfrage mit reqwest

Erstellen Sie einen reqwest::Client, weisen Sie ihr einen User-Agent und ein Timeout zu und verwenden Sie sie für jede Anfrage wieder. Der Client verwaltet einen Verbindungspool; wenn Sie also für jede Anfrage eine neue erstellen, wird dieser Pool verworfen. Ersetzen Sie den Inhalt von src/main.rs durch Folgendes:

use anyhow::Result;
use reqwest::Client;
use std::time::Duration;

fn build_client() -> Result<Client> {
    let client = Client::builder()
        .user_agent("rust-scraper-tutorial/0.1 (+https://example.com/contact)")
        .timeout(Duration::from_secs(30))
        .build()?;
    Ok(client)
}

async fn fetch(client: &Client, url: &str) -> Result<String> {
    let body = client
        .get(url)
        .send()
        .await?
        .error_for_status()?
        .text()
        .await?;
    Ok(body)
}

#[tokio::main]
async fn main() -> Result<()> {
    let client = build_client()?;
    let html = fetch(&client, "https://books.toscrape.com/").await?;
    println!("downloaded {} bytes", html.len());
    Ok(())
}

Führen Sie es mit cargo run. Ein paar Details sind wichtig:

  • #[tokio::main] startet die Tokio-Laufzeitumgebung, sodass main kann async.
  • error_for_status() wandelt 4xx- und 5xx-Antworten in Fehler um. Ohne diese Option gibt `reqwest` einfach den Inhalt einer 404-Seite zurück, und dein Parser findet stillschweigend nichts.
  • Der User-Agent benennt deinen Scraper und gibt eine Kontakt-URL an. Das ist auf einer Übungsseite höflich. Auf echten Websites musst du oft auch realistische Request-Header setzen.
  • anyhow::Result ermöglicht dir die Verwendung ? bei Fehlern aus reqwest, URL, CSV und Serde nutzen, ohne einen eigenen Fehlertyp definieren zu müssen.

Die reqwest-Dokumentation behandelt Header, Cookies, Proxys und die übrigen ClientBuilder Optionen.

So parsen Sie HTML mit dem „scraper“-Crate

Die „scraper“-Crate parst eine HTML-Zeichenkette in ein Dokument, das Sie mit CSS-Selektoren abfragen können. Sie führen den Parsing-Vorgang einmalig durch, indem Sie Html::parse_document, kompilieren jeden Selektor mit Selector::parseund rufen anschließend .select() auf, um die passenden Elemente zu durchlaufen. Fügen Sie diese Funktion unten ein fetch:

use scraper::{Html, Selector};

fn first_look(html: &str) {
    let document = Html::parse_document(html);
    let card = Selector::parse("article.product_pod").expect("valid selector");
    let title_link = Selector::parse("h3 > a").expect("valid selector");
    let price = Selector::parse("p.price_color").expect("valid selector");

    println!("books on this page: {}", document.select(&card).count());

    if let Some(first) = document.select(&card).next() {
        let link = first.select(&title_link).next().expect("title link");
        let title = link.value().attr("title").unwrap_or_default();
        let price_text: String = first.select(&price).next().expect("price").text().collect();
        println!("first book: {title} ({})", price_text.trim());
    }
}

Rufen Sie anschließend first_look(&html); in main nach dem Abruf auf. Die Ausgabe zeigt die 20 Produktkarten auf der ersten Seite:

books on this page: 20
first book: A Light in the Attic (£51.77)

Drei Methoden übernehmen den Großteil der Arbeit:

  • .select(&selector) gibt einen Iterator mit ElementRef Werte zurück. Sie können .select() jeden einzelnen erneut aufrufen, um darin zu suchen – auf diese Weise beschränken Sie eine Abfrage auf eine einzelne Produktkarte.
  • .value().attr("title") Liest ein Attribut. Es gibt Option<&str>, da das Attribut möglicherweise nicht existiert.
  • .text() durchläuft die Textknoten innerhalb eines Elements und .collect::<String>() verbindet diese miteinander.

Buchtitel werden auf dieser Website im Linktext gekürzt, daher lesen wir stattdessen den vollständigen Titel aus dem title Attribut aus. Falls du eine Auffrischung zur Syntax von CSS-Selektoren benötigst: Unser Spickzettel zu CSS-Selektoren behandelt die Muster, die Scraper am häufigsten verwenden. Die Dokumentation zur „scraper“-Crate listet die vollständige API auf.

parse_document vs. parse_fragment

Verwenden Sie Html::parse_document für ganze Seiten, die Sie herunterladen. Es erstellt den vollständigen Baum, einschließlich <html>, <head>, und <body>. Html::parse_fragment ist für HTML-Ausschnitte gedacht, wie zum Beispiel einen Teil, den du bereits aus einer Seite ausgeschnitten hast, oder das Markup innerhalb eines JSON-Feldes. Wenn du eine ganze Seite an parse_fragment kann zu einem Baum führen, der nicht mit der Darstellung im Browser übereinstimmt, und Selektoren, die von der Dokumentstruktur abhängen, funktionieren dann nicht mehr.

So extrahieren Sie strukturierte Daten in eine Rust-Struktur

Definieren Sie eine Struktur für den gewünschten Datensatz, füllen Sie diese aus jeder Karte mit Daten und leiten Sie Serialize , damit serde sie später ausgeben kann. Speichere für jedes Buch den Titel, den Preis als Zahl, die Sternebewertung von 1 bis 5, den Verfügbarkeitsstatus und eine absolute URL.

use scraper::{Html, Selector};
use serde::Serialize;
use std::sync::LazyLock;
use url::Url;

#[derive(Debug, Serialize)]
struct Book {
    title: String,
    price: f64,
    rating: u8,
    in_stock: bool,
    url: String,
}

struct BookSelectors {
    card: Selector,
    link: Selector,
    price: Selector,
    rating: Selector,
    stock: Selector,
    next: Selector,
}

static SEL: LazyLock<BookSelectors> = LazyLock::new(|| {
    let s = |css: &str| Selector::parse(css).expect("valid selector");
    BookSelectors {
        card: s("article.product_pod"),
        link: s("h3 > a"),
        price: s("p.price_color"),
        rating: s("p.star-rating"),
        stock: s("p.instock.availability"),
        next: s("li.next > a"),
    }
});

fn rating_from_class(class: &str) -> u8 {
    match class.split_whitespace().find(|c| *c != "star-rating") {
        Some("One") => 1,
        Some("Two") => 2,
        Some("Three") => 3,
        Some("Four") => 4,
        Some("Five") => 5,
        _ => 0,
    }
}

/// Parses one listing page. Kept sync on purpose: scraper::Html is not Send.
fn parse_books(html: &str, page_url: &Url) -> (Vec<Book>, Option<Url>) {
    let doc = Html::parse_document(html);

    let books = doc
        .select(&SEL.card)
        .filter_map(|card| {
            let a = card.select(&SEL.link).next()?;
            let title = a.value().attr("title")?.trim().to_string();
            let href = a.value().attr("href")?;
            let price_text: String = card.select(&SEL.price).next()?.text().collect();
            let price = price_text.trim().trim_start_matches('£').parse::<f64>().ok()?;
            let rating = card
                .select(&SEL.rating)
                .next()
                .and_then(|p| p.value().attr("class"))
                .map(rating_from_class)
                .unwrap_or(0);
            let in_stock = card
                .select(&SEL.stock)
                .next()
                .map(|p| p.text().collect::<String>().contains("In stock"))
                .unwrap_or(false);
            let url = page_url.join(href).ok()?.to_string();
            Some(Book { title, price, rating, in_stock, url })
        })
        .collect();

    let next_url = doc
        .select(&SEL.next)
        .next()
        .and_then(|a| a.value().attr("href"))
        .and_then(|href| page_url.join(href).ok());

    (books, next_url)
}

Dies ersetzt first_look aus dem vorherigen Schritt, löschen Sie also diese Funktion und ihren separaten scraper Import. Was der Code tut:

  • Selektoren werden einmalig erstellt. LazyLock kompiliert jeden Selektor beim ersten Mal SEL und verwendet sie danach auf jeder Seite wieder. Ein Aufruf Selector::parse innerhalb der Karten-Schleife würde dazu führen, dass derselbe Selektor 20 Mal pro Seite neu kompiliert wird.
  • Die Bewertung ergibt sich aus einem Klassennamen. Die Website kennzeichnet Bewertungen als class="star-rating Three", daher rating_from_class überspringt star-rating und ordnet das Wort einer Zahl zu.
  • Der Preis wird in ein f64. Leerzeichen und das £ Vorzeichen werden zuerst entfernt. Zahlen, die als Zahlen gespeichert werden, lassen sich später leichter sortieren und filtern.
  • Relative Links werden mit Url::join. Die href Werte auf der Seite sind relativ, wie zum Beispiel catalogue/a-light-in-the-attic_1000/index.html. Durch die Verknüpfung mit der Seiten-URL werden sie so aufgelöst, wie es ein Browser tun würde, einschließlich ../ Segmente auf tiefer liegenden Seiten.
  • filter_map überspringt fehlerhafte Karten. Fehlt bei einer Karte der Titel oder der Preis, geben die ? geben die Operatoren None und diese Karte wird verworfen, anstatt den Lauf zum Absturz zu bringen.
  • Die Funktion gibt außerdem die URL der nächsten Seite zurück, die für den Paginierungsschritt benötigt wird.

Um die ersten beiden Bücher auszudrucken, aktualisieren Sie main:

#[tokio::main]
async fn main() -> Result<()> {
    let client = build_client()?;
    let url = Url::parse("https://books.toscrape.com/")?;
    let html = fetch(&client, url.as_str()).await?;
    let (books, next) = parse_books(&html, &url);
    println!("{}", serde_json::to_string_pretty(&books[..2])?);
    println!("next page: {:?}", next.map(|u| u.to_string()));
    Ok(())
}

Die Ausgabe ist sauberes, typisiertes JSON mit absoluten URLs:

[
  {
    "title": "A Light in the Attic",
    "price": 51.77,
    "rating": 3,
    "in_stock": true,
    "url": "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
  },
  {
    "title": "Tipping the Velvet",
    "price": 53.74,
    "rating": 1,
    "in_stock": true,
    "url": "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"
  }
]
next page: Some("https://books.toscrape.com/catalogue/page-2.html")

So handhaben Sie die Paginierung in Rust

Um jede Seite zu scrapen, folge dem „next“-Link, bis er nicht mehr vorhanden ist. Jede Schleife ruft eine Seite ab, analysiert deren Bücher und liest die nächste URL, die parse_books bereits mit Url::join. Die Schleife stoppt, wenn kein „Weiter“-Link mehr vorhanden ist oder wenn die von dir als Sicherheitsnetz festgelegte Seitenobergrenze erreicht wird.

const MAX_PAGES: usize = 60;

async fn scrape_all(client: &Client, start: &str) -> Result<Vec<Book>> {
    let mut next = Some(Url::parse(start)?);
    let mut all = Vec::new();
    let mut pages = 0;

    while let Some(url) = next.take() {
        if pages >= MAX_PAGES {
            eprintln!("stopping at the {MAX_PAGES}-page cap");
            break;
        }
        let html = fetch(client, url.as_str()).await?;
        let (books, next_url) = parse_books(&html, &url);
        all.extend(books);
        pages += 1;
        next = next_url;
        tokio::time::sleep(Duration::from_millis(500)).await;
    }

    println!("pages: {pages}, books: {}", all.len());
    Ok(all)
}

Rufen Sie das Programm mit scrape_all(&client, "https://books.toscrape.com/catalogue/page-1.html").await? und sie durchläuft alle 50 Seiten des Katalogs und sammelt dabei 1.000 Bücher:

pages: 50, books: 1000

while let Some(url) = next.take() ist eine kompakte Art zu sagen: „Mach weiter, solange es eine nächste Seite gibt.“ Die Wartezeit von einer halben Sekunde verhindert, dass die Schleife den Server so schnell belastet, wie es deine Verbindung zulässt, und die Seitenbegrenzung schützt dich vor einer Website, deren „Weiter“-Link auf sich selbst verweist.

Dies ist nach wie vor Scraping, kein Crawling: Du folgst einer bekannten Kette von Seiten, anstatt jeden Link auf einer Website zu entdecken. Bist du dir nicht sicher, was du brauchst? Sieh dir unsere Erklärung zu Scraping vs. Crawling an. Wenn der Auftrag dazu führt, dass viele verwandte Seiten nach einem Zeitplan gesammelt werden müssen, kann ein verwaltetes, begrenztes Crawling die URL-Erkennung und die Begrenzungen übernehmen.

So scrapen Sie mehrere Seiten gleichzeitig

Wenn Sie die Seiten-URLs bereits kennen, können Sie mehrere auf einmal abrufen, anstatt eine nach der anderen. Verwenden Sie futures::stream mit buffer_unordered(n), das höchstens n Anfragen gleichzeitig in Bearbeitung hält. Die Seiten-URLs des Katalogs folgen einem Muster, sodass wir alle 50 im Voraus erstellen können:

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

async fn scrape_concurrently(client: &Client) -> Vec<Book> {
    let urls: Vec<Url> = (1..=50)
        .map(|n| {
            Url::parse(&format!("https://books.toscrape.com/catalogue/page-{n}.html"))
                .expect("valid URL")
        })
        .collect();

    let results: Vec<(Url, Result<Vec<Book>>)> = stream::iter(urls)
        .map(|url| {
            let client = client.clone();
            async move {
                let result = async {
                    let html = fetch(&client, url.as_str()).await?;
                    Ok(parse_books(&html, &url).0)
                }
                .await;
                (url, result)
            }
        })
        .buffer_unordered(4)
        .collect()
        .await;

    let mut books = Vec::new();
    for (url, result) in results {
        match result {
            Ok(page_books) => books.extend(page_books),
            Err(e) => eprintln!("failed {url}: {e:#}"),
        }
    }
    books
}

Warum es so aufgebaut ist:

  • client.clone() ist ressourcenschonend. Eine Anfrage Client ist ein Handle zu einem gemeinsam genutzten Verbindungspool, sodass jede Aufgabe dieselben Verbindungen wiederverwendet.
  • buffer_unordered(4) begrenzt die Parallelität auf vier Anfragen. Eine höhere Anzahl führt zu schnelleren Abrufen, belastet den Server jedoch auch stärker. Beginne mit einer niedrigen Anzahl auf jeder Website, die dir nicht gehört.
  • Jede Seite verfügt über einen eigenen Result. Eine fehlgeschlagene Seite wird mit ihrer URL protokolliert, anstatt die anderen 49 abzubrechen. Du kannst die fehlgeschlagenen URLs sammeln und es später erneut versuchen.
  • Die Ergebnisse werden in ungeordneter Reihenfolge geliefert. Wenn die Reihenfolge wichtig ist, sortieren Sie die Bücher anschließend oder verwenden Sie buffered statt buffer_unordered.

Wenn asynchrones Rust neu für dich ist, erklärt das Tokio-Tutorial Aufgaben und Laufzeiten, und die Dokumentation zu `buffer_unordered` behandelt die anderen Stream-Kombinatoren.

Warum sagt Rust, dass HTML nicht zwischen Threads gesendet werden kann?

scraper::Html ist doch Send, daher kann eine mit tokio::spawn , kann diese nicht über einen .await. Tokio kann eine gestartete Aufgabe jederzeit in einen anderen Thread verschieben .await, und der Compiler lehnt alles ab, was nicht sicher verschoben werden kann. Diese Version schlägt fehl:

// Does not compile: `doc` is still alive at the second .await
let handle = tokio::spawn(async move {
    let html = fetch(&client, "https://books.toscrape.com/").await?;
    let doc = Html::parse_document(&html);
    let next = fetch(&client, "https://books.toscrape.com/catalogue/page-2.html").await?;
    Ok::<_, anyhow::Error>(doc.root_element().text().count() + next.len())
});

Der Compiler meldet:

error: future cannot be sent between threads safely
note: future is not `Send` as this value is used across an await
    let doc = Html::parse_document(&html);
        --- has type `Html` which is not `Send`

Die Lösung besteht darin, die Auswertung innerhalb einer regulären `sync`-Funktion oder eines Blocks durchzuführen, der vor dem nächsten .await, und die eigenen Daten zurückzugeben. Deshalb parse_books ist eine einfache fn , das Vec<Book>:

// Compiles: parsing happens in a sync function that returns owned data
let handle = tokio::spawn(async move {
    let url = Url::parse("https://books.toscrape.com/")?;
    let html = fetch(&client, url.as_str()).await?;
    let (books, _) = parse_books(&html, &url);
    let next = fetch(&client, "https://books.toscrape.com/catalogue/page-2.html").await?;
    Ok::<_, anyhow::Error>(books.len() + next.len())
});

Der Html Wert wird innerhalb von parse_books, sodass die Aufgabe nur String und Book Werte über die .await.

Wie man fehlgeschlagene Anfragen höflich erneut versucht

Wiederhole nur die Fehler, die beim zweiten Mal möglicherweise erfolgreich sind: 429 „Too Many Requests“ und 5xx-Serverfehler. Warte nach jedem Fehlversuch länger, und wenn der Server einen Retry-After Header sendet, warte stattdessen so lange. Versuche es nicht erneut bei 404 oder anderen 4xx-Antworten, da eine erneute Anfrage die Antwort nicht ändern wird.

use reqwest::StatusCode;

async fn get_with_retry(client: &Client, url: &str, max_tries: u32) -> Result<String> {
    let mut delay = Duration::from_millis(500);

    for attempt in 1..=max_tries {
        match client.get(url).send().await {
            Ok(res) if res.status().is_success() => return Ok(res.text().await?),
            Ok(res)
                if res.status() == StatusCode::TOO_MANY_REQUESTS
                    || res.status().is_server_error() =>
            {
                let wait = res
                    .headers()
                    .get(reqwest::header::RETRY_AFTER)
                    .and_then(|v| v.to_str().ok())
                    .and_then(|s| s.parse::<u64>().ok())
                    .map(Duration::from_secs)
                    .unwrap_or(delay);
                eprintln!("attempt {attempt}: {} for {url}, waiting {wait:?}", res.status());
                tokio::time::sleep(wait).await;
            }
            Ok(res) => anyhow::bail!("{} for {url}", res.status()),
            Err(e) if attempt < max_tries => {
                eprintln!("attempt {attempt}: {e}");
                tokio::time::sleep(delay).await;
            }
            Err(e) => return Err(e.into()),
        }
        delay *= 2;
    }

    anyhow::bail!("gave up on {url} after {max_tries} tries")
}

Die Wartezeit verdoppelt sich nach jedem fehlgeschlagenen Versuch: eine halbe Sekunde, dann eine Sekunde, dann zwei. Netzwerkfehler wie Timeouts werden ebenfalls wiederholt, bis zum letzten Versuch. Eine fehlende Seite wird schnell als Fehler erkannt:

404 Not Found for https://books.toscrape.com/does-not-exist.html

Um dies überall zu nutzen, tauschen Sie fetch durch get_with_retry(&client, url.as_str(), 3)aus. Dieser Helper liest nur die numerische Form von Retry-After. Manche Server senden stattdessen ein HTTP-Datum, und in diesem Fall greift der Helper auf seine eigene Verzögerung zurück. Wenn du statt auf Fehler zu reagieren eine konstante Anfragerate über viele Aufgaben hinweg erzielen möchtest, füge die „governor“-Crate hinzu und warte vor jeder Anfrage auf deren Ratenbegrenzer.

So speichern Sie gescrapte Daten als CSV und JSON

Da Book abgeleitet Serialize, können die Crates „csv“ und „serde_json“ diese ohne jeglichen Mapping-Code schreiben. Die „csv“-Crate verwendet die Feldnamen der Struktur als Kopfzeile.

fn save_csv(books: &[Book], path: &str) -> Result<()> {
    let mut writer = csv::Writer::from_path(path)?;
    for book in books {
        writer.serialize(book)?;
    }
    writer.flush()?;
    Ok(())
}

fn save_json(books: &[Book], path: &str) -> Result<()> {
    std::fs::write(path, serde_json::to_string_pretty(books)?)?;
    Ok(())
}

Verbinden Sie alles in main:

#[tokio::main]
async fn main() -> Result<()> {
    let client = build_client()?;
    let books = scrape_all(&client, "https://books.toscrape.com/catalogue/page-1.html").await?;
    save_csv(&books, "books.csv")?;
    save_json(&books, "books.json")?;
    Ok(())
}

Die ersten Zeilen von books.csv sehen wie folgt aus:

title,price,rating,in_stock,url
A Light in the Attic,51.77,3,true,https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
Tipping the Velvet,53.74,1,true,https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html

Die CSV-Crate setzt Felder, die Kommas oder Anführungszeichen enthalten, in Anführungszeichen, sodass Titel mit Satzzeichen in einer Spalte bleiben. Rufe writer.flush() auf, bevor der Writer den Gültigkeitsbereich verlässt, da sonst ein Schreibfehler am Ende verloren geht. Bei sehr umfangreichen Durchläufen sollten die Bücher jeder Seite sofort beim Eintreffen geschrieben werden, anstatt alles im Speicher zu halten.

So werden mit Rust JavaScript-gerenderte Seiten ausgelesen

reqwest sieht nur den HTML-Code, den der Server sendet. Wenn eine Seite ihren Inhalt nach dem Laden mit JavaScript aufbaut, ist dieser Inhalt nicht in der Antwort enthalten, und Ihre Selektoren liefern keine Ergebnisse. Vergewissern Sie sich, dass dies tatsächlich der Fall ist, bevor Sie das Tool wechseln, und wählen Sie dann die einfachste Lösung, die funktioniert: eingebettete Daten an erster Stelle, ein Headless-Browser an zweiter Stelle und eine verwaltete API, wenn das Rendering nur ein Teil des Problems ist.

So prüfen Sie, ob eine Seite JavaScript benötigt

Rufen Sie die Seite mit reqwest ab und zählen Sie die Elemente, die Sie erwarten. quotes.toscrape.com/js/ zeigt im Browser 10 Zitate an. Behalten Sie für diesen Teil build_client und fetch in src/main.rs und ersetzen Sie den Rest durch den folgenden Code. Folgendes sieht reqwest:

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

fn count_quotes(html: &str) -> usize {
    let doc = Html::parse_document(html);
    let quote = Selector::parse("div.quote").expect("valid selector");
    doc.select(&quote).count()
}
div.quote in raw HTML: 0

Keine Übereinstimmungen im Roh-HTML und 10 auf dem Bildschirm bedeuten, dass JavaScript die Zitate generiert. Du kannst dies auch manuell überprüfen: „Quelltext anzeigen“ zeigt, was der Server gesendet hat, während das DevTools-Fenster „Elemente“ die Seite nach Ausführung der Skripte anzeigt. Wenn dein Zieltext nur in den DevTools erscheint, benötigt die Seite JavaScript oder eine andere Datenquelle.

Zunächst eingebettetes JSON extrahieren

Viele JavaScript-Seiten liefern ihre Daten innerhalb des HTML-Codes, in einem Inline- <script> , das vom Seitencode gelesen wird. „quotes.toscrape.com/js/“ tut dies mit var data = [...]. Du kannst dieses Array aus dem Roh-HTML herauslösen und es mit serde deserialisieren, ohne dass ein Browser beteiligt ist. Füge diese Typen und die Funktion in dieselbe Datei ein:

#[derive(Debug, Deserialize)]
struct Author {
    name: String,
}

#[derive(Debug, Deserialize)]
struct Quote {
    text: String,
    author: Author,
    tags: Vec<String>,
}

fn quotes_from_inline_script(html: &str) -> Result<Vec<Quote>> {
    let marker = "var data =";
    let start = html
        .find(marker)
        .ok_or_else(|| anyhow::anyhow!("no `var data` in the page"))?
        + marker.len();
    let rest = &html[start..];
    let end = rest
        .find("];")
        .ok_or_else(|| anyhow::anyhow!("end of the data array not found"))?
        + 1;
    Ok(serde_json::from_str(rest[..end].trim())?)
}

Rufe beide Funktionen für den HTML-Code aus fetch:

#[tokio::main]
async fn main() -> Result<()> {
    let client = build_client()?;
    let html = fetch(&client, "https://quotes.toscrape.com/js/").await?;
    println!("div.quote in raw HTML: {}", count_quotes(&html));
    let quotes = quotes_from_inline_script(&html)?;
    println!("quotes from the inline script: {}", quotes.len());
    let first = &quotes[0];
    println!("{} ({}) {:?}", first.text, first.author.name, first.tags);
    Ok(())
}
div.quote in raw HTML: 0
quotes from the inline script: 10
“The world as we have created it is a process of our thinking. It cannot be changed without changing our thinking.” (Albert Einstein) ["change", "deep-thoughts", "thinking", "world"]

Das sind alle 10 Zitate, getippt und strukturiert, aus einer einzigen HTTP-Anfrage. serde ignoriert JSON-Felder, die in deiner Struktur nicht deklariert sind, sodass du nur das modellierst, was du benötigst. Ein solches String-Slicing ist anfällig, wenn sich das Skript ändert; halte den Marker daher spezifisch und gib deutlich einen Fehler aus, wenn er fehlt.

Das gleiche Prinzip funktioniert auch für Daten, die nach dem Öffnen der Seite geladen werden. Öffne den Tab „Netzwerk“ in den DevTools, filtere nach „Fetch/XHR“ und lade die Seite neu. Wenn die Seite einen JSON-Endpunkt aufruft, kannst du diesen Endpunkt oft direkt mit `request` anfragen und die Antwort deserialisieren – das ist schneller und stabiler als das Parsen von HTML.

Rendere die Seite mit `headless_chrome`

Wenn die Daten erst nach dem Rendern vorliegen, nutze einen echten Browser. Die Crate „headless_chrome“ steuert Chrome oder Chromium über das DevTools-Protokoll mit einer synchronen API, sodass „tokio“ nicht benötigt wird. Füge sie mit cargo add headless_chrome. Chrome oder Chromium muss auf dem Rechner installiert sein, auf dem der Scraper läuft. Speichern Sie dies als src/bin/headless.rs und führen Sie es mit cargo run --bin headless.

use headless_chrome::{Browser, LaunchOptions};
use scraper::{Html, Selector};

fn main() -> anyhow::Result<()> {
    let browser = Browser::new(LaunchOptions::default_builder().headless(true).build()?)?;
    let tab = browser.new_tab()?;
    tab.navigate_to("https://quotes.toscrape.com/js/")?;
    tab.wait_for_element("div.quote")?;
    let html = tab.get_content()?;

    let doc = Html::parse_document(&html);
    let text = Selector::parse("div.quote span.text").expect("valid selector");
    let quotes: Vec<String> = doc.select(&text).map(|e| e.text().collect()).collect();
    println!("rendered quotes: {}", quotes.len());
    Ok(())
}
rendered quotes: 10

wait_for_element blockiert, bis der Selektor übereinstimmt, sodass du die Seite nicht liest, bevor die Skripte beendet sind. get_content gibt das gerenderte HTML zurück, das du mit demselben Scraper-Code wie zuvor parsen kannst. Das Rendern beansprucht weitaus mehr CPU-Leistung und Arbeitsspeicher als eine einfache Anfrage, verwende es daher nur für die Seiten, die es benötigen. Die headless_chrome-Dokumentation behandelt Klicks, Tastatureingaben, Screenshots und das Abfangen von Anfragen.

Asynchrone und WebDriver-Alternativen

chromiumoxide unterstützt ebenfalls das DevTools-Protokoll, jedoch mit einer asynchronen API, die sich in einen Tokio-Scraper integrieren lässt. Es gibt einen Browser und einen Handler zurück, und du musst eine Aufgabe starten, die den Handler kontinuierlich abfragt, da sonst jeder Browser-Aufruf hängen bleibt. fantoccini und thirtyfour verfolgen stattdessen den WebDriver-Ansatz. Sie steuern Chrome oder Firefox über „chromedriver“ oder „geckodriver“, die du neben deinem Scraper installieren und ausführen musst. All dies bedeutet, dass du Browser selbst ausführen und patchen musst. Wenn du Rendering, Wartezeiten und Screenshots benötigst, kannst du Seiten auch ohne ausgeführte Browser rendern, indem du die Aufgabe an eine gehostete Browser-Laufzeitumgebung übergibst.

Wann stößt das selbst erstellte Rust-Scraping an seine Grenzen?

Der Scraper, den du gerade erstellt hast, funktioniert, weil books.toscrape.com und quotes.toscrape.com Übungsseiten sind, die automatisierte Anfragen begrüßen. Viele Produktionsseiten tun dies jedoch nicht. Derselbe Code, der 1.000 fehlerfreie Buchtitel zurückgibt, kann plötzlich mit 403-Fehlern, CAPTCHA-Seiten, Ratenbeschränkungen pro IP-Adresse, Browser-Fingerabdruck-Prüfungen oder länderabhängigen Inhalten scheitern. Die Geschwindigkeit von Rust hilft hier nicht weiter, da die Beschränkungen davon abhängen, wer die Anfrage stellt, und nicht davon, wie schnell sie erfolgt.

Symptom

Mögliche Ursache

Behebung in Eigenregie

Wann man aufhören sollte

403 Forbidden bei jeder Anfrage

Die Website markiert Ihren Client oder Ihre IP-Adresse

Senden Sie realistische Header, verlangsamen Sie die Anfrage

Die Sperre bleibt auch bei niedrigen Anfrageraten bestehen

429 Zu viele Anfragen

Ratenbegrenzung pro IP oder pro Sitzung

Verringern Sie die Anzahl gleichzeitiger Zugriffe, halten Sie sich daran Retry-After

Sie benötigen mehr Durchsatz, als eine IP-Adresse zulässt

Eine CAPTCHA-Seite anstelle des Inhalts

Bot-Erkennung

Reduzieren Sie die Anfragerate, prüfen Sie die Nutzungsbedingungen der Website

CAPTCHAs erscheinen auch bei normalem Datenverkehr

Der Inhalt funktioniert im Browser, aber nicht in Headless Chrome

Fingerabdruck-Prüfungen

Überprüfen Sie die Startoptionen für den Headless-Modus

Sie verwalten Browser-Patches

Unterschiedliche Inhalte oder Preise je nach Region

Geografisch gezielte Antworten

Weiterleitung über eine IP-Adresse in diesem Land

Sie benötigen viele Länder

Jede selbst implementierte Lösung erfordert zusätzliche Infrastruktur: Proxy-Pools, Browser-Flotten, Wiederholungswarteschlangen und Überwachung. Unser Leitfaden zur Vermeidung von Sperren geht näher auf Header, Pacing und Proxys ein. Ab einem bestimmten Punkt ist es sinnvoller, das Abrufen einem Dienst zu überlassen und Ihren Rust-Code für die Analyse und Speicherung zu nutzen.

So rufen Sie die Scraper-API aus Rust auf

Die Scraper-API ruft die Seite für Sie ab, kümmert sich um den Zugriff und Wiederholungsversuche und kann JavaScript ausführen. Ihr Rust-Code behält denselben Request-Client und dieselbe Scraper-Auswertung bei. Sie senden eine GET-Anfrage mit Ihrem API-Schlüssel und einer URL-kodierten Ziel-URL und fügen dann Optionen wie render_js oder country nur dann, wenn die Seite diese benötigt.

Dieses Beispiel rendert die JavaScript-Zitate-Seite über die API von einem Standort in den USA aus und parst das Ergebnis. Der Schlüssel wird aus einer Umgebungsvariablen gelesen, sodass er niemals in Ihrem Quellcode erscheint:

use anyhow::{Context, Result};
use scraper::{Html, Selector};
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("WSA_API_KEY").context("set WSA_API_KEY first")?;
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(120))
        .build()?;

    let res = client
        .get("https://api.webscrapingapi.com/v2")
        .query(&[
            ("api_key", api_key.as_str()),
            ("url", "https://quotes.toscrape.com/js/"),
            ("render_js", "1"),
            ("country", "us"),
        ])
        .send()
        .await?;

    let status = res.status();
    let body = res.text().await?;
    if !status.is_success() {
        anyhow::bail!("API returned {status}: {}", &body[..body.len().min(300)]);
    }

    let doc = Html::parse_document(&body);
    let quote = Selector::parse("div.quote").expect("valid selector");
    println!("quotes via Scraper API: {}", doc.select(&quote).count());
    Ok(())
}

Speichern Sie die Datei als src/bin/scraper_api.rs, legen Sie den Schlüssel in Ihrer Shell fest und führen Sie es aus:

export WSA_API_KEY="your_api_key"
cargo run --bin scraper_api

Was Sie beachten sollten:

  • .query() kodiert die Ziel-URL für Sie. Das ist die reqwest-Methode, für die die query Funktion, die Sie bei der Einrichtung aktiviert haben.
  • Das Timeout ist länger als zuvor. Das Rendern einer Seite dauert länger als ein einfacher Abruf, daher lassen 120 Sekunden der API genügend Zeit, die Seite zu laden und zu rendern.
  • Die Statusprüfung gibt den Fehlertext aus. Ein ungültiger Schlüssel gibt 401 Unauthorized mit {"error":"Invalid API key"}, was weitaus einfacher zu debuggen ist als ein Parser, der keine Elemente findet.
  • Der Parsing-Code ändert sich nicht. Die Antwort ist HTML, daher funktionieren die Selektoren und Strukturen aus den vorherigen Abschnitten unverändert.

Bewahren Sie den API-Schlüssel auf der Serverseite auf. Versenden Sie ihn nicht in Client-Apps, committen Sie ihn nicht in ein Repository und geben Sie ihn nicht in Logs aus.

Häufige Rust-Scraping-Fehler und wie man sie behebt

Die meisten Rust-Scraping-Fehler sind auf Änderungen an Crate-Funktionen, asynchrone Regeln oder Seiten zurückzuführen, die nicht das enthalten, was man erwartet. Hier sind die einzelnen Symptome mit den entsprechenden Lösungen.

Fehler oder Symptom

Ursache

Behebung

E0599: Keine Methode mit dem Namen query für die Struktur RequestBuilder

Anfrage 0.13 wurde query eine Opt-in-Funktion

cargo add reqwest --features query

reqwest verfügt nicht über diese Funktion rustls-tls

Die Funktion wurde in Version 0.13 umbenannt

Entfernen (rustls ist die Standardeinstellung)

konnte nicht gefunden werden blocking in reqwest

Die blocking Funktion ist deaktiviert

Aktivieren blocking oder den asynchronen Client verwenden

Future kann nicht sicher zwischen Threads übertragen werden (Html)

Html wird über eine .await

In einer synchronen Funktion parsen und eigene Daten zurückgeben

Ein Selektor gibt nichts zurück

JavaScript-gerenderter Inhalt oder ein falscher Selektor

Überprüfen Sie den Roh-HTML-Code und gehen Sie anschließend zum JavaScript-Abschnitt über

Selector::parse Panik

Ungültige Selektor-Syntax

Testen Sie den Selektor zunächst in den DevTools

403- oder 429-Antworten

Blockierung oder Ratenbegrenzung

Verlangsamen Sie den Vorgang, versuchen Sie es mit Backoff erneut und sehen Sie sich dann den Abschnitt „DIY-Wall“ an

Relative URLs in Ihrer Ausgabe

Roh href Werte

Lösen Sie diese mit Url::join

Unlesbare Zeichen im Text

Falsche Codierungsannahme

Überprüfen Sie den Zeichensatz im Content-Type Header und im <meta charset>

Wenn ein Fehler nicht in der Tabelle aufgeführt ist, gib den Statuscode und die ersten paar hundert Bytes des Antworttextes aus. Die meisten Scraping-Fehler werden offensichtlich, sobald du siehst, was der Server tatsächlich gesendet hat.

So scrapen Sie verantwortungsbewusst mit Rust

Führen Sie das Scraping so durch, dass der Website-Betreiber damit leben kann. Lesen Sie die robots.txt der Website, die dem Robots Exclusion Protocol (RFC 9309) folgt, und überspringen Sie die Pfade, die für Ihren User-Agent nicht zugelassen sind. Halten Sie die Parallelität gering, fügen Sie Verzögerungen ein und halten Sie sich daran Retry-After , wenn der Server dich auffordert, langsamer vorzugehen. Identifiziere deinen Client mit einem User-Agent, der eine Kontakt-URL enthält. Halte dich an die Nutzungsbedingungen der Website und vermeide das Sammeln personenbezogener Daten, es sei denn, du hast eine klare rechtliche Grundlage dafür. Weitere Informationen zu unserem Ansatz findest du in unseren Richtlinien für verantwortungsvollen Umgang mit Webdaten.

FAQ

Eignet sich Rust für das Web-Scraping?

Ja, insbesondere für Scraper, die über einen langen Zeitraum laufen oder viele Seiten abrufen. Rust benötigt wenig Speicher, verarbeitet mit Tokio viele gleichzeitige Anfragen effizient und wird als einzelne Binärdatei ausgeliefert. Python ist für einmalige Skripte schneller und verfügt über mehr Browser-Tools, daher erstellen viele Teams Prototypen in Python und verlagern die „Hot Loop“ nach Rust.

Was ist das beste Rust-Crate für das Web-Scraping?

Die meisten Projekte verwenden „reqwest“ zum Senden von Anfragen und „scraper“ zum Parsen von HTML mit CSS-Selektoren, ausgeführt auf „tokio“. Füge „serde“ für strukturierte Ausgaben, „csv“ für Tabellenkalkulationen und „futures“ für begrenzte Parallelität hinzu. Für JavaScript-gerenderte Seiten füge „headless_chrome“ oder „chromiumoxide“ hinzu. Verwende „spider“, wenn du ein vollständiges Crawler-Framework anstelle einer benutzerdefinierten Schleife benötigst.

Wie scrape ich eine mit JavaScript gerenderte Website mit Rust?

Stelle zunächst sicher, dass die Daten im rohen HTML fehlen. Suche dann in einem Inline-Skript oder einer JSON-Anfrage, die die Seite stellt, danach und parse diese mit serde. Wenn die Daten erst nach dem Rendern vorhanden sind, steuere Chrome mit headless_chrome oder chromiumoxide an oder rufe eine Scraping-API auf, die JavaScript für dich rendert.

Warum lässt sich mein reqwest-Code nach dem Upgrade nicht mehr kompilieren?

reqwest 0.13 hat seine Funktionen geändert. Die .query() und .form() benötigen nun die query und form , die rustls-tls Feature wurde in rustlsumbenannt, und „rustls“ ist das Standard-TLS-Backend. Blockierende Anfragen benötigen weiterhin die blocking Feature. Aktualisieren Sie die Features in Cargo.toml und die meisten Fehler verschwinden.

Warum meldet Rust, dass der HTML-Code des Scrapers nicht zwischen Threads gesendet werden kann?

Der scraper::Html Typ ist nicht Send, daher kann eine Tokio-Task ihn nicht über eine .await. Analysieren Sie die Seite in einer regulären Funktion oder einem Block, der vor der nächsten .await, und gib eigene Werte wie String oder deine eigene Struktur zurück. Die Aufgabe enthält dann nur noch Daten, deren Verschiebung sicher ist.

Wie vermeide ich, beim Scraping mit Rust blockiert zu werden?

Sende einen eindeutigen User-Agent, verwende denselben Client, begrenze die Parallelität, füge Verzögerungen ein und versuche es bei 429-Antworten mit einem Backoff erneut, der Retry-After. Halten Sie sich an robots.txt und die Nutzungsbedingungen der Website. Websites mit CAPTCHAs, Fingerprinting oder IP-spezifischen Beschränkungen können Sie dennoch blockieren – hier helfen rotierende IPs oder eine verwaltete Scraping-API.

Kann ich Websites in Rust ohne async scrapen?

Ja. Aktivieren Sie die blocking Funktion von reqwest und verwende reqwest::blocking::Clientoder nutze die kleinere „ureq“-Crate, die von Haus aus synchron arbeitet. Das Parsen mit dem Scraper funktioniert in beiden Fällen gleich. Blockierender Code ist für kleine Skripte einfacher, aber „async“ mit „tokio“ lässt sich besser skalieren, wenn du viele Seiten auf einmal abrufst.

Wie geht es nun weiter?

Du hast nun einen Rust-Scraper, der Seiten abruft, parst, paginiert, parallel läuft, höflich Wiederholungsversuche durchführt und saubere Daten exportiert. Mit ein paar weiteren Schritten wird er produktionsreif:

  • Füge eine gleichmäßige Ratenbegrenzung mit der „governor“-Crate hinzu, sodass sich jede Aufgabe ein gemeinsames Anfragebudget teilt, anstatt auf „sleep“-Anweisungen zu setzen.
  • Rendern Sie nur dort, wo es unbedingt nötig ist. Behalten Sie „reqwest“ für statische Seiten und eingebettetes JSON bei und senden Sie nur die Seiten, die wirklich JavaScript benötigen, an Headless Chrome.
  • Verlagern Sie das Abrufen, sobald Blöcke beginnen. Sobald Sie mehr Zeit mit Proxys und CAPTCHAs verbringen als mit dem Parsen, verlagern Sie den Abrufschritt auf eine verwaltete API und behalten Sie den Rest Ihres Rust-Codes bei.

Behalte deinen Rust-Code, überspringe die Blöcke

Richten Sie denselben reqwest-Client auf die Scraper-API aus und erhalten Sie die Seite gerendert aus dem Land Ihrer Wahl zurück, ohne selbst Browser oder Proxys ausführen zu müssen. Beginnen Sie mit 5.000 kostenlosen Anfragen. Es fallen keine zusätzlichen Kosten für JavaScript-Rendering oder Geotargeting an, und fehlgeschlagene Anfragen werden nicht in Rechnung gestellt.

Siehe Preisübersicht der Scraper-API

Über den Autor

Mihai Maxim, Full-Stack-Entwickler @ WebScrapingAPI

Mihai Maxim

Full-Stack-Entwickler

Mihai Maxim ist Full-Stack-Entwickler bei WebScrapingAPI, wo er in verschiedenen Bereichen des Produkts mitwirkt und an der Entwicklung zuverlässiger Tools und Funktionen für die Plattform mitarbeitet.

Web-Scraping mit AWS Lambda: Leitfaden für Python und Java 2026
Anleitungen

Web-Scraping mit AWS Lambda: Leitfaden für Python und Java 2026

TL;DR: Kurz gesagt: Web-Scraping mit AWS Lambda funktioniert am besten, wenn jeder Aufruf kurz, begrenzt und unabhängig wiederholbar ist. Beginnen Sie mit direktem HTTP, AWS SAM und S3 und fügen Sie erst dann SQS, Container, Browser-Rendering, Proxys oder eine verwaltete Abrufebene hinzu, wenn sich im Rahmen der Arbeitslast herausstellt, dass diese erforderlich sind.

Suciu Dan26 min read
Artikel lesen
So verwenden Sie GoSpider: Crawlen, URLs bereinigen und Daten extrahieren
Anleitungen

So verwenden Sie GoSpider: Crawlen, URLs bereinigen und Daten extrahieren

TL;DR: GoSpider ist ein Befehlszeilen-Crawler zum Auffinden von URLs, kein vollständiger Scraper für strukturierte Daten. Diese Anleitung zur Verwendung von GoSpider zeigt einen begrenzten Crawl, die saubere Verarbeitung der Ausgabe, die Übergabe von Colly an CSV sowie einen Diagnosepfad für 403-Antworten oder Seiten, die eine JavaScript-Darstellung erfordern.

Suciu Dan20 min read
Artikel lesen
Wie man Redfin scrappt: Python-Leitfaden für Immobiliendaten
Anleitungen

Wie man Redfin scrappt: Python-Leitfaden für Immobiliendaten

TL;DR: Redfin stellt versteckte API-Endpunkte zur Verfügung, die strukturiertes JSON für Immobilienangebote zurückgeben, wodurch das fragile HTML-Parsing vollständig übersprungen werden kann. Diese Anleitung führt Sie durch den Aufbau eines Python-Scrapers, der Miet- und Verkaufsdaten extrahiert, nach Standort sucht, neue Angebote über XML-Sitemaps überwacht und saubere Ergebnisse in CSV oder JSON exportiert.

Suciu Dan11 min read
Artikel lesen

Los geht’s

Sind Sie bereit, Ihre Datenerfassung zu erweitern?

Schließen Sie sich den über 2.000 Unternehmen an, die WebScrapingAPI nutzen, um Webdaten im Unternehmensmaßstab ohne zusätzlichen Infrastrukturaufwand zu extrahieren.