URL da Sessão: Como Garantir a Privacidade do Usuário Durante a Interação Humano-Computador?

Scrapeless Scraping Browser agora suporta totalmente tarefas de automação através de fluxos de trabalho baseados em sessão. Seja iniciado via Playground ou API, todas as execuções do programa podem ser sincronizadamente rastreadas no Dashboard.

• Abra a Live View para monitorar o status de execução em tempo real.
• Compartilhe a URL ao vivo para interação remota do usuário — como páginas de login, preenchimento de formulários ou conclusão de pagamentos.
• Revise todo o processo de execução com o Replay da Sessão.

Mas você pode se perguntar:

O que exatamente são essas funcionalidades de Sessão? Como elas me beneficiam? E como eu as uso?

Neste blog, exploraremos a Sessão do Scrapeless Scraping Browser em profundidade, cobrindo:

• O conceito e propósito da Live View
• O que é a Live URL
• Como usar a Live URL para interação direta do usuário
• Por que o Replay da Sessão é essencial

Live View: Monitoramento de Programa em Tempo Real

A funcionalidade Live View no Scrapeless Scraping Browser permite que você rastreie e controle sessões do navegador em tempo real. Especificamente, ela permite que você observe cliques, entradas e todas as ações do navegador, monitore fluxos de trabalho de automação, depure scripts manualmente e assuma o controle direto da sessão, se necessário.

Criando uma Sessão do Navegador

Primeiro, você precisa criar uma sessão. Existem duas maneiras de fazer isso:

Método 1: Criar uma sessão via Playground

Método 2: Criar uma sessão via API

Você também pode criar uma sessão usando nossa API. Consulte a documentação da API: Documentação da API do Scraping Browser. Nossa funcionalidade de sessão ajudará você a gerenciar sua sessão, incluindo capacidades de visualização em tempo real.

const puppeteer =require('puppeteer-core');
 
const token = 'Chave da API'
 
// impressão digital personalizada
const fingerprint = {
    platform: 'Windows',
}
 
const query = new URLSearchParams({
    session_ttl: 180,
    session_name: 'teste_scraping', // nome da sessão
    proxy_country: 'QUALQUER',
    token: token,
    fingerprint: encodeURIComponent(JSON.stringify(fingerprint)),
});
 
const connectionURL = `wss://browser.scrapeless.com/browser?${query.toString()}`;
 
(async () => {
    const browser = await puppeteer.connect({browserWSEndpoint: connectionURL});
    const page = await browser.newPage();
 
    await page.goto('https://www.scrapeless.com');
    await new Promise(res => setTimeout(res, 3000));
 
    await page.goto('https://www.google.com');
    await new Promise(res => setTimeout(res, 3000));
 
    await page.goto('https://www.youtube.com');
    await new Promise(res => setTimeout(res, 3000));
 
    await browser.close();
})();

Ver Sessões Ao Vivo

Na interface de gerenciamento de sessão do Scrapeless, você pode facilmente visualizar sessões ao vivo:

Método 1: Ver Sessões Ao Vivo Diretamente no Dashboard

Após criar uma sessão no Playground, você verá a sessão em execução ao vivo no lado direito.

Ou, você pode verificar o status da sessão na página Sessões Ao Vivo:

Método 2: Ver Sessão via Live URL

Uma Live URL é gerada para uma sessão em execução, permitindo que você assista ao processo ao vivo em um navegador.

As Live URLs são úteis para:

• Depuração & Monitoramento: Assista tudo em tempo real ou compartilhe com colegas de equipe.
• Interação Humana: Controle ou insira diretamente — permitindo que o usuário insira informações sensíveis como senhas de forma segura.

Você pode copiar a Live URL clicando no ícone "🔗" na página de Sessões Ao Vivo. Tanto as sessões criadas no Playground quanto via API suportam Live URL.

1. Obter Live URL do Dashboard

Veja nosso tutorial abaixo:

2. Obter Live URL via API

Você também pode recuperar a Live URL por meio de chamadas de API. O código de exemplo abaixo busca todas as sessões em execução pela API de sessão, e então usa a API Live URL para recuperar a visualização ao vivo de uma sessão específica:

import requests
 
API_CONFIG = {
    "host": "https://api.scrapeless.com",
    "headers": {
        "x-api-token": "Chave da API",
        "Content-Type": "application/json"
    }
}
 
 
async def fetch_live_url(task_id):
    try:
        live_response = requests.get(f"{API_CONFIG['host']}/browser/{task_id}/live", headers=API_CONFIG["headers"])
 
        if not live_response.ok:
            raise Exception(f"falha ao buscar live url: {live_response.status_code} {live_response.reason}")
 
        live_result = live_response.json()
        if live_result and live_result.get("data"):
            print(f"taskId: {task_id}")
            print(f"liveUrl: {live_result['data']}")
        else:

print("nenhum dado de url ao vivo disponível para esta tarefa")
    except Exception as error:
        print(f"erro ao buscar url ao vivo para a tarefa {task_id}: {str(error)}")
 
 
async def fetch_browser_sessions():
    try:
        session_response = requests.get(f"{API_CONFIG['host']}/browser/running", headers=API_CONFIG["headers"])
 
        if not session_response.ok:
            raise Exception(f"falha ao buscar sessões: {session_response.status_code} {session_response.reason}")
 
        session_result = session_response.json()
 
        sessions = session_result.get("data")
        if not sessions or not isinstance(sessions, list) or len(sessions) == 0:
            print("nenhuma sessão do navegador ativa encontrada")
            return
 
        task_id = sessions[0].get("taskId")
        if not task_id:
            print("id da tarefa não encontrado nos dados da sessão")
            return
 
        await fetch_live_url(task_id)
    except Exception as error:
        print(f"erro ao buscar sessões do navegador: {str(error)}")
 
 
