Découvrez le SDK Python de Bright Data : scraper, rechercher et obtenir des données web

Dans ce guide, vous apprendrez :

• Ce qu’est le SDK Python de Bright Data.
• Comment il fonctionne en coulisses, y compris le fonctionnement de l’authentification.
• Ce qu’il propose, y compris les modes synchrone et asynchrone, les fonctionnalités clés et les méthodes.
• Comment installer le SDK et exécuter vos premières requêtes étape par étape.
• Des sujets avancés comme le polling, le scraping concurrent, et plus encore.
• Des cas d’usage réels, de la comparaison des résultats de moteurs de recherche à l’analyse de pages web avec BeautifulSoup pour l’extraction manuelle de données.

Entrons dans le vif du sujet !

Qu’est-ce que le SDK Python de Bright Data ?

Le SDK Python de Bright Data est une bibliothèque Python conçue pour simplifier les interactions avec les produits Bright Data.

Le SDK est disponible via le package PyPI brightdata-sdk. Il fournit une interface unifiée pour scraper des sites web, récupérer les résultats de moteurs de recherche, accéder à des jeux de données prêts à l’emploi et travailler avec les solutions Bright Data.

Concrètement, le SDK Python inclut des intégrations prêtes à l’emploi avec plus de 100 API Scraper de Bright Data, vous aidant à accéder à des données publiques fraîches et structurées depuis des plateformes comme Amazon, LinkedIn, Instagram, TikTok, et bien d’autres.

Remarque : Si vous préférez travailler dans le terminal, le CLI de Bright Data vous offre bon nombre des mêmes capacités via des commandes en ligne de commande. Découvrez comment utiliser le CLI de Bright Data avec des agents IA.

Pour aller plus loin :

• Documentation du SDK Python de Bright Data
• Dépôt officiel du SDK Python de Bright Data

Comment fonctionne le SDK Python

En coulisses, le SDK enveloppe les API de Bright Data dans des classes Python. Ainsi, vous pouvez interagir avec les services Bright Data sans construire manuellement des requêtes HTTP, appeler des points de terminaison API et analyser les réponses. Vous pouvez simplement appeler des méthodes Python conviviales pour les développeurs.

La bibliothèque est entièrement typée et bien documentée, ce qui facilite l’exploration de ses capacités dans votre IDE.

Vous bénéficiez d’autocomplétion, d’indications de type et d’exemples d’utilisation pour vous aider à comprendre les paramètres disponibles et comment utiliser chaque méthode. Les objets retournés sont également typés, vous permettant d’accéder facilement aux champs de réponse.

L’authentification est gérée via le token API de Bright Data ou, si vous vous êtes déjà authentifié via le CLI de Bright Data, les identifiants enregistrés par brightdata login. Notez que si votre compte Bright Data ne dispose pas des API requises que le SDK appelle en coulisses, la bibliothèque les configure automatiquement pour vous.

Ce que propose le SDK

Maintenant que le modèle principal est clair, l’étape suivante consiste à explorer ce que le SDK Python apporte.

Fonctionnalités principales

Le SDK Python de Bright Data couvre un large éventail de capacités, notamment :

• Web scraping : Scraper une ou plusieurs URL simultanément et récupérer le contenu de sites web avec un minimum de code.
• Résultats de moteurs de recherche : Récupérer les résultats de Google, Bing et Yandex, avec prise en charge des requêtes géolocalisées et des recherches en lot.
• Scrapers spécifiques aux plateformes : Extraire des données structurées depuis Amazon, LinkedIn, Instagram, Facebook, TikTok, YouTube, Reddit, Pinterest, ChatGPT, Perplexity, et d’autres plateformes.
• Recherche spécifique aux plateformes : Découvrir des profils, des offres d’emploi, des publications et d’autres contenus à l’aide de paramètres de recherche plutôt que d’URL seules.
• Intégration Scraper Studio : Exécuter des scrapers personnalisés, déclencher des tâches de collecte, surveiller leur statut et récupérer les résultats.
• Méthodes et réponses typées : Bénéficiez d’indications de type, d’autocomplétion IDE, de suggestions de paramètres et d’objets de réponse structurés pour un développement plus facile.
• Gestion de compte et d’API : Vérifier la connectivité, inspecter les informations et l’utilisation du compte, lister les API et gérer les configurations d’API.
• Export de données : Enregistrer les résultats de jeux de données web collectés aux formats JSON, CSV ou JSONL.

