Precisa executar o mesmo script da API do Multilogin em vários servidores? Com Python e SSH, você pode controlar tudo a partir de um único computador, sem precisar se conectar a cada servidor e iniciar o script manualmente.

➡️ Gere um token de automação → configure o acesso SSH → adicione remote_api.py a cada servidor → execute auto.py no seu computador.

Este exemplo testa a conexão com a API do Multilogin buscando uma lista de telefones em nuvem. Quando tudo estiver funcionando, você pode substituir a solicitação de teste pelas suas próprias tarefas de automação.

Antes de começar

Você vai precisar de:

• Python 3 no seu computador e nos servidores remotos
• Acesso por chave SSH a cada servidor, com a chave do host verificada
• Um token de automação do Multilogin válido
• Acesso à internet em cada servidor para se conectar à API do Multilogin

SSH e Multilogin usam credenciais diferentes. A chave SSH conecta você ao servidor, enquanto o token de automação permite que o script envie solicitações para a API do Multilogin.

Passo 1: prepare os servidores

Primeiro, confirme que você consegue se conectar a cada servidor via SSH.

Abra o terminal no seu computador e execute:

ssh username@server-ip

Substitua username e server-ip pelos seus dados.

Se for a primeira conexão, confirme a impressão digital SSH do servidor com o administrador antes de confiar nela.

Depois, instale as bibliotecas Python necessárias.

No seu computador:

python3 -m pip install paramiko

Em cada servidor remoto:

python3 -m pip install requests

Se você usa um ambiente virtual Python, instale as bibliotecas nele e use o mesmo ambiente para executar os scripts.

Passo 2: crie o script da API do Multilogin

Vamos começar com um teste simples. O script vai solicitar à API do Multilogin a lista de telefones em nuvem para confirmar que cada servidor consegue se conectar.

Crie um arquivo chamado remote_api.py na pasta inicial de cada servidor remoto.

import sys
import requests

token = sys.stdin.readline().strip()

if not token:
    raise SystemExit("No automation token provided.")

url = "https://api.multilogin.com/mobile_profiles/phone/list"

headers = {
    "Authorization": f"Bearer {token}",
    "Accept": "application/json",
}

params = {
    "page": 1,
    "page_size": 10,
}

try:
    response = requests.get(
        url,
        headers=headers,
        params=params,
    )
    response.raise_for_status()

    result = response.json()
    status = result.get("status", {})

    if status.get("http_code") != 200:
        raise RuntimeError(
            status.get("message", "Unknown API error")
        )

    print("Connected to Multilogin API successfully.")

except (requests.RequestException, ValueError, RuntimeError) as error:
    print(f"API request failed: {error}")
    raise SystemExit(1)

O script recebe o token de automação quando é executado. Assim, você não precisa salvar seu e-mail, senha ou token do Multilogin no arquivo.

Este teste não altera seus perfis. Ele apenas solicita a primeira página da lista de telefones em nuvem.

Passo 3: crie o script de conexão com os servidores

Agora vamos conectar tudo.

Crie auto.py no seu computador. Esse script se conecta a cada servidor, envia o token de automação e executa remote_api.py.

import sys
import getpass
import paramiko

servers = [
    {"username": "username1", "host": "server1-ip", "port": 22},
    {"username": "username2", "host": "server2-ip", "port": 22},
]

token = getpass.getpass("Multilogin automation token: ")

if not token:
    raise SystemExit("No automation token provided.")

failed_servers = []

