Automatización en Octo Browser: reduciendo drásticamente los costes de tiempo

¿Te gustaría probar Octo Browser con descuento?
Usa el código promocional OCTOBLOG para obtener un 30% de descuento en cualquier suscripción. Esta oferta es válida solo para nuevos usuarios.

¿Dónde se necesita más la automatización de navegadores?

Realizar acciones repetitivas manualmente consume un tiempo que podría dedicarse a tareas más importantes. Además de ahorrar tiempo y concentración, la automatización también ayuda a prevenir errores. Repetir la misma acción cientos de veces hace que los errores sean casi inevitables, por ejemplo, configurar etiquetas incorrectas o lanzar perfiles sin asignar los proxies adecuados. A diferencia de los humanos, los algoritmos no cometen este tipo de errores. Con un script bien probado, puedes tener la seguridad de que todo se ejecuta correctamente.

Además de resolver tareas generales, la automatización es especialmente útil en las siguientes áreas:

• Marketing de afiliados: Automatiza la creación masiva de perfiles y su configuración, incluyendo cookies, proxies, extensiones y páginas de inicio.

• Cultivo de cuentas: Crea rápidamente cuentas en las ubicaciones geográficas necesarias y prepáralas automáticamente. Exporta todos los perfiles de la lista de exportación.

• Web scraping: Ajusta la frecuencia de solicitudes por IP a niveles seguros, rota proxies y modifica las huellas digitales en caso de bloqueos.

• E-commerce: Desarrolla scripts para automatizar tareas laboriosas y analizar de forma segura los datos de la competencia.

• Apuestas y caza de bonos: Simplifica la creación de perfiles con las geolocalizaciones y parámetros de huella digital requeridos. Automatiza acciones masivas en múltiples cuentas para eludir los límites de apuestas.

Primeros pasos con la API

Hemos analizado las llamadas a la API de nuestros usuarios y hemos notado que muchos equipos están implementando activamente scripts para gestionar perfiles, cambiando así los enfoques comunes del multicuentas. Muchos líderes de importantes equipos de marketing de afiliados destacan la comodidad de nuestra API como una de las ventajas clave de Octo frente a la competencia.

Nuestra API actual te permite crear perfiles con las huellas digitales que necesites, añadir proxies, asignar etiquetas, así como iniciar y detener escenarios automáticos utilizando cualquier framework de automatización de navegadores. También puedes trabajar con tus perfiles en un modo híbrido, aprovechando al máximo la combinación de los beneficios de la automatización con el ajuste fino que permite el control manual tradicional de tus cuentas.

Puedes encontrar tu token de API en la Configuración adicional de tu Cuenta Maestra de Octo Browser

Tu token de API

Octo Browser te brinda acceso a tu token de API a partir de la Suscripción Base en adelante. Los límites de tus llamadas a la API se determinan según tu suscripción. Si tienes una Suscripción Advanced, puedes aumentar aún más tus límites de API a 1,000 solicitudes por minuto (RPM) y 50,000 solicitudes por hora (RPH). Para límites aún mayores, ponte en contacto con el Servicio de Atención al Cliente.

Elegir el lenguaje de programación

El tema de la selección del lenguaje de programación es demasiado amplio para cubrir aquí todas las combinaciones posibles de lenguajes y librerías. En nuestro ejemplo utilizaremos Node.js + Axios, ya que tenemos experiencia con este entorno de trabajo. Otros lenguajes, como C o C#, pueden ser más rápidos, pero cada uno tiene sus propias características, sutilezas y casos de uso. Puedes elegir cualquier lenguaje basándote en tu experiencia.

Uso de IA para reescribir código

A nosotros mismos nos encanta la automatización y siempre nos esforzamos por optimizar nuestro trabajo, por lo que utilizamos la IA para reescribir el código al lenguaje necesario. Es bastante sencillo: puedes pedirle a ChatGPT que convierta el código por ti con la siguiente instrucción: Convierte este script en Node.js con Axios a Python con la librería Requests.

