Le Runtime Navigateur pour les Agents IA

Offrez à votre agent un navigateur avec un système immunitaire intégré. Orchestrez des agents Puppeteer & Playwright qui naviguent sur des sites complexes, gèrent les défilements infinis et contournent automatiquement les défenses anti-bot, sans intégrer d’outils tiers.

Aucune carte de crédit requise
400M+ actions effectuées quotidiennement
Plus d'1M de sessions simultanées
400M+ IPs dans 195 pays
Plus de 3M de domaines débloqués
Plus de 2,5 Po collectés quotidiennement

Naviguez sur n'importe quel site web comme un humain

Agent Browser est une plateforme d'automatisation de navigateur basée sur le cloud, conçue spécifiquement pour les agents IA. Elle combine une infrastructure de navigateur avec des capacités intégrées de déblocage de sites web.
Déblocage avancé
  • Accédez facilement à n'importe quel site public grâce au fingerprinting de navigateur et à la résolution de CAPTCHA.
Mise à l'échelle automatique
  • Lancez des sessions parallèles illimitées depuis n'importe quelle géolocalisation sans perte de performance.
Sessions gérées
  • Utilisez des navigateurs headful ou headless pour contrôler le contexte, les cookies et les onglets.
Environnement standardisé
  • Intégration transparente via API ou MCP, sans configuration spécifique par site.

Rendre le Web prêt pour l'IA

Accédez facilement à n’importe quel site public grâce au fingerprinting de navigateur et à la résolution de CAPTCHA.

Lancez des sessions parallèles illimitées depuis n’importe quelle géolocalisation sans perte de performance.

Utilisez des navigateurs headful ou headless pour contrôler le contexte, les cookies et les onglets.

Intégration transparente via API ou MCP, sans configuration spécifique par site.

Bright Data alimente les meilleures marques mondiales

Bright Data permet aux agents IA autonomes de naviguer sur des sites web, de trouver des informations et d'effectuer des actions automatiquement dans un environnement simple à intégrer, cohérent et fiable

Optimisez vos workflows les plus complexes

Des interactions web autonomes aux pipelines de données à l'échelle entreprise, Agent Browser permet aux agents IA d'effectuer des tâches complexes basées sur le navigateur.

Interaction agent

  • Activez les automatisations de tâches agentiques
  • Remplissez des formulaires, effectuez des recherches, et plus encore
  • Démarrage rapide avec une faible latence
  • Assurez des sessions sécurisées et isolées

Navigation furtive

  • Utilisez des proxies de géolocalisation
  • Fingerprinting similaire à un humain
  • Résolvez automatiquement les CAPTCHAs
  • Gérez les cookies et les sessions

Pipeline de données prêt pour l'IA

  • Découvrez des sources de données pertinentes
  • Collecte en temps réel ou par lots
  • Sortie structurée ou non structurée
  • Intégration transparente via MCP

Navigateurs Headless et Headful pour un accès et une navigation web illimités et rentables

Agent Browser offre des capacités de navigateur headless et headful avec des fonctionnalités avancées de déblocage, de mise à l'échelle et de sécurité, conçues spécifiquement pour les charges de travail des agents IA.
Empreintes similaires à un humain

Émulation des navigateurs des vrais utilisateurs pour simuler une expérience humaine

Mode furtif

Contournez éthiquement la détection des bots et résolvez les CAPTCHAs

Sessions à faible latence

Connexion en moins d'une seconde et sessions stables garantissant une interaction fluide

Définir les en-têtes de référence

Simulez du trafic provenant de sites web populaires ou de confiance

Gérer les cookies et les sessions

Évitez les blocages potentiels liés aux facteurs de cookies

Nouvelles tentatives automatiques et rotation d'IP

Réessayez continuellement les requêtes et effectuez une rotation des IPs en arrière-plan

Couverture géographique mondiale

