Automação no Octo Browser: reduzindo os custos de tempo

Onde a Automação do Navegador é Mais Necessária?

Realizar ações repetitivas manualmente consome tempo que poderia ser gasto em tarefas mais importantes. Além de economizar seu tempo e foco, a automação também ajuda a prevenir erros. Repetir a mesma ação centenas de vezes torna os erros quase inevitáveis, por exemplo, definir tags erradas ou lançar perfis sem atribuir os proxies corretos. Ao contrário dos humanos, algoritmos não cometem tais erros. Com um script bem testado, você pode ter certeza de que tudo será executado corretamente.

Além de resolver tarefas gerais, a automação é especialmente útil nas seguintes áreas:

• Marketing de afiliados: Automatizar criação em massa de perfis e configuração, incluindo cookies, proxies, extensões e páginas iniciais.

• Farming de contas: Crie rapidamente contas nos geos necessários e prepare-as automaticamente. Exporte todos os perfis na lista de exportação.

• Web scraping: Ajustar a frequência de solicitações por IP para níveis seguros, rotacionar proxies e modificar impressões digitais em caso de bloqueios.

• E-commerce: Desenvolver scripts para automatizar tarefas intensivas em mão de obra e fazer parsing seguro de dados de concorrentes.

• Apostas e caça a bônus: Simplificar a criação de perfis com localizações geográficas e parâmetros de impressão digital necessários. Automatizar ações em massa entre contas para contornar limites de apostas.

Começando com a API

Analisamos as chamadas da API de nossos usuários e notamos que muitas equipes estão implementando ativamente scripts para gerenciar perfis, mudando assim as abordagens comuns à multi-conta. Muitos líderes de grandes equipes de marketing de afiliados destacam a conveniência de nossa API como uma das principais vantagens do Octo em relação aos concorrentes.

Nossa API atual permite que você crie perfis com as impressões digitais digitais necessárias, adicione proxies, atribua tags, assim como inicie e pare cenários automáticos usando qualquer framework de automação de navegador. Você também pode trabalhar com seus perfis em um modo híbrido, aproveitando ao máximo a combinação dos benefícios da automação com a afinação que o controle manual tradicional de suas contas permite.

Você pode encontrar seu token de API nas Configurações adicionais da sua Conta Master do Octo Browser

Seu token de API

O Octo Browser dá acesso ao seu token de API começando com a assinatura Base e superior. Seus limites de chamadas de API são determinados pela sua assinatura. Se você tiver uma assinatura Avançada, pode aumentar ainda mais seus limites de API para 1.000 solicitações por minuto (RPM) e 50.000 solicitações por hora (RPH). Para limites ainda mais altos, entre em contato com Serviço ao Cliente.

Escolhendo a linguagem de programação

O tópico da seleção da linguagem de programação é amplo demais para cobrir todas as possíveis combinações de linguagem e biblioteca aqui. No nosso exemplo, utilizaremos Node.js + Axios, pois temos experiência com este stack. Outras linguagens, como C ou C#, podem ser mais rápidas, mas cada uma tem suas próprias características, pontos finos e casos de uso. Você pode escolher qualquer linguagem com base em sua experiência.

Usando IA para reescrever código

Amamos automação e sempre nos esforçamos para optimizar nosso trabalho, então usamos IA para reescrever código na linguagem necessária. É bem simples: você pode pedir ao ChatGPT para converter código para você usando o seguinte prompt: Converta este script em Node.js com Axios para Python com a biblioteca Requests.

//módulos

const axios = require('axios');

//aqui está a configuração. Cole seu token da API do Octo aqui e você pode modificar isso para suas necessidades pessoais

const config = {

octo_token: "OCTO_API_TOKEN",

octo_api_base_url: "https://app.octobrowser.net/api/v2/automation/",

data: {

extensions: ['aapfglkgnhmiaabhiijkjpfmhllaodgp@4.2.3'],

bookmarks: [{ "name": "google", "url": "https://google.com" }, { "name": "facebook", "url": "https://facebook.com" }],

start_pages: ["https://google.com", "https://facebook.com"]

}

}

const OCTO_REMOTE_API = axios.create({

baseURL: config.octo_api_base_url,

timeout: 10000,

headers: {

'X-Octo-Api-Token': config.octo_token,

'Content-Type': "application/json"

}

});

//funções

async function sleep(ms) {

return new Promise(resolve => setTimeout(resolve, ms * 1000));

}

async function check_limits(response) {

let rpm = response.headers['x-ratelimit-remaining'];

let rph = response.headers['x-ratelimit-remaining-hour'];

if (rpm < 10) {

console.log("Aguardando um minuto...");

await sleep(60);

}

if (rph < 10) {

console.log("Aguardando uma hora...");

await sleep(3600);

}

}

