--- title: "Das Bright Data Python SDK: Scrapen, Suchen und Web-Daten abrufen" slug: bright-data-python-sdk date: 2026-10-18T12:29:35+00:00 modified: 2026-10-18T12:29:38+00:00 permalink: https://brightdata.de/blog/ai/bright-data-python-sdk type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [AI](https://brightdata.de/blog/ai) [AI](https://brightdata.de/blog/ai) # Das Bright Data Python SDK: Scrapen, Suchen und Web-Daten abrufen Erfahren Sie, wie Sie das Bright Data Python SDK nutzen, um Websites zu scrapen, Google und Bing zu durchsuchen, Daten zu exportieren und Jobs parallel in Python auszuführen. 20 min lesen [ ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![Bright Data Python SDK](https://media.brightdata.de/2026/10/Bright-Data-Python-SDK.png) In diesem Leitfaden lernen Sie: - Was das Bright Data Python SDK ist. - Wie es im Hintergrund funktioniert, einschließlich der Authentifizierung. - Was es bietet, einschließlich synchroner und asynchroner Modi, Hauptfunktionen und Methoden. - Wie Sie das SDK installieren und Ihre ersten Anfragen Schritt für Schritt ausführen. - Fortgeschrittene Themen wie Polling, gleichzeitiges Scraping und mehr. - Praxisnahe Anwendungsfälle, vom Vergleich von Suchmaschinenergebnissen bis zum Parsen von Webseiten mit BeautifulSoup für die manuelle Datenextraktion. Legen wir los! ## Was ist das Bright Data Python SDK? Das [Bright Data Python SDK](https://docs.brightdata.com/api-reference/SDK) ist eine Python-Bibliothek, die die Interaktion mit [Bright-Data-Produkten](/products) vereinfachen soll. Das SDK ist über das PyPI-Paket [`brightdata-sdk`](https://pypi.org/project/brightdata-sdk/) verfügbar. Es bietet eine einheitliche Schnittstelle zum Scrapen von Websites, Abrufen von Suchmaschinenergebnissen, Zugriff auf fertige Datensätze und zur Arbeit mit Bright-Data-Lösungen. Im Detail enthält das Python SDK einsatzbereite Integrationen mit über 100 [Bright Data Scraper APIs](/products/web-scraper), die Ihnen helfen, auf aktuelle, strukturierte, öffentlich verfügbare Daten von Plattformen wie Amazon, LinkedIn, Instagram, TikTok und vielen anderen zuzugreifen. **Hinweis**: Wenn Sie lieber im Terminal arbeiten, bietet Ihnen die [Bright Data CLI](https://docs.brightdata.com/products/cli/overview) viele derselben Funktionen über Befehlszeilenbefehle. Erfahren Sie, wie Sie die [Bright Data CLI mit KI-Agenten](/blog/ai/bright-data-cli-with-top-coding-agents) nutzen. **Weiterführende Links**: - [*Dokumentation des Bright Data Python SDK*](https://docs.brightdata.com/api-reference/SDK) - [*Offizielles Repository des Bright Data Python SDK*](https://github.com/brightdata/sdk-python) ## Wie das Python SDK funktioniert Im Hintergrund kapselt das SDK die Bright Data APIs in Python-Klassen. So können Sie mit Bright-Data-Diensten interagieren, ohne manuell HTTP-Anfragen zu erstellen, API-Endpunkte aufzurufen und Antworten zu parsen. Stattdessen rufen Sie einfach entwicklerfreundliche Python-Methoden auf. Die Bibliothek ist vollständig typisiert und ausführlich dokumentiert, was die Erkundung ihrer Fähigkeiten in Ihrer IDE erleichtert. ![Beachten Sie die IDE-Autovervollständigung, Nutzungsvorschläge und Methodendokumentation](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791816660506_image.png)Sie erhalten Autovervollständigung, Typhinweise und Anwendungsbeispiele, die Ihnen helfen, die verfügbaren Parameter zu verstehen und jede Methode richtig zu nutzen. Auch die zurückgegebenen Objekte sind typisiert, sodass Sie leicht auf die Antwortfelder zugreifen können. Die Authentifizierung erfolgt über das [Bright Data API-Token](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key) oder, falls Sie sich bereits über die Bright Data CLI authentifiziert haben, über die von [`brightdata login`](https://docs.brightdata.com/products/cli/commands#brightdata-login) gespeicherten Zugangsdaten. Beachten Sie, dass das SDK die erforderlichen APIs automatisch für Sie einrichtet, falls Ihr Bright-Data-Konto diese im Hintergrund aufgerufenen APIs noch nicht besitzt. ## Was das SDK bietet Nachdem das Kernmodell klar ist, besteht der nächste Schritt darin, zu untersuchen, was das Python SDK zu bieten hat. ### Hauptfunktionen Das Bright Data Python SDK deckt eine breite Palette an Funktionen ab, darunter: - **Web-Scraping**: Scrapen Sie einzelne oder mehrere URLs gleichzeitig und rufen Sie Website-Inhalte mit minimalem Code ab. - **Suchmaschinenergebnisse**: Rufen Sie Ergebnisse von Google, Bing und Yandex ab, mit Unterstützung für standortspezifische Abfragen und Batch-Suchen. - **Plattformspezifische Scraper**: Extrahieren Sie strukturierte Daten von Amazon, LinkedIn, Instagram, Facebook, TikTok, YouTube, Reddit, Pinterest, ChatGPT, Perplexity und anderen Plattformen. - **Plattformspezifische Suche**: Entdecken Sie Profile, Jobs, Beiträge und andere Inhalte anhand von Suchparametern statt nur über URLs. - [**Scraper-Studio-Integration**](https://docs.brightdata.com/products/scraper-studio/overview): Führen Sie benutzerdefinierte Scraper aus, lösen Sie Sammelaufträge aus, überwachen Sie deren Status und rufen Sie Ergebnisse ab. - **Typisierte Methoden und Antworten**: Profitieren Sie von Typhinweisen, IDE-Autovervollständigung, Parametervorschlägen und strukturierten Antwortobjekten für eine einfachere Entwicklung. - **Konto- und API-Verwaltung**: Überprüfen Sie die Konnektivität, sehen Sie Kontoinformationen und Nutzung ein, listen Sie APIs auf und verwalten Sie API-Konfigurationen. - **Datenexport**: Speichern Sie gesammelte Web-Datensatzergebnisse in den Formaten JSON, CSV oder JSONL. ### Wichtigste SDK-Methoden Beginnen Sie mit der Installation des Bright Data Python SDK: ```none pip install brightdata-sdk ``` Nach der Installation importieren Sie das SDK und erhalten Zugriff auf viele Methoden, wie zum Beispiel: **Methode****Was sie macht****Bright-Data-Produkt**`client.scrape_url(url)`Ruft den Inhalt einer URL oder einer Liste von URLs ab und [umgeht jedes Anti-Bot-System](https://docs.brightdata.com/concepts/how-bright-data-handles-blocking)[Unlocker API](/products/web-unlocker)`client.search.google(query=...)`Führt eine Google-Suche aus und gibt geparste organische Ergebnisse zurück[SERP-API](/products/serp-api)`client.search.bing(query=...)`Führt eine Bing-Suche aus und gibt geparste organische Ergebnisse zurückSERP-API (siehe den [Migrationsleitfaden für die Bing Web Search API](https://docs.brightdata.com/products/serp-api/parsed-json-results/bing-to-bright-data-serp-migration-guide))`client.scrape..(url=...)`Extrahiert strukturierte Daten von einer Zielplattform, wie z. B. `client.scrape.amazon.products`Scraper APIs`client.search.linkedin.jobs(...)`Durchsucht eine Plattform nach Parametern statt nach URLsSpezifische Scraper APIs`client.datasets.(filter=...)`Fordert einen gefilterten Snapshot von einem vorab gesammelten Datensatz an[Dataset-APIs](https://docs.brightdata.com/api-reference/marketplace-dataset-api/filter-dataset)`client.scraper_studio.run(collector=..., input=...)`Löst einen benutzerdefinierten Web-Scraping-Collector aus und gibt dessen Datensätze zurück[Scraper Studio](/products/web-scraper/studio)`client.browser.get_connect_url()`Erstellt den CDP-Endpunkt, um Playwright oder Puppeteer mit einem Cloud-Browser zu verbinden[Browser-API](/products/scraping-browser)`client.list_zones()`Listet die in Ihrem Konto verfügbaren Zonen aufKeine### Synchrone und asynchrone Clients Das SDK bietet zwei Clients mit denselben Methodennamen, aber unterschiedlichen Ausführungsmodellen: - `BrightDataClient`: Der asynchrone Client, konzipiert für Anwendungen, die `asyncio` verwenden und hohe Parallelität bewältigen müssen. - `SyncBrightDataClient`: Der synchrone Client, ideal für einfache Skripte und unkomplizierte, sequentielle Anfragen. So rufen Sie `scrape_url()` mit `SyncBrightDataClient` auf: ```none from brightdata import SyncBrightDataClient with SyncBrightDataClient() as client: result = client.scrape_url("https://example.com") print(result.data) ``` Entsprechend müssen Sie bei `BrightDataClient` [`async with` zur Verwaltung des Clients und `await` zum Aufruf asynchroner Methoden verwenden](https://docs.python.org/3/howto/a-conceptual-overview-of-asyncio.html): ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape_url("https://example.com") print(result.data) asyncio.run(main()) ``` Beide Beispiele geben das HTML der Zielseite in `result.data` zurück: ![Das HTML der Ziel-example.com-Seite](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791817848730_image.png)Beachten Sie, dass `scrape_url()`, obwohl `BrightDataClient` asynchron ist, standardmäßig `mode="sync"` verwendet. Das bedeutet, dass der Aufruf wartet, bis das Scraping-Ergebnis verfügbar ist, bevor er zurückkehrt. Um `scrape_url()` im rein asynchronen Modus zu verwenden, übergeben Sie `mode="async"`: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape_url( url="https://example.com", mode="async", poll_interval=5, # Alle 5 Sekunden prüfen poll_timeout=180, # Bis zu 3 Minuten erlauben ) print(result.data) asyncio.run(main()) ``` Im asynchronen Scraping-Modus führt das SDK Folgendes aus: 1. Sendet eine Anfrage an den Web-Unlocker-API-Endpunkt. 2. Empfängt eine `response_id`, die die ausstehende Anfrage identifiziert. 3. Fragt den Ergebnis-Endpunkt mit dieser ID ab, bis die Daten bereit sind oder das Timeout erreicht ist. 4. Gibt die Ergebnisdaten zurück, sobald sie verfügbar sind. Weitere Informationen zur Wahl zwischen synchronem und asynchronem Anfragemodus finden Sie in der [Sync-vs.-Async-Dokumentation](https://docs.brightdata.com/concepts/sync-vs-async). **Hinweise**: - Die Parameter `poll_interval` und `poll_timeout` steuern, wie oft das SDK Ergebnisse prüft und wie lange es wartet. Für `scrape_url()` liegen die Standardwerte bei `2` bzw. `30` Sekunden. - Asynchrone Web-Unlocker-Anfragen können etwa zwei Minuten dauern, also stellen Sie `poll_timeout` entsprechend ein. ### Automatische Einrichtung der Bright Data APIs Anfragen über das SDK basieren auf Bright Data APIs, die in Ihrem Konto konfiguriert sind: ![Die in Ihrem Konto konfigurierten Bright Data APIs](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791821313295_image.png)Standardmäßig setzen sowohl `SyncBrightDataClient` als auch `BrightDataClient` `auto_create_zones=True`. Diese Option steuert, ob das SDK die erforderlichen API-Zonen erstellt, falls sie noch nicht existieren. Wenn die automatische Erstellung aktiviert ist, stellt das SDK sicher, dass folgende Zonen verfügbar sind, bevor die erste API-Anfrage gesendet wird: - `sdk_unlocker` für die Web-Unlocker-API - `sdk_serp` für die SERP-API ![Beachten Sie die beiden vom SDK erstellten APIs](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791822018286_image.png)Wenn Sie Ihre API-Zonen lieber selbst verwalten möchten, setzen Sie `auto_create_zones=False`. Das SDK erstellt die APIs dann nicht, sodass Sie die Namen Ihrer bestehenden Zonen über `web_unlocker_zone` und `serp_zone` angeben müssen. Um eine benutzerdefinierte Unlocker-API-Zone zu verwenden, schreiben Sie: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient( auto_create_zones=False, web_unlocker_zone="web_unlocker", # Durch Ihre benutzerdefinierte Unlocker-API-Zone ersetzen ) as client: result = await client.scrape_url("https://example.com") print(result.data) asyncio.run(main()) ``` ## Erste Schritte mit dem Bright Data Python SDK: Schritt-für-Schritt-Anleitung Nachdem die Konzepte klar sind, ist es Zeit, das SDK zu installieren, zu authentifizieren und seine Methoden zu testen. ### Voraussetzungen Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben: - [Python 3.9+](https://www.python.org/downloads/) lokal installiert. - Ein [Bright-Data-Konto](/?hs_signup=1). - Ein Bright Data API-Token, das Sie im [Bright Data Control Panel](/cp/setting/users) generieren können. ### Schritt 1: Installieren Sie das SDK Installieren Sie das Bright Data Python SDK über pip mit: ```none pip install brightdata-sdk ``` Wenn Sie bereits eine ältere Version installiert haben, aktualisieren Sie sie mit: ```none pip install -U brightdata-sdk ``` **Wichtig:** Dieser Leitfaden bezieht sich auf SDK-Versionen nach `2.5.0`. Gut gemacht! Fahren Sie direkt mit der Authentifizierung fort. ### Schritt 2: Authentifizieren Sie sich mit Ihrem Bright Data API-Token Das Bright Data Python SDK liest die Umgebungsvariable `BRIGHTDATA_API_KEY`, um Anfragen an Bright Data APIs zu authentifizieren. Unter Linux oder macOS setzen Sie die erforderliche Umgebungsvariable auf Ihren Bright Data API-Schlüssel mit: ```none export BRIGHTDATA_API_KEY="" ``` Unter Windows PowerShell führen Sie aus: ```none $Env:BRIGHTDATA_API_KEY = "" ``` Sobald die Umgebungsvariable gesetzt ist, übernimmt der standardmäßige asynchrone Client Ihren API-Schlüssel automatisch: ```none from brightdata import BrightDataClient async with BrightDataClient() as client: # ... ``` Sie können Ihren API-Schlüssel auch direkt beim Erstellen des Clients über das Argument `token` übergeben: ```none from brightdata import BrightDataClient async with BrightDataClient(token="") as client: # Make API requests here ... ``` Das direkte Übergeben des Tokens kann für schnelle Tests nützlich sein. Vermeiden Sie es dennoch, API-Schlüssel fest in Quelldateien einzubetten. Das SDK prüft Zugangsdaten in folgender Reihenfolge: 1. Das an `BrightDataClient` oder `SyncBrightDataClient` übergebene `token`-Argument. 2. Die Umgebungsvariable `BRIGHTDATA_API_TOKEN`. 3. Die Umgebungsvariable `BRIGHTDATA_API_KEY`. 4. Von der Bright Data CLI über `brightdata login` gespeicherte Zugangsdaten, falls verfügbar. Sie sind startklar! Sie können nun das Python SDK verwenden, um Webseiten zu scrapen, Suchergebnisse abzurufen und auf andere Bright Data APIs zuzugreifen. ### Schritt 3: Führen Sie Ihre erste Web-Datensammlungsaufgabe aus Nachdem das SDK installiert und authentifiziert ist, führen Sie Ihr erstes Scraping aus. Angenommen, Sie möchten strukturierte Daten von einem [bestimmten LinkedIn-Profil](https://es.linkedin.com/in/antonello-zanini) sammeln. Für diese Aufgabe können Sie die [Bright Data LinkedIn Profiles Scraper API](/products/web-scraper/linkedin/profiles) verwenden, die über die Methode `client.scrape.linkedin.profiles()` verfügbar ist. Diese gibt die Profildaten in einem strukturierten Objekt zurück: ```none import asyncio from brightdata import BrightDataClient from pprint import pprint async def main(): async with BrightDataClient() as client: result = await client.scrape.linkedin.profiles( url="https://linkedin.com/in/antonello-zanini" # Ziel-LinkedIn-Profil zum Scrapen ) print(f"Success: {result.success}") print("\nScraped profile data:") pprint(result.data, indent=2, sort_dicts=False) asyncio.run(main()) ``` Das Ergebnis sieht wie folgt aus: ![Die vom Skript zurückgegebenen strukturierten LinkedIn-Profildaten](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835516140_image.png)Beachten Sie, wie die Methode wie erwartet frisch gescrapte, strukturierte, öffentliche Daten des angegebenen LinkedIn-Profils zurückgibt: ![Das Ziel-LinkedIn-Profil](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835586169_image.png)Mission erfüllt! ## Erweiterte Nutzung Nachdem Sie sich mit den Grundlagen vertraut gemacht haben, sind Sie bereit, fortgeschrittenere Themen zu erkunden. ### Polling-Mechanismus Manche Scraping-Aufgaben dauern länger als ein paar Sekunden, und Sie möchten vielleicht die Kontrolle darüber behalten, was während der Ausführung geschieht. Für diese Fälle ermöglicht Ihnen Bright Data, [Scraper APIs als asynchrone Jobs auszuführen](https://docs.brightdata.com/api-reference/rest-api/scraper/asynchronous-requests). Die Idee besteht darin, das Scraping auszulösen und sofort einen Job zurückzubekommen. Anschließend prüfen Sie dessen Status, warten auf den Abschluss und rufen die Ergebnisse ab, sobald sie erzeugt wurden. Normalerweise würde dies eine benutzerdefinierte Polling-Logik erfordern, aber das SDK bietet bereits Methoden, die den Prozess vereinfachen. Das folgende Skript führt asynchrones Scraping für ein LinkedIn-Profil durch: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: # Start the scraping task and return a job right away job = await client.scrape.linkedin.profiles_trigger( url="https://es.linkedin.com/in/antonello-zanini" ) print(f"Job triggered: {job.snapshot_id}") # The ID that identifies this job # Check the current state of the job, such as "running" or "ready" status = await job.status() print(f"Status: {status}") # Poll the job until it is "ready" await job.wait(timeout=180, verbose=True) # Download the records once the job is ready data = await job.fetch() print(f"Got {len(data) if isinstance(data, list) else 1} records") asyncio.run(main()) ``` Nachfolgend sehen Sie, was jede SDK-Methode macht: 1. `profiles_trigger()` startet den Scraping-Job und gibt ein Job-Objekt zurück, ohne auf den Abschluss des Scrapings zu warten. 2. `job.status()` prüft den aktuellen Job-Status. 3. `job.wait()` fragt den Job-Status in regelmäßigen Abständen ab, bis der Job bereit ist oder das Timeout erreicht wird. Standardmäßig prüft es den Status alle 10 Sekunden. Wird zuerst das Timeout erreicht, löst es einen [`TimeoutError`](https://docs.python.org/3/builtins/exceptions.html#TimeoutError) aus. 4. `job.fetch()` ruft die gescrapten Datensätze ab, sobald der Job bereit ist. Das Setzen von `verbose=True` gibt jede Statusprüfung aus, sodass Sie den Fortschritt des Jobs verfolgen können: ![Die vom vorherigen Skript erzeugten Protokolle](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791832933568_image.png)Wenn Sie nicht jeden Schritt selbst verwalten müssen, kombiniert `to_result()` das Warten, Abrufen und Verpacken der Daten in ein Ergebnisobjekt: ```none import asyncio from brightdata import BrightDataClient from pprint import pprint async def main(): async with BrightDataClient() as client: # Start the scraping task and return a job right away job = await client.scrape.linkedin.profiles_trigger( url="https://es.linkedin.com/in/antonello-zanini" ) print(f"Job triggered: {job.snapshot_id}") # The ID that identifies this job result = await job.to_result(timeout=180) # Poll, fetch, and get the data print(f"Success: {result.success}") print("\nScraped profile data:") pprint(result.data, indent=2, sort_dicts=False) asyncio.run(main()) ``` Dies gibt dasselbe Ergebnisobjekt zurück wie die zuvor in diesem Tutorial gezeigte Methode `scrape.linkedin.profiles()`. Wenn Sie mehr Kontrolle über das Polling benötigen, können Sie eine eigene Schleife implementieren, indem Sie wiederholt `job.status()` aufrufen und Ihre Logik basierend auf dem zurückgegebenen Status (d. h. `"running"`, `"ready"` oder `"error"`) anpassen. ### Mehrere Seiten gleichzeitig scrapen Wenn Sie mehrere Seiten abrufen müssen, übergeben Sie eine Liste von URLs an die Scraping-Methode des Bright Data Python SDK. Das SDK ruft sie gleichzeitig ab und gibt ein Ergebnisobjekt pro URL zurück. Werfen Sie einen Blick auf das Beispiel unten: ```none import asyncio from brightdata import BrightDataClient urls = [ "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html", "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html", "https://books.toscrape.com/catalogue/soumission_998/index.html", ] async def main(): async with BrightDataClient() as client: # Fetch all the URLs concurrently results = await client.scrape_url(urls) # Each item in results is a result object for one URL for i, r in enumerate(results): if r.success: # Skip the URLs that failed print(f"URL: {urls[i]}") print(f"{r.data[:500]}...") # First 500 characters of the raw HTML print("-" * 80 + "\n") asyncio.run(main()) ``` Das Skript gibt für jede erfolgreiche URL eine Zeile aus und zeigt die ersten 500 Zeichen des rohen HTML: ![Beachten Sie die drei verschiedenen gescrapten HTML-Seiten](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791833920080_image.png)Dasselbe Prinzip gilt für die Plattform-Scraper. Das folgende Skript sammelt zwei LinkedIn-Profile gleichzeitig: ```none import asyncio from brightdata import BrightDataClient PROFILE_URLS = [ "https://es.linkedin.com/in/antonello-zanini", "https://it.linkedin.com/in/federico-trotta", ] async def main(): async with BrightDataClient() as client: linkedin = client.scrape.linkedin # Trigger every profile first, so all the jobs start before you wait on any of them job = await linkedin.profiles_trigger(url=PROFILE_URLS) # Poll the job until it is "ready" await job.wait(timeout=180, verbose=True) # Download the records once the job is ready data = await job.fetch() print(f"Got {len(data) if isinstance(data, list) else 1} records") asyncio.run(main()) ``` Die Ausgabe ist ein Datensatz mit zwei gleichzeitig gescrapten Profilen: ![Beachten Sie, dass das Skript zwei LinkedIn-Profile gleichzeitig gescrapt hat](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791834093109_image.png)### Abgerufene Daten exportieren Das SDK kann zwei Arten von Daten speichern: Datensatzeinträge und `scrape`-Methodenergebnisse. Datensatzeinträge können mit dem Helfer `export()` exportiert werden, während ein `scrape`-Ergebnis den Helfer `save_to_file()` besitzt. [Datensätze](/products/datasets) sind nützlich, wenn Sie vorab gesammelte Daten statt frischer Scrapes benötigen. Um Datensatzeinträge zu exportieren, erstellen Sie einen Snapshot und laden die Einträge herunter, dann übergeben Sie sie an den Helfer `export()`, der sie in eine Datei schreibt: ```none import asyncio from brightdata import BrightDataClient from brightdata.datasets import export async def main(): async with BrightDataClient() as client: imdb = client.datasets.imdb_movies # Create a snapshot for the filtered records # (movies with an IMDB rating of 9+ and 100+ ratings) # then download them as a list snapshot_id = await imdb( filter={ "operator": "and", "filters": [ {"name": "imdb_rating", "operator": ">=", "value": 9}, {"name": "imdb_rating_count", "operator": ">", "value": 100}, ], }, records_limit=10, ) data = await imdb.download(snapshot_id) export(data, "imdb_top_rated.csv") # The .csv extension selects the CSV format asyncio.run(main()) ``` **Hinweis**: Das Ausgabeformat wird anhand der Dateierweiterung ausgewählt, unterstützt werden `.json`, `.jsonl` und `.csv`. Das obige Skript erstellt die folgende Datei `imdb_top_rated.csv` im Ordner Ihres Projekts: ![Die Ausgabedatei ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835152372_image.png)Um ein `scrape`-Methodenergebnis in eine Datei zu exportieren, rufen Sie `save_to_file()` auf: ```none import asyncio from brightdata import BrightDataClient async def main(): async with BrightDataClient() as client: result = await client.scrape.linkedin.profiles( url="https://es.linkedin.com/in/antonello-zanini" ) result.save_to_file("antonello_zanini.json", format="json") # Written to disk asyncio.run(main()) ``` **Hinweis**: Nur das JSON-Format wird unterstützt. Dies erzeugt eine Datei `antonello_zanini.json` wie folgt: ![Die Ausgabedatei ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835250162_image.png)## Das Bright Data Python SDK in Aktion: Anwendungsfälle Nach der Erkundung fortgeschrittenerer Szenarien verfügen Sie nun über das nötige Hintergrundwissen, um reale Anwendungsfälle anzugehen. ### Suchmaschinenergebnisse vergleichen Beim [SERP-Tracking](/use-cases/serp-tracking) ist es wichtig zu verstehen, wie unterschiedliche Suchmaschinen dieselbe Abfrage behandeln. Das folgende Skript führt dieselbe Abfrage auf Google und Bing aus: ```none # pip install brightdata-sdk import asyncio from brightdata import BrightDataClient # The query to run on multiple search engines query = "best HTML parsers" async def main(): async with BrightDataClient() as client: # Get parsed search results from Google and Bing google = await client.search.google(query=query, num_results=10) bing = await client.search.bing(query=query, num_results=10) # Print the top three results from each search engine for name, result in [("Google", google), ("Bing", bing)]: print(f"\n{name}:") for item in result.data[:3]: print(f" - {item['title']} ({item['url']})") asyncio.run(main()) ``` Google und Bing geben geparste organische Suchergebnisse mit Feldern wie `title` und `url` zurück. Sie können direkt auf diese Daten zugreifen, zum Beispiel, um die obersten drei Ergebnisse auszugeben: ![Beachten Sie die abgerufenen Top-3-Ergebnisse auf Google und Bing für dieselbe Suchanfrage](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840322204_image.png)### Vollständige Amazon-Produktinformationen abrufen [Das Scrapen von Amazon](/blog/how-tos/how-to-scrape-amazon) bedeutet mehr, als strukturierte Daten von einer Produktseite zu sammeln. Es kann auch die Extraktion von Produktbewertungen umfassen, die wertvolle Informationen für Produktbewertungen, Stimmungsanalysen, Überwachung und mehr liefern. Dank der verschiedenen Bright Data Scraper APIs können Sie sowohl Produktinformationen als auch Bewertungen über das SDK abrufen, wie unten gezeigt: ```none # pip install brightdata-sdk import asyncio from brightdata import BrightDataClient product_url = "https://www.amazon.com/dp/B0DCH8VDXF/" async def main(): async with BrightDataClient() as client: # Retrieve both the product and reviews data product = await client.scrape.amazon.products(url=product_url) reviews = await client.scrape.amazon.reviews(url=product_url, pastDays=30, keyWord="quality") # Print the scraped data print(f"Title: {product.data['title']}") print(f"Price: {product.data['final_price']}") print(f"Rating: {product.data['rating']}") print(f"Reviews fetched: {len(reviews.data)}") asyncio.run(main()) ``` Das Skript nutzte die Filteroptionen von `client.scrape.amazon.reviews()`, um nur Bewertungen der letzten 30 Tage abzurufen, die das Schlüsselwort “quality” enthalten. Die Ausgabe sieht wie folgt aus: ![Beachten Sie die Produkt- und Bewertungsdaten](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840123670_image.png)**Hinweis**: Die zurückgegebenen Werte hängen vom Produkt und dem Zeitpunkt der Anfrage ab. ### Eine entsperrte Seite mit BeautifulSoup parsen Ein typischer [Web-Scraping-Fahrplan](/blog/web-data/web-scraping-roadmap) umfasst: 1. Das Abrufen einer Webseite. 2. Das Parsen mit [einem HTML-Parser](/blog/web-data/best-python-html-parsers). 3. Das Extrahieren der benötigten Daten. Das Problem ist, dass viele Websites [Anti-Scraping-Maßnahmen](/blog/web-data/anti-scraping-techniques) einsetzen, die automatisierte Anfragen nach HTML-Inhalten blockieren können. Eine mögliche Lösung besteht darin, auf diese Seiten über einen Dienst wie die Bright Data Web Unlocker API zuzugreifen, der Browser-Fingerprinting, Proxy-Rotation, CAPTCHA-Lösung und andere Herausforderungen bewältigt. Angenommen, Sie möchten eine Produktseite aus dem [NBA Store für ein Stephen-Curry-Trikot der Golden State Warriors](https://store.nba.com/golden-state-warriors/mens-golden-state-warriors-stephen-curry-fanatics-royal-fast-break-replica-jersey-icon-edition/t-14140641+p-138834682113177+z-9-2551128663?_ref=p-SFLP:m-GRID:i-r0c0:po-0) abrufen und Name, Marke, Preis, Verfügbarkeit und verfügbare Größen sammeln. Das folgende Skript verwendet die SDK-Methode `scrape_url()`, um die Seite abzurufen, lädt das zurückgegebene [HTML in BeautifulSoup](/blog/how-tos/beautiful-soup-web-scraping) und extrahiert die Produktfelder: ```none # pip install brightdata-sdk beautifulsoup4 import asyncio from brightdata import BrightDataClient from bs4 import BeautifulSoup import json NBA_PRODUCT_URL = ( "https://store.nba.com/golden-state-warriors/mens-golden-state-warriors-stephen-curry-" "fanatics-royal-fast-break-replica-jersey-icon-edition/t-14140641+p-138834682113177+z-9-2551128663" "?_ref=p-SFLP:m-GRID:i-r0c0:po-0" ) async def main(): # Fetch the page via scrape_url() to avoid anti-bots async with BrightDataClient() as client: result = await client.scrape_url(NBA_PRODUCT_URL) # Load the HTML into BeautifulSoup to parse it soup = BeautifulSoup(result.data, "html.parser") # Extract the product name from the page's main heading title = soup.find("h1", attrs={"data-talos": "labelPdpProductTitle"}).get_text(strip=True) # Find the JSON-LD block that describes the product product_ld_data = None for script in soup.find_all("script", type="application/ld+json"): data = json.loads(script.string) if data.get("@type") == "Product": product_ld_data = data break # Access some data from it brand = product_ld_data["brand"] images = product_ld_data["image"] # Read the price and availability from the first offer offer = product_ld_data["offers"][0] price = offer["priceSpecification"]["price"] currency = offer["priceSpecification"]["priceCurrency"] availability = offer["availability"].rsplit("/", 1)[-1] # Extract the sizes, which are buttons, and their visible text is the size label (S, M, L, ...) sizes = [b.get_text(strip=True) for b in soup.find_all("button", attrs={"data-talos": "buttonSize"})] # Collect the scraped data product = { "title": title, "brand": brand, "images": images, "price": price, "currency": currency, "availability": availability, "sizes": sizes, } # Print the scraped data print(json.dumps(product, indent=2)) asyncio.run(main()) ``` Die Ausgabe sieht wie folgt aus: ![Die aus der entsperrten NBA-Produktseite geparsten Daten](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791836755290_image.png)Diese Felder entsprechen den auf der Zielseite angezeigten Informationen. ![Die Ziel-NBA-Produktseite](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840804593_image.png)## Fazit In diesem Blogbeitrag haben Sie erfahren, wie das Bright Data Python SDK ein einziges Python-Paket für den Zugriff auf die Scraping-, Such- und Datensatzprodukte von Bright Data bereitstellt. Sie haben auch gesehen, wie man das SDK installiert und in realen Szenarien einsetzt. Um mehr zu erfahren, erkunden Sie die [offizielle Dokumentation](https://docs.brightdata.com/api-reference/SDK), das [GitHub-Repository](https://github.com/brightdata/sdk-python) und das [Beispielverzeichnis](https://github.com/brightdata/sdk-python/tree/main/examples), das funktionierende Skripte für jede Funktion enthält. Wenn Sie das SDK nützlich finden, geben Sie dem Repository gerne einen Stern! Erstellen Sie noch heute ein Bright-Data-Konto und probieren Sie das Python SDK aus, um den Zugriff auf Bright Data APIs zu vereinfachen. ## FAQ ### Warum ist das Bright Data Python SDK nützlich? Es gibt Python-Entwicklern ein einheitliches Paket, um Websites zu scrapen, Suchmaschinenabfragen auszuführen, Bot-Erkennung und CAPTCHAs zu umgehen, strukturierte Plattformdaten zu extrahieren und auf über 100 fertige Datensätze zuzugreifen. Dank ihm müssen Sie diese Infrastruktur nicht selbst aufbauen. ### Benötige ich die Bright Data CLI, um das SDK zu nutzen? Nein. Das SDK funktioniert mit einem API-Token, das in `BRIGHTDATA_API_KEY` oder `BRIGHTDATA_API_TOKEN` gesetzt ist. Wenn Sie bereits `brightdata login` ausgeführt haben, greift das SDK auf die von der CLI gespeicherten Zugangsdaten zurück, sodass Sie nichts weiter konfigurieren müssen. ### Was ist der Unterschied zwischen der Bright Data CLI, dem Python SDK, dem MCP und Agent Skills? Die CLI führt Bright-Data-Befehle über Ihr Terminal aus. Das Python SDK ermöglicht Ihrem Python-Code den Aufruf der APIs. Der [Bright Data MCP](/ai/mcp-server)-Server stattet KI-Agenten mit Scraping- und Suchwerkzeugen aus, und [Agent Skills](/blog/ai/bright-data-skills-coding-agents) bringen Coding-Agenten bei, wie sie Bright Data nutzen. ### Was ist der Unterschied zwischen dem Bright Data Python SDK und dem Bright Data JavaScript SDK? Das Python SDK (`brightdata-sdk`, installiert mit pip) bietet synchrone und asynchrone Clients mit snake\_case-Methoden wie `scrape_url()`. Das JavaScript SDK ([`@brightdata/sdk`](https://docs.brightdata.com/api-reference/SDK-JS), installiert mit npm) läuft auf Node.js und verwendet camelCase-Methoden wie `scrapeUrl()`. ### Wann sollte ich den synchronen oder asynchronen Modus verwenden? Verwenden Sie den synchronen Client für einfache Skripte und schnelle Prüfungen, da jeder Aufruf blockiert, bis das Ergebnis bereit ist. Verwenden Sie den asynchronen Client für Workloads mit hoher Parallelität, Batch-Jobs und Hintergrundverarbeitung. Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis [ ](https://news.ycombinator.com/submitlink?t=Das+Bright+Data+Python+SDK%3A+Scrapen%2C+Suchen+und+Web-Daten+abrufen&u=https://brightdata.de/blog/ai/bright-data-python-sdk) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Das+Bright+Data+Python+SDK%3A+Scrapen%2C+Suchen+und+Web-Daten+abrufen&url=https://brightdata.de/blog/ai/bright-data-python-sdk) [ ](http://www.reddit.com/submit?title=Das+Bright+Data+Python+SDK%3A+Scrapen%2C+Suchen+und+Web-Daten+abrufen&url=https://brightdata.de/blog/ai/bright-data-python-sdk) ## Das könnte Sie auch interessieren [ ![Claude Code Routines](https://media.brightdata.de/2026/10/Claude-Code-Routines.png) ](https://brightdata.de/blog/ai/claude-code-routines "Claude Code Routines: Tägliche Web-Überwachung mit Bright Data planen") [AI ![Satyam Tripathi](https://media.brightdata.de/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Claude Code Routines: Tägliche Web-Überwachung mit Bright Data planen Erfahre, wie du Claude Code Routinen mit Bright Data Webzugriff gibst und einen täglichen Preismonitor baust, der jede gelesene Seite prüft. 18-Oct-2026 29 min lesen ](https://brightdata.de/blog/ai/claude-code-routines) [ ![Is There a Google Search API](https://media.brightdata.de/2026/10/Is-There-a-Google-Search-API_.png) ](https://brightdata.de/blog/web-data-de/google-search-api "Gibt es eine Google Search API? Optionen nach Custom Search") [Web Data ![Satyam Tripathi](https://media.brightdata.de/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Gibt es eine Google Search API? Optionen nach Custom Search Erfahren Sie, wie Sie von Googles Custom Search JSON API zu Bright Datas SERP API migrieren, mit einem Drop-in cse.list()-Adapter und einer Parameterzuordnung. 18-Oct-2026 7 min lesen ](https://brightdata.de/blog/web-data-de/google-search-api) [ ![Amazon Bedrock Knowledge Bases with Bright Data](https://media.brightdata.de/2026/08/Amazon-Bedrock-Knowledge-Bases-with-Bright-Data.png) ](https://brightdata.de/blog/wie/amazon-bedrock-knowledge-bases-with-bright-data "Wie man Amazon Bedrock Knowledge Bases mit Bright Data mit Live-Webdaten versorgt") [How Tos ![Satyam Tripathi](https://media.brightdata.de/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Wie man Amazon Bedrock Knowledge Bases mit Bright Data mit Live-Webdaten versorgt Bright Data ermöglicht es Amazon Bedrock Knowledge Bases, auf Webdaten zuzugreifen, die durch JavaScript-Rendering, Bot-Schutz oder Geo-Beschränkungen blockiert sind. 15-Oct-2026 46 min lesen ](https://brightdata.de/blog/wie/amazon-bedrock-knowledge-bases-with-bright-data)