自定义 CDP 函数

Captcha.Solve({
    detectTimeout?: number // Detect timeout in millisecond for solver to detect captcha  
    options?: CaptchaOptions[] // Configuration options for captcha solving  
}) : SolveResult

SolveResult : {  
  status: SolveStatus // Detect and solve status  
  type?: string // Detected captcha type  
  error?: string // Error if captcha was not solved  
}

SolveStatus : string enum {  
  "not_detected" // Captcha was not detected  
  "solve_finished" // Captcha successfully solved  
  "solve_failed" // Captcha detected, but was not solved  
  "invalid" // Something goes wrong  
}

const page = await browser.newPage();
const client = await page.target().createCDPSession();
await page.goto('[https://site-with-captcha.com](https://site-with-captcha.com/)');  

// Note 1: If no captcha was found it will return not_detected status after detectTimeout   
// Note 2: Once a CAPTCHA is solved, if there is a form to submit, it will be submitted by default   

const client = await page.target().createCDPSession();  
const {status} = await client.send('Captcha.Solve', {detectTimeout: 30*1000});   
console.log(`Captcha solve status: ${status}`)

page = await browser.new_page()   
client = await page.context.new_cdp_session(page)   
await page.goto('[https://site-with-captcha.com](https://site-with-captcha.com/)')  
# Note 1: If no captcha was found it will return not_detected status after detectTimeout   
# Note 2: Once a CAPTCHA is solved, if there is a form to submit, it will be submitted by default  
client = await page.context.new_cdp_session(page)  
solve_result = await client.send('Captcha.Solve', { 'detectTimeout': 30*1000 })   
status = solve_result['status']   
print(f'Captcha solve status: {status}') 

Captcha.setAutoSolve({  
  autoSolve: boolean // Whether to automatically solve captcha after navigate  
  options?: CaptchaOptions[] // Configuration options for captcha auto-solving  
}) : void

CaptchaOptions : {  
  type: string // Captcha type  
  disabled?: boolean // Disable detect and solve for specified captcha  
  ... // additinal options related to captcha type  
}

// Node.js Puppeteer - Disable Captcha auto-solver completely  
const page = await browser.newPage();  
const client = await page.target().createCDPSession();  
await client.send('Captcha.setAutoSolve', { autoSolve: false })

# Python Playwright - Disable Captcha auto-solver completely  
page = await browser.new_page()  
client = await page.context.new_cdp_session(page)  
await client.send('Captcha.setAutoSolve', {'autoSolve': False}):

# Python Selenium - Disable Captcha auto-solver completely  
driver.execute('executeCdpCommand', {  
    'cmd': 'Captcha.setAutoSolve',  
    'params': {'autoSolve': False},  
})

// Node.js Puppeteer - Disable Captcha auto-solver for ReCaptcha only  
const page = await browser.newPage();  
const client = await page.target().createCDPSession();  
await client.send('Captcha.setAutoSolve', {  
    autoSolve: true,  
    options: [{  
        type: 'usercaptcha',  
        disabled: true,  
    }],  
});

# Python Playwright - Disable Captcha auto-solver for ReCaptcha only  
page = await browser.new_page()  
client = await page.context.new_cdp_session(page)  
await client.send('Captcha.setAutoSolve', {  
    'autoSolve': True,  
    'options': [{  
        'type': 'usercaptcha',  
        'disabled': True,  
    }],  
})

// Node.js Puppeteer - manually solving CAPTCHA after navigation  
const page = await browser.newPage();  
const client = await page.target().createCDPSession();  
await client.send('Captcha.setAutoSolve', { autoSolve: false });  
await page.goto('https://site-with-captcha.com', { timeout: 2*60*1000 });  
const {status} = await client.send('Captcha.Solve', { detectTimeout: 30*1000 });  
console.log('Captcha solve status:', status);