async function get_total_profiles(){

const response = await OCTO_REMOTE_API.get('/profiles?page=0&page_len=10');

const total_profiles = response.data.total_count;

const total_pages = Math.ceil(response.data.total_count/100);

console.log(`Total de Perfis: ${total_profiles}\nTotal de Páginas: ${total_pages}`);

await check_limits(response);

return total_pages;

}

async function get_all_profiles_uuids(total_pages){

let profiles = [];

for (let i = 0; i < total_pages; i++) {

let response = await OCTO_REMOTE_API.get(`/profiles?page=${i}&page_len=100`);

await check_limits(response);

profiles.push(...response.data.data);

}

return profiles;

}

async function patch_all_profiles(profiles){

let updated = [];

let not_updated = [];

for (let profile of profiles) {

try{

const response = await OCTO_REMOTE_API.patch(`/profiles/${profile.uuid}`, config.data);

await check_limits(response);

updated.push(profile);

console.log(`Atualizado com sucesso ${profile.uuid}`);

} catch (error) {

not_updated.push(profile);

console.error(`ERROR: Não foi possível atualizar o perfil ${profile.uuid}`);

}

}

return [updated, not_updated];

}

//processo principal

(async () => {

const total = await get_total_profiles();

const profiles = await get_all_profiles_uuids(total);

const [updated, not_updated] = await patch_all_profiles(profiles);

console.log(`Processo finalizado:\nAtualizados: ${updated.length}\nNão atualizados: ${not_updated.length}`);

})();

Vamos fornecer os trechos para o ChatGPT

Claro, aqui está o equivalente script Python usando a biblioteca Requests:

import requests

import math

import time

# Configuração

config = {

"octo_token": "OCTO_API_TOKEN",

"octo_api_base_url": "https://app.octobrowser.net/api/v2/automation/",

"data": {

"extensions": ["aapfglkgnhmiaabhiijkjpfmhllaodgp@4.2.3"],

"bookmarks": [

{"name": "google", "url": "https://google.com"},

{"name": "facebook", "url": "https://facebook.com"}

],

"start_pages": ["https://google.com", "https://facebook.com"]

}

}

# Configuração da sessão

session = requests.Session()

session.headers.update({

"X-Octo-Api-Token": config["octo_token"],

"Content-Type": "application/json"

})

session.timeout = 10

# Funções auxiliares

def sleep(seconds):

time.sleep(seconds)

def check_limits(response):

rpm = int(response.headers.get("x-ratelimit-remaining", 0))

rph = int(response.headers.get("x-ratelimit-remaining-hour", 0))

if rpm < 10:

print("Aguardando um minuto...")

sleep(60)

if rph < 10:

print("Aguardando uma hora...")

sleep(3600)

# Funções da API

def get_total_profiles():

response = session.get(f"{config['octo_api_base_url']}profiles?page=0&page_len=10")

response.raise_for_status()

total_profiles = response.json()["total_count"]

total_pages = math.ceil(total_profiles / 100)

print(f"Total de Perfis: {total_profiles}\nTotal de Páginas: {total_pages}")

check_limits(response)

return total_pages

def get_all_profiles_uuids(total_pages):

profiles = []

for i in range(total_pages):

response = session.get(f"{config['octo_api_base_url']}profiles?page={i}&page_len=100")

response.raise_for_status()

check_limits(response)

profiles.extend(response.json()["data"])

return profiles

def patch_all_profiles(profiles):

updated = []

not_updated = []

for profile in profiles:

try:

response = session.patch(

f"{config['octo_api_base_url']}profiles/{profile['uuid']}",

json=config["data"]

)

response.raise_for_status()

check_limits(response)

updated.append(profile)

print(f"Atualizado com sucesso {profile['uuid']}")

except Exception as e:

not_updated.append(profile)

print(f"ERROR: Não foi possível atualizar o perfil {profile['uuid']} - {str(e)}")

return updated, not_updated

# Processo principal

if __name__ == "__main__":

try:

total = get_total_profiles()

profiles = get_all_profiles_uuids(total)

updated, not_updated = patch_all_profiles(profiles)

print(f"Processo finalizado:\nAtualizados: {len(updated)}\nNão atualizados: {len(not_updated)}")

except Exception as e:

print(f"Erro fatal: {str(e)}")

Observe que a biblioteca "requests" precisa ser instalada em seu ambiente Python para que este script funcione. Você pode instalá-la usando pip:

pip install requests

Além disso, substitua "OCTO_API_TOKEN" pelo seu token real para fazer chamadas à API.

Usando ChatGPT para converter scripts

Trabalhando com as bibliotecas Puppeteer, Selenium e Playwright

