In der Welt der Online-Immobilienanzeigen ist das Scraping von Airbnb-Immobilienanzeigen mit Rust eine unverzichtbare Fähigkeit für alle, die diese beliebte Plattform nutzen möchten, die eine große Auswahl an Unterkünften bietet. Egal, ob Sie eine Reise planen oder den Immobilienmarkt verstehen möchten, das Scraping von Airbnb-Anzeigen kann wertvolle Erkenntnisse liefern. In diesem Leitfaden erfahren Sie, wie Sie Airbnb-Anzeigen mit Rust, einer leistungsstarken Programmiersprache, scrapen können. Um unsere Scraping-Reise reibungsloser zu gestalten, verwenden wir die Crawlbase Crawling API, ein Tool, das wir in der Vergangenheit erfolgreich eingesetzt haben.

In den folgenden Abschnitten führen wir Sie durch die Einrichtung von Rust auf Ihrem Computer, stellen Ihnen die Crawlbase-API vor und führen Sie Schritt für Schritt durch das Scraping von Airbnb-Immobilienangeboten. Von der Navigation auf den Suchseiten von Airbnb bis zum Speichern Ihrer Scraping-Daten – wir haben alles im Griff. Begleiten Sie uns auf diesem Abenteuer, während wir die Stärke von Rust mit der Datenextraktion von Crawlbase kombinieren, um die in Airbnbs riesiger Sammlung von Immobilienangeboten verborgenen Informationen aufzudecken. Lassen Sie uns anfangen!

Inhaltsverzeichnis

  1. Scraping von Airbnb-Inseraten mit der Crawlbase Crawling API in Rust
  • Warum Airbnb-Immobilienangebote scrapen?
  • Vorteile der Verwendung der Crawlbase Crawling API mit Rost
  1. Einrichten Ihrer Umgebung
  • Installieren der Programmiersprache Rust
  • Erstellen eines neuen Rust-Projekts
  • Auswahl der richtigen integrierten Entwicklungsumgebung (IDE)
  • Abrufen der API-Anmeldeinformationen für die Crawlbase Crawling API
  1. Die Website-Struktur von Airbnb verstehen
  • Erkunden der Komponenten der Airbnb-Suchseite
  • Identifizierung der wichtigsten Elemente für das Scraping
  1. Einführung in Crawlbase Crawling API
  • Überblick über die Crawlbase Crawling API
  • Vorteile und Möglichkeiten der Nutzung der Crawling API
  • Crawlbase Crawling API mit Rost
  1. Scraping von Airbnb-Immobilienangeboten
  • Crawlen der HTML-Suchseite von Airbnb
  • Untersuchen von HTML zum Abrufen von CSS-Selektoren
  • Abrufen von Immobilienlistendaten aus HTML
  1. Speichern von Scraped-Daten
  • Speichern von Scraped-Daten in einer CSV-Datei
  • Speichern von Scraped-Daten in einer SQLite-Datenbank
  1. Zusammenfassung
  2. Häufig gestellte Fragen (FAQs)

Scraping von Airbnb-Inseraten mit der Crawlbase Crawling API in Rust

Ein Ausflug in die Welt des Scrapings Airbnb Inserate mit Rust und der Crawlbase-API bieten Datenenthusiasten und -forschern eine Vielzahl von Möglichkeiten. Dieses Unterfangen ermöglicht eine detaillierte Untersuchung der Funktionsweise der Airbnb-Daten und bietet einen Weg, wertvolle Erkenntnisse zu gewinnen. Lassen Sie uns nun das Scraping von Airbnb-Inseraten untersuchen und die Vorteile der Verwendung der Crawlbase entdecken. Crawling API mit Rost.

Warum Airbnb-Immobilienangebote scrapen?

Die Notwendigkeit, Airbnb zu scrapen, ergibt sich aus mehreren Faktoren, die jeweils zu einem gründlicheren Verständnis der Immobiliendynamik der Plattform beitragen:

  • Datenfülle: Airbnb hostet eine Vielzahl von Immobilienangeboten, weshalb Scraping für die umfassende Extraktion einer breiten Palette von Daten unabdingbar ist.
  • Granulare Einblicke: Für Benutzer, die nach bestimmten Details suchen oder eine eingehende Marktanalyse durchführen, bietet Scraping einen systematischen Ansatz zur Extraktion gezielter Informationen und verbessert so die Erkenntnisse über Immobilienattribute und Marktdynamik.
  • Marktforschung: Das Scraping von Airbnb-Inseraten erleichtert eine differenzierte Erkundung des Immobilienmarktes und hilft bei der Identifizierung von Trends, Preisschwankungen und beliebten Annehmlichkeiten an verschiedenen Standorten.
  • Benutzerdefinierte Abfragen: Mit Scraping können Benutzer Abfragen anpassen, um präzise Informationen zu extrahieren, egal ob es um Immobilientypen, Annehmlichkeiten oder Preisstrategien geht. Diese Anpassung gewährleistet die Extraktion relevanter und fokussierter Daten entsprechend den spezifischen Forschungsanforderungen.

Vorteile der Verwendung der Crawlbase Crawling API mit Rost

Vorteile der Verwendung der Crawlbase Crawling API mit Rost
  • Leistungsexzellenz: Der Ruf von Rust in Bezug auf Leistung, Sicherheit und Low-Level-Kontrolle passt perfekt zu den Anforderungen von Web Scraping.
  • Effizienz gesteigert: Die Fähigkeit von Rust, mit Systemdetails auf niedriger Ebene umzugehen, ergänzt die Feinheiten des Web Scraping und führt zu einem effizienten und zuverlässigen Prozess.
  • Nahtlose Integration: Die Kombination von Rust mit dem Crawling API vereinfacht komplexe Scraping-Szenarien und ermöglicht die problemlose Extraktion dynamischer Webinhalte.
  • Reibungslose Navigation: Die Fähigkeit von Crawlbase, dynamische Webinhalte zu verarbeiten, gewährleistet ein nahtloses Scraping-Erlebnis, was insbesondere für die Navigation auf den vielfältigen und dynamischen Seiten von Airbnb wichtig ist.
  • Erkennung vermeiden: Crawlbases rotierende IP-Adressen und Anti-Crawling-Maßnahmen verbessern die Zuverlässigkeit des Scraping-Prozesses und verringern das Risiko, blockiert zu werden oder auf CAPTCHA-Herausforderungen stoßen zu müssen.

Im weiteren Verlauf führen wir Sie durch die Einrichtung Ihrer Rust-Umgebung und veranschaulichen, wie Sie die Funktionen der Crawlbase-API für optimale Scraping-Ergebnisse nutzen.

Einrichten Ihrer Umgebung

Die Vorbereitung Ihrer Umgebung ist ein entscheidender Schritt, bevor Sie sich mit den Feinheiten des Scrapings von Airbnb-Immobilienangeboten mit Rust und Crawlbase befassen. Crawling API. Diese umfassende Einrichtung umfasst die Installation der erforderlichen Tools, die Auswahl einer geeigneten integrierten Entwicklungsumgebung (IDE) und das Abrufen der erforderlichen API-Anmeldeinformationen. Lassen Sie uns jede Komponente aufschlüsseln, um einen reibungslosen und effizienten Entwicklungsprozess zu gewährleisten.

Installieren der Programmiersprache Rust

Die Installation von Rust und die Konfiguration von Abhängigkeiten sind wichtige Schritte, um Ihre Umgebung für das Scraping von Airbnb-Immobilienangeboten mit Rust und Crawlbase einzurichten. Crawling API. Befolgen Sie die nachstehenden ausführlichen Anweisungen für die Betriebssysteme Windows und Ubuntu.

