Interações Semelhantes a Humanas

Um dos principais diferenciais entre uma automação bem-sucedida e bots facilmente detectados é o quão realistas são as interações. O Pydoll fornece ferramentas sofisticadas para tornar sua automação virtualmente indistinguível do comportamento humano.

Melhorias Futuras

O Pydoll está continuamente melhorando suas capacidades de interação semelhante à humana. Versões futuras incluirão:

• Velocidade de digitação variável: Intervalos aleatórios integrados entre as teclas para eliminar a necessidade de aleatorização manual
• Sequências de teclado realistas: Simulação automática de erros de digitação, retrocesso (backspace), correções e pausas dinâmicas para máximo realismo
• Deslocamentos (offsets) de clique aleatórios automáticos: Parâmetro opcional para randomizar automaticamente as posições de clique dentro dos elementos, eliminando cálculos manuais de deslocamento
• Simulação de movimento do mouse: Trajetórias de cursor realistas com curvas de bezier
• Eventos delta do mouse: Padrões naturais de aceleração e desaceleração
• Comportamento de hover (passar o mouse): Atrasos e movimentos realistas ao passar o mouse
• Padrões de rolagem (scroll): Velocidades de rolagem e momentum semelhantes aos humanos com um método scroll() dedicado
• Variações de tempo: Atrasos aleatórios para evitar padrões previsíveis

Essas funcionalidades aproveitam as capacidades do CDP e do JavaScript para máximo realismo.

Por que Interações Semelhantes a Humanas Importam

Sites modernos empregam técnicas sofisticadas de detecção de bots:

• Análise de tempo de eventos: Detectando ações impossivelmente rápidas ou perfeitamente cronometradas
• Rastreamento de movimento do mouse: Identificando movimentos em linha reta ou teletransporte instantâneo
• Padrões de teclado: Percebendo inserção de texto instantânea sem pressionamentos de tecla individuais
• Posições de clique: Detectando cliques sempre no centro exato dos elementos
• Sequências de ação: Identificando padrões não humanos no comportamento do usuário

O Pydoll ajuda você a evitar a detecção, fornecendo métodos de interação realistas que imitam o comportamento real do usuário.

Cliques Realistas

Clique Básico com Eventos de Mouse Simulados

O método click() simula eventos reais de pressionar e soltar o mouse, diferentemente de cliques baseados em JavaScript:

import asyncio
from pydoll.browser.chromium import Chrome

async def realistic_clicking():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com')

        button = await tab.find(id="submit-button")

        # Clique realista básico
        await button.click()

        # O clique inclui:
        # - Movimento do mouse até o elemento
        # - Evento de pressionar o mouse
        # - Tempo de espera (hold) configurável
        # - Evento de soltar o mouse

asyncio.run(realistic_clicking())

Clique com Deslocamento de Posição (Offset)

Usuários reais raramente clicam no centro exato dos elementos. Use deslocamentos para variar as posições dos cliques:

Estado Atual: Cálculo Manual de Deslocamento

Atualmente, você deve calcular manualmente e randomizar os deslocamentos de clique para cada interação. Versões futuras incluirão um parâmetro opcional para randomizar automaticamente as posições de clique dentro dos limites do elemento.

import asyncio
import random
from pydoll.browser.chromium import Chrome

async def click_with_offset():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/form')

        submit_button = await tab.find(tag_name="button", type="submit")

        # Clicar ligeiramente fora do centro (mais natural)
        await submit_button.click(
            x_offset=5,   # 5 pixels à direita do centro
            y_offset=-3   # 3 pixels acima do centro
        )

        # Atualmente: Varie manualmente o deslocamento para cada clique para parecer mais humano
        for item in await tab.find(class_name="clickable-item", find_all=True):
            offset_x = random.randint(-10, 10)
            offset_y = random.randint(-10, 10)
            await item.click(x_offset=offset_x, y_offset=offset_y)
            await asyncio.sleep(random.uniform(0.5, 2.0))

asyncio.run(click_with_offset())

Tempo de Espera (Hold) do Clique Ajustável

Varie a duração do pressionamento do botão do mouse para simular diferentes estilos de clique:

import asyncio
from pydoll.browser.chromium import Chrome

async def variable_hold_time():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com')

        button = await tab.find(class_name="action-button")

        # Clique rápido (padrão é 0.1s)
        await button.click(hold_time=0.05)

        # Clique normal
        await button.click(hold_time=0.1)

        # Clique mais lento e deliberado
        await button.click(hold_time=0.2)

        # Simular hesitação do usuário
        await asyncio.sleep(0.8)
        await button.click(hold_time=0.15)