import asyncio
 
asyncio.run(fetch_browser_sessions())

3. Obter URL Ao Vivo via comando CDP

Para obter o URL Ao Vivo enquanto o código está em execução, use o comando CDP Agent.liveURL:

import asyncio
 
from pyppeteer import launcher
 
 
async def main():
    try:
        browser = await launcher.connect(
            browserWSEndpoint="wss://browser.scrapeless.com/browser?token=APIKey&session_ttl=180&proxy_country=ANY"
        )
        page = await browser.newPage()
        await page.goto('https://www.scrapeless.com')
 
        client = await page.target.createCDPSession()
        result = await client.send('Agent.liveURL')
        print(result)
    except Exception as e:
        print(e)
 
 
asyncio.run(main())

Um destaque que vale a pena mencionar:

A URL Ao Vivo não apenas permite monitoramento em tempo real, mas também interação humano-máquina.

Por exemplo: Você precisa que o usuário insira sua senha de login.

“Oh não! Você está tentando roubar minhas informações privadas? De jeito nenhum!”

Na verdade, o usuário pode inserir os dados sozinho na tela — e tudo permanece 100% privado. Este método direto, mas seguro, é o que a URL Ao Vivo possibilita — interação remota.

URL Ao Vivo: Como Isso Permite Colaboração e Interação com o Usuário

Vamos usar o registro e login no Scrapeless como exemplo e ver como interagir diretamente com os usuários.

Aqui está o código que você precisará:

const puppeteer = require("puppeteer-core");

(async () => {
    const fingerprint = {
        // impressões digitais da tela personalizadas
        screen: {
            width: 1920,
            height: 1080,
        },
        args: {
            // definir o tamanho da janela com o mesmo valor da impressão digital da tela
            "--window-size": "1920,1080",
        },
    };

    const query = new URLSearchParams({
        token: "APIKey",
        session_ttl: 600,
        proxy_country: "ANY",
        fingerprint: encodeURIComponent(JSON.stringify(fingerprint)),
    });
    const browserWsEndpoint = `wss://browser.scrapeless.com/browser?${query.toString()}`;

    try {
        const browser = await puppeteer.connect({
            browserWSEndpoint: browserWsEndpoint,
        });

        const page = await browser.newPage();
        await page.setViewport(null);

        await page.goto(`https://app.scrapeless.com/passport/register`, {
            timeout: 120000,
            waitUntil: "domcontentloaded",
        });

        const client = await page.createCDPSession();
        const result = await client.send("Agent.liveURL");

        // você pode compartilhar a url ao vivo com qualquer usuário
        console.log(`${result.liveURL}`);

        // esperar 5 minutos para o registro do usuário
        await page.waitForSelector("#none-existing-selector", {timeout: 300_000});
    } catch (e) {
        console.log(e);
    }
})()

Execute o código acima e compartilhe a URL Ao Vivo com o usuário, como: URL de Registro do Scrapeless.

Todas as etapas anteriores, como:

• Navegando até o site
• Visitando a página inicial do Scrapeless
• Clicando em login e entrando na página de registro

Todas essas podem ser feitas diretamente criando uma sessão usando o código acima. O passo mais crítico é que o usuário precisa inserir seu e-mail e senha para completar o registro.

Depois de compartilhar a URL Ao Vivo com o usuário, você pode acompanhar remotamente o processo de execução do programa. O programa será executado automaticamente e pulará até a página que requer interação do usuário. A senha inserida pela outra parte ficará completamente oculta, e o usuário não precisa se preocupar com vazamento de senha.

Para refletir de maneira mais intuitiva o processo de operação do usuário, consulte os seguintes passos de interação:

O seguinte processo interativo é executado completamente na URL Ao Vivo

Replay de Sessão: Reproduza a Execução do Programa para Depurar Tudo

O Replay de Sessão é uma recriação em formato de vídeo de uma sessão de usuário construída usando a Biblioteca de Gravação. Os replays são criados com base em snapshots do estado do DOM da aplicação web (a representação HTML na memória do navegador). Ao reproduzir cada snapshot, você verá um registro das ações realizadas durante toda a sessão: incluindo todos os carregamentos de página, atualizações e navegações que ocorreram durante sua visita ao site.

O Replay de Sessão pode ajudá-lo a solucionar todos os aspectos do funcionamento do seu programa. Todas as operações de página serão registradas e salvas como um vídeo. Se você encontrar algum problema durante a sessão, pode solucioná-lo e ajustá-lo através da reprodução.

• Vá para Sessões
• Clique em Histórico de Sessão
• Localize a sessão

• Nos detalhes da sessão, clique no botão Reproduzir para assistir e revisar a execução:

Considerações Finais

O Scrapeless Scraping Browser permite que você monitore em tempo real, interaja remotamente e reproduza todos os passos.

• Visualização Ao Vivo: Assista a atividade do navegador como um streaming ao vivo. Veja cada clique e entrada!
• URL Ao Vivo: Gere um link compartilhável onde os usuários podem inserir seus dados diretamente. Totalmente privado, completamente seguro.
• Replay de Sessão: Depure como um profissional reproduzindo exatamente o que aconteceu — sem necessidade de reexecutar o programa.

Seja você um desenvolvedor depurando, um PM realizando uma demonstração, ou um suporte ao cliente guiando um usuário — as Sessões Scrapeless oferecem suporte.

É hora de tornar a automação inteligente e amigável para o ser humano.

Comece seu teste gratuito agora!