for server in servers:
    username = server["username"]
    host = server["host"]
    port = server.get("port", 22)

    print(f"\nConnecting to {username}@{host}")

    try:
        with paramiko.SSHClient() as ssh:
            ssh.load_system_host_keys()
            ssh.set_missing_host_key_policy(
                paramiko.RejectPolicy()
            )

            ssh.connect(
                hostname=host,
                port=port,
                username=username,
                look_for_keys=True,
                allow_agent=True,
                timeout=15,
            )

            stdin, stdout, stderr = ssh.exec_command(
                "python3 ~/remote_api.py"
            )

            stdin.write(token + "\n")
            stdin.flush()
            stdin.channel.shutdown_write()

            output = stdout.read().decode().strip()
            errors = stderr.read().decode().strip()
            exit_code = stdout.channel.recv_exit_status()

            if output:
                print(output)

            if errors:
                print(errors)

            if exit_code != 0:
                print(f"Script failed with exit code {exit_code}")
                failed_servers.append(host)

    except Exception as error:
        print(f"Connection failed: {error}")
        failed_servers.append(host)

if failed_servers:
    print("\nFailed servers: " + ", ".join(failed_servers))
    sys.exit(1)

Substitua os nomes de usuário, endereços dos servidores e portas de exemplo pelos seus próprios dados.

O script usa chaves SSH, então você não precisa salvar senhas dos servidores no código. Ele também verifica se cada servidor é confiável antes de se conectar.

Passo 4: execute os scripts

Tudo pronto? Agora é só testar a conexão.

1. Abra o terminal no seu computador
2. Vá até a pasta que contém auto.py
3. Execute:

python3 auto.py

4. Digite seu token de automação quando solicitado
5. Confira o resultado de cada servidor
6. Se a conexão funcionar, você verá:

Connected to Multilogin API successfully.

Se algo der errado, o script mostrará qual servidor falhou.

O token não aparece na tela enquanto você digita, e o script não o imprime nem salva.

Passo 5: adicione sua própria automação

Quando o teste estiver funcionando, você pode substituir a verificação de conexão pelas tarefas que realmente precisa executar.

Troque a solicitação de teste em remote_api.py pelas ações da API do Multilogin que quiser usar.

Por exemplo, você pode:

1. Obter uma lista de telefones em nuvem ou perfis de navegador
2. Verificar quais perfis estão em execução
3. Criar ou atualizar perfis
4. Iniciar ou parar perfis compatíveis

Por exemplo, se você gerencia contas em vários servidores, pode usar essa configuração para verificar o status dos perfis em todos eles sem precisar se conectar manualmente a cada servidor.

Você encontra os endpoints disponíveis, parâmetros obrigatórios e exemplos de resposta na documentação da API do Multilogin.

Solução de problemas

A conexão SSH falhou

Tente se conectar manualmente:

ssh username@server-ip

Se não funcionar, verifique sua chave SSH e confirme se você tem permissão para acessar o servidor.

Se aparecer um erro de chave de host desconhecida, confirme a impressão digital do servidor e adicione-a aos hosts SSH confiáveis antes de tentar novamente.

O Python não encontra uma biblioteca

Confirme se você instalou a biblioteca correta no lugar certo:

Seu computador: paramiko

Servidores remotos: requests

Se você usa um ambiente virtual, confirme que está executando o script com o interpretador Python correto.

A API do Multilogin retorna um erro

Primeiro, confira a mensagem de erro. Estas são algumas respostas comuns:

401 – Unauthorized: o token de automação pode estar ausente, incorreto ou expirado

403 – Forbidden: seu espaço de trabalho ou sua função pode não ter permissão para essa solicitação

429 – Too Many Requests: seu espaço de trabalho atingiu o limite de requisições da API

Para mais ajuda, consulte limites de requisições e códigos de resposta da API do Multilogin.

O Python não consegue verificar o certificado da API

Se você usa um proxy corporativo ou uma configuração de rede personalizada, o Python pode não reconhecer o certificado usado na conexão.

Peça ao administrador o pacote de autoridade certificadora (CA) aprovado e configure o Requests para usá-lo.

Não desative a verificação do certificado. Ela ajuda a proteger sua conexão.

Mantenha seu token de automação privado

Execute esses scripts apenas em servidores confiáveis.

O token de automação é enviado por uma conexão SSH criptografada, mas o script remoto consegue acessá-lo durante a execução. Se alguém tiver controle do servidor, poderá capturar o token e usar as permissões do seu espaço de trabalho.