//modules
const axios = require('axios');
//here is config. Paste your Octo API Token here and you can modify this for your personal needs
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"
    }
});
//functions
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("Waiting a minute...");
        await sleep(60);
    }
    if (rph < 10) {
        console.log("Waiting an hour...");
        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 Profiles: ${total_profiles}\nTotal Pages: ${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(`Successfully updated ${profile.uuid}`);
        } catch (error) {
            not_updated.push(profile);
            console.error(`ERROR: Can't patch profile ${profile.uuid}`);
        }
    }
    return [updated, not_updated];
}
//main process
(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(`Finished process:\nUpdated: ${updated.length}\nNot updated: ${not_updated.length}`);
})();

//modules
const axios = require('axios');
//here is config. Paste your Octo API Token here and you can modify this for your personal needs
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"
    }
});
//functions
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("Waiting a minute...");
        await sleep(60);
    }
    if (rph < 10) {
        console.log("Waiting an hour...");
        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 Profiles: ${total_profiles}\nTotal Pages: ${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(`Successfully updated ${profile.uuid}`);
        } catch (error) {
            not_updated.push(profile);
            console.error(`ERROR: Can't patch profile ${profile.uuid}`);
        }
    }
    return [updated, not_updated];
}
//main process
(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(`Finished process:\nUpdated: ${updated.length}\nNot updated: ${not_updated.length}`);
})();

Pasémosle los fragmentos de código a ChatGPT

Claro, aquí tienes el script equivalente en Python utilizando la librería Requests:

import requests
import math
import time
# Config
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"]
    }
}
# Session setup
session = requests.Session()
session.headers.update({
    "X-Octo-Api-Token": config["octo_token"],
    "Content-Type": "application/json"
})
session.timeout = 10
# Helper functions
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("Waiting a minute...")
        sleep(60)
    if rph < 10:
        print("Waiting an hour...")
        sleep(3600)
# API functions
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 Profiles: {total_profiles}\nTotal Pages: {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"Successfully updated {profile['uuid']}")
        except Exception as e:
            not_updated.append(profile)
            print(f"ERROR: Can't patch profile {profile['uuid']} - {str(e)}")
    
    return updated, not_updated
# Main process
if __name__ == "__main__":
    try:
        total = get_total_profiles()
        profiles = get_all_profiles_uuids(total)
        updated, not_updated = patch_all_profiles(profiles)
        print(f"Finished process:\nUpdated: {len(updated)}\nNot updated: {len(not_updated)}")
    except Exception as e:
        print(f"Fatal error: {str(e)}")

import requests
import math
import time
# Config
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"]
    }
}
# Session setup
session = requests.Session()
session.headers.update({
    "X-Octo-Api-Token": config["octo_token"],
    "Content-Type": "application/json"
})
session.timeout = 10
# Helper functions
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("Waiting a minute...")
        sleep(60)
    if rph < 10:
        print("Waiting an hour...")
        sleep(3600)
# API functions
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 Profiles: {total_profiles}\nTotal Pages: {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"Successfully updated {profile['uuid']}")
        except Exception as e:
            not_updated.append(profile)
            print(f"ERROR: Can't patch profile {profile['uuid']} - {str(e)}")
    
    return updated, not_updated
# Main process
if __name__ == "__main__":
    try:
        total = get_total_profiles()
        profiles = get_all_profiles_uuids(total)
        updated, not_updated = patch_all_profiles(profiles)
        print(f"Finished process:\nUpdated: {len(updated)}\nNot updated: {len(not_updated)}")
    except Exception as e:
        print(f"Fatal error: {str(e)}")

Ten en cuenta que es necesario instalar la librería "requests" en tu entorno de Python para que este script funcione. Puedes instalarla usando pip:

pip install requests

pip install requests

Además, reemplaza "OCTO_API_TOKEN" con tu token real para realizar llamadas a la API.

Uso de ChatGPT para convertir scripts

Trabajar con las librerías Puppeteer, Selenium y Playwright

Los frameworks de automatización de navegadores generalmente están diseñados para funcionar bien con Google Chrome, que se basa en Chromium. Como Octo Browser también está construido sobre el motor de Chromium, interactúa con estos frameworks de manera fluida.

Automatización con Selenium

Selenium es una herramienta popular para automatizar acciones en el navegador, ya que permite modelar el comportamiento del usuario en un sitio web.

Características clave

• Automatización de tareas web.

• Funciona con sitios web dinámicos que utilizan JavaScript y AJAX.