asyncio.run(variable_hold_time())

Quando Usar click() vs click_using_js()

Entender a diferença é crucial para evitar detecção:

import asyncio
from pydoll.browser.chromium import Chrome

async def click_methods_comparison():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com')

        button = await tab.find(id="interactive-button")

        # Método 1: click() - Simula eventos reais do mouse
        # Dispara todos os eventos do mouse (mousedown, mouseup, click)
        # Respeita o posicionamento do elemento
        # Mais realista e mais difícil de detectar
        # Requer que o elemento esteja visível e dentro da viewport
        await button.click()

        # Método 2: click_using_js() - Usa JavaScript click()
        # Funciona em elementos ocultos
        # Execução mais rápida
        # Contorna sobreposições visuais
        # Pode ser detectado como automação
        # Não dispara a mesma sequência de eventos de um usuário real
        await button.click_using_js()

asyncio.run(click_methods_comparison())

Melhor Prática: Prefira Eventos do Mouse

Use click() para interações voltadas ao usuário para manter o realismo. Reserve click_using_js() para operações de backend, elementos ocultos, ou quando a velocidade é crítica e a detecção não é uma preocupação.

Entrada de Texto Realista

Digitação Natural com Intervalos

O método type_text() simula a digitação humana enviando pressionamentos de tecla individuais. O parâmetro interval adiciona um atraso fixo entre cada pressionamento de tecla.

Estado Atual: Aleatorização Manual Necessária

Atualmente, o parâmetro interval usa um atraso constante para todos os caracteres. Para máximo realismo, você precisa randomizar manualmente as velocidades de digitação (como mostrado nos exemplos avançados abaixo). Versões futuras incluirão velocidade de digitação variável automática com aleatoriedade integrada.

import asyncio
from pydoll.browser.chromium import Chrome

async def natural_typing():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/login')

        username_field = await tab.find(id="username")
        password_field = await tab.find(id="password")

        # Digitar com intervalos fixos (atualmente)
        # Digitação humana média: 0.1-0.3 segundos por caractere
        await username_field.type_text("john.doe@example.com", interval=0.15)

        # Digitação mais lenta para senhas complexas
        await password_field.type_text("MyC0mpl3xP@ssw0rd!", interval=0.12)

asyncio.run(natural_typing())

Entrada Rápida para Campos Não Visíveis

Para campos que não exigem realismo (como campos ocultos ou operações de backend), use insert_text():

import asyncio
from pydoll.browser.chromium import Chrome

async def fast_vs_realistic_input():
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/form')

        # Digitação realista para campos visíveis
        username = await tab.find(id="username")
        await username.click()
        await username.type_text("john_doe", interval=0.12)

        # Inserção rápida para campos ocultos ou de backend
        hidden_field = await tab.find(id="hidden-token")
        await hidden_field.insert_text("very-long-generated-token-12345678")

        # Digitação realista para campos que importam
        comment = await tab.find(id="comment-box")
        await comment.click()
        await comment.type_text("This looks like human input!", interval=0.15)

asyncio.run(fast_vs_realistic_input())

Controle Avançado de Teclado

Para documentação abrangente sobre controle de teclado, incluindo teclas especiais, combinações de teclas, modificadores e tabelas de referência completas de teclas, veja Controle de Teclado.

Combinando Técnicas para Máximo Realismo

Exemplo Completo de Preenchimento de Formulário

Aqui está um exemplo abrangente combinando todas as técnicas de interação semelhantes a humanas. Isso demonstra a abordagem manual atual para alcançar o máximo realismo — versões futuras automatizarão muito dessa aleatorização:

import asyncio
import random
from pydoll.browser.chromium import Chrome
from pydoll.constants import Key

