Как обойти капчу на сайте SHEIN

import requests
import time
import base64
import os

API_KEY = os.environ.get("APIKEY", "ВАШ_API_КЛЮЧ")

def solve_captcha_task(task_payload: dict, timeout: int = 180) -> dict:
    url = "https://2captcha.com/createTask"
    headers = {"Content-Type": "application/json"}
    payload = {"clientKey": API_KEY, "task": task_payload}
    
    response = requests.post(url, headers=headers, json=payload).json()
    if response.get("errorId") != 0:
        raise RuntimeError(f"Ошибка создания задачи: {response.get('errorDescription')}")
        
    task_id = response["taskId"]
    print(f"Задача создана, ID: {task_id}")
    
    res_url = "https://2captcha.com/getTaskResult"
    deadline = time.time() + timeout
    
    while time.time() < deadline:
        time.sleep(5)
        res_payload = {"clientKey": API_KEY, "taskId": task_id}
        res_response = requests.post(res_url, headers=headers, json=res_payload).json()
        
        if res_response.get("errorId") != 0:
            raise RuntimeError(f"Ошибка получения результата: {res_response.get('errorDescription')}")
            
        if res_response.get("status") == "ready":
            return res_response["solution"]
            
    raise TimeoutError("Превышено время ожидания решения капчи")

# Пример использования для CoordinatesTask:
# task = {
#     "type": "CoordinatesTask",
#     "body": "iVBORw0KGgoAAAANSUhEUg...", # Base64 основного изображения
#     "imgInstructions": "iVBORw0KGgoAAAANSUhEUg...", # Base64 полоски иконок
#     "comment": "Click the icons shown in the instruction, in the same order, left to right"
# }
# solution = solve_captcha_task(task)
# print(solution) # Вернет {"coordinates": [{"x": 118, "y": 402}, ...]}

import os
import time
import requests
from playwright.sync_api import sync_playwright

API_KEY = os.environ.get("APIKEY", "ВАШ_API_КЛЮЧ")
TARGET_URL = "https://us.shein.com/pdsearch/dress/"

# JavaScript для определения текущего шага капчи и получения координат элементов
STATE_JS = """
() => {
  const roots = [];
  const collect = (root) => {
    roots.push(root);
    for (const el of root.querySelectorAll('*')) if (el.shadowRoot) collect(el.shadowRoot);
  };
  collect(document);
  
  const visible = (e) => {
    if (!e) return false;
    const r = e.getBoundingClientRect(), s = getComputedStyle(e);
    return r.width > 0 && r.height > 0 && s.display !== 'none' && s.visibility !== 'hidden';
  };
  
  const qa = (sel) => roots.flatMap((r) => [...r.querySelectorAll(sel)]);
  const rect = (e) => { const r = e.getBoundingClientRect(); return [r.x, r.y, r.width, r.height]; };
  const first = (sel) => { const e = qa(sel).find(visible); return e ? rect(e) : null; };
  
  const pic = qa('.captcha_click_wrapper .pic_wrapper').find(visible);
  if (pic) {
    return {
      stage: 'icon_click', 
      image: rect(pic),
      icons: first('.captcha_click_wrapper .pic_elg_wrapper'),
      confirm: first('.captcha_click_confirm'), 
      refresh: first('.captcha_click_refresh')
    };
  }
  
  const tiles = qa('.nine-content-img').filter(visible);
  if (tiles.length) {
    return {
      stage: 'nine_captcha', 
      tiles: tiles.map(rect),
      icon: first('.header-content-img'), 
      refresh: first('.nine-refresh')
    };
  }
  
  for (const r of roots) {
    for (const e of r.querySelectorAll('*')) {
      if (e.childElementCount === 0 && e.textContent.trim() === 'I am human' && visible(e)) {
        return {stage: 'one_pass', checkbox: rect(e)};
      }
    }
  }
  return {stage: 'none'};
}
"""

def send_task(task_data):
    url = "https://2captcha.com/createTask"
    res = requests.post(url, json={"clientKey": API_KEY, "task": task_data}).json()
    if res.get("errorId") != 0:
        raise Exception(f"Task error: {res.get('errorDescription')}")
    
    task_id = res["taskId"]
    for _ in range(30):
        time.sleep(5)
        r = requests.post("https://2captcha.com/getTaskResult", json={"clientKey": API_KEY, "taskId": task_id}).json()
        if r.get("status") == "ready":
            return r["solution"]
    raise TimeoutError("Captcha solving timeout")