Ventajas

• Flexibilidad y compatibilidad con muchos lenguajes de programación.

• Uso gratuito con una comunidad grande y activa.

• Código abierto.

Desventajas

• Lento y consume muchos recursos.

• Se requiere una buena comprensión de conceptos de programación.

La automatización de navegadores con Selenium te permite optimizar diferentes tareas de perfiles, desde simples scripts de automatización hasta rastreadores web (crawlers) que buscan, recopilan e interactúan con datos de diferentes recursos en línea.

Selenium es bien conocido por quienes tienen experiencia gestionando varias cuentas a la vez. Se puede implementar directamente en el navegador y puede utilizarse para imitar las acciones de un humano real. Sin embargo, Selenium no siempre es la solución perfecta, y su enmascaramiento puede ser detectado por varias plataformas, entre ellas CloudFlare.

CloudFlare es un proveedor de servicios de seguridad web que ofrece servicios de redes de entrega de contenido seguras, protección contra ataques DDoS y servidores DNS. Los sitios web utilizan las soluciones de CloudFare para detectar consultas iniciadas por Selenium.

Automatización con Puppeteer

Puppeteer es una librería de Node.js que te permite automatizar el trabajo con navegadores basados en Chromium utilizando el protocolo DevTools.

Características

• Herramienta potente y flexible para la automatización de acciones web.

• Puede interactuar con páginas web como un navegador normal.

• Existe una adaptación no oficial para Python conocida como Pyppeteer, y hemos creado una guía sobre cómo conectarla.

Ventajas

• Una excelente opción para trabajar con sitios web dinámicos y ejecutar código JavaScript.

• Una API fácil e intuitiva de usar y configurar.

• Una herramienta gratuita con una comunidad activa.

Desventajas

• Solo es compatible con JavaScript (Node.js), pero existen adaptaciones no oficiales para otros lenguajes. Por ejemplo, una adaptación para Python llamada Pyppeteer.

• Consume muchos recursos y es más lenta que otras librerías.

Automatización con Playwright

Playwright es una librería de Node.js que facilita una automatización segura, rápida y eficaz para Chromium, Firefox y WebKit utilizando la misma API.

Características

• Dispone de una herramienta de generación de código, CodeGen. Puedes utilizarla para evitar escribir grandes cantidades de código repetitivo, lo que ahorra mucho tiempo.

• Puedes ralentizar la velocidad de ejecución de las acciones en una página web utilizando el parámetro slowMo, lo que acerca la velocidad de estas acciones a los valores humanos reales.

• Soporte nativo para trabajar con Shadow DOM.

Ventajas

• Código abierto.

• Fácil de instalar y configurar.

• Soporta todos los motores de navegación necesarios.

• Soporta los tres sistemas operativos principales (macOS, Windows, Linux).

