Bei Google Flüge handelt es sich um einen häufig genutzten Flugbuchungsdienst, über den eine Fülle von Daten, darunter Flugpreise, Flugpläne und Fluglinieninformationen, abgerufen werden können. Leider bietet Google keinen öffentlichen API-Zugriff auf diese Daten an. Web-Scraping kann jedoch eine gute Alternative sein, um diese Daten zu extrahieren.
In diesem Artikel werde ich Ihnen zeigen, wie Sie mithilfe von Python einen zuverlässigen Google-Flüge-Scraper erstellen können. Dabei werden die einzelnen Schritte durchgegangen, um alle Aspekte des Vorgangs zu verdeutlichen.
Warum Google Flüge scrapen?
Das Scraping von Google Flüge bietet gleich mehrere Vorteile, darunter:
- Nachverfolgung von Entwicklung der Flugpreise
- Analyse von Preisdynamik
- Ermittlung des günstigsten Zeitpunkts zur Flugbuchung
- Preisvergleich über verschiedene Zeiträume und Fluggesellschaften
Reisende können auf diese Weise nach den besten Angeboten suchen und Geld sparen. Unternehmen profitieren von der Möglichkeit zur Marktanalyse, Wettbewerbsbeobachtung sowie zur Entwicklung effektiver Preisstrategien.
Erstellung des Google-Flüge-Scraper
Der von uns erstellte Scraper gestattet Ihnen die Eingabe bestimmter Details wie Abflughafen, Zielort, Reisedatum und Ticketart (einfach oder Hin- und Rückflug). Bei der Buchung einer Hin- und Rückreise müssen Sie zusätzlich ein Rückreisedatum angeben. Der Scraper erledigt den Rest: Er lädt alle verfügbaren Flüge, extrahiert die Daten und speichert die Ergebnisse zur weiteren Analyse in einer JSON-Datei.
Für Einsteiger im Bereich Web-Scraping mit Python empfehlen wir dieses Tutorial .
1. Welche Daten kann man aus Google Flüge extrahieren?
Im Folgenden finden Sie eine Liste der Daten, die Sie aus Google Flüge extrahieren können:Flugliniennamen, Abflug- und Ankunftszeiten, Gesamtdauer, Anzahl der Zwischenstopps, Ticketpreise und Daten zu den Umweltauswirkungen (z. B. CO2-Emissionen).
Im Folgenden finden Sie ein Beispiel der Daten, die Sie scrapen können:
{
"airline": "Alaska",
"departure_time": "5:22 PM",
"arrival_time": "9:13 PM",
"duration": "6 hr 51 min",
"stops": "Nonstop",
"price": "₹51,984",
"co2_emissions": "282 kg CO2e",
"emissions_variation": "-22% emissions"
}
2. Einrichten der Umgebung
Richten wir zunächst die Umgebung für die Ausführung des Scraper in Ihrem System ein.
# Create a virtual environment (optional)
python -m venv flight-scraper-env
# Activate the virtual environment
# On Windows:
.\flight-scraper-env\Scripts\activate
# On macOS/Linux:
source flight-scraper-env/bin/activate
# Install required packages
pip install playwright tenacity asyncio
# Install Playwright browsers
playwright install chromium
Playwright eignet sich ideal für die Automatisierung von Browsern sowie zur Interaktion mit dynamischen Websites wie Google Flüge. Zur Implementierung eines Wiederholungsmechanismus verwenden wir Tenacity .
Sollten Sie Playwright noch nicht kennen, lesen Sie bitte den Leitfaden zum Thema Web-Scraping mit Playwright.
3. Festlegen von Datenklassen
Mit der Datenklasse von Python lassen sich die Suchparameter und Flugdaten übersichtlich strukturieren.
from dataclasses import dataclass
from typing import Optional
@dataclass
class SearchParameters:
departure: str
destination: str
departure_date: str
return_date: Optional[str] = None
ticket_type: str = "One way"
@dataclass
class FlightData:
airline: str
departure_time: str
arrival_time: str
duration: str
stops: str
price: str
co2_emissions: str
emissions_variation: str
Beispielsweise speichert die Klasse „ SearchParameters “ Details zur Flugsuche wie Abflug- und Zielort, Reisezeitraum und Ticketart, während die Klasse „ FlightData “ Daten zu jedem Flug speichert, darunter Fluggesellschaft, Preis, CO2-Emissionen und andere relevante Angaben.
4. Scraper-Logik in der Klasse „FlightScraper“
Die wichtigste Scraping-Logik ist in der FlightScraper -Klasse enthalten. Nachfolgend ist eine detaillierte Aufschlüsselung aufgeführt:
4.1 Festlegung von CSS-Selektoren
Zur Extraktion von Daten müssen bestimmte Elemente auf der Google-Flüge-Seite lokalisiert werden. Dies erfolgt mithilfe von CSS-Selektoren. In der FlightScraper- Klasse werden die Selektoren wie folgt festgelegt:
class FlightScraper:
SELECTORS = {
"airline": "div.sSHqwe.tPgKwe.ogfYpf",
"departure_time": 'span[aria-label^="Departure time"]',
"arrival_time": 'span[aria-label^="Arrival time"]',
"duration": 'div[aria-label^="Total duration"]',
"stops": "div.hF6lYb span.rGRiKd",
"price": "div.FpEdX span",
"co2_emissions": "div.O7CXue",
"emissions_variation": "div.N6PNV",
}
Diese Selektoren zielen auf Daten wie den Namen der Fluggesellschaft, Flugzeiten, Flugdauer, Zwischenlandungen, Preis und Emissionen ab.
Name der Fluggesellschaft:
Abflugzeit:
Ankunftszeit:
Flugdauer:
Anzahl der Zwischenlandungen:
Preis:
CO2e:
Abweichung derCO2-Emissionen:
4.2 Ausfüllen des Suchformulars
Die Methode _fill_search_form simuliert das Ausfüllen des Suchformulars mit Angaben zu Abflug, Ziel und Datum:
async def _fill_search_form(self, page, params: SearchParameters) -> None:
# First, let's pick our ticket type
ticket_type_div = page.locator("div.VfPpkd-TkwUic[jsname='oYxtQd']").first
await ticket_type_div.click()
await page.wait_for_selector("ul[aria-label='Select your ticket type.']")
await page.locator("li").filter(has_text=params.ticket_type).nth(0).click()
# Now, let's fill in our departure and destination
from_input = page.locator("input[aria-label='Where from?']")
await from_input.click()
await from_input.fill("")
await page.keyboard.type(params.departure)
# ... rest of the form filling code
4.3 Laden sämtlicher Ergebnisse
Google Flüge nutzt Paginierung, um Flüge zu laden. Klicken Sie auf die Schaltfläche „Weitere Flüge anzeigen“, um alle verfügbaren Flüge zu laden:
async def _load_all_flights(self, page) -> None:
while True:
try:
more_button = await page.wait_for_selector(
'button[aria-label*="more flights"]', timeout=5000
)
if more_button:
await more_button.click()
await page.wait_for_timeout(2000)
else:
break
except:
break
4.4 Extrahieren von Flugdaten
Sobald die Flüge geladen sind, können Sie die Flugdetails scrapen:
async def _extract_flight_data(self, page) -> List[FlightData]:
await page.wait_for_selector("li.pIav2d", timeout=30000)
await self._load_all_flights(page)
flights = await page.query_selector_all("li.pIav2d")
flights_data = []
for flight in flights:
flight_info = {}
for key, selector in self.SELECTORS.items():
element = await flight.query_selector(selector)
flight_info[key] = await self._extract_text(element)
flights_data.append(FlightData(**flight_info))
return flights_data
5. Einfügen eines Wiederholungsmechanismus
Um unseren Scraper noch zuverlässiger zu gestalten, fügen Sie mithilfe der Tenacity- Bibliothek eine Wiederholungslogik hinzu:
@retry(stop=stop_after_attempt(3), wait=wait_fixed(5))
async def search_flights(self, params: SearchParameters) -> List[FlightData]:
async with async_playwright() as p:
browser = await p.chromium.launch(headless=False)
context = await browser.new_context(
user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) ..."
)
# ... rest of the search implementation
6. Speichern der Scraper-Ergebnisse
Speichern Sie die extrahierten Flugdaten für zukünftige Analysen in einer JSON-Datei.
def save_results(self, flights: List[FlightData], params: SearchParameters) -> str:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = (
f"flight_results_{params.departure}_{params.destination}_{timestamp}.json"
)
output_data = {
"search_parameters": {
"departure": params.departure,
"destination": params.destination,
"departure_date": params.departure_date,
"return_date": params.return_date,
"search_timestamp": timestamp,
},
"flights": [vars(flight) for flight in flights],
}
filepath = os.path.join(self.results_dir, filename)
with open(filepath, "w", encoding="utf-8") as f:
json.dump(output_data, f, indent=2, ensure_ascii=False)
return filepath
7. Ausführen des Scraper
Nachfolgend erfahren Sie, wie man den Google-Flüge-Scraper ausführt:
async def main():
scraper = FlightScraper()
params = SearchParameters(
departure="MIA",
destination="SEA",
departure_date="2024-12-01",
# return_date="2024-12-30",
ticket_type="One way",
)
try:
flights = await scraper.search_flights(params)
print(f"Successfully found {len(flights)} flights")
except Exception as e:
print(f"Error during flight search: {str(e)}")
if __name__ == "__main__":
asyncio.run(main())
Endergebnisse
Nach der Ausführung des Scraper werden Ihre Flugdaten in einer JSON-Datei gespeichert, welche wie folgt aussieht:
{
"search_parameters": {
"departure": "MIA",
"destination": "SEA",
"departure_date": "2024-12-01",
"return_date": null,
"search_timestamp": "20241027_172017"
},
"flights": [
{
"airline": "American",
"departure_time": "7:45 PM",
"arrival_time": "11:38 PM",
"duration": "6 hr 53 min",
"stops": "Nonstop",
"price": "₹50,755",
"co2_emissions": "303 kg CO2e",
"emissions_variation": "-16% emissions"
},
{
"airline": "Alaska",
"departure_time": "5:22 PM",
"arrival_time": "9:13 PM",
"duration": "6 hr 51 min",
"stops": "Nonstop",
"price": "₹51,984",
"co2_emissions": "282 kg CO2e",
"emissions_variation": "-22% emissions"
},
{
"airline": "Alaska",
"departure_time": "9:00 AM",
"arrival_time": "12:40 PM",
"duration": "6 hr 40 min",
"stops": "Nonstop",
"price": "₹62,917",
"co2_emissions": "325 kg CO2e",
"emissions_variation": "-10% emissions"
}
]
}
Den vollständigen Code können Sie in meinem GitHub Gist einsehen.
HäufigeHerausforderungen bei der Skalierung von Google-Flüge-Scraping
Bei der Skalierung des Daten-Scrapings von Google Flüge stellen IP-Blockierung und CAPTCHAs üblicherweise eine Herausforderung dar. Senden Sie etwa mit einem Scraper innerhalb eines kurzen Zeitraums zu viele Anfragen, können Websites unter Umständen Ihre IP-Adresse blockieren. Zur Vermeidung dieses Szenarios können Sie eine manuelle IP-Rotation vornehmen oder sich für einen der führenden Proxy-Dienste entscheiden. Falls Sie sich nicht sicher sind, welche Art von Proxy sich am besten für Ihren Anwendungsfall anbietet, sehen Sie sich unseren Leitfaden zu den besten Proxys für das Web-Scraping an.
Eine weitere Herausforderung stellt der Umgang mit CAPTCHAs dar. Websites greifen häufig auf diese zurück, bei Verdacht auf Bot-Traffic, wodurch Ihr Scraper bis zur Lösung des CAPTCHAs gesperrt wird. Ein solcher manueller Prozess ist zeitaufwendig und komplex.
Welche Lösung bietet sich also an? Hierzu gleich mehr!
Die Lösung: Web-Scraping-Tools von Bright Data
Bright Data bietet ein breites Spektrum an Lösungen, die darauf ausgelegt sind, Ihre Web-Scraping-Bemühungen effizient zu vereinfachen und zu skalieren. Schauen wir uns an, wie Bright Data Ihnen helfen kann, diese häufigen Herausforderungen zu meistern.
1. Residential-Proxys
Durch Residential-Proxys von Bright Data haben Sie die Möglichkeit, auf anspruchsvolle Ziel-Websites zuzugreifen und diese zu scrapen. Mit Residential-Proxys lassen sich Web-Scraping-Anfragen über legitime Privatanschlüsse weiterleiten. Ihre Anfragen erscheinen den Ziel-Websites so, als kämen sie von echten Benutzern aus einer bestimmten Region oder einem bestimmten Gebiet. Anstatt diese Probleme manuell anzugehen, erledigt Web-Unlocker diesen Vorgang automatisch und passt sich mit einer hohen Erfolgsquote (in der Regel 100 %) an sich ändernde Website-Sperren an.
2. Web-Unlocker
Der Web-Unlocker von Bright Data hingegen empfiehlt sich für Scraping-Projekte, bei denen CAPTCHAs oder sonstige Einschränkungen zu überwindensind. Anstatt diese Probleme manuell anzugehen, erledigt Web-Unlocker diesen Vorgang automatisch und passt sich mit einer hohen Erfolgsquote (in der Regel 100 %) an sich ändernde Website-Sperren an. Senden Sie einfach eine Anfrage und der Web-Unlocker erledigt den Rest.
3. Scraping-Browser
Der Scraping-Browser von Bright Dataist ein weiteres leistungsstarkes Entwicklungstool, das mit Headless-Browsern wie Puppeteer oder Playwright verwendet werden kann. Ganz anders als herkömmliche Headless-Browser bewältigt der Scraping-Browser das Lösen von CAPTCHA, Browser-Fingerprinting, Wiederholungsversuche und vieles mehr – ganz automatisch –, sodass Sie sich auf das Erfassen von Daten konzentrieren können, ohne sich um Einschränkungen seitens der Website sorgen zu müssen.
Fazit
In diesem Artikel wurde erläutert, wie Google-Flüge-Daten mithilfe von Python und Playwright gescrapet werden können. Zwar kann manuelles Scraping effektiv sein, doch ist es oft mit Herausforderungen wie IP-Sperren und dem Bedarf an fortlaufender Skriptpflege verbunden. Nutzen Sie zur Vereinfachung und Verbesserung Ihrer Datenerfassung Lösungen von Bright Data, wie z. B. Residential-Proxys, Web-Unlocker und Scraping-Browser.
Melden Sie sich noch heute für eine kostenlose Testversion von Bright Data an!
Zudem finden Sie in unseren Leitfäden Informationen zum Scraping anderer Google-Dienste, wie z. B. Google-Suchergebnisse, Google Trends, Google Scholar und Google Maps.
Keine Kreditkarte erforderlich