async def human_like_form_filling():
    """Preencher um formulário com máximo realismo para evitar detecção."""
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/registration')

        # Esperar um pouco (usuário lendo a página)
        await asyncio.sleep(random.uniform(1.5, 3.0))

        # Preencher o primeiro nome com velocidade de digitação variável
        first_name = await tab.find(id="first-name")
        await first_name.click(
            x_offset=random.randint(-5, 5),
            y_offset=random.randint(-5, 5)
        )
        await asyncio.sleep(random.uniform(0.2, 0.5))

        # Digitação manual caractere por caractere com atrasos aleatórios
        # (Isso será automatizado em versões futuras)
        name_text = "John"
        for char in name_text:
            await first_name.type_text(char, interval=0)
            await asyncio.sleep(random.uniform(0.08, 0.22))

        # Tab para o próximo campo
        await asyncio.sleep(random.uniform(0.3, 0.8))
        await first_name.press_keyboard_key(Key.TAB)

        # Preencher o sobrenome
        await asyncio.sleep(random.uniform(0.2, 0.5))
        last_name = await tab.find(id="last-name")
        await last_name.type_text("Doe", interval=random.uniform(0.1, 0.18))

        # Tab para o email
        await asyncio.sleep(random.uniform(0.4, 1.0))
        await last_name.press_keyboard_key(Key.TAB)

        # Preencher email com pausas realistas
        await asyncio.sleep(random.uniform(0.2, 0.5))
        email = await tab.find(id="email")

        email_text = "john.doe@example.com"
        for i, char in enumerate(email_text):
            await email.type_text(char, interval=0)
            # Pausa mais longa nos símbolos @ e . (natural)
            if char in ['@', '.']:
                await asyncio.sleep(random.uniform(0.2, 0.4))
            else:
                await asyncio.sleep(random.uniform(0.08, 0.2))

        # Simular usuário revisando o que digitou
        await asyncio.sleep(random.uniform(1.0, 2.5))

        # Aceitar checkbox de termos com deslocamento
        terms_checkbox = await tab.find(id="accept-terms")
        await terms_checkbox.click(
            x_offset=random.randint(-3, 3),
            y_offset=random.randint(-3, 3),
            hold_time=random.uniform(0.08, 0.15)
        )

        # Pausar antes de enviar (usuário revisando formulário)
        await asyncio.sleep(random.uniform(1.5, 3.0))

        # Clicar em enviar com parâmetros realistas
        submit_button = await tab.find(tag_name="button", type="submit")
        await submit_button.click(
            x_offset=random.randint(-8, 8),
            y_offset=random.randint(-5, 5),
            hold_time=random.uniform(0.1, 0.2)
        )

        print("Formulário enviado com comportamento semelhante ao humano")

asyncio.run(human_like_form_filling())

Melhores Práticas para Evitar Detecção

Aleatorização Manual Atualmente Necessária

As seguintes melhores práticas representam o estado atual do Pydoll, onde você deve implementar a aleatorização manualmente. Embora isso exija mais código, oferece um controle refinado sobre o comportamento. Versões futuras automatizarão esses padrões, mantendo o mesmo nível de realismo.

1. Sempre Adicione Atrasos Aleatórios

import asyncio
import random
from pydoll.browser.chromium import Chrome

# Ruim: Tempo previsível
await element1.click()
await element2.click()
await element3.click()

# Bom: Tempo variável (atualmente necessário)
await element1.click()
await asyncio.sleep(random.uniform(0.5, 1.5))
await element2.click()
await asyncio.sleep(random.uniform(0.8, 2.0))
await element3.click()

2. Varie as Posições dos Cliques

import asyncio
import random
from pydoll.browser.chromium import Chrome

# Ruim: Sempre clica no centro
for button in buttons:
    await button.click()

# Bom: Posições variadas (atualmente manual)
for button in buttons:
    await button.click(
        x_offset=random.randint(-10, 10),
        y_offset=random.randint(-10, 10)
    )

3. Simule Comportamento Natural do Usuário

import asyncio
import random
from pydoll.browser.chromium import Chrome

async def natural_user_simulation(tab):
    # Usuário chega na página
    await tab.go_to('https://example.com')

    # Usuário lê o conteúdo da página (1-3 segundos)
    await asyncio.sleep(random.uniform(1.0, 3.0))

    # Usuário rola para baixo para ver mais
    # Atualmente: Rolagem manual com JavaScript (instantâneo, não realista)
    # Futuro: Método scroll() dedicado com momentum e aceleração humanos
    await tab.execute_script("window.scrollBy(0, 300)")
    await asyncio.sleep(random.uniform(0.5, 1.5))

    # Usuário encontra e clica no botão
    button = await tab.find(class_name="cta-button")
    await button.click(
        x_offset=random.randint(-5, 5),
        y_offset=random.randint(-5, 5)
    )

    # Usuário espera o conteúdo carregar
    await asyncio.sleep(random.uniform(0.8, 1.5))

4. Combine Múltiplas Técnicas

import asyncio
import random
from pydoll.browser.chromium import Chrome