Rust unter Windows installieren:

  • Besuchen Sie die offizielle Rust-Website: https://www.rust-lang.org/tools/install.
  • Klicken Sie auf die Schaltfläche „Rust herunterladen“.
  • Führen Sie die heruntergeladene ausführbare Datei aus.
  • Befolgen Sie die Installationsanweisungen auf dem Bildschirm und stellen Sie sicher, dass Sie während des Installationsvorgangs die Option zum Hinzufügen von Rust zum Systempfad auswählen.

Rust auf Ubuntu installieren:

  • Öffnen Sie ein Terminalfenster.
  • Führen Sie den folgenden Befehl aus, um das Rust-Installationsprogramm herunterzuladen und auszuführen:
1
curl --proto '=https' --tlsv1.3 https://sh.rustup.rs -sSf | sh
  • Befolgen Sie die Anweisungen auf dem Bildschirm, um die Rust-Installation abzuschließen. Stellen Sie sicher, dass Sie die Option zum Hinzufügen von Rust zum Systempfad auswählen.

Erstellen eines neuen Rust-Projekts

Bevor wir uns mit dem Web Scraping mit Rust befassen, erstellen wir ein neues Rust-Projekt, um den Code organisiert zu halten. Befolgen Sie diese Schritte, um mit Cargo, dem Paketmanager von Rust, ein Projektverzeichnis und ein einfaches „Hallo Welt!“-Rust-Programm zu erstellen.

Erstellen eines Projektverzeichnisses

Beginnen Sie mit der Erstellung eines Verzeichnisses zum Speichern Ihres Rust-Codes. Zur besseren Organisation empfehlen wir die Erstellung eines Projektverzeichnisses in Ihrem Home-Verzeichnis.

Für Linux, macOS und Power-Shell unter Windows:

1
2
3
4
$ mkdir ~/Projekte
$ cd ~/Projekte
$ Fracht neu my_airbnb_scraper
$ cd mein_airbnb_scraper

Für Windows CMD:

1
2
3
4
> mkdir "%BENUTZERPROFIL%\Projekte"
> cd /d "%BENUTZERPROFIL%\Projekte"
> Fracht neu my_airbnb_scraper
> cd mein_airbnb_scraper

Projektstruktur

Wenn Sie verwenden, cargo new, Cargo initialisiert ein neues Rust-Projekt für Sie. Es erstellt ein Cargo.toml Datei, die die Konfigurationsdatei für Ihr Projekt ist, und eine src Verzeichnis, das die . enthält main.rs Datei, in der sich Ihr Rust-Code befindet.

1
2
3
4
mein_airbnb_scraper
|-- Cargo.toml
`-- Quelle
    `-- main.rs

Schreiben und Ausführen eines Rust-Programms

Öffnen Sie den Microsoft Store auf Ihrem Windows-PC. main.rs Datei in das src Verzeichnis und ersetzen Sie seinen Inhalt durch den folgenden Code:

1
2
3
4
5
// Dateiname: main.rs

fn Haupt-() {
    drucken!("Hallo Welt!");
}

Speichern Sie die Datei und kehren Sie zu Ihrem Terminalfenster im ~/projects/my_airbnb_scraper Verzeichnis. Verwenden Sie den folgenden Befehl, um die Datei zu kompilieren und auszuführen:

Für Linux, macOS oder Windows CMD:

1
Ladelauf

Unabhängig von Ihrem Betriebssystem sollten Sie die Ausgabe „Hallo Welt!“ auf dem Terminal sehen. Herzlichen Glückwunsch! Sie haben gerade Ihr erstes Rust-Programm geschrieben und ausgeführt und damit Ihren Einstieg in die Welt der Rust-Programmierung markiert. Willkommen!

Erforderliche Abhängigkeiten installieren:

  • Öffnen Sie eine Eingabeaufforderung oder ein Terminalfenster in Ihrem Projektverzeichnis.
  • Verwenden Sie die folgenden Befehle, um die erforderlichen Rust-Bibliotheken (Kisten) für das Web Scraping hinzuzufügen:
1
2
3
4
5
6
Fracht hinzufügen Anfrage
Ladungszugabeschaber
Fracht URL-Kodierung hinzufügen
Fracht hinzufügen CSV
Fracht hinzufügen Serde
Fracht hinzufügen rusqlite
  1. Bitte: Eine beliebte HTTP-Clientbibliothek für Rust, die das Erstellen von HTTP-Anfragen vereinfacht. Sie wird häufig für Web Scraping und die Interaktion mit Web-APIs verwendet.
  2. Schaber: Eine Rust-Kiste für HTML- und XML-Analyse das eine bequeme Möglichkeit zum Navigieren und Bearbeiten strukturierter Dokumente mithilfe von Selektoren bietet, ähnlich wie jQuery in JavaScript.
  3. URL-Kodierung: Eine Rust-Kiste zur URL-Kodierung und -Dekodierung. Sie erleichtert die Manipulation von URL-Komponenten und gewährleistet die richtige Formatierung für die Verwendung in HTTP-Anfragen oder anderen Kontexten, in denen URLs kodiert werden müssen.
  4. csv: Diese Rust-Kiste wird zum Lesen und Schreiben von CSV-Dateien (Comma-Separated Values) verwendet. Sie bietet Funktionen zum Parsen von CSV-Daten in strukturierte Datensätze und zum Zurückkonvertieren strukturierter Datensätze in das CSV-Format. Die csv Crate ist unverzichtbar, wenn Sie tabellarische Daten speichern oder abrufen möchten, und ist besonders nützlich zum Speichern von Scraped-Informationen.
  5. sein von: Ein vielseitiges Serialisierungs- und Deserialisierungsframework für Rust. Das serde Mit Crate können Sie Rust-Datenstrukturen nahtlos in verschiedene Formate wie JSON oder Binärdateien konvertieren und umgekehrt. Die Einbindung ist wichtig, wenn Sie Daten dauerhaft in einem serialisierten Format speichern oder übertragen müssen, eine häufige Anforderung in Web Scraping-Szenarien.
  6. Abonnieren: Das rusqlite Crate ist eine Rust-Bibliothek für die Interaktion mit SQLite-Datenbanken. Sie bietet eine praktische und sichere Schnittstelle zum Ausführen von SQL-Operationen, sodass Rust-Programme eine Verbindung zu SQLite-Datenbanken herstellen, Abfragen ausführen und Transaktionen effizient verwalten können.

Cargo.toml Dateivorschau:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[Paket]
Name = "mein_airbnb_scraper"
Version = "0.1.0"
Ausgabe = "2021"

# Weitere Schlüssel und ihre Definitionen finden Sie unter https://doc.rust-lang.org/cargo/reference/manifest.html

[Abhängigkeiten]
csv = "1.3.0"
Bitte = { version = "0.11.22", Funktionen = ["Blockierung"]}
Abonnieren = "0.30.0"
Schaber = "0.18.1"
sein von = { version = "1.0.193", Funktionen = ["ableiten"]}
URL-Kodierung = "2.1.3"

Diese Schritte stellen sicher, dass Sie Rust zusammen mit den erforderlichen Crates für effektives Web Scraping auf Ihrem System installiert haben.

Auswahl der richtigen integrierten Entwicklungsumgebung (IDE)

Die Auswahl der richtigen integrierten Entwicklungsumgebung (IDE) ist eine wichtige Entscheidung, die Ihre Entwicklungserfahrung bei der Arbeit mit Rust für Web Scraping erheblich beeinflussen kann. Hier sind einige beliebte IDEs, die Sie in Betracht ziehen können:

