Das Bright Data Python SDK: Scrapen, Suchen und Web-Daten abrufen

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 ist eine Python-Bibliothek, die die Interaktion mit Bright-Data-Produkten vereinfachen soll.

Das SDK ist über das PyPI-Paket 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, 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 viele derselben Funktionen über Befehlszeilenbefehle. Erfahren Sie, wie Sie die Bright Data CLI mit KI-Agenten nutzen.

Weiterführende Links:

• Dokumentation des Bright Data Python SDK
• Offizielles Repository des Bright Data Python SDK

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.

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 oder, falls Sie sich bereits über die Bright Data CLI authentifiziert haben, über die von 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: 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:

pip install brightdata-sdk

Nach der Installation importieren Sie das SDK und erhalten Zugriff auf viele Methoden, wie zum Beispiel:

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:

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:

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:

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":

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.

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:

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

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:

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+ lokal installiert.
• Ein Bright-Data-Konto.
• Ein Bright Data API-Token, das Sie im Bright Data Control Panel generieren können.

Schritt 1: Installieren Sie das SDK

Installieren Sie das Bright Data Python SDK über pip mit:

pip install brightdata-sdk

Wenn Sie bereits eine ältere Version installiert haben, aktualisieren Sie sie mit:

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:

export BRIGHTDATA_API_KEY=""

Unter Windows PowerShell führen Sie aus:

$Env:BRIGHTDATA_API_KEY = ""

Sobald die Umgebungsvariable gesetzt ist, übernimmt der standardmäßige asynchrone Client Ihren API-Schlüssel automatisch:

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:

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 sammeln.

Für diese Aufgabe können Sie die Bright Data LinkedIn Profiles Scraper API verwenden, die über die Methode client.scrape.linkedin.profiles() verfügbar ist. Diese gibt die Profildaten in einem strukturierten Objekt zurück:

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:

Beachten Sie, wie die Methode wie erwartet frisch gescrapte, strukturierte, öffentliche Daten des angegebenen LinkedIn-Profils zurückgibt:

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.

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:

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 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:

Wenn Sie nicht jeden Schritt selbst verwalten müssen, kombiniert to_result() das Warten, Abrufen und Verpacken der Daten in ein Ergebnisobjekt:

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:

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:

Dasselbe Prinzip gilt für die Plattform-Scraper. Das folgende Skript sammelt zwei LinkedIn-Profile gleichzeitig:

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:

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 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:

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:

Um ein scrape-Methodenergebnis in eine Datei zu exportieren, rufen Sie save_to_file() auf:

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:

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 ist es wichtig zu verstehen, wie unterschiedliche Suchmaschinen dieselbe Abfrage behandeln. Das folgende Skript führt dieselbe Abfrage auf Google und Bing aus:

# 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:

Vollständige Amazon-Produktinformationen abrufen

Das Scrapen von 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:

# 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:

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 umfasst:

1. Das Abrufen einer Webseite.
2. Das Parsen mit einem HTML-Parser.
3. Das Extrahieren der benötigten Daten.

Das Problem ist, dass viele Websites Anti-Scraping-Maßnahmen 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 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 und extrahiert die Produktfelder:

# 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:

Diese Felder entsprechen den auf der Zielseite angezeigten Informationen.

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, das GitHub-Repository und das Beispielverzeichnis, 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-Server stattet KI-Agenten mit Scraping- und Suchwerkzeugen aus, und Agent Skills 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, 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.