--- title: "Découvrez le SDK Python de Bright Data : scraper, rechercher et obtenir des données web" slug: bright-data-python-sdk date: 2026-10-18T12:33:04+00:00 modified: 2026-10-18T12:33:07+00:00 permalink: https://brightdata.fr/blog/ai/bright-data-python-sdk type: blog --- [ Blog ](https://brightdata.fr/blog "Blog") / [AI](https://brightdata.fr/blog/ai) [AI](https://brightdata.fr/blog/ai) # Découvrez le SDK Python de Bright Data : scraper, rechercher et obtenir des données web Découvrez comment utiliser le SDK Python de Bright Data pour scraper des sites web, rechercher sur Google et Bing, exporter des données et exécuter des tâches en parallèle en Python. 23 min de lecture [ ![Antonello Zanini](https://media.brightdata.fr/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.fr/2026/10/Bright-Data-Python-SDK.png) 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](https://docs.brightdata.com/api-reference/SDK) est une bibliothèque Python conçue pour simplifier les interactions avec les [produits Bright Data](/products). Le SDK est disponible via le package PyPI [`brightdata-sdk`](https://pypi.org/project/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](/products/web-scraper), 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](https://docs.brightdata.com/products/cli/overview) 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](/blog/ai/bright-data-cli-with-top-coding-agents). **Pour aller plus loin** : - [*Documentation du SDK Python de Bright Data*](https://docs.brightdata.com/api-reference/SDK) - [*Dépôt officiel du SDK Python de Bright Data*](https://github.com/brightdata/sdk-python) ## 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. ![Notez l'autocomplétion de l'IDE, les suggestions d'utilisation et la documentation des méthodes](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791816660506_image.png)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](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key) ou, si vous vous êtes déjà authentifié via le CLI de Bright Data, les identifiants enregistrés par [`brightdata login`](https://docs.brightdata.com/products/cli/commands#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**](https://docs.brightdata.com/products/scraper-studio/overview) : 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 : ```none pip install brightdata-sdk ``` Une fois installé, importez le SDK, et vous aurez accès à de nombreuses méthodes, telles que : **Méthode****Ce qu’elle fait****Produit Bright Data**`client.scrape_url(url)`Récupère le contenu d’une URL ou d’une liste d’URL, [en contournant tout système anti-bot](https://docs.brightdata.com/concepts/how-bright-data-handles-blocking)[API Unlocker](/products/web-unlocker)`client.search.google(query=...)`Exécute une recherche Google et retourne les résultats organiques analysés[API SERP](/products/serp-api)`client.search.bing(query=...)`Exécute une recherche Bing et retourne les résultats organiques analysésAPI SERP (voir le [guide de migration pour la Bing Web Search API](https://docs.brightdata.com/products/serp-api/parsed-json-results/bing-to-bright-data-serp-migration-guide))`client.scrape..(url=...)`Extrait des données structurées d’une plateforme cible, comme `client.scrape.amazon.products`API Scraper`client.search.linkedin.jobs(...)`Recherche dans une plateforme par paramètres plutôt que par URLAPI Scraper spécifiques`client.datasets.(filter=...)`Demande un instantané filtré d’un jeu de données pré-collecté[API Datasets](https://docs.brightdata.com/api-reference/marketplace-dataset-api/filter-dataset)`client.scraper_studio.run(collector=..., input=...)`Déclenche un collecteur de web scraping personnalisé et retourne ses enregistrements[Scraper Studio](/products/web-scraper/studio)`client.browser.get_connect_url()`Construit le point de terminaison CDP pour connecter Playwright ou Puppeteer à un navigateur cloud[API Browser](/products/scraping-browser)`client.list_zones()`Liste les zones disponibles dans votre compteAucun### 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` : ```none 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](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()) ``` Les deux exemples retournent le HTML de la page cible dans `result.data` : ![Le HTML de la page cible example.com](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791817848730_image.png)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"` : ```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, # 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](https://docs.brightdata.com/concepts/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 : ![Les API Bright Data configurées dans votre compte](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791821313295_image.png)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 ![Notez les deux API créées par le SDK](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791822018286_image.png)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 : ```none 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+](https://www.python.org/downloads/) installé localement. - Un [compte Bright Data](/?hs_signup=1). - Un token API Bright Data, que vous pouvez générer dans le [panneau de configuration Bright Data](/cp/setting/users). ### Étape n°1 : Installer le SDK Installez le SDK Python de Bright Data via pip avec : ```none pip install brightdata-sdk ``` Si vous avez déjà une version plus ancienne installée, mettez-la à jour avec : ```none 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 : ```none export BRIGHTDATA_API_KEY="" ``` Sur Windows PowerShell, exécutez : ```none $Env:BRIGHTDATA_API_KEY = "" ``` Une fois la variable d’environnement définie, le client asynchrone par défaut récupère automatiquement votre clé API : ```none 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` : ```none from brightdata import BrightDataClient async with BrightDataClient(token="") 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](https://es.linkedin.com/in/antonello-zanini). Pour cette tâche, vous pouvez utiliser l’[API Scraper LinkedIn Profiles de Bright Data](/products/web-scraper/linkedin/profiles), disponible via la méthode `client.scrape.linkedin.profiles()`. Celle-ci retourne les données du profil dans un objet structuré : ```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" # 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 : ![Les données structurées du profil LinkedIn retournées par le script](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835516140_image.png)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 : ![Le profil LinkedIn cible](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835586169_image.png)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](https://docs.brightdata.com/api-reference/rest-api/scraper/asynchronous-requests). 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 : ```none 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`](https://docs.python.org/3/builtins/exceptions.html#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 : ![Les logs produits par le script précédent](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791832933568_image.png)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 : ```none 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 : ```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: # 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 : ![Notez les trois différentes pages HTML scrapées](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791833920080_image.png)La même idée s’applique aux scrapers de plateforme. Le script suivant collecte deux profils LinkedIn simultanément : ```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 # 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 : ![Notez que le script a scrapé deux profils LinkedIn simultanément](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791834093109_image.png)### 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](/products/datasets) 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 : ```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 # 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 : ![Le fichier de sortie ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835152372_image.png)Pour exporter un résultat de méthode `scrape` vers un fichier, appelez `save_to_file()` : ```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") # É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 fichier de sortie ](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791835250162_image.png)## 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](/use-cases/serp-tracking), 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 : ```none # 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 : ![Notez les trois premiers résultats récupérés sur Google et Bing pour la même requête de recherche](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840322204_image.png)### Obtenir des informations complètes sur un produit Amazon Le [scraping d’Amazon](/blog/how-tos/how-to-scrape-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 : ```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: # 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 : ![Notez les données du produit et des avis](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840123670_image.png)**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](/blog/web-data/web-scraping-roadmap) courante implique : 1. Récupérer une page web. 2. L’analyser avec [un parseur HTML](/blog/web-data/best-python-html-parsers). 3. Extraire les données requises. Le problème est que de nombreux sites web utilisent des [mesures anti-scraping](/blog/web-data/anti-scraping-techniques) 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](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) 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](/blog/how-tos/beautiful-soup-web-scraping), et extrait les champs du produit : ```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(): # 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 : ![Les données analysées de la page produit NBA débloquée](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791836755290_image.png)Ces champs correspondent aux informations affichées sur la page cible. ![La page produit NBA cible](https://media.brightdata.com/2026/10/s_E99EAF242DF71FD840F1A7951C8299B6C3A5C7DFC72A5CE7E1E12632B311F396_1791840804593_image.png)## 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](https://docs.brightdata.com/api-reference/SDK), le [dépôt GitHub](https://github.com/brightdata/sdk-python), et le [répertoire d’exemples](https://github.com/brightdata/sdk-python/tree/main/examples), 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](/ai/mcp-server) fournit aux agents IA des outils de scraping et de recherche, et les [Agent Skills](/blog/ai/bright-data-skills-coding-agents) 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`](https://docs.brightdata.com/api-reference/SDK-JS), 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. Contacter ventesEssai gratuit![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Table des matières [ ](https://news.ycombinator.com/submitlink?t=D%C3%A9couvrez+le+SDK+Python+de+Bright+Data+%3A+scraper%2C+rechercher+et+obtenir+des+donn%C3%A9es+web&u=https://brightdata.fr/blog/ai/bright-data-python-sdk) [ ](https://www.linkedin.com/shareArticle?mini=true&title=D%C3%A9couvrez+le+SDK+Python+de+Bright+Data+%3A+scraper%2C+rechercher+et+obtenir+des+donn%C3%A9es+web&url=https://brightdata.fr/blog/ai/bright-data-python-sdk) [ ](http://www.reddit.com/submit?title=D%C3%A9couvrez+le+SDK+Python+de+Bright+Data+%3A+scraper%2C+rechercher+et+obtenir+des+donn%C3%A9es+web&url=https://brightdata.fr/blog/ai/bright-data-python-sdk) ## Vous pourriez aussi être intéressé par [ ![Claude Code Routines](https://media.brightdata.fr/2026/10/Claude-Code-Routines.png) ](https://brightdata.fr/blog/ai/claude-code-routines "Routines Claude Code : Programmer la Surveillance Web Quotidienne avec Bright Data") [AI ![Satyam Tripathi](https://media.brightdata.fr/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Routines Claude Code : Programmer la Surveillance Web Quotidienne avec Bright Data Apprenez à donner aux routines Claude Code un accès web avec Bright Data et créez un moniteur de prix quotidien qui vérifie chaque page qu’il lit. 18-Oct-2026 15 min de lecture ](https://brightdata.fr/blog/ai/claude-code-routines) [ ![Is There a Google Search API](https://media.brightdata.fr/2026/10/Is-There-a-Google-Search-API_.png) ](https://brightdata.fr/blog/donnees-web/google-search-api "Existe-t-il une API de recherche Google ? Options après Custom Search") [Données Web ![Satyam Tripathi](https://media.brightdata.fr/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Existe-t-il une API de recherche Google ? Options après Custom Search Découvrez comment migrer de l’API JSON Custom Search de Google vers l’API SERP de Bright Data, avec un adaptateur cse.list() plug-and-play et une table de paramètres. 18-Oct-2026 8 min de lecture ](https://brightdata.fr/blog/donnees-web/google-search-api) [ ![Amazon Bedrock Knowledge Bases with Bright Data](https://media.brightdata.fr/2026/08/Amazon-Bedrock-Knowledge-Bases-with-Bright-Data.png) ](https://brightdata.fr/blog/savoir-faire/amazon-bedrock-knowledge-bases-with-bright-data "Comment alimenter Amazon Bedrock Knowledge Bases avec des données web en direct grâce à Bright Data") [How Tos ![Satyam Tripathi](https://media.brightdata.fr/2024/09/Satyam-Tripathi-50x50.png) Satyam Tripathi Technical Writer ### Comment alimenter Amazon Bedrock Knowledge Bases avec des données web en direct grâce à Bright Data Bright Data permet à Amazon Bedrock Knowledge Bases d’accéder aux données web bloquées par le rendu JavaScript, la protection anti-bot, ou les restrictions géographiques. 15-Oct-2026 56 min de lecture ](https://brightdata.fr/blog/savoir-faire/amazon-bedrock-knowledge-bases-with-bright-data)