Visual Studio-Code (VS-Code):

  • Webseite: https://code.visualstudio.com/
  • Beschreibung: VS Code ist ein kostenloser, quelloffener Code-Editor, der von Microsoft entwickelt wurde. Er bietet eine breite Palette an Erweiterungen und ist daher vielseitig für verschiedene Programmieraufgaben geeignet, darunter Web Scraping in Rust.
  • Eigenschaften:
    • IntelliSense zur Codevervollständigung.
    • Integrierte Git-Unterstützung.
    • Erweiterungen für die Rust-Programmierung.

IntelliJ IDEA mit Rust-Plugin:

  • Webseite: https://www.jetbrains.com/idea/
  • Beschreibung: IntelliJ IDEA ist eine leistungsstarke IDE mit einem Rust-Plugin, das hervorragende Unterstützung für die Rust-Entwicklung bietet. Obwohl IntelliJ IDEA nicht kostenlos ist, bietet es eine kostenlose Community Edition mit grundlegenden Funktionen.
  • Eigenschaften:
    • Intelligente Code-Vervollständigung.
    • Erweiterte Navigation und Refactoring.
    • Eingebautes Terminal.

Eclipse mit RustDT-Plugin:

  • Webseite: https://www.eclipse.org/
  • Beschreibung: Eclipse ist eine weit verbreitete IDE und das RustDT-Plugin erweitert ihre Fähigkeiten für die Rust-Entwicklung. Es ist eine Open-Source-Option, die für Entwickler geeignet ist, die mit Eclipse vertraut sind.
  • Eigenschaften:
    • Rust-Projektmanagement.
    • Syntaxhervorhebung und Codevervollständigung.
    • Integrierter Debugger.

Rostanalysator (Standalone):

  • Webseite: https://rust-analyzer.github.io/
  • Beschreibung: Rust Analyzer ist keine traditionelle IDE, sondern ein Sprachserver, der mit verschiedenen Code-Editoren funktioniert. Er bietet Funktionen wie Code-Vervollständigung, Referenzsuche und mehr.
  • Eigenschaften:
    • Leicht und schnell.
    • Funktioniert mit Editoren wie VS Code, Sublime Text und anderen.

Probieren Sie ein paar Optionen aus, um herauszufinden, welche am besten zu Ihren Präferenzen und Entwicklungsanforderungen passt. Jede hier erwähnte IDE hat ihre Stärken, also wählen Sie diejenige aus, die zu Ihrem Rust-Web-Scraping-Projekt passt.

Abrufen der API-Anmeldeinformationen für die Crawlbase Crawling API

Um unser Web Scraping Projekt erfolgreich zu machen, nutzen wir die Leistungsfähigkeit der Crawlbase Crawling API. Diese API ist darauf ausgelegt, komplexe Web Scraping-Szenarien wie Airbnb-Preise effizient zu handhaben. Sie vereinfacht den Zugriff auf Webinhalte und umgeht dabei gängige Herausforderungen wie JavaScript-Rendering, CAPTCHAs und Anti-Scraping-Maßnahmen.

So starten Sie mit der Crawlbase Crawling API:

  1. Besuchen Sie die Crawlbase-Website: Öffnen Sie Ihren Webbrowser und navigieren Sie zu Crawlbase-Anmeldeseite um den Registrierungsprozess zu starten.
  2. Geben Sie Ihre Daten an: Sie werden aufgefordert, Ihre E-Mail-Adresse anzugeben und ein Passwort für Ihr Crawlbase-Konto zu erstellen. Geben Sie die erforderlichen Informationen ein.
  3. Verification: Nach dem Absenden Ihrer Daten müssen Sie möglicherweise Ihre E-Mail-Adresse bestätigen. Suchen Sie in Ihrem Posteingang nach einer Bestätigungs-E-Mail von Crawlbase und folgen Sie den bereitgestellten Anweisungen.
  4. Login: Sobald Ihr Konto verifiziert ist, kehren Sie zur Crawlbase-Website zurück und melden Sie sich mit Ihren neu erstellten Anmeldeinformationen an.
  5. Greifen Sie auf Ihr API-Token zu: Sie benötigen ein API-Token, um die Crawlbase zu verwenden Crawling API. Sie finden Ihre API-Token auf Ihrem Crawlbase-Dashboard.

Note: Crawlbase bietet zwei Arten von Token an, einen für statische Websites und einen für dynamische oder JavaScript-basierte Websites. Da wir Airbnb scrapen, das für das dynamische Laden von Inhalten auf JavaScript angewiesen ist, entscheiden wir uns für den JavaScript-Token. Crawlbase bietet großzügigerweise ein anfängliches Kontingent von 1,000 kostenlosen Anfragen für den Crawling API, was es zu einer ausgezeichneten Wahl für unser Web-Scraping-Projekt macht.

Nachdem wir nun unsere Umgebung eingerichtet haben, sind wir bereit, tiefer in die Website-Struktur von Airbnb einzutauchen und die Crawlbase effektiv zu nutzen. Crawling API für unser Web-Scraping-Vorhaben.

Die Website-Struktur von Airbnb verstehen

Die Geheimnisse der Airbnb-Website-Architektur zu entschlüsseln ist so, als würde man vor Antritt einer Reise eine Karte in die Hand nehmen. In diesem Abschnitt entschlüsseln wir die komplexen Komponenten der Airbnb-Suchseite und beleuchten die Schlüsselelemente, die das Fundament einer effektiven Scraping-Strategie bilden.

Die Komponenten der Airbnb-Suchseite erkunden

Airbnb-Suchseite
  1. Suchleiste:

Die Suchleiste ist der digitale Kompass für Benutzer, die durch das umfangreiche Angebot von Airbnb navigieren. Sie ist nicht nur ein visuelles Element, sondern ein interaktives Gateway. Durch die Untersuchung des HTML hinter dieser Leiste erhalten wir Einblicke, wie Airbnb Suchanfragen programmgesteuert strukturiert.

  1. Suchergebnisse:

Wenn Benutzer auf „Suchen“ klicken, enthüllt die Seite eine Fülle von Immobilienergebnissen. Jeder Eintrag befindet sich in einer bestimmten HTML-Struktur. Das Erfassen der Nuancen dieser Containerelemente ist entscheidend, um einzelne Immobiliendetails systematisch isolieren und extrahieren zu können.

  1. Filter:

Airbnb stellt den Nutzern Filter zur Verfügung, die eine Feinabstimmung der Ergebnisse ermöglichen. Die HTML-Elemente, die diesen Filtern entsprechen, müssen identifiziert werden. Das Erkennen dieser Markierungen ermöglicht ein präzises Scraping basierend auf Kriterien wie Preisspanne, Immobilientyp und Ausstattung.

  1. Paginierung:

Wenn sich die Schatztruhe der Ergebnisse über mehrere Seiten erstreckt, kommt die Paginierung ins Spiel. Zu verstehen, wie Airbnb die Paginierung in der HTML-Struktur implementiert, ist vergleichbar mit dem Entschlüsseln der Wendepunkte unserer Karte. Es ebnet den Weg für eine systematische Erkundung verschiedener Ergebnisseiten.

Identifizieren der Schlüsselelemente für das Scraping

Bei der Suche nach Airbnb-Unterkunftsdaten ist die Auswahl der richtigen HTML-Elemente der Kompass, der zum Erfolg führt:

  1. Container für Immobilienangebote:

Der Ausgangspunkt in der riesigen HTML-Landschaft besteht darin, den Container zu finden, der die einzelnen Immobilieneinträge enthält. Dieser Container wird zum Mittelpunkt der Iteration, eine Schatztruhe, die darauf wartet, für Details geöffnet zu werden.

  1. Listing Details:

