Google Finance scrapenMarktdaten mit Python

Google Finance gehört zu den meistgenutzten Quellen für Echtzeit-Marktdaten, und seine Kursseiten enthalten genau die strukturierten Zahlen, die Price-Tracking, Portfolio-Monitoring und Recherche antreiben: den aktuellen Preis, die Tagesveränderung in Wert und Prozent, den vorherigen Schlusskurs und die wichtigsten Marktkennzahlen wie Marktkapitalisierung, KGV sowie die Tages- und Jahres-Handelsbandbreiten. Für jeden, der einen Korb von Tickern beobachtet, sind diese öffentlichen Marktdaten das Rohmaterial, und sie manuell über Dutzende von Symbolen hinweg zu kopieren ist langsam und fehleranfällig.

Dieser Leitfaden zeigt Ihnen, wie Sie Google Finance mit Python zuverlässig scrapen. Sie bauen ein kleines, lauffähiges Skript, das gerenderte Kursseiten über die Crawling API abruft, die gewünschten Felder mit BeautifulSoup parst, mehrere Ticker durchläuft und sauberes JSON exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Marktdaten, die sachlicher Natur und nicht persönlich sind; der Abschnitt zur Rechtslage gegen Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie das auf echtes Volumen ansetzen.

Was Sie bauen werden

Ein Python-Skript, das eine Liste von Google-Finance-Kurs-URLs (eine pro Ticker im SYMBOL:EXCHANGE-Format, das Google verwendet) entgegennimmt, jede gerenderte Seite über die Crawling API abruft und einen strukturierten Datensatz pro Aktie extrahiert. Das laufende Beispiel verwendet GOOGL, AAPL und MSFT auf dem NASDAQ. Wir holen diese Felder:

• Titel der Unternehmensname oben auf der Kursseite.
• Preis der aktuelle angegebene Preis der Aktie.
• Veränderung die absolute Preisveränderung und ihr Prozentsatz für die Sitzung.
• Vorheriger Schlusskurs der Schlusskurs der vorherigen Sitzung.
• Marktdaten der Block mit Schlüsselkennzahlen: Marktkapitalisierung, KGV sowie die Tages- und Jahresbandbreiten, sofern vorhanden.

Warum eine einfache Anfrage bei Google Finance scheitert

Fordern Sie eine Google-Finance-Kurs-URL mit einem einfachen HTTP-Client an, erhalten Sie eine Antwort mit Status 200, aber nur einen Bruchteil der Daten im Body. Zwei Faktoren arbeiten gegen Sie. Erstens füllt Google Finance seine Kursseiten im Browser durch JavaScript, sodass das initiale HTML eine dünne Hülle ist. Das deutlichste Zeichen ist der Prozentsatz der Preisveränderung: Extrahieren Sie ihn aus dieser ersten Antwort, erhalten Sie None, da dieser Wert clientseitig nach dem Laden gerendert wird. Zweitens kennzeichnet Google automatisierten Traffic schnell. Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden ratenbegrenzt, IP-gesperrt oder herausgefordert, bevor sie den gerenderten Inhalt erreichen.

Ein funktionierender Google-Finance-Scraper benötigt also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser und einem Pool von rotierenden Residential Proxies aufbauen, aber diesen Stack gesund zu halten ist der Großteil der Arbeit. Die Crawling API faltet beides in einen einzigen Aufruf: Senden Sie ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück. Für den breiteren Hintergrund zu gerenderten Zielen lesen Sie, wie man JavaScript-Websites crawlt.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon dauert lange.

Grundlegendes Python. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Wenn Sie neu auf der Parsing-Seite sind, ist der BeautifulSoup-Leitfaden ein guter Begleiter zu diesem Tutorial.

Python 3.8 oder neuer. Bestätigen Sie Ihre Version mit python --version. Wenn Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda und stellen Sie sicher, dass Python in Ihrem PATH ist.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token (JS-Token) von der Konto-Docs-Seite. Crawlbase enthält bis zu 20.000 kostenlose Anfragen zum Start, was für diesen Leitfaden mehr als ausreicht, und Sie zahlen nur für erfolgreiche Anfragen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, also halten Sie es aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die Bibliotheken, die der Scraper benötigt.

python --version