• Soporta todos los lenguajes de programación necesarios (Python, Golang, Java, JS, C#).

• Soporta ejecutores de pruebas (test runners como Mocha, Jest, Jasmine).

• Integración con herramientas CI/CD (Jenkins, CircleCI, Azure Pipeline, TravisCI).

• Retrasos automáticos, evitando que tengas que codificar retrasos explícitos.

• Función de espera automática (auto-wait).

• Ejecución paralela cuando necesitas abrir múltiples pestañas simultáneamente.

• Un Reporter muy cómodo.

Desventajas

• Un producto relativamente nuevo.

• Una comunidad relativamente limitada.

• No tiene soporte para Ruby.

API: Configuración del entorno

1. Instala Visual Studio Code para comenzar. Elige tu sistema operativo y su tipo (32 o 64 bits).

2. Instala Node.js. Pulsa Enter dos veces durante la instalación para descargar paquetes adicionales en la ventana de PowerShell.

3. Crea una nueva carpeta de trabajo en una ubicación conveniente. Abre VS Code y presiona Ctrl + K + O, luego selecciona la carpeta que acabas de crear.

4. Instala la extensión NPM. Te permite instalar paquetes para Node.js y ASP.NET Core y controlarlos. Para hacerlo, presiona Ctrl + P y, en la barra de búsqueda, escribe ext install npm. Selecciona la primera extensión que aparezca en la lista.

Instalación de la extensión NPM en Visual Studio Code

1. Instala la extensión Code runner. Para hacerlo, presiona Ctrl + P e introduce ext install code runner en la ventana de búsqueda. Instala la primera extensión de la lista.

2. Abre la terminal de VS Code y genera package.json usando el comando npm init -y. Verás el archivo package.json en el explorador y el mensaje correspondiente en la terminal.

Generar package.json con autocompletado de campos estándar

Inicialización de un nuevo repositorio en Visual Studio Code

1. Instala las librerías utilizando el comando npm i axios puppeteer playwright en la terminal de VS Code. Deberías ver una nueva subcarpeta llamada node-modules y un nuevo archivo package-lock.json.

Fragmentos de código útiles para el uso de multicuentas en Octo Browser

Puedes utilizar fragmentos de código listos para usar de la Base de conocimientos de la API de Octo Browser, por ejemplo, un script preparado para obtener los nombres de todos los perfiles en tu cuenta.

//connecting modules
const fs = require('fs').promises;
const axios = require('axios');
//here is config. Paste your Octo API Token here
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"
    }
});
//functions
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("Waiting a minute...");
        await sleep(60);
    }
    if (rph < 10) {
        console.log("Waiting an hour...");
        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 Profiles: ${total_profiles}\nTotal Pages: ${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: While trying writing the file some error occured:\n${error}`);
    }
}
//main process
(async () => {
    const total_pages = await get_total_pages();
    const profiles = await get_all_profiles_titles(total_pages);
    await write_file(profiles);
    console.log('Finished. Check profiles_titles.txt file...');
})()

//connecting modules
const fs = require('fs').promises;
const axios = require('axios');
//here is config. Paste your Octo API Token here
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"
    }
});
//functions
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("Waiting a minute...");
        await sleep(60);
    }
    if (rph < 10) {
        console.log("Waiting an hour...");
        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 Profiles: ${total_profiles}\nTotal Pages: ${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: While trying writing the file some error occured:\n${error}`);
    }
}
//main process
(async () => {
    const total_pages = await get_total_pages();
    const profiles = await get_all_profiles_titles(total_pages);
    await write_file(profiles);
    console.log('Finished. Check profiles_titles.txt file...');
})()

Crear y ejecutar el script

Crea un archivo .js. Al hacer clic derecho en el Explorador se mostrarán los archivos creados. Ve a la documentación de la API y selecciona Node.js — Axios (usualmente cURL es la opción por defecto). Puedes lanzar el script de automatización ejecutando el comando node nombre_del_script.js en la terminal de VS Code.

¿Debería utilizar la automatización para mi equipo?

Nuestras encuestas muestran constantemente que cada vez más equipos recurren a la automatización, ya que reduce significativamente el tiempo de trabajo y permite procesos independientes y asíncronos dentro de los perfiles. Incluso las optimizaciones menores en los flujos de trabajo rutinarios darán resultados notables y acelerarán significativamente tu trabajo en Octo Browser. ¡Dile adiós a configurar proxies manualmente, añadir páginas de inicio o instalar extensiones para cada perfil! Puedes usar fragmentos de código listos para usar de nuestra Base de Conocimientos o modificarlos para tus necesidades específicas, alcanzando nuevos niveles en tus sistemas de multicuentas.

Preguntas frecuentes

Me preocupa que el script pueda robar mis cuentas, tokens o contraseñas.

El código que ofrecemos es abierto y totalmente transparente. Puedes comprobar por ti mismo que no se realizan solicitudes a recursos de terceros, el script solo utiliza librerías oficiales y se ejecuta de forma local en tu ordenador.

¿Puedo modificar el script para adaptarlo mejor a mis necesidades?

¡Por supuesto! Al fin y al cabo, es código abierto. Estaremos encantados de que utilices nuestros scripts como estructura básica adaptable para tus tareas.

¿Las solicitudes a la API local consumen el límite disponible de solicitudes?

De todas las solicitudes disponibles en la columna de la API local, solo las solicitudes Start Profile (Iniciar Perfil) cuentan para tu límite. Las solicitudes List Active Profiles, Stop Profile, Force Stop Profile, Login, Logout, Get Client Version y Update Client no cuentan para dicho límite.