RPA com Python: guia prático, do primeiro robô ao painel de resultados

O que é RPA com Python e quando vale a pena

RPA com Python é construir robôs de automação de processos escrevendo código em Python, em vez de montar fluxos numa ferramenta de RPA como UiPath ou Power Automate. O robô faz o mesmo trabalho: entra nos sistemas, preenche formulários, baixa relatórios, lê planilhas e PDFs e lança dados no ERP. A diferença é que cada passo é uma linha de código, usando bibliotecas gratuitas.

O Python virou a linguagem de automação por ser simples de ler e ter biblioteca para quase tudo. É também uma das linguagens mais usadas do mundo: na pesquisa da Stack Overflow de 2025, 57,9% dos desenvolvedores disseram ter usado Python, alta de 7 pontos percentuais sobre 2024, e ele lidera o índice TIOBE de outubro de 2026, com 19,23%. Na prática, isso significa mais gente que sabe manter o robô e mais respostas prontas quando algo dá errado.

Vale a pena quando a equipe já programa, quando os robôs precisam de lógica que não cabe bem num fluxo visual (validações, cálculos, chamadas de API, IA) ou quando o custo de licença por robô pesa. Se você ainda está entendendo o que é RPA e que processos automatizar, comece pelo guia de RPA na automação de processos.

Python ou ferramenta de RPA (UiPath, Power Automate)?

Não existe resposta única: depende de quem vai construir e manter os robôs. A tabela resume as diferenças que mais pesam na escolha:

As duas coisas também se misturam. A UiPath tem um pacote oficial de atividades Python (Python Scope, Run Python Script, Invoke Python Method), compatível com versões até o Python 3.13. Já o Power Automate para desktop tem a ação "Executar script Python", mas ela só oferece o Python 2.7 ou o 3.4 (o padrão é o 2.7), versões que não recebem mais atualizações. Por isso, quando o fluxo do Power Automate precisa de Python moderno, o melhor caminho é chamar um script externo, com o Python instalado na máquina.

Bibliotecas Python para RPA

Cada biblioteca resolve um tipo de tarefa. Um robô real costuma combinar duas ou três: uma para operar o sistema e outras para tratar os dados.

Para sistemas web, prefira o Playwright. Segundo a documentação, ele espera automaticamente que o elemento esteja visível, estável e habilitado antes de clicar ou digitar, o que elimina a maior parte dos sleep espalhados pelo código e dos erros intermitentes. O Selenium continua uma boa escolha e controla o navegador como um usuário faria, na máquina local ou numa máquina remota.

O PyAutoGUI é o mais fácil de começar e o mais frágil em produção: qualquer mudança de resolução, janela fora do lugar ou pop-up inesperado faz o clique cair no lugar errado. Ele tem uma trava de segurança útil enquanto você desenvolve: segundo a documentação, levar o mouse a um dos cantos da tela interrompe o robô com uma exceção. A BotCity publica seu framework de automação como código aberto (licença Apache 2.0) e oferece um orquestrador para agendar e acompanhar os robôs.

Como criar um robô RPA com Python, passo a passo

O exemplo abaixo resolve uma tarefa comum: entrar num portal, exportar o relatório do dia, filtrar os itens pendentes e gerar uma planilha para o time. Troque o endereço e os nomes dos campos pelos do seu sistema.

1. Crie um ambiente isolado para o robô e instale as bibliotecas:

python -m venv .venv
.venv\Scripts\activate          # no Linux: source .venv/bin/activate
pip install playwright pandas openpyxl
playwright install chromium

2. Guarde usuário e senha fora do código, em variáveis de ambiente ou num cofre de senhas. Nunca no arquivo do robô, que vai para o Git.
3. Escreva o robô em funções pequenas, uma para cada etapa:

import os
from pathlib import Path

import pandas as pd
from playwright.sync_api import sync_playwright

PASTA = Path("relatorios")
PASTA.mkdir(exist_ok=True)


def baixar_relatorio() -> Path:
    with sync_playwright() as p:
        navegador = p.chromium.launch(headless=True)
        pagina = navegador.new_page()
        pagina.goto("https://portal.suaempresa.com.br/login")
        pagina.get_by_label("Usuário").fill(os.environ["PORTAL_USUARIO"])
        pagina.get_by_label("Senha").fill(os.environ["PORTAL_SENHA"])
        pagina.get_by_role("button", name="Entrar").click()
        pagina.get_by_role("link", name="Relatórios").click()
        with pagina.expect_download() as espera:
            pagina.get_by_role("button", name="Exportar CSV").click()
        arquivo = PASTA / espera.value.suggested_filename
        espera.value.save_as(arquivo)
        navegador.close()
    return arquivo


def gerar_planilha(arquivo: Path) -> int:
    dados = pd.read_csv(arquivo, sep=";", decimal=",")
    pendentes = dados[dados["status"] == "PENDENTE"]
    pendentes.to_excel(arquivo.with_suffix(".xlsx"), index=False)
    return len(pendentes)


if __name__ == "__main__":
    print(gerar_planilha(baixar_relatorio()), "itens pendentes")