python -m venv google_finance_env
source google_finance_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit google_finance_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie einzelne Felder per CSS-Selektor herausziehen können. Das json-Modul wird mit der Standardbibliothek geliefert, also muss für den Exportschritt nichts weiter installiert werden.

Schritt 1: Eine gerenderte Google-Finance-Seite abrufen

Beginnen Sie damit, eine fertige Seite zu erhalten. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie eine Kurs-URL an. Google Finance lädt seine Werte asynchron, also übergeben Sie ajax_wait und page_wait, um auf den dynamischen Inhalt zu warten, bevor die Seite erfasst wird. Den Crawlbase-cb_status (legacy pc_status) vor dem Parsen zu prüfen hält Fehler laut statt still.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

OPTIONS = {
    "ajax_wait": "true",
    "page_wait": 5000,
}

def crawl(page_url):
    response = api.get(page_url, OPTIONS)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

if __name__ == "__main__":
    quote_url = "https://www.google.com/finance/quote/GOOGL:NASDAQ"
    html = crawl(quote_url)
    print(html[:500] if html else "No HTML returned")

Die zwei Warte-Optionen sind wichtig für ein clientseitig gerendertes Ziel wie Google Finance. ajax_wait weist die API an, auf das Laden asynchroner Inhalte zu warten, und page_wait hält eine feste Anzahl von Millisekunden nach dem Laden an, damit spät-rendernde Werte erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn der Veränderungsprozentsatz leer zurückkommt. Führen Sie das Skript mit python google_finance_scraper.py aus und Sie sollten echtes Kursseiten-Markup sehen, nicht die Hülle, die eine einfache Anfrage zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Preis, Veränderung und Titel parsen

Mit fertigem HTML in der Hand laden Sie es in BeautifulSoup und ziehen die Überschriftenfelder heraus. Google Finance hält den Unternehmensnamen, den aktuellen Preis und die Sitzungsveränderung im main-Bereich der Seite, jedes in einer generierten Klasse. Die Selektoren unten kommen direkt aus dem Live-Kurs-Layout: Der Titel sitzt in zzDege, der Preis in AHmHk und der Veränderungsprozentsatz in JwB6zf. Jede Suche ist abgesichert, damit ein fehlendes Feld None zurückgibt statt den Lauf abstürzen zu lassen.

from bs4 import BeautifulSoup

def get_price(soup):
    el = soup.find("main")
    if not el:
        return None
    price = el.find("div", "AHmHk")
    return price.get_text(strip=True) if price else None

def get_change_percentage(soup):
    main = soup.find("main")
    if not main:
        return None
    change = main.find("div", "JwB6zf")
    return change.get_text(strip=True) if change else None

def get_stock_title(soup):
    main = soup.find("main")
    if not main:
        return None
    title = main.find("div", "zzDege")
    return title.get_text(strip=True) if title else None

Das JwB6zf-Element ist das zu beobachtende. Bei einer dünnen, nicht gerenderten Antwort fehlt es vollständig und get_change_percentage gibt None zurück; sobald die Seite über das JS-Token gerendert ist, trägt es die Sitzungsveränderung in Wert und Prozent. Dieses einzelne Feld ist der einfachste Beweis, dass das Rendering seine Arbeit tut.

Schritt 3: Den Marktdatenblock parsen

Unterhalb der Überschriftenzahlen listet Google Finance die Schlüsselkennzahlen als Label- und Wertezeilen auf: vorheriger Schlusskurs, Tagesspanne, Jahresspanne, Marktkapitalisierung, KGV und mehr. Jede Zeile ist ein gyFHrc-Container, der ein Label in mfs7Fc und einen Wert in P6K39c enthält. Jede Zeile in ein Dictionary zu gehen hält den Parser widerstandsfähig: Welche Kennzahlen auch immer ein bestimmter Ticker aufweist, erscheinen als Schlüssel, und Sie lesen Previous close, Market cap, P/E ratio, Day range und Year range direkt aus diesem Dictionary.

def get_market_data(soup):
    rows = soup.find_all("div", {"class": "gyFHrc"})
    data = {}
    for row in rows:
        label = row.find("div", {"class": "mfs7Fc"})
        value = row.find("div", {"class": "P6K39c"})
        if label and value:
            data[label.get_text(strip=True)] = value.get_text(strip=True)
    return data

KEEP = ["Previous close", "Day range", "Year range", "Market cap", "P/E ratio"]