async def advanced_stealth_automation():
    """Combinar múltiplas técnicas para máxima furtividade."""
    async with Chrome() as browser:
        tab = await browser.start()

        # Usar espera de carregamento de página semelhante à humana
        await tab.go_to('https://example.com/sensitive-page')
        await asyncio.sleep(random.uniform(2.0, 4.0))

        # Rolar realisticamente (abordagem manual atual)
        # Versões futuras terão um método scroll() dedicado com momentum
        for _ in range(random.randint(2, 4)):
            scroll_amount = random.randint(200, 500)
            await tab.execute_script(f"window.scrollBy(0, {scroll_amount})")
            await asyncio.sleep(random.uniform(0.8, 2.0))

        # Encontrar elemento com timeout (simulando busca do usuário)
        target = await tab.find(
            class_name="target-element",
            timeout=random.randint(3, 7)
        )

        # Clicar com todos os parâmetros realistas
        await target.click(
            x_offset=random.randint(-12, 12),
            y_offset=random.randint(-8, 8),
            hold_time=random.uniform(0.09, 0.18)
        )

        # Tempo de reação humano
        await asyncio.sleep(random.uniform(0.5, 1.2))

asyncio.run(advanced_stealth_automation())

Trocas entre Desempenho e Realismo

Às vezes, você precisa equilibrar velocidade com realismo:

import asyncio
from pydoll.browser.chromium import Chrome

async def balanced_automation():
    """Escolher o nível de realismo apropriado com base no contexto."""
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/scraping-target')

        # Fase 1: Interação inicial (alto realismo)
        # É quando os sistemas de detecção estão mais ativos
        login_button = await tab.find(text="Login")
        await asyncio.sleep(random.uniform(1.0, 2.0))
        await login_button.click(
            x_offset=random.randint(-5, 5),
            y_offset=random.randint(-5, 5)
        )

        await asyncio.sleep(random.uniform(0.5, 1.0))

        username = await tab.find(id="username")
        await username.type_text("user@example.com", interval=0.12)

        await asyncio.sleep(random.uniform(0.3, 0.7))

        password = await tab.find(id="password")
        await password.type_text("password123", interval=0.10)

        submit = await tab.find(type="submit")
        await asyncio.sleep(random.uniform(0.8, 1.5))
        await submit.click()

        # Fase 2: Extração de dados autenticada (menos realismo, mais velocidade)
        # Menos escrutínio após autenticação bem-sucedida
        await asyncio.sleep(2)

        # Navegação rápida pelas páginas
        items = await tab.find(class_name="data-item", find_all=True)

        for item in items:
            # Clique rápido sem deslocamentos
            await item.click_using_js()
            await asyncio.sleep(0.3)  # Atraso mínimo

            # Extrair dados
            title = await tab.find(class_name="title")
            data = await title.text

            # Navegação rápida
            await tab.execute_script("window.history.back()")
            await asyncio.sleep(0.5)

asyncio.run(balanced_automation())

Monitorando e Ajustando

Teste o realismo da sua automação:

import asyncio
import random
import time
from pydoll.browser.chromium import Chrome

async def test_interaction_timing():
    """Registrar tempos para garantir padrões realistas."""
    async with Chrome() as browser:
        tab = await browser.start()
        await tab.go_to('https://example.com/test-page')

        # Medir e registrar o tempo de interação
        elements = await tab.find(class_name="clickable", find_all=True)

        timings = []
        last_time = time.time()

        for i, element in enumerate(elements):
            await element.click(
                x_offset=random.randint(-8, 8),
                y_offset=random.randint(-8, 8)
            )

            current_time = time.time()
            elapsed = current_time - last_time
            timings.append(elapsed)

            print(f"Clique {i+1}: {elapsed:.3f}s desde a última ação")
            last_time = current_time

            await asyncio.sleep(random.uniform(0.5, 2.0))

        # Analisar distribuição de tempo
        avg_time = sum(timings) / len(timings)
        print(f"\nTempo médio entre ações: {avg_time:.3f}s")
        print(f"Min: {min(timings):.3f}s, Max: {max(timings):.3f}s")

        # Bom: Tempo variável com média realista (1-2 segundos)
        # Ruim: Tempo constante ou irrealisticamente rápido (<0.1s)

asyncio.run(test_interaction_timing())

Aprenda Mais

Para mais informações sobre métodos de interação com elementos:

• Localização de Elementos: Localize elementos para interagir
• Domínio WebElement: Análise profunda das capacidades do WebElement
• Operações com Arquivos: Faça upload de arquivos e lide com downloads

Domine as interações semelhantes a humanas, e sua automação será mais confiável, mais difícil de detectar e espelhará mais de perto o comportamento real do usuário.