# Python Playwright- manually solving CAPTCHA after navigation  
page = await browser.new_page()  
client = await page.context.new_cdp_session(page)  
await client.send('Captcha.setAutoSolve', {'autoSolve': False})  
await page.goto('https://site-with-captcha.com', timeout=2*60_000)  
solve_result = await client.send('Captcha.Solve', {'detectTimeout': 30_000})  
print('Captcha solve status:', solve_result['status'])

# Python Selenium - manually solving CAPTCHA after navigation  
driver.execute('executeCdpCommand', {  
    'cmd': 'Captcha.setAutoSolve',  
    'params': {'autoSolve': False},  
})  
driver.get('https://site-with-captcha.com')  
solve_result = driver.execute('executeCdpCommand', {  
    'cmd': 'Captcha.Solve',  
    'params': {'detectTimeout': 30_000},  
})  
print('Captcha solve status:', solve_result['value']['status'])

Emulation.setDevice({device: '[device_name]'});

Emulation.setDevice({device: 'iPhone X'});

const puppeteer = require('puppeteer-core');
const fs = require('fs/promises');
const {
  AUTH = 'SBR_ZONE_FULL_USERNAME:SBR_ZONE_PASSWORD',
  TARGET_URL = 'https://example.com',
  CERT_FILE = 'client.pfx',
  CERT_PASS = 'secret',
} = process.env;

async function scrape(url = TARGET_URL, file = CERT_FILE, pass = CERT_PASS) {
  if (AUTH == 'SBR_ZONE_FULL_USERNAME:SBR_ZONE_PASSWORD') {
    throw new Error(`Provide Browser API credentials in AUTH`
        + ` environment variable or update the script.`);
  }
  console.log(`Connecting to Browser...`);
  const browserWSEndpoint = `wss://${AUTH}@brd.superproxy.io:9222`;
  const browser = await puppeteer.connect({ browserWSEndpoint });
  try {
    console.log(`Connected! Installing ${file} certificate...`);
    const page = await browser.newPage();
    const client = await page.createCDPSession();
    const cert = (await fs.readFile(CERT_FILE)).toString('base64');
    await client.send('Browser.addCertificate', { cert, pass });
    console.log(`Installed! Navigating to ${url}...`);
    await page.goto(url, { timeout: 2 * 60 * 1000 });
    console.log(`Navigated! Scraping page content...`);
    const data = await page.content();
    console.log(`Scraped! Data: ${data}`);
  } finally {
    await browser.close();
  }
}

scrape();

from os import environ
from base64 import standard_b64encode
from selenium.webdriver import Remote, ChromeOptions as Options
from selenium.webdriver.chromium.remote_connection import ChromiumRemoteConnection as Connection

AUTH = environ.get('AUTH', default='SBR_ZONE_FULL_USERNAME:SBR_ZONE_PASSWORD')
TARGET_URL = environ.get('TARGET_URL', default='https://example.com')
CERT_FILE = environ.get('CERT_FILE', default='client.pfx')
CERT_PASS = environ.get('CERT_PASS', default='secret')

def scrape(url=TARGET_URL, file=CERT_FILE, pswd=CERT_PASS):
    if AUTH == 'SBR_ZONE_FULL_USERNAME:SBR_ZONE_PASSWORD':
    raise Exception('Provide Browser API credentials in AUTH '
                    'environment variable or update the script.')
    print('Connecting to Browser...')
    server_addr = f'https://{AUTH}@brd.superproxy.io:9515'
    connection = Connection(server_addr, 'goog', 'chrome')
    driver = Remote(connection, options=Options())
    try:
        print(f'Connected! Installing {file} certificate...')
        with open(file, 'rb') as f:
            cert = standard_b64encode(f.read()).decode()
        driver.execute('executeCdpCommand', {
            'cmd': 'Browser.addCertificate',
            'params': {'cert': cert, 'pass': pswd},
        })
        print(f'Installed! Navigating to {url}...')
        driver.get(url)
        print('Navigated! Scraping page content...')
        data = driver.page_source
        print(f'Scraped! Data: {data}')
    finally:
        driver.quit()

scrape()