def select_market_fields(market_data):
    return {key: market_data[key] for key in KEEP if key in market_data}

Der get_market_data-Helfer erfasst jedes Label- und Wertepaar auf der Seite, sodass Sie keinen Selektor pro Kennzahl hartcodieren müssen. select_market_fields verengt das dann auf den hiesigen Umfang: vorheriger Schlusskurs, die Tages- und Jahresspannen, Marktkapitalisierung und KGV. Da der Filter if key in market_data prüft, lässt ein Ticker, der eine dieser Größen weglässt, diesen Schlüssel einfach aus dem Datensatz aus, statt zu scheitern. Halten Sie die vollständige get_market_data-Ausgabe, wenn Sie später auch das Durchschnittsvolumen oder die primäre Börse wollen.

Schritt 4: Das vollständige Skript zusammenbauen

Verbinden Sie nun die Teile zu einem lauffähigen Skript: Jede Kursseite abrufen, die Überschriftenfelder und den Marktblock parsen und die Datensätze als JSON exportieren. Die Funktion extract_quote bringt die Helfer pro Feld in einen einzelnen Datensatz zusammen, und main iteriert über eine Liste von SYMBOL:EXCHANGE-URLs, damit Sie in einem Durchlauf mehrere Ticker abrufen können.

import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

OPTIONS = {
    "ajax_wait": "true",
    "page_wait": 5000,
}

KEEP = ["Previous close", "Day range", "Year range", "Market cap", "P/E ratio"]

def crawl(page_url):
    response = api.get(page_url, OPTIONS)
    if response["headers"]["cb_status"] == "200":
        return response["body"].decode("utf-8")
    print(f"Request failed: {response['headers']['cb_status']}")
    return None

def text_in_main(soup, class_name):
    main = soup.find("main")
    if not main:
        return None
    el = main.find("div", class_name)
    return el.get_text(strip=True) if el else None

def get_market_data(soup):
    rows = soup.find_all("div", {"class": "gyFHrc"})
    data = {}
    for row in rows:
        label = row.find("div", {"class": "mfs7Fc"})
        value = row.find("div", {"class": "P6K39c"})
        if label and value:
            data[label.get_text(strip=True)] = value.get_text(strip=True)
    return data

def extract_quote(html, url):
    soup = BeautifulSoup(html, "html.parser")
    market = get_market_data(soup)
    return {
        "url": url,
        "title": text_in_main(soup, "zzDege"),
        "price": text_in_main(soup, "AHmHk"),
        "change": text_in_main(soup, "JwB6zf"),
        "previous_close": market.get("Previous close"),
        "market_data": {key: market[key] for key in KEEP if key in market},
    }

def main():
    urls = [
        "https://www.google.com/finance/quote/GOOGL:NASDAQ",
        "https://www.google.com/finance/quote/AAPL:NASDAQ",
        "https://www.google.com/finance/quote/MSFT:NASDAQ",
    ]
    records = []
    for url in urls:
        html = crawl(url)
        if html:
            records.append(extract_quote(html, url))
        time.sleep(2)

    with open("finance_data.json", "w") as f:
        json.dump(records, f, indent=2)
    print(f"Saved {len(records)} quotes")

if __name__ == "__main__":
    main()

Der einzelne text_in_main-Helfer ersetzt die drei nahezu identischen Titel-, Preis- und Veränderungsfunktionen von früher: Er findet den main-Bereich, sucht eine generierte Klasse und gibt den bereinigten Text oder None zurück. extract_quote baut einen Datensatz pro Ticker zusammen, zieht den vorherigen Schlusskurs aus dem Markt-Dictionary heraus und verschachtelt den Rest unter market_data. Der Zwei-Sekunden-Schlaf steuert das Tempo des Laufs, damit Sie die Site nicht überlasten. Bearbeiten Sie die urls-Liste, um weitere Symbole zu scrapen.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python google_finance_scraper.py aus und Sie erhalten einen sauberen strukturierten Datensatz pro Ticker, bereit für Analyse, eine Datenbank oder eine Tabellenkalkulation. Die folgenden Werte sind illustrativ; Ihr Lauf gibt zurück, was der Live-Kurs anzeigt.