Principales méthodes du SDK

Commencez par installer le SDK Python de Bright Data :

pip install brightdata-sdk

Une fois installé, importez le SDK, et vous aurez accès à de nombreuses méthodes, telles que :

Clients synchrones et asynchrones

Le SDK fournit deux clients avec les mêmes noms de méthodes mais des modèles d’exécution différents :

• BrightDataClient : Le client asynchrone, conçu pour les applications utilisant asyncio et nécessitant de gérer des charges de travail à haute concurrence.
• SyncBrightDataClient : Le client synchrone, idéal pour les scripts simples et les requêtes séquentielles directes.

Voici comment appeler scrape_url() en utilisant SyncBrightDataClient :

from brightdata import SyncBrightDataClient

with SyncBrightDataClient() as client:
    result = client.scrape_url("https://example.com")
    print(result.data)

De manière équivalente, avec BrightDataClient, vous devez utiliser async with pour gérer le client et await pour appeler les méthodes asynchrones :

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())

Les deux exemples retournent le HTML de la page cible dans result.data :

Gardez à l’esprit que bien que BrightDataClient soit asynchrone, scrape_url() utilise mode="sync" par défaut. Cela signifie que l’appel attend que le résultat du scraping soit disponible avant de retourner. Pour utiliser scrape_url() en mode purement asynchrone, passez 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,   # Vérifier toutes les 5 secondes
            poll_timeout=180,  # Autoriser jusqu'à 3 minutes
        )
        print(result.data)

asyncio.run(main())

En mode de scraping asynchrone, le SDK :

1. Envoie une requête au point de terminaison de l’API Web Unlocker.
2. Reçoit un response_id qui identifie la requête en attente.
3. Interroge le point de terminaison des résultats à l’aide de cet ID jusqu’à ce que les données soient prêtes ou que le délai d’attente soit atteint.
4. Retourne les données de résultat lorsqu’elles deviennent disponibles.

Pour plus d’informations sur le choix entre les modes de requête synchrone et asynchrone, consultez la documentation Sync vs. Async.

Remarques :

• Les paramètres poll_interval et poll_timeout contrôlent la fréquence à laquelle le SDK vérifie les résultats et la durée d’attente. Pour scrape_url(), leurs valeurs par défaut sont respectivement 2 secondes et 30 secondes.
• Les requêtes asynchrones Web Unlocker peuvent prendre environ deux minutes pour se terminer, donc définissez poll_timeout en conséquence.

Configuration automatique des API Bright Data

Les requêtes effectuées via le SDK reposent sur les API Bright Data configurées dans votre compte :

Par défaut, à la fois SyncBrightDataClient et BrightDataClient définissent auto_create_zones=True. Cette option contrôle si le SDK crée les zones API requises si elles n’existent pas déjà.

Lorsque la création automatique est activée, le SDK s’assure que les zones suivantes sont disponibles avant d’effectuer la première requête API :

• sdk_unlocker pour l’API Web Unlocker
• sdk_serp pour l’API SERP

Si vous préférez gérer vous-même vos zones API, définissez auto_create_zones=False. Le SDK ne créera pas les API, vous devez donc fournir les noms de vos zones existantes via web_unlocker_zone et serp_zone.

Pour utiliser une zone API Unlocker personnalisée, écrivez :

import asyncio
from brightdata import BrightDataClient

async def main():
    async with BrightDataClient(
        auto_create_zones=False,
        web_unlocker_zone="web_unlocker", # Remplacez par votre zone API Unlocker personnalisée
    ) as client:
        result = await client.scrape_url("https://example.com")
        print(result.data)

asyncio.run(main())

Premiers pas avec le SDK Python de Bright Data : guide étape par étape

Les concepts étant clairs, il est temps d’installer, d’authentifier et de tester les méthodes du SDK.

Prérequis

Avant de commencer, assurez-vous d’avoir :

• Python 3.9+ installé localement.
• Un compte Bright Data.
• Un token API Bright Data, que vous pouvez générer dans le panneau de configuration Bright Data.