4. Rode com o navegador visível (headless=False) enquanto desenvolve, para ver cada passo. Em produção, volte para headless=True.
5. Teste com os casos ruins: senha errada, relatório vazio, portal fora do ar. É aqui que a próxima seção entra.

Repare que o robô procura os elementos pelo que a pessoa vê na tela ("Usuário", "Entrar", "Exportar CSV"), e não por posições ou caminhos longos no HTML. Isso deixa o robô bem mais resistente às mudanças de layout do portal.

Tratamento de erros, logs e novas tentativas

Um robô que só funciona no caminho feliz vai parar na primeira instabilidade do portal. Em produção, todo robô precisa de quatro coisas:

• Novas tentativas para falhas passageiras, como uma página que demorou ou uma conexão que caiu;
• Log em arquivo, com data e hora de cada etapa e o erro completo;
• Captura da tela no erro, para ver o que o robô estava vendo quando falhou;
• Controle dos itens já processados, para que uma nova tentativa não lance a mesma nota duas vezes.

Uma função simples resolve as tentativas e o log:

import logging
import time

logging.basicConfig(
    filename="robo.log",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
)
log = logging.getLogger("robo_relatorio")


def com_tentativas(etapa, tentativas=3, espera=60):
    for n in range(1, tentativas + 1):
        try:
            return etapa()
        except Exception:
            log.exception("Tentativa %d de %d falhou", n, tentativas)
            if n == tentativas:
                raise
            time.sleep(espera)

Para a captura de tela, envolva os passos do navegador num try e chame pagina.screenshot(path="erros/erro.png", full_page=True) no except, antes de relançar a exceção. Para os itens processados, guarde a chave de cada um (número da nota, do pedido) numa tabela ou planilha, e confira antes de lançar.

Como agendar e orquestrar robôs em Python

Um robô só economiza tempo quando roda sozinho. Existem três caminhos, do mais simples ao mais completo:

1. Agendador de Tarefas do Windows. Cria uma tarefa que chama o Python do ambiente do robô, por exemplo de segunda a sexta às 7h:

   schtasks /create /tn "Robo Relatorio" /sc weekly /d MON,TUE,WED,THU,FRI /st 07:00 ^
     /tr "C:\robos\relatorio\.venv\Scripts\python.exe C:\robos\relatorio\robo.py"

   Robôs que usam a tela (PyAutoGUI, pywinauto) precisam de uma sessão do Windows aberta, então configure a tarefa para rodar com o usuário conectado.
2. cron, no Linux. Bom para robôs web sem tela (headless). A linha abaixo, no crontab -e, roda o robô de segunda a sexta às 7h:

   0 7 * * 1-5 /opt/robos/relatorio/.venv/bin/python /opt/robos/relatorio/robo.py

3. Orquestrador. Quando os robôs passam de alguns poucos, vale um orquestrador para agendar, distribuir as execuções entre as máquinas, guardar credenciais e reexecutar o que falhou. Para Python, há opções como o orquestrador da BotCity e o Control Room da Robocorp.

Como monitorar os robôs e mostrar o resultado

Agendado, o robô some de vista. É aí que mora o risco: um robô que parou na sexta à noite só é notado na segunda, quando o trabalho já acumulou. E, mesmo funcionando, ele não conta para ninguém quanto tempo está economizando. Quem mantém robôs em Python costuma descobrir as falhas pelo usuário reclamando e calcular a economia numa planilha, uma vez por ano.

A Colmeia RPA resolve as duas coisas com duas linhas no robô. O SDK em Python avisa o painel quando o robô começa e quando termina, com sucesso ou com o erro:

from painel_robos import execucao

with execucao("rpa_relatorio_pendentes") as ex:
    arquivo = com_tentativas(baixar_relatorio)
    ex.quantidade = gerar_planilha(arquivo)

Se o bloco terminar normalmente, o robô aparece com sucesso; se der exceção, aparece com o erro e a mensagem, na hora. O SDK nunca derruba nem trava o robô: se o painel estiver fora do ar, o robô segue normalmente. Cada robô vira um personagem num escritório virtual ao vivo, e o painel soma as horas e os reais economizados por robô, por setor e no total, pronto para a TV da área ou para a reunião com a diretoria.

Painel de resultados ao vivo

• R$ 108.381economizados
• 2.382 hde trabalho manual economizadas
• 15.795execuções com sucesso
• 75%de sucesso

Antes de ter os números reais, estime o retorno na calculadora de ROI de RPA, com o tempo manual, o volume e o custo da hora de cada processo.

Fontes

1. Stack Overflow. 2025 Developer Survey: Technology. 2025.
2. TIOBE. TIOBE Index, outubro de 2026.
3. Microsoft. Scripting actions reference (Power Automate for desktop). Microsoft Learn, atualizado em 28 out. 2026.
4. Microsoft. Power Automate disponível no Windows sem custo adicional. Microsoft Learn.
5. UiPath. Python Activities. UiPath Docs, 2026.
6. Playwright. Auto-waiting e Installation. Documentação do Playwright para Python.
7. Selenium. WebDriver. Documentação do Selenium.
8. PyAutoGUI. PyAutoGUI documentation (Fail-Safes).
9. BotCity. BotCity Framework - Python (GitHub, licença Apache 2.0) e site da BotCity.