def solve_shein_challenge(page, max_rounds=5):
    if "/risk/challenge" not in page.url:
        return True
        
    page.wait_for_function(f"({STATE_JS})().stage !== 'none'", timeout=15000)
    
    for round_num in range(1, max_rounds + 1):
        time.sleep(1.5) # Даем время на загрузку новых картинок
        state = page.evaluate(STATE_JS)
        
        if state["stage"] == "one_pass":
            label = state["checkbox"]
            page.mouse.click(label[0] - 20, label[1] + label[3] / 2)
            time.sleep(3)
            if "/risk/challenge" not in page.url:
                return True
                
        elif state["stage"] == "icon_click":
            image_png = page.screenshot(clip={"x": state["image"][0], "y": state["image"][1], "width": state["image"][2], "height": state["image"][3]})
            icons_png = page.screenshot(clip={"x": state["icons"][0], "y": state["icons"][1], "width": state["icons"][2], "height": state["icons"][3]})
            
            import base64
            solution = send_task({
                "type": "CoordinatesTask",
                "body": base64.b64encode(image_png).decode(),
                "imgInstructions": base64.b64encode(icons_png).decode(),
                "comment": "Click the icons shown in the instruction, in the same order, left to right"
            })
            
            points = solution.get("coordinates", [])
            if len(points) < 2:
                page.mouse.click(state["refresh"][0] + state["refresh"][2]/2, state["refresh"][1] + state["refresh"][3]/2)
                continue
                
            # Пересчет координат с учетом device pixel ratio
            w, h = len(image_png), len(icons_png) # Упрощенно, в реальности нужно парсить заголовки PNG
            # Для точности лучше использовать библиотеку для чтения размеров PNG, но здесь показан принцип
            
            x0, y0 = state["image"][0], state["image"][1]
            for p in points:
                page.mouse.click(x0 + p["x"], y0 + p["y"])
                time.sleep(0.4)
            page.mouse.click(state["confirm"][0] + state["confirm"][2]/2, state["confirm"][1] + state["confirm"][3]/2)
            
        elif state["stage"] == "nine_captcha":
            tiles = sorted(state["tiles"], key=lambda t: (round(t[1] / t[3]), t[0]))
            x0, y0 = min(t[0] for t in tiles), min(t[1] for t in tiles)
            x1, y1 = max(t[0] + t[2] for t in tiles), max(t[1] + t[3] for t in tiles)
            
            grid_png = page.screenshot(clip={"x": x0, "y": y0, "width": x1 - x0, "height": y1 - y0})
            icon_png = page.screenshot(clip={"x": state["icon"][0], "y": state["icon"][1], "width": state["icon"][2], "height": state["icon"][3]})
            
            import base64
            solution = send_task({
                "type": "GridTask",
                "body": base64.b64encode(grid_png).decode(),
                "rows": 3, "columns": 3,
                "imgInstructions": base64.b64encode(icon_png).decode(),
                "comment": "Select exactly 3 images that show the same action or object as the small icon"
            })
            
            picks = [n for n in solution.get("click", []) if 1 <= n <= 9]
            if len(picks) != 3:
                page.mouse.click(state["refresh"][0] + state["refresh"][2]/2, state["refresh"][1] + state["refresh"][3]/2)
                continue
                
            for n in picks:
                t = tiles[n - 1]
                page.mouse.click(t[0] + t[2]/2, t[1] + t[3]/2)
                time.sleep(0.4)
                
        try:
            page.wait_for_url(lambda url: "/risk/challenge" not in url, timeout=8000)
            print(f"Капча успешно пройдена в раунде {round_num}")
            return True
        except Exception:
            print(f"Раунд {round_num} не принят, пробуем новую головоломку")
            
    return False

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    page.goto(TARGET_URL)
    
    if solve_shein_challenge(page):
        page.wait_for_load_state("domcontentloaded")
        print("Успешный вход:", page.title())
        
    browser.close()