Jeder Inseratscontainer enthält wertvolle Informationen – Name der Immobilie, Preis, Lage und Ausstattung. Um diese Details zu enthüllen, ist Präzision von größter Bedeutung. CSS-Selektoren mit chirurgischer Präzision gewährleistet die Extraktion relevanter Details unabhängig von Präsentationsvariationen.

  1. Seitennummerierungssteuerung:

Bei Abenteuern über mehrere Seiten ist es wichtig, die HTML-Steuerelemente zur Paginierung zu verstehen. Durch die Identifizierung von Links zu den nächsten und vorherigen Seiten kann der Scraper nahtlos durch die umfangreichen Immobilienangebote von Airbnb navigieren.

Nachdem wir nun eine detaillierte Karte der Airbnb-Website haben, besteht der nächste Schritt darin, Rust und die Crawlbase zu verwenden Crawling API um diesen digitalen Raum zu erkunden und Informationen daraus zu sammeln.

Einführung in Crawlbase Crawling API

Wenn wir uns auf die Reise begeben, Airbnb-Preisdaten zu scrapen, kommen wir zu einem entscheidenden Verbündeten – der Crawlbase Crawling API. In diesem Abschnitt geben wir einen Überblick über dieses unverzichtbare Tool und erläutern seine Vorteile und Fähigkeiten im Bereich des Airbnb-Scrapings. Darüber hinaus zeigen wir Ihnen, wie Sie die Leistungsfähigkeit der Crawlbase-Python-Bibliothek für ein nahtloses Scraping-Erlebnis nutzen können.

Übersicht über Crawlbase Crawling API

Die Crawlbase Crawling API ist eine vielseitige Lösung, die auf die Komplexität des Web Scraping zugeschnitten ist, insbesondere in Szenarien wie Airbnb, wo dynamische Inhalte eine geschickte Handhabung erfordern. Diese API ist ein echter Game-Changer, da sie den Zugriff auf Webinhalte vereinfacht, JavaScript rendert und HTML-Inhalte präsentiert, die zur Analyse bereit sind.

Vorteile und Möglichkeiten der Nutzung der Crawling API

Nutzung der Crawlbase Crawling API für das Scraping von Airbnb bringt mehrere Vorteile mit sich:

  1. JavaScript-Rendering: Viele Websites, darunter auch Airbnb, verlassen sich beim dynamischen Laden von Inhalten stark auf JavaScript. Die Crawlbase-API verarbeitet diese Elemente geschickt und gewährleistet umfassenden Zugriff auf die dynamisch gerenderten Seiten von Airbnb.
  2. Vereinfachte Anfragen: Die API abstrahiert die Komplexität der Verwaltung HTTP-Anfragen, Cookies und Sitzungen. So können Sie sich auf die Verfeinerung Ihrer Scraping-Logik konzentrieren, während die API die technischen Nuancen nahtlos übernimmt.
  3. Gut strukturierte Daten: Die über die API erhaltenen Daten sind in der Regel gut strukturiert, was die Datenanalyse und Extraktionsprozess. Dadurch wird sichergestellt, dass Sie die gewünschten Preisinformationen effizient von Airbnb abrufen können.
  4. Skalierbarkeit: Die Crawlbase Crawling API unterstützt skalierbares Scraping durch effiziente Verwalten mehrerer Anfragen gleichzeitig. Diese Skalierbarkeit ist insbesondere angesichts der vielfältigen und umfangreichen Preisinformationen auf Airbnb von Vorteil.

Note: Die Crawlbase Crawling API bietet Ihnen eine Vielzahl von Parametern, mit denen Sie Ihre Scraping-Anfragen optimieren können. Diese Parameter können an Ihre individuellen Anforderungen angepasst werden, sodass Ihre Web-Scraping-Bemühungen effizienter und präziser werden. Sie können die vollständige Liste der verfügbaren Parameter im API-Dokumentation.

Crawlbase Crawling API mit Rost

Bei der Verwendung von Rust für Bahnkratzen mit der Crawlbase Crawling API, interagieren Sie direkt mit der API, indem Sie HTTP-Anfragen stellen. Obwohl Crawlbase derzeit keine dedizierte Rust-Bibliothek bereitstellt, ist die Integration in Ihre Rust-Anwendung ein unkomplizierter Vorgang.

Hier ist eine Schritt-für-Schritt-Anleitung zur Nutzung der Crawlbase Crawling API mit Rust:

HTTP-Anfragen stellen:

Nutzen Sie die HTTP-Clientbibliotheken von Rust, wie z. B. reqwest oder surf, um HTTP-Anfragen an die Crawlbase zu stellen Crawling API Endpunkt. Erstellen Sie die API-Anforderungs-URL, indem Sie „user_token“ durch Ihr tatsächliches Crawlbase-API-Token und „url_to_scrape“ durch die URL der Airbnb-Unterkunftsseite ersetzen, die Sie scrapen möchten.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Beispiel mit reqwest
- erwünscht;