Accédez au contenu localisé depuis n'importe quel pays, ville, état ou ASN

Support d'automatisation de navigateur

Compatible avec Playwright, Puppeteer et Selenium

Sécurité de niveau entreprise

Les instances de navigateur peuvent s'intégrer au VPN et à l'authentification unique d'entreprise

                              const pw = require('playwright');

const SBR_CDP = 'wss://brd-customer-CUSTOMER_ID-zone-ZONE_NAME:[email protected]:9222';

async function main() {
    console.log('Connecting to Scraping Browser...');
    const browser = await pw.chromium.connectOverCDP(SBR_CDP);
    try {
        const page = await browser.newPage();
        console.log('Connected! Navigating to https://example.com...');
        await page.goto('https://example.com');
        console.log('Navigated! Scraping page content...');
        const html = await page.content();
        console.log(html);
    } finally {
        await browser.close();
    }
}

main().catch(err => {
    console.error(err.stack || err);
    process.exit(1);
});
                              
                            
                              import asyncio
from playwright.async_api import async_playwright

SBR_WS_CDP = 'wss://brd-customer-CUSTOMER_ID-zone-ZONE_NAME:[email protected]:9222'

async def run(pw):
    print('Connecting to Scraping Browser...')
    browser = await pw.chromium.connect_over_cdp(SBR_WS_CDP)
    try:
        page = await browser.new_page()
        print('Connected! Navigating to https://example.com...')
        await page.goto('https://example.com')
        print('Navigated! Scraping page content...')
        html = await page.content()
        print(html)
    finally:
        await browser.close()
 
async def main():
    async with async_playwright() as playwright:
        await run(playwright)
 
if __name__ == '__main__':
    asyncio.run(main())
                              
                            
                              const puppeteer = require('puppeteer-core');

const SBR_WS_ENDPOINT = 'wss://brd-customer-CUSTOMER_ID-zone-ZONE_NAME:[email protected]:9222';

async function main() {
    console.log('Connecting to Scraping Browser...');
    const browser = await puppeteer.connect({
        browserWSEndpoint: SBR_WS_ENDPOINT,
    });
    try {
        const page = await browser.newPage();
        console.log('Connected! Navigating to https://example.com...');
        await page.goto('https://example.com');
        console.log('Navigated! Scraping page content...');
        const html = await page.content();
        console.log(html)
    } finally {
        await browser.close();
    }
}

main().catch(err => {
    console.error(err.stack || err);
    process.exit(1);
});
                              
                            
                              const { Builder, Browser } = require('selenium-webdriver');

const SBR_WEBDRIVER = 'https://brd-customer-CUSTOMER_ID-zone-ZONE_NAME:[email protected]:9515';

async function main() {
    console.log('Connecting to Scraping Browser...');
    const driver = await new Builder()
        .forBrowser(Browser.CHROME)
        .usingServer(SBR_WEBDRIVER)
        .build();
    try {
        console.log('Connected! Navigating to https://example.com...');
        await driver.get('https://example.com');
        console.log('Navigated! Scraping page content...');
        const html = await driver.getPageSource();
        console.log(html);
    } finally {
        driver.quit();
    }
}

main().catch(err => {
    console.error(err.stack || err);
    process.exit(1);
});
                              
                            
                              from selenium.webdriver import Remote, ChromeOptions
from selenium.webdriver.chromium.remote_connection import ChromiumRemoteConnection

SBR_WEBDRIVER = 'https://brd-customer-CUSTOMER_ID-zone-ZONE_NAME:[email protected]:9515'
 
def main():
    print('Connecting to Scraping Browser...')
    sbr_connection = ChromiumRemoteConnection(SBR_WEBDRIVER, 'goog', 'chrome')
    with Remote(sbr_connection, options=ChromeOptions()) as driver:
        print('Connected! Navigating to https://example.com...')
        driver.get('https://example.com')
        print('Navigated! Scraping page content...')
        html = driver.page_source
        print(html)
 