[
  {
    "url": "https://www.google.com/finance/quote/GOOGL:NASDAQ",
    "title": "Alphabet Inc Class A",
    "price": "$163.79",
    "change": "+1.01 (0.62%)",
    "previous_close": "$162.78",
    "market_data": {
      "Previous close": "$162.78",
      "Day range": "$163.09 - $167.12",
      "Year range": "$103.71 - $174.71",
      "Market cap": "2.04T USD",
      "P/E ratio": "25.54"
    }
  },
  {
    "url": "https://www.google.com/finance/quote/AAPL:NASDAQ",
    "title": "Apple Inc",
    "price": "$169.30",
    "change": "-0.61 (0.36%)",
    "previous_close": "$170.33",
    "market_data": {
      "Previous close": "$170.33",
      "Day range": "$169.11 - $172.71",
      "Year range": "$164.08 - $199.62",
      "Market cap": "2.61T USD",
      "P/E ratio": "26.34"
    }
  }
]

Beachten Sie, dass das change-Feld nun einen echten Wert statt null trägt. Bei einem einfachen, nicht gerenderten Fetch kommt es leer zurück, weil Google es clientseitig malt; die Anfrage über das JS-Token zu leiten ist das, was es erscheinen lässt. Von hier fallen die Datensätze direkt in pandas oder eine beliebige Tabellenkalkulation zum Verfolgen von Preisbewegungen, zum Vergleichen des KGV einer Watchlist oder zum Speisen eines Price-Intelligence-Workflows.

Auf eine Watchlist skalieren und nicht geblockt werden

Das obige Skript ruft drei Ticker ab, aber die Form skaliert auf eine vollständige Watchlist durch Erweiterung der urls-Liste. Wenn der Lauf wächst, halten einige Gewohnheiten ihn gesund, und sie gelten für jedes schwierige Ziel.

• Anfragen steuern. Kurse in einer engen Schleife zu hämmern ist der schnellste Weg zur Drosselung oder Herausforderung. Der oben genannte Zwei-Sekunden-Schlaf ist der Boden, nicht die Decke; verbreitern Sie ihn für größere Watchlists und variieren Sie Ihre Symbole statt einen Pfad mit voller Geschwindigkeit neu abzurufen.
• Auf Rotation setzen. Ein Pool von Residential IPs verteilt Anfragen über viele reale Benutzeradressen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Status-Codes lesen. Ein Lauf, der beginnt, Nicht-200-cb_status-Werte zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen zum Ignorieren.

Für größere Jobs stellt der asynchrone Crawler Anfragen in die Warteschlange und liefert Ergebnisse an einen Webhook, was zum Auffrischen vieler Ticker nach einem Zeitplan geeignet ist, ohne offene Verbindungen zu halten. Für das breitere Playbook lesen Sie, wie man Websites scrapt, ohne geblockt zu werden. Der gleiche Render-plus-vertrauenswürdige-IP-Ansatz überträgt sich auch auf andere Marktquellen, wie zum Beispiel das Scrapen von Kryptopreisen von CoinMarketCap.

Ist das Scrapen von Google Finance legal?

Ob das Scrapen von Google Finance erlaubt ist, hängt von Googles Nutzungsbedingungen, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten machen. Googles Bedingungen schränken automatisierten Zugriff auf seine Dienste ein, sodass Scraping gegen diese Bedingungen verstoßen kann, unabhängig davon, wie sorgfältig Ihr Tooling ist. Kein Code hier ändert das; er lässt nur den technischen Teil funktionieren. Lesen Sie Googles Nutzungsbedingungen und die robots.txt für die Google-Finance-Pfade und behandeln Sie beides als Grenze dessen, was Sie sammeln und wie oft Sie es anfordern.

Die Daten, auf die sich dieser Leitfaden richtet, liegen fest auf der öffentlichen, nicht-persönlichen Seite der Linie: Aktienkurse, die Sitzungsveränderung, vorheriger Schlusskurs, Marktkapitalisierung, KGV sowie die Tages- und Jahresspannen sind sachliche Marktdaten, keine persönlichen Informationen von jemandem. Das hält die Arbeit enger als das Scrapen von Sites mit Nutzerinhalten, stellt Sie aber nicht über Googles Bedingungen. Bleiben Sie bei Kursseiten, die jeder Besucher ohne Konto laden kann, halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Googles Server nicht belasten, und verbreiten Sie die zugrundeliegenden Marktfeeds nicht pauschal weiter, da Börsen und Datenanbieter diese Zahlen lizenzieren und die Lizenzierung den Zahlen folgt.