Frameworks de automação de navegador geralmente são feitos para funcionar bem com o Google Chrome, que é baseado em Chromium. Como o Octo Browser também é construído sobre o kernel Chromium, ele interage com esses frameworks de maneira fluida.

Automação com Selenium

Selenium é uma ferramenta popular para automatizar ações de navegador, pois permite modelar ações do usuário em um site.

Principais características

• Automação de tarefas na web.

• Funciona com sites dinâmicos que usam JavaScript e AJAX.

Vantagens

• Flexibilidade e suporte para muitas linguagens de programação.

• Gratuito para uso com uma comunidade grande e ativa.

• Código aberto.

Desvantagens

• Lento e consome muitos recursos.

• Você precisa ter um bom entendimento de conceitos de programação.

A automação de navegadores com Selenium permite otimizar diferentes tarefas de perfil, que vão desde scripts de automação simples até web crawlers que buscam, coletam e interagem com dados de diferentes recursos online.

O Selenium é bem conhecido por aqueles que têm experiência em gerenciar várias contas ao mesmo tempo. Ele pode ser implantado diretamente no navegador e pode ser usado para imitar ações de um humano real. No entanto, o Selenium nem sempre é a solução perfeita, e seu mascaramento pode ser detectado por várias plataformas, incluindo a CloudFlare.

CloudFlare é um fornecedor de serviços de segurança da web que oferece serviços de entrega de conteúdo seguros, proteção contra ataques DDoS e servidores DNS. Os sites usam soluções da CloudFare para detectar consultas iniciadas pelo Selenium.

Automação com Puppeteer

Puppeteer é uma biblioteca Node.js que permite automatizar o trabalho com navegadores baseados em Chromium usando o protocolo DevTools.

Características

• Ferramenta poderosa e flexível para automação de ações web.

• Consegue interagir com páginas da web como um navegador regular.

• Há um porto não oficial conhecido como Pyppeteer, e nós criamos um guia sobre como conectá-lo.

Vantagens

• Uma ótima escolha para trabalhar com sites dinâmicos e executar código JavaScript.

• Uma API fácil e intuitiva que é fácil de usar e configurar.

• Uma ferramenta gratuita com uma comunidade ativa.

Desvantagens

• Suporta apenas JavaScript (Node.js), mas existem portas não oficiais para outras linguagens. Por exemplo, uma porta para Python chamada Pyppeteer.

• Pesada em recursos; mais lenta do que algumas outras bibliotecas.

Automação com Playwright

Playwright é uma biblioteca Node.js que facilita a automação segura, rápida e eficaz para Chromium, Firefox e WebKit usando a mesma API.

Características

• Uma ferramenta de geração de código, CodeGen, está disponível. Você pode usá-la para evitar escrever grandes quantidades de código repetitivo, o que economiza muito tempo.

• Você pode diminuir a velocidade de conclusão de ações em uma página da web usando o parâmetro slowMo, que traz a velocidade de conclusão dessas ações mais próxima dos valores reais de um humano.

• Suporta nativamente o trabalho com Shadow DOM.

Vantagens

• Código aberto.

• Fácil de instalar e configurar.

• Suporta todos os mecanismos de navegador necessários.

• Suporta todos os três principais sistemas operacionais (macOS, Windows, Linux).