fn Haupt-() -> Ergebnis<(), reqwest::Fehler> {
    lassen Benutzertoken = "IHR_CRAWLBASE_TOKEN";
    lassen Zu scrapende URL = „https://www.airbnb.com/property-page-url“;
    lassen api_url = Format!(„https://api.crawlbase.com/?token={}&url={}“, Benutzertoken, zu scrapende URL);

    lassen Antwort = AnforderungWest::Blockierung::bekommen(&API_URL)?;

    // Behandeln Sie hier die API-Antwort
    drucken!("Antwort: {:?}", Antwort);

    Ok(())
}

API-Antworten verarbeiten:

Die API-Antwort erfolgt je nach ausgewählter Option entweder im JSON- oder HTML-Format. Wenn Sie HTML wählen, enthält die Antwort den HTML-Inhalt der angeforderten URL.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Beispiel Fortsetzung
- std::io::Lesen;

fn Haupt-() -> Ergebnis<(), reqwest::Fehler> {
    // ... (vorheriger Code)

    lassen mut Inhalt = Schnur::neu();
    Antwort.in_reader().In Zeichenfolge lesen(&mut Inhalt)?;

    // Jetzt enthält „content“ den HTML-Inhalt der gescrapten Seite
    drucken!(„HTML-Inhalt: {}“, Inhalt);

    Ok(())
}

Fehlerbehandlung:

Implementieren Sie eine geeignete Fehlerbehandlung, um potenzielle Probleme wie Netzwerkfehler oder erfolglose API-Anfragen zu beheben.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Beispiel Fortsetzung
fn Haupt-() -> Ergebnis<(), reqwest::Fehler> {
    // ... (vorheriger Code)

    if Antwort.Status().ist_erfolg() {
        // Erfolgreiche API-Antwort
        drucken!("Anfrage erfolgreich!");
    } sonst {
        // Fehler bei API-Anfragen behandeln
        drucken!(„Anforderung fehlgeschlagen mit Statuscode: {}“, Antwort.Status());
    }

    Ok(())
}

Indem Sie diese Schritte in Ihre Rust-Anwendung integrieren, können Sie die Crawlbase effektiv nutzen Crawling API um die Immobilienseiten von Airbnb zu durchsuchen und wertvolle Informationen für Ihr Projekt zu extrahieren.

Scraping von Airbnb-Immobilienangeboten

Nachdem wir uns nun mit den Feinheiten der Initiierung von Anfragen und dem Verständnis der HTML-Struktur von Airbnb befasst haben, tauchen wir nun in den praktischen Prozess des Scrapings von Airbnb-Immobilienangeboten mit Rust und der Crawlbase ein. Crawling API.

Crawlen der HTML-Suchseite von Airbnb

Im Bereich Rust, Interaktion mit der Crawlbase Crawling API beinhaltet das Erstellen von HTTP-Anfragen zum Abrufen von HTML-Inhalten. Unten sehen Sie ein Beispiel für einen Rust-Codeausschnitt, der zeigt, wie eine GET-Anfrage an die Airbnb-Suchseite initiiert wird. Kopieren Sie diesen Code und ersetzen Sie ihn durch main.rs Dateiinhalt damit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Crawling der HTML-Suchseite von Airbnb

- erwünscht;
- urlencoding::kodieren;

fn Haupt-() -> Ergebnis<(), reqwest::Fehler> {
    // Kodieren Sie die Airbnb-URL mithilfe der Urlencoding-Kiste
    lassen kodierte Airbnb-Such-URL = kodieren("https://www.airbnb.com/s/United-States/homes?query=United%20States&checkin=2023-12-07&checkout=2023-12-08&adults=2");

    // Ersetzen Sie „YOUR_CRAWLBASE_JS_TOKEN“ durch Ihr Token
    lassen crawlbase_api_url = Format!(„https://api.crawlbase.com/?token=YOUR_CRAWLBASE_JS_TOKEN&url={}&page_wait=5000&ajax_wait=true“, codierte_airbnb_search_url);

    // Machen Sie eine GET-Anfrage an die Airbnb-Suchseite
    lassen Antwort = AnforderungWest::Blockierung::bekommen(crawlbase_api_url)?;

    //Überprüfen Sie, ob die Anfrage erfolgreich war (Statuscode 200)
    if Antwort.Status().ist_erfolg() {
        // Extrahierter HTML-Inhalt
        lassen suchseite_html = Antwort.Text()?;
        drucken!("{}", Suchseite_html);
    } sonst {
        drucken!(„Die Seite konnte nicht abgerufen werden. Statuscode: {}“, Antwort.Status());
    }

    Ok(())
}

Dieser Rust-Code verwendet die reqwest Kiste, um eine GET-Anfrage an die Airbnb-Suchseite über die Crawlbase durchzuführen Crawling APIdem „Vermischten Geschmack“. Seine crawlbase_api_url Variable ist eine URL, die mit Ihrem Crawlbase API-Token und der codierten Airbnb-Suchseiten-URL mit bestimmten Suchparametern wie Standort, Check-in- und Check-out-Daten und Anzahl der Erwachsenen erstellt wurde. Der Code sendet diese URL dann über die reqwest::blocking::get Funktion, die den HTML-Inhalt der Suchseite abruft. Sie überprüft, ob die Anfrage erfolgreich war, indem sie den Statuscode untersucht, und druckt bei Erfolg den extrahierten HTML-Inhalt aus. Dieser Code dient als erster Schritt beim Web Scraping von Airbnb-Immobilienangeboten und ruft das Roh-HTML für die weitere Analyse und Extraktion von Immobiliendaten ab.

Beispielausgabe:

Gecrawlter HTML-Screenshot

Untersuchen von HTML zum Abrufen von CSS-Selektoren

Nachdem der HTML-Inhalt von der Eigenschaftenseite abgerufen wurde, besteht der nächste Schritt darin, seine Struktur zu analysieren und den Speicherort der Preisdaten zu ermitteln. Bei dieser Aufgabe kommen uns Webentwicklungstools und Browser-Entwicklertools zu Hilfe. Lassen Sie uns skizzieren, wie Sie die HTML-Struktur überprüfen und diese wertvollen CSS-Selektoren freilegen können:

Airbnb-Suchseite prüfen
  1. Öffnen Sie die Webseite: Navigieren Sie zur Airbnb-Website und landen Sie auf einer Immobilienseite, die Ihr Interesse weckt.
  2. Klicken Sie mit der rechten Maustaste und prüfen Sie: Klicken Sie mit der rechten Maustaste auf ein Element, das Sie extrahieren möchten (z. B. eine Buy Box), und wählen Sie im Kontextmenü „Untersuchen“ oder „Element untersuchen“. Dieser mystische Zauberspruch ruft die Entwicklertools des Browsers hervor.
  3. Suchen Sie die HTML-Quelle: Innerhalb der Grenzen der Entwicklertools wird der HTML-Quellcode der Webseite seine Geheimnisse preisgeben. Bewegen Sie den Cursor über verschiedene Elemente im HTML-Bedienfeld und erleben Sie, wie die entsprechenden Teile der Webseite wie von Zauberhand aufleuchten.
  4. Identifizieren von CSS-Selektoren: Um Daten aus einem bestimmten Element freizugeben, klicken Sie in den Entwicklertools mit der rechten Maustaste darauf und wählen Sie „Kopieren“ > „Selektor kopieren“. Mit diesem eleganten Manöver wird der CSS-Selektor für dieses Element in Ihre Zwischenablage übertragen, damit er für Ihre Web Scraping-Beschwörungen verwendet werden kann.

Sobald Sie über diese Selektoren verfügen, können Sie mit der Strukturierung Ihres Daten-Scrapers fortfahren, um die erforderlichen Informationen effektiv zu extrahieren.

Abrufen von Immobilienlistendaten aus HTML

Mit den identifizierten CSS-Selektoren können wir nun die Daten der Immobilienliste aus dem HTML abrufen. Wir verwenden Scraper, eine beliebte HTML-Parsing-Kiste, um das HTML zu durchsuchen und Informationen aus den angegebenen Elementen zu sammeln.

Sie können beispielsweise Immobilientitel, Preise, Bewertungen und andere relevante Details aus dem HTML-Inhalt extrahieren. Die abgerufenen Daten werden dann strukturiert und können zur weiteren Analyse oder Verarbeitung gespeichert werden. Lassen Sie uns unser vorheriges Skript erweitern und diese Informationen aus HTML extrahieren.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
- erwünscht;
- Scraper::{Html, Selektor};
- urlencoding::kodieren;

fn Haupt-() -> Ergebnis<(), reqwest::Fehler> {
    // Kodieren Sie die Airbnb-URL mithilfe der Urlencoding-Kiste
    lassen kodierte Airbnb-Such-URL = kodieren("https://www.airbnb.com/s/United-States/homes?query=United%20States&checkin=2023-12-07&checkout=2023-12-08&adults=2");

    // Ersetzen Sie „YOUR_CRAWLBASE_JS_TOKEN“ durch Ihr tatsächliches Crawlbase-API-Token
    lassen crawlbase_api_url = Format!(„https://api.crawlbase.com/?token=YOUR_CRAWLBASE_JS_TOKEN&url={}&page_wait=5000&ajax_wait=true“, codierte_airbnb_search_url);

    // Machen Sie eine GET-Anfrage an die Airbnb-Suchseite
    lassen Antwort = AnforderungWest::Blockierung::bekommen(&crawlbase_api_url)?;

    //Überprüfen Sie, ob die Anfrage erfolgreich war (Statuscode 200)
    if Antwort.Status().ist_erfolg() {
        // Extrahierter HTML-Inhalt
        lassen suchseite_html = Antwort.Text()?;

        // Daten aus HTML extrahieren
        lassen Ergebnisse = Seite scrapen(&Suchseite_html);

        // Drucken oder verwenden Sie die Scraped-Daten
        
für Folge in Ergebnisse {
            drucken!("Titel: {}", Ergebnis.Titel);
            drucken!("Bewertung: {}", Ergebnis.Bewertung);
            drucken!("Preis: {}", Ergebnis.Preis);
            drucken!("---");
        }
    } sonst {
        drucken!(
            „Die Seite konnte nicht abgerufen werden. Statuscode: {}“,
            Antwort.Status()
        );
    }

    Ok(())
}

// Struktur zur Darstellung eines Suchergebnisses
#[ableiten(Debug)]
struct Suchergebnis {
    Titel: Schnur,
    Bewertung: Schnur,
    Preis: Schnur,
}

// Daten aus HTML extrahieren und ein Array von SearchResult-Objekten zurückgeben
fn Seite scrapen(html: &str) -> Ein Ding{
    lassen Fragment = HTML::Dokument analysieren(html);
    lassen Wähler = Selektor::parsen(„div#site-content div[itemprop=\"itemListElement\"]“).auspacken();

    // Initialisieren Sie einen Vektor zum Speichern der Suchergebnisse
    lassen mut Ergebnisse = Ein Ding::neu();

    // Über jedes Listing-Ergebnis iterieren und Daten extrahieren
    
für Knoten in Fragment.wählen(&Selektor) {
        lassen Titel = Text extrahieren(&Knoten, "div[data-testid=\"Auflistungskartentitel\"]");
        lassen Wertung = Text extrahieren(&Knoten, „div.g1qv1ctd span span.r1dxllyb“);
        lassen Preis  = Text extrahieren(&Knoten, „div.g1qv1ctd div.pquyp1l div._i5duul span.a8jt5op“);

        // Erstelle ein SearchResult-Objekt und füge es dem Vektor hinzu
        lassen Folge = Suchergebnis {
            Titel,
            Bewertung,
            Preis,
        };
        Ergebnisse angezeigtdrücken(Ergebnis);
    }

    Ergebnisse
}

// Hilfsfunktion zum Extrahieren von Textinhalten aus einem bestimmten Selektor
fn Text extrahieren(Knoten: &scraper::ElementRef, Selektor: &str) -> Schnur {
    lassen Unterselektor = Selektor::parsen(Wähler).auspacken();
    if lassen Manche(Element) = Knoten.wählen(&sub_selektor).weiter() {
        Element.Text().sammeln()
    } sonst {
        Schnur::neu()
    }
}

Das Skript beginnt mit der Kodierung der Airbnb-Such-URL mit den erforderlichen Abfrageparametern. Anschließend erstellt es eine URL für eine Web Scraping-API (vermutlich Crawlbase) und sendet eine GET-Anfrage, um den HTML-Inhalt der Airbnb-Suchseite abzurufen. Nachdem sichergestellt wurde, dass die Anfrage erfolgreich war, fährt das Skript mit der Extraktion des HTML-Inhalts fort und verwendet die scraper Kiste, um das Dokument zu analysieren. Es verwendet CSS-Selektoren, um bestimmte Elemente anzusprechen, die Immobilienangebote darstellen. Die extrahierten Daten, einschließlich Immobilientitel, Bewertungen und Preise, werden in einem strukturierten Format unter Verwendung eines benutzerdefinierten SearchResult struct. Schließlich druckt oder verwendet das Skript die Scraped-Daten. Es ist wichtig zu beachten, dass beim Einsatz solcher Skripte verantwortungsvolle Web Scraping-Praktiken, die Einhaltung der Servicebedingungen und ethische Aspekte beachtet werden sollten.

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
Titel : Wohnmobil/Wohnwagen in Half Moon Bay
Rating: 4.99 (85)
Preis: $329 pro Nacht
---
Titel : Baumhaus in East Point
Rating: 4.78 (442)
Preis: $250 pro Nacht, ursprünglich $300
---
Titel : Chalet in Skykomish
Rating: 4.84 (568)
Preis: $295 pro Nacht, ursprünglich $365
---
Titel : Baumhaus in Port Angeles
Rating: 4.87 (484)
Preis: $325 pro Nacht
---
Titel : Kleines Haus in Orderville
Rating: 4.93 (317)
Preis: $162 pro Nacht, ursprünglich $249
---
Titel : Kleines Haus in Putney
Rating: 4.95 (647)
Preis: $200 pro Nacht
---
Titel : Zuhause in Williams
Rating: 5.0 (21)
Preis: $235 pro Nacht, ursprünglich $349
---
Titel : Bauernhofaufenthalt in Kalispell
Rating: 5.0 (161)
Preis: $199 pro Nacht, ursprünglich $266
---
Titel : Hütte in Woodstock
Rating: 4.9 (41)
Preis: $70 pro Nacht, ursprünglich $148
---
Titel : Hütte in Fredericksburg
Rating: 4.97 (312)
Preis: $215 pro Nacht
---
Titel : Eigentumswohnung in Whitethorn
Rating: 4.97 (111)
Preis: $500 pro Nacht
---
Titel : Hütte in Canes Bed Rd
Rating: 5.0 (655)
Preis: $80 pro Nacht
---
Titel : Schloss in Sequim
Rating: 4.77 (410)
Preis: $235 pro Nacht, ursprünglich $334
---
Titel : Kuppel im Joshua Tree
Rating: 4.95 (736)
Preis: $89 pro Nacht, ursprünglich $159
---
Titel : Gästehaus in Idledale
Rating: 4.96 (759)
Preis: $375 pro Nacht
---
Titel : Bauernhofaufenthalt in Joshua Tree
Rating: 4.93 (45)
Preis: $110 pro Nacht, ursprünglich $153
---
Titel : Zelt in Brooksville
Rating: 4.87 (192)
Preis: $54 pro Nacht, ursprünglich $66
---
Titel : Zuhause in Joshua Tree
Rating: 4.98 (197)
Preis: $210 pro Nacht, ursprünglich $365
---

Speichern von Scraped-Daten

Nach dem erfolgreichen Scraping der Daten von den Immobilienseiten von Airbnb besteht der nächste entscheidende Schritt darin, diese wertvollen Informationen für zukünftige Analysen und Referenzzwecke zu speichern. In diesem Abschnitt werden wir zwei gängige Methoden zur Datenspeicherung untersuchen: Speicherung von Scraped-Daten in einer CSV-Datei und Speichern in einer SQLite-Datenbank. Mit diesen Methoden können Sie Ihre Scraped-Daten effizient organisieren und verwalten.

Speichern von Scraped-Daten in einer CSV-Datei

CSV ist ein weit verbreitetes Format zum Sichern tabellarischer Daten. Es stellt eine einfache und leicht verständliche Methode zum Speichern strukturierter Daten dar und ist daher eine hervorragende Option zum Archivieren Ihrer extrahierten Airbnb-Immobiliendaten.

Wir werden einen zusätzlichen Schritt einbauen, um die gesammelten Daten in einer CSV-Datei zu speichern und so unser vorheriges Web Scraping-Skript zu verbessern. Nachfolgend sehen Sie eine verfeinerte Version des Skripts:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
- csv::Autor;
- erwünscht;
- Scraper::{Html, Selektor};
- std::Fehler::Fehler;
- urlencoding::kodieren;

fn Haupt-() -> Ergebnis<(), Verpackung<dyn Fehler>> {
    // Kodieren Sie die Airbnb-URL mithilfe der Urlencoding-Kiste
    lassen kodierte Airbnb-Such-URL = kodieren("https://www.airbnb.com/s/United-States/homes?query=United%20States&checkin=2023-12-07&checkout=2023-12-08&adults=2");

    // Ersetzen Sie „YOUR_CRAWLBASE_JS_TOKEN“ durch Ihr tatsächliches Crawlbase-API-Token
    lassen crawlbase_api_url = Format!(„https://api.crawlbase.com/?token=YOUR_CRAWLBASE_JS_TOKEN&url={}&page_wait=5000&ajax_wait=true“, codierte_airbnb_search_url);

    // Machen Sie eine GET-Anfrage an die Airbnb-Suchseite
    lassen Antwort = AnforderungWest::Blockierung::bekommen(&crawlbase_api_url)?;

    //Überprüfen Sie, ob die Anfrage erfolgreich war (Statuscode 200)
    if Antwort.Status().ist_erfolg() {
        // Extrahierter HTML-Inhalt
        lassen suchseite_html = Antwort.Text()?;

        // Daten aus HTML extrahieren
        lassen Ergebnisse = Seite scrapen(&Suchseite_html)?;

        // Die extrahierten Daten in eine CSV-Datei schreiben
        in CSV schreiben("Ausgabe.csv", &Ergebnisse)?;

    } sonst {
        drucken!(
            „Die Seite konnte nicht abgerufen werden. Statuscode: {}“,
            Antwort.Status()
        );
    }

    Ok(())
}

// Struktur zur Darstellung eines Suchergebnisses
#[ableiten(Debug, serde::Serialisieren)]
struct Suchergebnis {
    Titel: Schnur,
    Bewertung: Schnur,
    Preis: Schnur,
}

// Daten aus HTML extrahieren und ein Ergebnis zurückgeben  , Kasten >
fn Seite scrapen(html: &str) -> Ergebnis<Ein Ding, Verpackung<dyn Fehler>> {
    lassen Fragment = HTML::Dokument analysieren(html);
    lassen Wähler = Selektor::parsen(„div#site-content div[itemprop=\"itemListElement\"]“).auspacken();

    // Initialisieren Sie einen Vektor zum Speichern der Suchergebnisse
    lassen mut Ergebnisse = Ein Ding::neu();

    // Über jedes Listing-Ergebnis iterieren und Daten extrahieren
    
für Knoten in Fragment.wählen(&Selektor) {
        lassen Titel = Text extrahieren(&Knoten, "div[data-testid=\"Auflistungskartentitel\"]");
        lassen Wertung = Text extrahieren(&Knoten, „div.g1qv1ctd span span.r1dxllyb“);
        lassen Preis  = Text extrahieren(&Knoten, „div.g1qv1ctd div.pquyp1l div._i5duul span.a8jt5op“);

        // Erstelle ein SearchResult-Objekt und füge es dem Vektor hinzu
        lassen Folge = Suchergebnis {
            Titel,
            Bewertung,
            Preis,
        };
        Ergebnisse angezeigtdrücken(Ergebnis);
    }

    Ok(Ergebnisse)
}

// Hilfsfunktion zum Extrahieren von Textinhalten aus einem bestimmten Selektor
fn Text extrahieren(Knoten: &scraper::ElementRef, Selektor: &str) -> Schnur {
    lassen Unterselektor = Selektor::parsen(Wähler).auspacken();
    if lassen Manche(Element) = Knoten.wählen(&sub_selektor).weiter() {
        Element.Text().sammeln()
    } sonst {
        Schnur::neu()
    }
}

// Die extrahierten Daten in eine CSV-Datei schreiben
fn in CSV schreiben(Dateipfad: &str, Ergebnisse: &[Suchergebnis]) -> Ergebnis<(), Verpackung<dyn Fehler>> {
    lassen mut Schriftsteller = Autor::Von_Pfad(Dateipfad)?;

    // Den CSV-Header schreiben
    Schriftsteller.Datensatz schreiben(&["Titel", "Bewertung", "Preis"])?;

    // Schreibe jedes Suchergebnis in die CSV-Datei
    
für Folge in Ergebnisse {
        Schriftsteller.Datensatz schreiben(&[&Ergebnis.Titel, &Ergebnis.Bewertung, &Ergebnis.Preis])?;
    }

    Schriftsteller.spülen()?;
    Ok(())
}

Dieses aktualisierte Skript enthält die CSV-Kiste für die CSV-Verarbeitung. SearchResult struct leitet nun die Serialize Trait aus der Serde-Kiste, um es mit der CSV-Serialisierung kompatibel zu machen. Das write_to_csv Funktion hinzugefügt, um die Scraped-Daten in eine CSV-Datei zu schreiben. Stellen Sie sicher, dass Sie „YOUR_CRAWLBASE_JS_TOKEN“ ersetzen und den Ausgabedateipfad nach Bedarf aktualisieren.

Speichern von Scraped-Daten in einer SQLite-Datenbank

Wenn Sie eine strukturiertere und besser abfragbare Methode zur Datenspeicherung bevorzugen, ist SQLite eine hervorragende Option. Die Einrichtung einer Datenbanktabelle ermöglicht Ihnen die systematische Speichern Sie Ihre Scraped-Daten, wodurch ein optimierter Datenabruf und eine optimierte Datenbearbeitung ermöglicht werden. Im Folgenden werden die Anpassungen am Skript beschrieben, um SQLite-Datenbankspeicher zu integrieren:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
- erwünscht;
- rusqlite::{Verbindung, Ergebnis};
- Scraper::{Html, Selektor};
- urlencoding::kodieren;

fn Haupt-() -> Ergebnis<(), Verpackung<dyn std::Fehler::Fehler>> {
    // Kodieren Sie die Airbnb-URL mithilfe der Urlencoding-Kiste
    lassen kodierte Airbnb-Such-URL =
        kodieren("https://www.airbnb.com/s/United-States/homes?query=United%20States&checkin=2023-12-07&checkout=2023-12-08&adults=2");

    // Ersetzen Sie „YOUR_CRAWLBASE_JS_TOKEN“ durch Ihr tatsächliches Crawlbase-API-Token
    lassen crawlbase_api_url = Format!(
        „https://api.crawlbase.com/?token=YOUR_CRAWLBASE_JS_TOKEN&url={}&page_wait=5000&ajax_wait=true“,
        kodierte Airbnb-Such-URL
    );

    // Machen Sie eine GET-Anfrage an die Airbnb-Suchseite
    lassen Antwort = AnforderungWest::Blockierung::bekommen(&crawlbase_api_url)?;

    //Überprüfen Sie, ob die Anfrage erfolgreich war (Statuscode 200)
    if Antwort.Status().ist_erfolg() {
        // Extrahierter HTML-Inhalt
        lassen suchseite_html = Antwort.Text()?;

        // Daten aus HTML extrahieren
        lassen Ergebnisse = Seite scrapen(&Suchseite_html);

        // Die extrahierten Daten in SQLite speichern
        in_Datenbank speichern(&Ergebnisse)?;
    } sonst {
        drucken!(
            „Die Seite konnte nicht abgerufen werden. Statuscode: {}“,
            Antwort.Status()
        );
    }

    Ok(())
}

// Struktur zur Darstellung eines Suchergebnisses
#[ableiten(Debug)]
struct Suchergebnis {
    Titel: Schnur,
    Bewertung: Schnur,
    Preis: Schnur,
}

// Daten aus HTML extrahieren und ein Array von SearchResult-Objekten zurückgeben
fn Seite scrapen(html: &str) -> Ein Ding{
    lassen Fragment = HTML::Dokument analysieren(html);
    lassen Wähler = Selektor::parsen(„div#site-content div[itemprop=\"itemListElement\"]“).auspacken();

    // Initialisieren Sie einen Vektor zum Speichern der Suchergebnisse
    lassen mut Ergebnisse = Ein Ding::neu();

    // Über jedes Listing-Ergebnis iterieren und Daten extrahieren
    
für Knoten in Fragment.wählen(&Selektor) {
        lassen Titel = Text extrahieren(&Knoten, "div[data-testid=\"Auflistungskartentitel\"]");
        lassen Wertung = Text extrahieren(&Knoten, „div.g1qv1ctd span span.r1dxllyb“);
        lassen Preis  = Text extrahieren(&Knoten, „div.g1qv1ctd div.pquyp1l div._i5duul span.a8jt5op“);

        // Erstelle ein SearchResult-Objekt und füge es dem Vektor hinzu
        lassen Folge = Suchergebnis {
            Titel,
            Bewertung,
            Preis,
        };
        Ergebnisse angezeigtdrücken(Ergebnis);
    }

    Ergebnisse
}

// Hilfsfunktion zum Extrahieren von Textinhalten aus einem bestimmten Selektor
fn Text extrahieren(Knoten: &scraper::ElementRef, Selektor: &str) -> Schnur {
    lassen Unterselektor = Selektor::parsen(Wähler).auspacken();
    if lassen Manche(Element) = Knoten.wählen(&sub_selektor).weiter() {
        Element.Text().sammeln()
    } sonst {
        Schnur::neu()
    }
}

// Die extrahierten Daten in einer SQLite-Datenbank speichern
fn in_Datenbank speichern(Ergebnisse: &[Suchergebnis]) -> Ergebnis<()> {
    lassen conn = Verbindung::XNUMXh geöffnet("airbnb_data.db")?;

    //Erstelle eine Tabelle, falls sie nicht existiert
    Anschlussausführen(
        "CREATE TABLE IF NOT EXISTS-Auflistungen (
            id INTEGER PRIMÄRSCHLÜSSEL,
            Titel TEXT NICHT NULL,
            Bewertung TEXT,
            Preis TEXT NICHT NULL
        )",
        [],
    )?;

    //Daten in die Tabelle einfügen
    lassen mut Anw = Anschl.vorbereiten(„INSERT INTO listings (title, rating, price) VALUES (?, ?, ?)“)?;
    
für Folge in Ergebnisse {
        stmt.ausführen(&[&Ergebnis.Titel, &Ergebnis.Bewertung, &Ergebnis.Preis])?;
    }

    Ok(())
}

Die store_in_database Die Funktion im bereitgestellten Rust-Skript erleichtert die Speicherung von gescrapten Airbnb-Immobilienlistendaten in einer SQLite-Datenbank. Sie beginnt mit der Herstellung einer Verbindung zur SQLite-Datenbankdatei namens airbnb_data.db. Wenn der listings Tabelle existiert nicht, die Funktion erstellt sie mit Spalten für id, title, rating und priceAnschließend bereitet die Funktion eine SQL-Anweisung zum Einfügen von Daten in die listings Tabelle. Anschließend iteriert er über den Vektor von SearchResult Objekte, wobei die SQL-Anweisung für jeden Eintrag ausgeführt wird, um den entsprechenden Objekttitel, die Bewertung und den Preis in die Datenbank einzufügen. Der Prozess verwendet parametrisierte SQL-Abfragen, um die Datenintegrität sicherzustellen und SQL-Injection zu verhindern. Auf diese Weise wird die store_in_database Die Funktion bietet einen systematischen und sicheren Mechanismus zum Speichern der ausgelesenen Daten aus den Airbnb-Immobilieninseraten in einer SQLite-Datenbank und ermöglicht so das spätere Abrufen und Analysieren.

Zusammenfassung

Dieser Leitfaden vermittelt Ihnen das grundlegende Know-how und die Werkzeuge, um mit Rust und Crawlbase ganz einfach Airbnb-Immobilienangebote zu scrapen. Crawling API. Egal, ob Sie neu in diesem Bereich sind oder bereits über Erfahrung verfügen, die hier erläuterten Ideen bieten einen guten Ausgangspunkt für Ihre Bemühungen.

Wenn Sie Ihre Web Scraping-Reise fortsetzen, denken Sie daran, dass die Vielseitigkeit dieser Fähigkeiten über Airbnb hinausgeht. Entdecken Sie unsere zusätzlichen Anleitungen für Plattformen wie Amazon, eBay, Walmart und AliExpress, und erweitern Sie Ihr Scraping-Know-how.

Weitere Guides:
📜 So scrapen Sie Airbnb-Preise

Web Scraping stellt Herausforderungen dar, und unser Engagement für Ihren Erfolg geht über diesen Leitfaden hinaus. Wenn Sie auf Hindernisse stoßen oder weitere Anleitung benötigen, Crawlbase-Supportteam ist bereit, Ihnen zu helfen. Ihr Erfolg beim Web Scraping ist unsere Priorität und wir freuen uns darauf, Sie auf Ihrem Scraping-Weg zu unterstützen.

Häufig gestellte Fragen (FAQs)

Web Scraping ist eine neutrale Technologie, aber ihre Rechtmäßigkeit hängt oft von den Nutzungsbedingungen der Website ab, die gescrapt wird. Airbnb hat wie viele andere Plattformen Richtlinien zur automatischen Datenerfassung. Vor dem Scraping ist es wichtig, die Nutzungsbedingungen und die robots.txt-Datei von Airbnb zu überprüfen, um sicherzustellen, dass die Regeln eingehalten werden.

F2: Kann ich Crawlbase verwenden Crawling API mit Rust für andere Websites als Airbnb?

Auf jeden Fall! Die Crawlbase Crawling API ist ein vielseitiges Tool, das über Airbnb hinausgeht. Es bietet eine robuste Lösung zum Scraping dynamischer und JavaScript-gesteuerter Inhalte auf verschiedenen Websites. Solange Sie über die entsprechenden API-Anmeldeinformationen verfügen und die Struktur der Zielwebsite verstehen, können Sie Rust und Crawlbase für das Web Scraping auf verschiedenen Plattformen verwenden.

F3: Ist Rust eine geeignete Sprache für Web Scraping?

Ja, Rust ist aufgrund seiner hohen Leistung, Speichersicherheitsfunktionen und seines starken Ökosystems eine ausgezeichnete Wahl für Web Scraping. Seine Parallelitätsunterstützung ermöglicht die effiziente Verarbeitung mehrerer Anfragen und das Eigentümersystem gewährleistet eine sichere Speicherverwaltung. Aufgrund seiner Zuverlässigkeit und Geschwindigkeit eignet sich Rust gut für den Aufbau von Web Scrapern, die vielfältige und komplexe Aufgaben bewältigen können.

F4: Was ist, wenn ich beim Einrichten meiner Rust-Umgebung für Web Scraping auf Probleme stoße?

Wenn Sie während des Einrichtungsvorgangs auf Probleme stoßen, sind die Rust-Community und die Dokumentation wertvolle Ressourcen. Die offizielle Rust-Dokumentation bietet umfassende Anleitungen zu Installation, Konfiguration und Abhängigkeiten. Darüber hinaus können Sie in Foren wie Stack Overflow oder Rust-bezogenen Communities mit erfahrenen Entwicklern in Kontakt treten, die möglicherweise Einblicke und Lösungen für bestimmte Probleme bieten.

F5: Wie kann ich die Seitennummerierung handhaben, wenn ich Airbnb-Immobilienanzeigen mit Rust scrape?

Die Handhabung der Paginierung ist eine häufige Anforderung beim Web Scraping, und unser Leitfaden befasst sich speziell mit diesem Aspekt. Wir werden effektive Techniken zur Navigation durch mehrere Seiten von Airbnb-Immobilienangeboten mit Rust und Crawlbase erkunden. Crawling APIMit diesen Methoden können Sie umfassende Datensätze effizient abrufen, ohne Einträge zu übersehen.