Étape n°1 : Installer le SDK

Installez le SDK Python de Bright Data via pip avec :

pip install brightdata-sdk

Si vous avez déjà une version plus ancienne installée, mettez-la à jour avec :

pip install -U brightdata-sdk

Important : Ce guide fait référence aux versions du SDK postérieures à 2.5.0.

Bien joué ! Passons tout de suite à l’authentification.

Étape n°2 : S’authentifier avec votre token API Bright Data

Le SDK Python de Bright Data lit la variable d’environnement BRIGHTDATA_API_KEY pour authentifier les requêtes vers les API Bright Data.

Sur Linux ou macOS, définissez la variable d’environnement requise avec votre clé API Bright Data :

export BRIGHTDATA_API_KEY="<VOTRE_CLE_API_BRIGHT_DATA>"

Sur Windows PowerShell, exécutez :

$Env:BRIGHTDATA_API_KEY = "<VOTRE_CLE_API_BRIGHT_DATA>"

Une fois la variable d’environnement définie, le client asynchrone par défaut récupère automatiquement votre clé API :

from brightdata import BrightDataClient

async with BrightDataClient() as client:
    # ...

Vous pouvez également passer votre clé API directement lors de la création du client via l’argument token :

from brightdata import BrightDataClient

async with BrightDataClient(token="<VOTRE_CLE_API_BRIGHT_DATA>") as client:
    # Effectuez des requêtes API ici
    ...

Passer le token directement peut être utile pour des tests rapides. Toutefois, évitez de coder en dur des clés API dans les fichiers source.

Le SDK vérifie les identifiants dans l’ordre suivant :

1. L’argument token passé à BrightDataClient ou SyncBrightDataClient.
2. La variable d’environnement BRIGHTDATA_API_TOKEN.
3. La variable d’environnement BRIGHTDATA_API_KEY.
4. Les identifiants enregistrés par le CLI de Bright Data via brightdata login, si disponibles.

Vous êtes prêt ! Vous pouvez maintenant utiliser le SDK Python pour scraper des pages web, récupérer des résultats de recherche et accéder à d’autres API Bright Data.

Étape n°3 : Exécuter votre première tâche de collecte de données web

Avec le SDK installé et authentifié, exécutez votre premier scraping. Supposons que vous souhaitiez collecter des données structurées à partir d’un profil LinkedIn spécifique.

Pour cette tâche, vous pouvez utiliser l’API Scraper LinkedIn Profiles de Bright Data, disponible via la méthode client.scrape.linkedin.profiles(). Celle-ci retourne les données du profil dans un objet structuré :

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" # Profil LinkedIn cible à scraper
        )

        print(f"Success: {result.success}")
        print("\nScraped profile data:")
        pprint(result.data, indent=2, sort_dicts=False)

asyncio.run(main())

Le résultat sera :

Remarquez comment la méthode retourne des données publiques fraîchement scrapées et structurées à partir du profil LinkedIn donné, comme prévu :

Mission accomplie !

Utilisation avancée

Maintenant que vous êtes à l’aise avec les bases, vous êtes prêt à explorer des sujets plus avancés.

Mécanisme de polling

Certaines tâches de scraping prennent plus de quelques secondes, et vous voudrez peut-être contrôler ce qui se passe pendant leur exécution. Pour ces situations, Bright Data vous permet d’exécuter les API Scraper en tant que tâches asynchrones.

L’idée est de déclencher le scraping et d’obtenir immédiatement une tâche en retour. Ensuite, vous vérifiez son statut, attendez qu’elle se termine, et récupérez les résultats une fois produits. Normalement, cela nécessiterait une logique de polling personnalisée, mais le SDK fournit déjà des méthodes qui simplifient le processus.

Le script suivant réalise un scraping asynchrone pour un profil LinkedIn :

import asyncio
from brightdata import BrightDataClient