• Suporta todas as linguagens de programação necessárias (Python, Golang, Java, JS, C#).

• Suporta executores de teste (Mocha, Jest, Jasmine).

• Integração com ferramentas CI/CD (Jenkins, CircleCI, Azure Pipeline, TravisCI).

• Atrasos automáticos, então você não precisa codificar atrasos explícitos manuais.

• A função de espera automática.

• Execução paralela quando você precisa abrir várias guias ao mesmo tempo.

• Um Reporter confortável.

Desvantagens

• Um produto relativamente novo.

• Uma comunidade relativamente limitada.

• Sem suporte a Ruby.

API: Configurando o Ambiente

1. Instale Visual Studio Code para começar. Escolha seu sistema operacional e seu tipo (32 ou 64 bits).

2. Instale Node.js. Pressione Enter duas vezes durante a instalação para baixar pacotes adicionais na janela do PowerShell.

3. Crie uma nova pasta de trabalho em um local conveniente. Abra o VS Code e pressione Ctrl + K + O, em seguida, selecione a pasta que você acabou de criar.

4. Instale a extensão NPM. Ela permite que você instale pacotes para Node.js e ASP.NET Core e os controle. Para fazer isso, pressione Ctrl + P e, na janela de pesquisa, digite ext install npm. Escolha a primeira extensão da lista que aparece.

Instalando a extensão NPM no Visual Studio Code

1. Instale a extensão Code runner. Para fazer isso, pressione Ctrl + P e, na janela de pesquisa, digite ext install code runner. Instale a primeira extensão da lista.

2. Abra o terminal do VS Code e gere package.json usando o comando npm init -y. Você verá o arquivo package.json no explorador e uma mensagem correspondente no terminal.

Gere package.json com preenchimento automático dos campos padrão

Inicializando um novo repositório no Visual Studio Code

1. Instale as bibliotecas usando o comando npm i axios puppeteer playwright no terminal do VS Code. Você deverá ver uma nova subpasta, node-modules, e um novo arquivo package-lock.json.

Trechos úteis para multi-conta no Octo Browser

Você pode usar trechos prontos da Base de Conhecimento da API do Octo Browser, por exemplo, um script pronto para obter os nomes de todos os perfis em sua conta.

//conectando módulos

const fs = require('fs').promises;

const axios = require('axios');

//aqui está a configuração. Cole seu token da API do Octo aqui

const config = {

octo_token: "OCTO_API_TOKEN",

octo_api_base_url: "https://app.octobrowser.net/api/v2/automation/",

}

const OCTO_REMOTE_API = axios.create({

baseURL: config.octo_api_base_url,

timeout: 10000,

headers: {

'X-Octo-Api-Token': config.octo_token,

'Content-Type': "application/json"

}

});

//funções

async function sleep(ms) {

return new Promise(resolve => setTimeout(resolve, ms * 1000));

}

async function check_limits(response) {

let rpm = response.headers['x-ratelimit-remaining'];

let rph = response.headers['x-ratelimit-remaining-hour'];

if (rpm < 10) {

console.log("Aguardando um minuto...");

await sleep(60);

}

if (rph < 10) {

console.log("Aguardando uma hora...");

await sleep(3600);

}

}

async function get_total_pages() {

const response = await OCTO_REMOTE_API.get('/profiles?page=0&page_len=10');

const total_profiles = response.data.total_count;

const total_pages = Math.ceil(response.data.total_count / 100);

console.log(`Total de Perfis: ${total_profiles}\nTotal de Páginas: ${total_pages}`);

await check_limits(response);

return total_pages;

}

async function get_all_profiles_titles(total_pages) {

let profiles = [];

for (let i = 0; i < total_pages; i++) {

let response = await OCTO_REMOTE_API.get(`/profiles?page=${i}&page_len=100&fields=title`);

await check_limits(response);

profiles.push(...response.data.data);

}

return profiles;

}

async function write_file(profiles) {

const titles = profiles.map(item => item.title).filter(Boolean);

try {

await fs.writeFile('./profiles_titles.txt', titles.join('\n'), 'utf-8');

} catch (error) {

console.error(`ERROR: Ao tentar escrever o arquivo ocorreu algum erro:\n${error}`);

}

}

//processo principal

(async () => {

const total_pages = await get_total_pages();

const profiles = await get_all_profiles_titles(total_pages);

await write_file(profiles);

console.log('Finalizado. Verifique o arquivo profiles_titles.txt...');

})()

Criando e executando o script

Crie um arquivo .js. Clicando com o botão direito do mouse no Explorer, você verá os arquivos criados. Vá para a documentação da API e selecione Node.js — Axios (geralmente cURL é a opção padrão). Você pode executar o script criado rodando o comando node script_name.js‎ no terminal do VS Code.

Devo usar automação para minha equipe?

Nossas pesquisas mostram consistentemente que cada vez mais equipes estão aderindo à automação, pois isso reduz significativamente o tempo de trabalho e possibilita processos independentes e assíncronos dentro dos perfis. Mesmo pequenas otimizações em fluxos de trabalho rotineiros resultarão em resultados notáveis e acelerarão significativamente seu trabalho no Octo Browser. Diga adeus à configuração manual de proxies, adição de páginas iniciais ou instalação de extensões para cada perfil! Você pode usar trechos prontos de nossa Base de Conhecimento ou modificá-los para suas necessidades precisas para alcançar novos níveis de multi-conta.

Perguntas Frequentes

Estou preocupado que o script possa roubar minhas contas, tokens ou senhas.

O código que oferecemos é tanto aberto quanto totalmente transparente. Você pode ver por si mesmo que nenhuma solicitação a recursos de terceiros é feita, o script apenas usa bibliotecas oficiais e é executado em sua máquina local.

Posso modificar o script para atender melhor minhas necessidades?

Absolutamente! Afinal, isso é código aberto. Ficaríamos felizes se você usasse nossos scripts como a base ajustável para suas tarefas.

As solicitações da API Local consomem o limite de solicitações disponível?

Entre todas as solicitações disponíveis na coluna da API Local, apenas as solicitações de Iniciar Perfil contam para o seu limite. Listar Perfis Ativos, Parar Perfil, Forçar Parada de Perfil, Login, Logout, Obter Versão do Cliente, Atualizar Cliente não contam para o seu limite.