if __name__ == '__main__':
    main()
                              
                            

Intégrez facilement votre stack technologique

Intégrez Agent Browser à votre stack d'automatisation existant en quelques minutes. Utilisez vos scripts Puppeteer, Selenium ou Playwright sans modification.
  • Exécutez vos scripts Puppeteer, Selenium ou Playwright
  • Gestion automatisée des proxies et déblocage web
  • Obtenez des données en formats non structurés ou structurés
Voir la documentation

Agent Browser

Infrastructure de navigateur évolutive avec déblocage autonome

pay as you go plan icon
Pay as you go
$8 / GB
Sans engagement
Essai gratuit
Paiement à l'utilisation sans engagement mensuel
2nd plan icon
71 GB inclus
$7 / GB
$499 Facturation mensuelle
Essai gratuit
Conçu pour les équipes cherchant à développer leurs opérations
3rd plan icon
166 GB inclus
$6 / GB
$999 Facturation mensuelle
Essai gratuit
Conçu pour les grandes équipes ayant des besoins opérationnels étendus
4th plan icon
399 GB inclus
$5 / GB
$1999 Facturation mensuelle
Essai gratuit
Support avancé et fonctionnalités pour les opérations critiques
ENTERPRISE
Services de données d'élite pour des exigences commerciales haut de gamme.
CONTACTEZ-NOUS
  • Responsable de compte
  • Forfaits personnalisés
  • Accord de service Premium
  • Support prioritaire
  • Accueil personnalisé
  • SSO
  • Personnalisations
  • Journaux d'audit

FAQ

Agent Browser est une infrastructure de navigation serverless qui vous permet de déployer et de contrôler des navigateurs cloud avec des capacités intégrées de déblocage de sites web. Agent Browser gère automatiquement toutes les opérations de déblocage, notamment : la résolution de CAPTCHA, le fingerprinting de navigateur, les nouvelles tentatives automatiques, la sélection des en-têtes, des cookies & le rendu JavaScript, et plus encore, pour vous faire gagner du temps et des ressources.

Lors de la création et de l'exécution d'agents IA, les développeurs utilisent des navigateurs cloud pour rechercher et récupérer des informations, naviguer sur des sites web, agir et extraire des données. Comme le ferait un humain, mais de manière autonome et à grande échelle.

Scraping Browser est un navigateur GUI (alias navigateur "headful") qui utilise une interface graphique. Cependant, un développeur utilisera Agent Browser comme headless, interagissant avec le navigateur via une API ou MCP. Agent Browser est toutefois ouvert en tant que navigateur GUI sur l'infrastructure de Bright Data.

Pour choisir un navigateur automatisé, les développeurs peuvent opter pour un navigateur headless ou GUI/headful. Le terme "navigateur headless" désigne un navigateur web sans interface graphique. Utilisés avec un Proxy, les navigateurs headless peuvent être utilisés pour le scraping web, mais ils sont facilement détectés par les logiciels de protection anti-bot, rendant le scraping de données à grande échelle difficile. Les navigateurs GUI, comme Agent Browser (alias "headful"), utilisent une interface graphique. Les logiciels de détection de bots sont moins susceptibles de détecter les navigateurs GUI.

Oui, Agent Browser est entièrement compatible avec Puppeteer, Selenium et Playwright.

Agent Browser est un navigateur automatisé optimisé pour les agents IA autonomes, leur offrant la puissance des capacités de déblocage automatisé du Web Unlocker pour des workflows en plusieurs étapes. Tandis que Web Unlocker fonctionne avec des requêtes en une seule étape, Agent Browser est idéal lorsqu'un agent IA doit interagir avec des sites web. Il convient également parfaitement à tout projet de scraping de données nécessitant des navigateurs, une mise à l'échelle et une gestion automatisée de toutes les actions de déblocage de sites.