async def main():
    async with BrightDataClient() as client:
        # Démarre la tâche de scraping et retourne immédiatement une tâche
        job = await client.scrape.linkedin.profiles_trigger(
            url="https://es.linkedin.com/in/antonello-zanini"
        )
        print(f"Job triggered: {job.snapshot_id}")  # L'ID qui identifie cette tâche

        # Vérifie l'état actuel de la tâche, comme "running" ou "ready"
        status = await job.status()
        print(f"Status: {status}")

        # Interroge la tâche jusqu'à ce qu'elle soit "ready"
        await job.wait(timeout=180, verbose=True)

        # Télécharge les enregistrements une fois la tâche prête
        data = await job.fetch()
        print(f"Got {len(data) if isinstance(data, list) else 1} records")

asyncio.run(main())

Voici ce que fait chaque méthode du SDK :

1. profiles_trigger() démarre la tâche de scraping et retourne un objet de tâche sans attendre la fin du scraping.
2. job.status() vérifie le statut actuel de la tâche.
3. job.wait() interroge le statut de la tâche à intervalles réguliers jusqu’à ce qu’elle soit prête ou que le délai d’attente soit atteint. Par défaut, elle vérifie le statut toutes les 10 secondes. Si le délai d’attente est atteint en premier, elle lève une TimeoutError.
4. job.fetch() récupère les enregistrements scrapés une fois la tâche prête.

Définir verbose=True affiche chaque vérification de statut afin que vous puissiez suivre la progression de la tâche :

Si vous n’avez pas besoin de gérer chaque étape vous-même, to_result() combine l’attente, la récupération et l’encapsulation des données dans un objet de résultat :

import asyncio
from brightdata import BrightDataClient
from pprint import pprint

async def main():
    async with BrightDataClient() as client:
        # Démarre la tâche de scraping et retourne immédiatement une tâche
        job = await client.scrape.linkedin.profiles_trigger(
            url="https://es.linkedin.com/in/antonello-zanini"
        )
        print(f"Job triggered: {job.snapshot_id}")  # L'ID qui identifie cette tâche

        result = await job.to_result(timeout=180) # Interroge, récupère et obtient les données

        print(f"Success: {result.success}")
        print("\nScraped profile data:")
        pprint(result.data, indent=2, sort_dicts=False)

asyncio.run(main())

Cela retourne le même objet de résultat que la méthode scrape.linkedin.profiles() montrée plus tôt dans ce tutoriel.

Si vous avez besoin de plus de contrôle sur le polling, envisagez d’implémenter votre propre boucle en appelant à plusieurs reprises job.status() et en ajustant votre logique en fonction du statut retourné (c’est-à-dire "running", "ready", ou "error").

Scraper plusieurs pages simultanément

Lorsque vous devez récupérer plusieurs pages, passez une liste d’URL à la méthode de scraping du SDK Python de Bright Data. Le SDK les récupère simultanément et retourne un objet de résultat par URL. Jetez un œil à l’exemple ci-dessous :

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:
        # Récupère toutes les URL simultanément
        results = await client.scrape_url(urls)

        # Chaque élément dans results est un objet de résultat pour une URL
        for i, r in enumerate(results):
            if r.success:  # Ignore les URL qui ont échoué
                print(f"URL: {urls[i]}")
                print(f"{r.data[:500]}...")  # Premiers 500 caractères du HTML brut
                print("-" * 80 + "\n")

asyncio.run(main())

Le script affiche une ligne par URL réussie, montrant les 500 premiers caractères de son HTML brut :

La même idée s’applique aux scrapers de plateforme. Le script suivant collecte deux profils LinkedIn simultanément :

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

        # Déclenche chaque profil en premier, afin que toutes les tâches démarrent avant que vous n'attendiez l'une d'elles
        job = await linkedin.profiles_trigger(url=PROFILE_URLS)

        # Interroge la tâche jusqu'à ce qu'elle soit "ready"
        await job.wait(timeout=180, verbose=True)

        # Télécharge les enregistrements une fois la tâche prête
        data = await job.fetch()
        print(f"Got {len(data) if isinstance(data, list) else 1} records")

asyncio.run(main())

La sortie sera un jeu de données contenant deux profils, scrapés simultanément :

Exporter les données récupérées

Le SDK peut enregistrer deux types de données : les enregistrements de jeux de données et les résultats de méthode scrape. Les enregistrements de jeux de données peuvent être exportés avec l’assistant export(), tandis qu’un résultat scrape dispose de l’assistant save_to_file().