Dieser Leitfaden ist bewusst auf öffentliche Kursseiten beschränkt, weil das die Linie ist, die die Arbeit vertretbar hält. Er deckt nichts hinter einem Login, kostenpflichtige oder Premium-Daten oder Versuche, Authentifizierung oder Ratenlimits zu umgehen, ab. Wenn Ihr Projekt garantierte Betriebszeit, Weitergaberechte oder ein höheres Volumen als höfliches Scraping erlaubt benötigt, ist der richtige Weg ein lizenzierter Feed: Verwenden Sie für die Produktion eine offizielle Marktdaten-API oder einen lizenzierten Börsen-Feed. Das ist der richtige Weg für kommerzielle oder Massennutzung, nicht ein aggressiverer Scraper.

Häufig gestellte Fragen

Warum ist der Preisveränderungsprozentsatz bei einer einfachen Anfrage null?

Weil Google Finance diesen Wert clientseitig mit JavaScript rendert. Das initiale HTML ist eine Hülle, und das JwB6zf-Element, das die Sitzungsveränderung enthält, erscheint nur, nachdem die Skripte der Seite in einem Browser ausgeführt wurden. Eine rohe HTTP-Anfrage gibt Status 200 mit fehlender Veränderung zurück, weshalb das Feld None zurückgibt. Die Seite zuerst zu rendern, was das JS-Token der Crawling API übernimmt, lässt den Wert erscheinen, damit BeautifulSoup ihn lesen kann.

Brauche ich das normale Token oder das JS-Token für Google Finance?

Das JS-Token. Das normale Token ruft statisches HTML ab, das bei Google Finance die gleiche dünne Hülle wie ein einfacher Fetch ist, mit fehlendem Veränderungsprozentsatz. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass Preis, Veränderung und Kennzahlenblock alle vorhanden sind, wenn Sie sie parsen.

Welche Daten kann ich von einer Google-Finance-Kursseite scrapen?

Öffentliche Marktfelder: der Unternehmenstitel, der aktuelle Preis, die Sitzungsveränderung in Wert und Prozent, der vorherige Schlusskurs und der Kennzahlenblock, der Marktkapitalisierung, KGV sowie Tages- und Jahresspannen enthält, sofern vorhanden. Das sind sachliche öffentliche Kurse, die jeder Besucher laden kann, keine persönlichen Daten. Bleiben Sie in diesem Bereich und verwenden Sie einen lizenzierten Feed, wenn Sie Weitergaberechte benötigen.

Meine Selektoren geben None zurück. Was hat sich geändert?

Mit ziemlicher Sicherheit Googles Markup. Seine generierten Klassennamen (AHmHk für Preis, JwB6zf für Veränderung, zzDege für Titel und gyFHrc / mfs7Fc / P6K39c für die Kennzahlenzeilen) ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktionierten, brechen können. Untersuchen Sie einen Live-Kurs in den Entwicklertools Ihres Browsers erneut und aktualisieren Sie die Klassenstrings. Periodische Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Wie scrape ich mehrere Aktien auf einmal?

Google Finance adressiert jede Aktie als SYMBOL:EXCHANGE in der Kurs-URL, zum Beispiel GOOGL:NASDAQ. Bauen Sie eine Liste dieser URLs und iterieren Sie darüber, indem Sie die gleiche extract_quote-Funktion auf jeder gerenderten Seite aufrufen, wie die obige main-Funktion zeigt. Halten Sie eine kurze Schlafpause zwischen den Anfragen, um den Lauf zu steuern, und erweitern Sie die Liste auf Ihre gesamte Watchlist.

Gibt es eine offizielle Google-Finance-API für die Produktionsnutzung?

Google bietet keine öffentliche, unterstützte Marktdaten-API für Google Finance an, daher ist der zuverlässige Weg für die Produktion oder kommerzielle Nutzung ein lizenzierter Marktdatenanbieter oder ein offizieller Börsen-Feed statt das Scrapen der Webseite. Diese Feeds kommen mit Betriebszeitgarantien und Weitergabebedingungen, die das Scrapen einer öffentlichen Seite nicht bietet, was wichtig wird, sobald Datengenauigkeit oder Wiederverwendungsrechte Teil der Anforderung sind.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.