Les jeux de données sont utiles lorsque vous avez besoin de données pré-collectées plutôt que de scrapings frais. Pour exporter des enregistrements de jeux de données, créez un instantané et téléchargez les enregistrements, puis passez-les à l’assistant export(), qui les écrit dans un fichier :

import asyncio
from brightdata import BrightDataClient
from brightdata.datasets import export

async def main():
    async with BrightDataClient() as client:
        imdb = client.datasets.imdb_movies

        # Crée un instantané pour les enregistrements filtrés 
        # (films avec une note IMDB de 9+ et 100+ notes)
        # puis les télécharge sous forme de liste
        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")  # L'extension .csv sélectionne le format CSV

asyncio.run(main())

Remarque : Le format de sortie est choisi en fonction de l’extension, et .json, .jsonl, et .csv sont pris en charge.

Le script ci-dessus créera le fichier imdb_top_rated.csv suivant dans le dossier de votre projet :

Pour exporter un résultat de méthode scrape vers un fichier, appelez save_to_file() :

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")  # Écrit sur disque

asyncio.run(main())

Remarque : Seul le format JSON est pris en charge.

Cela produira un fichier antonello_zanini.json comme suit :

Le SDK Python de Bright Data en action : cas d’usage

Après avoir exploré des scénarios plus avancés, vous avez maintenant les bases nécessaires pour aborder des cas d’usage réels.

Comparer les résultats de moteurs de recherche

En matière de suivi SERP, il est important de comprendre comment différents moteurs de recherche traitent la même requête. Le script suivant exécute la même requête sur Google et Bing :

# pip install brightdata-sdk

import asyncio
from brightdata import BrightDataClient

# La requête à exécuter sur plusieurs moteurs de recherche
query = "best HTML parsers"

async def main():
    async with BrightDataClient() as client:
        # Obtient les résultats de recherche analysés de Google et Bing
        google = await client.search.google(query=query, num_results=10)
        bing = await client.search.bing(query=query, num_results=10)

        # Affiche les trois premiers résultats de chaque moteur de recherche
        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 et Bing retournent des résultats de recherche organiques analysés avec des champs tels que title et url. Vous pouvez accéder directement à ces données, par exemple pour afficher les trois premiers résultats :

Obtenir des informations complètes sur un produit Amazon

Le scraping d’Amazon va au-delà de la collecte de données structurées depuis une page produit. Cela peut également impliquer l’extraction d’avis produits, qui fournissent des informations précieuses pour l’évaluation de produits, l’analyse de sentiment, la surveillance, et plus encore.

Grâce aux différentes API Scraper de Bright Data, vous pouvez récupérer à la fois les informations produit et les avis via le SDK, comme illustré ci-dessous :

# 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:
        # Récupère à la fois les données du produit et des avis
        product = await client.scrape.amazon.products(url=product_url)
        reviews = await client.scrape.amazon.reviews(url=product_url, pastDays=30, keyWord="quality")

        # Affiche les données scrapées
        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())

Le script s’est appuyé sur les options de filtrage de client.scrape.amazon.reviews() pour ne récupérer que les avis des 30 derniers jours contenant le mot-clé “quality”.

La sortie ressemblera à ceci :

Remarque : Les valeurs retournées dépendent du produit et du moment de la requête.

Analyser une page débloquée avec BeautifulSoup

Une feuille de route web scraping courante implique :

1. Récupérer une page web.
2. L’analyser avec un parseur HTML.
3. Extraire les données requises.

Le problème est que de nombreux sites web utilisent des mesures anti-scraping qui peuvent bloquer les requêtes automatisées de contenu HTML. Une solution possible consiste à accéder à ces pages via un service tel que l’API Web Unlocker de Bright Data, qui gère l’empreinte du navigateur, la rotation de proxys, la résolution de CAPTCHA, et d’autres défis.

Par exemple, supposons que vous souhaitiez récupérer une page produit du NBA Store pour un maillot Stephen Curry des Golden State Warriors et recueillir son nom, sa marque, son prix, sa disponibilité et les tailles disponibles.

Le script suivant utilise la méthode scrape_url() du SDK pour récupérer la page, charge le HTML retourné dans BeautifulSoup, et extrait les champs du produit :

# 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():
    # Récupère la page via scrape_url() pour éviter les anti-bots
    async with BrightDataClient() as client:
        result = await client.scrape_url(NBA_PRODUCT_URL)

    # Charge le HTML dans BeautifulSoup pour l'analyser
    soup = BeautifulSoup(result.data, "html.parser")

    # Extrait le nom du produit depuis le titre principal de la page
    title = soup.find("h1", attrs={"data-talos": "labelPdpProductTitle"}).get_text(strip=True)

    # Trouve le bloc JSON-LD qui décrit le produit
    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

    # Accède à certaines données à partir de celui-ci
    brand = product_ld_data["brand"]
    images = product_ld_data["image"]

    # Lit le prix et la disponibilité de la première offre
    offer = product_ld_data["offers"][0]
    price = offer["priceSpecification"]["price"]
    currency = offer["priceSpecification"]["priceCurrency"]
    availability = offer["availability"].rsplit("/", 1)[-1]

    # Extrait les tailles, qui sont des boutons, et leur texte visible est le libellé de taille (S, M, L, ...)
    sizes = [b.get_text(strip=True) for b in soup.find_all("button", attrs={"data-talos": "buttonSize"})]

    # Collecte les données scrapées
    product = {
        "title": title,
        "brand": brand,
        "images": images,
        "price": price,
        "currency": currency,
        "availability": availability,
        "sizes": sizes,
    }

    # Affiche les données scrapées
    print(json.dumps(product, indent=2))

asyncio.run(main())

La sortie ressemblera à ceci :

Ces champs correspondent aux informations affichées sur la page cible.

Conclusion

Dans cet article de blog, vous avez appris comment le SDK Python de Bright Data fournit un seul package Python pour accéder aux produits de scraping, de recherche et de jeux de données de Bright Data. Vous avez également vu comment installer le SDK et l’utiliser dans des scénarios réels.

Pour en savoir plus, explorez la documentation officielle, le dépôt GitHub, et le répertoire d’exemples, qui contient des scripts fonctionnels pour chaque fonctionnalité. Si vous trouvez le SDK utile, pensez à donner une étoile au dépôt !

Créez un compte Bright Data dès aujourd’hui et essayez le SDK Python pour simplifier l’accès aux API Bright Data.

FAQ

Pourquoi le SDK Python de Bright Data est-il utile ?

Il offre aux développeurs Python un package unique et cohérent pour scraper des sites web, exécuter des requêtes sur les moteurs de recherche, contourner la détection de bots et les CAPTCHA, extraire des données structurées de plateformes, et accéder à plus de 100 jeux de données prêts à l’emploi. Grâce à lui, vous n’avez pas à construire cette infrastructure vous-même.

Ai-je besoin du CLI de Bright Data pour utiliser le SDK ?

Non. Le SDK fonctionne avec un token API défini dans BRIGHTDATA_API_KEY ou BRIGHTDATA_API_TOKEN. Si vous avez déjà exécuté brightdata login, le SDK se rabat sur les identifiants stockés par le CLI, vous n’avez donc rien d’autre à configurer.

Quelle est la différence entre le CLI Bright Data, le SDK Python, le MCP, et les Agent Skills ?

Le CLI exécute les commandes Bright Data depuis votre terminal. Le SDK Python permet à votre code Python d’appeler les API. Le serveur MCP de Bright Data fournit aux agents IA des outils de scraping et de recherche, et les Agent Skills apprennent aux agents de codage comment utiliser Bright Data.

Quelle est la différence entre le SDK Python de Bright Data et le SDK JavaScript de Bright Data ?

Le SDK Python (brightdata-sdk, installé avec pip) offre des clients synchrones et asynchrones avec des méthodes en snake_case comme scrape_url(). Le SDK JavaScript (@brightdata/sdk, installé avec npm) fonctionne sur Node.js et utilise des méthodes en camelCase comme scrapeUrl().

Quand dois-je utiliser le mode synchrone ou asynchrone ?

Utilisez le client synchrone pour les scripts simples et les vérifications rapides, car chaque appel bloque jusqu’à ce que le résultat soit prêt. Utilisez le client asynchrone pour les charges de travail à haute concurrence, les tâches en lot et le traitement en arrière-plan.