Freela de 250 Dólares com Python – Automação de Whatsapp

Já imaginou fazer um freela de 250 dólares com Python? Nesta aula, vou te ensinar um projeto real que pode te garantir uma renda extra!

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Freela de 250 Dólares com Python – Automação de Whatsapp

Na aula de hoje, eu quero te apresentar mais um freela de Python! Vamos construir juntos mais um projeto real e que estão oferecendo dinheiro por ele. Um freela de 250 dólares com Python!

A ideia é desenvolver uma automação de WhatsApp com Python, capaz de encaminhar mensagens para vários contatos. Entretanto, é importante ressaltar que, para evitar o bloqueio da conta, um dos requisitos desse projeto é enviar as mensagens em grupos de 5 contatos de cada vez.

O WhatsApp não permite automações nesse formato, e caso seja detectada essa atividade automatizada, sua conta poderá ser bloqueada. Portanto, é essencial tomar cuidado durante a execução dessas automações, a fim de evitar possíveis problemas.

Para concluir com sucesso esse projeto, utilizaremos as bibliotecas Selenium, pyperclip e webdriver-manager.

Eu estarei utilizando o VS Code como editor para esse projeto, mas sinta-se à vontade para utilizar qualquer outro editor com o qual você esteja familiarizado. Não se esqueça também de fazer o download dos arquivos referentes a esta aula.

Para ajudar na compreensão, minhas explicações e demonstrações serão feitas em um arquivo .ipynb, que é o formato de notebook do Python, como o utilizado no Jupyter Notebook. No entanto, se preferir, você também pode criar o projeto em um arquivo .py.

Escrevendo as Informações do Projeto

O primeiro passo ao iniciarmos a construção de um projeto é compreender e estruturar o que desejamos desenvolver para que ele possa ser executado.

No caso deste projeto específico, nosso objetivo é criar uma automação de WhatsApp capaz de encaminhar mensagens para uma lista de contatos ou grupos. Para evitar o bloqueio da nossa conta pelo WhatsApp, faremos o encaminhamento em grupos de até 5 contatos por vez.

Uma técnica que utilizaremos para evitar que o WhatsApp reconheça a automação é a adição de pausas no código, de modo a simular o comportamento de uma pessoa e não executar todas as etapas rapidamente.

Instalação das Bibliotecas

Para começar, vamos instalar a biblioteca Selenium. Como nosso projeto envolve o WhatsApp Web, o Selenium é uma excelente ferramenta para automatizar processos que ocorrem pela internet.

Além disso, o Selenium consegue simular bem o comportamento de um usuário utilizando o WhatsApp.

Em seguida, instalaremos a biblioteca pyperclip, que nos permitirá copiar e colar informações de forma eficiente. Por fim, instalaremos o webdriver-manager.

Até a versão 115 do Chrome, o Selenium exigia que baixássemos e instalássemos manualmente um arquivo chamado ChromeDriver para a automação. No entanto, o webdriver-manager faz esse gerenciamento automaticamente para nós.

Observação: É recomendado executar essa automação no Chrome ou no Firefox.

Como estamos utilizando um arquivo .ipynb, podemos fazer a instalação diretamente na célula utilizando o comando:

!pip install selenium pyperclip webriver-manager

Caso contrário, deveríamos executar a instalação pelo terminal do nosso editor, digitando o mesmo código sem o ponto de exclamação.

Importação das Bibliotecas

Vamos começar nosso código importando as bibliotecas necessárias para criar nosso navegador utilizando o Selenium.

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

O webdriver é responsável por criar nosso navegador, enquanto o Service e o ChromeDriverManager são utilizados para gerenciar o ChromeDriver, instalando-o ou atualizando-o, e criar a conexão entre o Python e o navegador.

Criação do Service e do Navegador

Após importar as bibliotecas, vamos criar o service que será responsável por gerenciar o ChromeDriver. Ele irá instalar o ChromeDriver, caso ainda não esteja instalado.

service = Service(ChromeDriverManager().install())

Em seguida, podemos criar o nosso navegador(nav) utilizando o serviço criado:

service = Service(ChromeDriverManager().install())
nav = webdriver.Chrome(service=service)

Importante: Caso você esteja utilizando outro navegador que não seja o Chrome, será necessário fazer algumas adaptações.

Ao executar o código, o navegador será aberto e você poderá ver a mensagem informando que o Chrome está sendo controlado por um software de teste automatizado.

Agora, precisamos abrir o site do WhatsApp Web. Vamos informar ao navegador o link completo para o site:

nav.get("https://web.whatsapp.com")

No site do WhatsApp, será necessário ler o QR code como de costume, para estabelecer a conexão com o seu aplicativo. Após essa etapa, você poderá executar a automação pelo tempo que for necessário. No entanto, sempre que iniciar o código, será necessário ler o QR code novamente.

Observação: O código construído até o momento é responsável por criar o navegador e abrir o site do WhatsApp. Caso você esteja executando todo o código em um único bloco ou arquivo .py, é importante adicionar um time.sleep entre a criação do navegador e o início da automação.

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time

service = Service(ChromeDriverManager().install())
nav = webdriver.Chrome(service=service)

nav.get("https://web.whatsapp.com")
time.sleep(60)

Dessa forma, você terá tempo para realizar a leitura do QR code e o código simulará o tempo de interação de uma pessoa real usando o site, em vez de executar todas as etapas rapidamente.

Inspecionar para identificar os elementos da página

Agora vamos manter o navegador aberto e utilizar o Selenium para controlá-lo. Para fazer isso, precisamos acessar os elementos da página.

Clique com o botão direito do mouse no navegador e selecione a opção Inspecionar.

Na janela que se abrir, clique nos três pontinhos localizados no canto superior direito e selecione a opção Undock into separate window.

Dessa forma, teremos a janela do navegador separada da janela do código, o que facilitará a identificação dos elementos necessários para o nosso projeto.

Agora, você pode selecionar a opção Select an element in the page to inspect it (uma seta) na parte superior do painel de inspeção. Ao passar o mouse sobre um elemento na página do WhatsApp, ele será identificado no código-fonte da página.

Definindo as variáveis do código

Dentro do nosso código, precisamos definir algumas variáveis que serão utilizadas ao longo da automação: a mensagem que iremos enviar e a lista de contatos.

mensagem = """Fala galera!
Se inscreve no canal da Hahstag Programação, os caras são feras!
"""

lista_contatos = ["Meu Numero", "Lira Hashtag - Comercial", "Eu, eu mesmo", "Nós e eu", "Grupo bom", "ultimo grupo"]

Para servir de exemplo, criei uma lista com 6 contatos, incluindo números e grupos, para encaminhar a nossa mensagem. No seu caso, você poderá adicionar quantos contatos forem necessários.

Primeiro passo – Mensagem para o próprio número

O processo que seguiremos para essa automação é enviar a mensagem para o nosso próprio número e, a partir daí, encaminhar para os números que definimos em nossa lista de contatos.

Para enviar a mensagem para o nosso próprio número, precisamos, na página do WhatsApp Web, clicar na lupa, digitar o nosso número na busca e pressionar Enter.

Para localizar e clicar na lupa de forma automática, precisamos selecionar esse elemento em nosso navegador. Faremos isso utilizando o método nav.find_element(). Aqui, nav é o nome que demos ao nosso navegador, e find_element() é o método que utilizaremos.

Nesse método, precisamos indicar qual informação ele utilizará para encontrar esse elemento. Para o nosso projeto, estaremos utilizando principalmente o XPath, que é um código atribuído a cada elemento de um site.

No navegador, utilize a seta na janela de inspeção e clique na lupa do WhatsApp Web.

O elemento será marcado no código-fonte da página. Clique com o botão direito do mouse sobre o elemento e selecione a opção Copy e depois Copy XPath.

Cole esse valor de XPath no nosso código, da seguinte forma:

nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/button/div[2]/span').click()

Como queremos clicar na lupa, adicionamos .click() ao final do método.

Importante: Ao passar o XPath para o método find_element, é recomendado que você o faça dentro de aspas simples. Isso porque alguns códigos de XPath possuem aspas duplas dentro deles, o que pode causar conflitos no Python.

Com a lupa clicada, agora precisamos selecionar o campo de busca dentro do WhatsApp. Vamos seguir o mesmo procedimento anterior: selecionar a seta na janela de inspeção, clicar no campo de busca e copiar o XPath correspondente.

No nosso código Python, faremos o mesmo processo utilizando o método find_element, mas desta vez passaremos o XPath correspondente ao campo de busca. Em seguida, adicionaremos .send_keys() seguido pelo texto (nome/número) que você deseja enviar, entre parênteses.

nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys("Meu Numero")

Após fazer isso, utilizando o mesmo elemento, precisamos pressionar a tecla Enter. Para isso, no início do nosso código, importaremos a funcionalidade Keys do Selenium.

from selenium.webdriver.common.keys import Keys

Com Keys importado, podemos concluir o processo de busca do nosso número da seguinte forma:

nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)

Se executarmos o código até agora, ele realizará todo esse processo automaticamente: clicará na lupa, digitará o número e pressionará Enter.

Com a conversa aberta, você irá notar que o campo de envio de mensagens já está selecionado. Portanto, só precisamos escrever a nossa mensagem nesse campo. O processo será o mesmo: inspecionar o campo onde escrevemos a mensagem e copiar o XPath correspondente.

nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(mensagem)

Neste momento, você pode seguir de duas formas: usando apenas o código acima, o que funcionará normalmente, ou utilizando a biblioteca Pyperclip.

A vantagem de usar o Pyperclip é que ele permite o envio de mensagens que contenham emojis. Sem ele, o Chrome ignorará os emojis da mensagem, ou eles podem aparecer quebrados.

Para utilizar o Pyperclip, importe a biblioteca no início do código:

import pyperclip

Em seguida, adapte o envio da mensagem da seguinte forma:

pyperclip.copy(mensagem)

nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.CONTROL + "v")

nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.ENTER)

O Pyperclip funcionará como um CTRL + C, então passaremos para o campo de mensagem o CTRL + V seguido da tecla Enter.

Ao executarmos o código, verificaremos que a mensagem foi enviada com sucesso.

Mas aqui, entra aquele problema de o WhatsApp perceber a automação e poder bloquear o número. Como tudo está sendo feito muito rapidamente, é importante criarmos alguns intervalos de espera dentro do nosso código. Para fazer isso, importaremos a biblioteca time.

Deixando nosso código assim:

from selenium.webdriver.common.keys import Keys
import pyperclip
import time

mensagem = """Fala galera!
Se inscreve no canal da Hahstag Programação, os caras são feras!
"""

lista_contatos = ["Meu Numero", "Lira Hashtag - Comercial", "Eu, eu mesmo", "Nós e eu", "Grupo bom", "ultimo grupo"]

# enviar a mensagem para o Meu Numero para poder depois encaminhar:

# clicar na lupa
nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/button/div[2]/span').click()
nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys("Meu Numero")
nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
time.sleep(1)

# escrever a mensagem para nós mesmos
pyperclip.copy(mensagem)
nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.CONTROL + "v")
nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.ENTER)
time.sleep(2)

Encaminhar a mensagem para os contatos

Com nossa mensagem já enviada para o nosso número, o próximo passo será encaminhá-la para os outros contatos da nossa lista.

Para encaminhar a mensagem para os contatos, primeiro precisamos selecioná-la, clicando na seta no canto superior direito da mensagem e escolhendo a opção de encaminhar.

No entanto, essa seta só fica visível quando o cursor do mouse está posicionado sobre a mensagem. Para simular o movimento do mouse, precisamos importar outra funcionalidade do Selenium chamada ActionChains. Adicione a seguinte linha no início do seu código:

from selenium.webdriver.common.action_chains import ActionChains

As ActionChains são sequências de ações que nos permitem executar uma ação e, em seguida, executar outra ação. Isso nos permitirá posicionar o cursor do mouse sobre a mensagem para, em seguida, localizar a seta de encaminhamento. O comando que usaremos será o seguinte:

ActionChains(nav).move_to_element(elemento).perform()

Aqui, ActionChains(nav) indica que vamos executar uma sequência de ações no navegador e move_to_element(elemento) move o cursor do mouse para o elemento que queremos. Finalmente, usamos .perform() para executar esse comando.

Agora, antes de executar as ActionChains, precisamos definir qual será o elemento (a mensagem) a ser selecionado. Um detalhe importante nesse processo é que, para selecionar a mensagem, não vamos usar o XPath, mas sim a classe dela. Isso ocorre porque os XPath das mensagens do WhatsApp são dinâmicos e serão modificados dependendo da quantidade e posição das mensagens.

Para identificar a classe que iremos usar, utilize a ferramenta de inspeção no navegador e selecione a caixa da mensagem que você deseja enviar. No código-fonte da página, navegue pelas linhas para cima até encontrar a primeira linha relacionada ao elemento da caixa de mensagem.

Esse elemento é o mais externo possível que envolve a caixa da nossa mensagem. Navegando pelo código, é possível ver que podemos trabalhar diretamente com esse elemento ou com a linha abaixo dele, pois ambos nos permitirão selecionar todo o elemento da mensagem.

Vamos utilizar então a linha de baixo e copiar uma das duas classes que ela possui (lembre-se de que essas classes podem ser diferentes no momento em que você estiver realizando o projeto).

Com essa informação em mãos, vamos voltar ao nosso código Python e criar uma lista de elementos que serão encontrados através do find_elements, mas passando como parâmetro a class name em vez do XPath.

lista_elementos = nav.find_elements('class name', '_2AOIt')

Essa lista terá todos os elementos que possuem a classe que definimos. É comum que elementos semelhantes tenham a mesma classe em sites. Portanto, é provável que as outras mensagens também tenham a classe _2AOIt.

Dessa forma, precisaremos percorrer essa lista de mensagens e encontrar aquela que tem o texto igual ao da mensagem que queremos enviar. Para fazer isso, criaremos um loop for.

lista_elementos = nav.find_elements('class name', '_2AOIt')

for item in lista_elementos:
    mensagem = mensagem.replace("\n", "")
    texto = item.text.replace("\n", "")
    if mensagem in texto:
        elemento = item

Observe que, como o WhatsApp pode alterar a quantidade de linhas puladas quando enviamos uma mensagem, para fazer a comparação, removeremos todos os espaços e quebras de linha da mensagem e do item que estamos verificando dentro da nossa lista.

Com esse código, conseguimos percorrer todas as mensagens da nossa lista de elementos, comparar com a mensagem que definimos no nosso código e, quando encontrarmos esse elemento, será ele que utilizaremos para executar a ação do ActionChains.

Então, na sequência, podemos definir nosso ActionChains, como havíamos visto antes:

ActionChains(nav).move_to_element(elemento).perform()

E em seguida, selecionar a setinha que abrirá o menu de compartilhar, localizando-a dentro do elemento que definimos no nosso loop for.

Podemos fazer isso da mesma forma como localizamos um elemento no navegador, mas buscando dentro do elemento.

Vamos pegar a classe desse elemento dentro da nossa janela de inspeção e adicionar ao nosso código.

lista_elementos = nav.find_elements('class name', '_2AOIt')

for item in lista_elementos:
    mensagem = mensagem.replace("\n", "")
    texto = item.text.replace("\n", "")
    if mensagem in texto:
        elemento = item

ActionChains(nav).move_to_element(elemento).perform()
elemento.find_element('class name', '_3u9t-').click()

Se executarmos o código até aqui, ele irá abrir o menu com a opção de encaminhar.

A partir desse menu, podemos inspecioná-lo novamente e obter o XPath da opção Encaminhar.

nav.find_element('xpath', '//*[@id="app"]/div/span[4]/div/ul/div/li[4]/div').click()

Isso fará com que a seguinte tela seja aberta:

Nessa janela, precisaremos clicar no botão de encaminhar no canto inferior direito. Então, vamos buscar esse elemento na nossa janela de inspeção e clicar nele.

nav.find_element('xpath', '//*[@id="main"]/span[2]/div/button[4]/span').click()

A partir daí, seremos direcionados para a janela onde selecionaremos os contatos para encaminhar a mensagem.

Nela, iremos escrever os nomes dos usuários para quem queremos encaminhar a mensagem, pressionar Enter, apagar o nome escrito e repetir o processo novamente.

Vamos começar encaminhando a mensagem apenas para o nosso próprio número para estruturar o processo. Então, vamos inspecionar a barra de busca que irá abrir para adicionar um destinatário.

Com o XPath dela, vamos passar o nosso número, pressionar Enter e depois apagar o número da barra de pesquisa.

nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys('Meu Numero')
 time.sleep(1)

nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
time.sleep(1)

nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.BACKSPACE)
time.sleep(1)

A mensagem ainda não será encaminhada, mas estará pronta para isso. Antes de realizar o encaminhamento, vamos definir esse processo para até 5 contatos, que é a quantidade máxima que podemos encaminhar de uma vez no WhatsApp.

Separar os contatos de 5 em 5 para o envio da mensagem

Vamos criar a lógica para separar os contatos em blocos de 5 pessoas para o envio da mensagem.

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

Esse código irá verificar se a quantidade de contatos é divisível por 5. Se for, o número de blocos será igual à quantidade de contatos dividido por 5. Caso contrário, o número de blocos será a quantidade de contatos dividido por 5 acrescido de 1.

Dessa forma, podemos determinar quantas vezes nosso loop precisa ser executado para enviar a mensagem para todos os contatos em blocos de 5 pessoas.

Além disso, vamos criar a lógica para modificar para quais contatos iremos enviar a cada iteração do loop, enviando primeiro para os cinco primeiros contatos, depois para os próximos cinco e assim sucessivamente.

Para definir essa lógica vamos criar a lista de envio dentro do nosso loop for. Definiremos que i_inicial será igual ao valor de i multiplicado por cinco, e i_final será igual a (i + 1) multiplicado por cinco. Assim, a primeira iteração pegará i = 0, resultando em i_inicial = 0 e i_final = 5. Na segunda iteração, com i = 1, teremos i_inicial = 5 e i_final = 10, e assim por diante.

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

for i in range(qtde_blocos):
    # rodar o codigo de encaminhar
    i_inicial = i * 5
    i_final = (i + 1) * 5
    lista_enviar = lista_contatos[i_inicial:i_final]

Dentro deste for, iremos trazer o código responsável por selecionar a mensagem que será encaminhada.

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

for i in range(qtde_blocos):
    # rodar o codigo de encaminhar
    i_inicial = i * 5
    i_final = (i + 1) * 5
    lista_enviar = lista_contatos[i_inicial:i_final]

    # selecionar a mensagem para enviar e abre a caixa de encaminhar
    lista_elementos = nav.find_elements('class name', '_2AOIt') 
    for item in lista_elementos:
        mensagem = mensagem.replace("\n", "")
        texto = item.text.replace("\n", "")
        if mensagem in texto:
            elemento = item
        
    ActionChains(nav).move_to_element(elemento).perform()
    elemento.find_element('class name', '_3u9t-').click()
    time.sleep(0.5)
    nav.find_element('xpath', '//*[@id="app"]/div/span[4]/div/ul/div/li[4]/div').click()
    nav.find_element('xpath', '//*[@id="main"]/span[2]/div/button[4]/span').click()
    time.sleep(1)

Após essa etapa, executaremos outro loop for, que estará fora do loop interno, mas ainda dentro do loop externo. Esse novo for será responsável por marcar a caixa de encaminhamento da mensagem para cada nome/número presente na lista_enviar. Adaptando o código que havíamos feito para marcar apenas o nosso próprio número teremos:

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

for i in range(qtde_blocos):
    # rodar o codigo de encaminhar
    i_inicial = i * 5
    i_final = (i + 1) * 5
    lista_enviar = lista_contatos[i_inicial:i_final]

    # selecionar a mensagem para enviar e abre a caixa de encaminhar
    lista_elementos = nav.find_elements('class name', '_2AOIt') 
    for item in lista_elementos:
        mensagem = mensagem.replace("\n", "")
        texto = item.text.replace("\n", "")
        if mensagem in texto:
            elemento = item
        
    ActionChains(nav).move_to_element(elemento).perform()
    elemento.find_element('class name', '_3u9t-').click()
    time.sleep(0.5)
    nav.find_element('xpath', '//*[@id="app"]/div/span[4]/div/ul/div/li[4]/div').click()
    nav.find_element('xpath', '//*[@id="main"]/span[2]/div/button[4]/span').click()
    time.sleep(1)

    for nome in lista_enviar:
        # selecionar os 5 contatos para enviar
        # escrever o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(nome)
        time.sleep(1)
        # dar enter
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
        time.sleep(1)
        # apagar o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.BACKSPACE)
        time.sleep(1)

E, por fim, vamos inspecionar o botão de enviar para pegar o correspondente xpath. Dentro apenas do primeiro “for”, definiremos que, após selecionarmos os cinco contatos, iremos clicar nesse botão.

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

for i in range(qtde_blocos):
    # rodar o codigo de encaminhar
    i_inicial = i * 5
    i_final = (i + 1) * 5
    lista_enviar = lista_contatos[i_inicial:i_final]

    # selecionar a mensagem para enviar e abre a caixa de encaminhar
    lista_elementos = nav.find_elements('class name', '_2AOIt') 
    for item in lista_elementos:
        mensagem = mensagem.replace("\n", "")
        texto = item.text.replace("\n", "")
        if mensagem in texto:
            elemento = item
        
    ActionChains(nav).move_to_element(elemento).perform()
    elemento.find_element('class name', '_3u9t-').click()
    time.sleep(0.5)
    nav.find_element('xpath', '//*[@id="app"]/div/span[4]/div/ul/div/li[4]/div').click()
    nav.find_element('xpath', '//*[@id="main"]/span[2]/div/button[4]/span').click()
    time.sleep(1)

    for nome in lista_enviar:
        # selecionar os 5 contatos para enviar
        # escrever o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(nome)
        time.sleep(1)
        # dar enter
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
        time.sleep(1)
        # apagar o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.BACKSPACE)
        time.sleep(1)

    nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/span/div/div/div/span').click()
    time.sleep(3)

Código Completo da Automação de WhatsApp

Nosso código final ficou estruturado da seguinte forma:

Primeira parte – Abre e faz a Conexão com o WhatsApp:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

service = Service(ChromeDriverManager().install())

nav = webdriver.Chrome(service=service)

nav.get("https://web.whatsapp.com")

Segunda parte – Cria e envia a mensagem para nosso próprio número:

from selenium.webdriver.common.keys import Keys
import pyperclip
import time

mensagem = """Fala galera!
Se inscreve no canal da Hahstag Programação, os caras são feras!
"""

lista_contatos = ["Meu Numero", "Lira Hashtag - Comercial", "Eu, eu mesmo", "Nós e eu", "Grupo bom", "ultimo grupo"]

# enviar a mensagem para o Meu Numero para poder depois encaminhar

# clicar na lupa
nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/button/div[2]/span').click()

nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys("Meu Numero")

nav.find_element('xpath', '//*[@id="side"]/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
time.sleep(1)

#Escrever a mensagem para nós mesmos
pyperclip.copy(mensagem)

nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.CONTROL + "v")

nav.find_element('xpath', '//*[@id="main"]/footer/div[1]/div/span[2]/div/div[2]/div[1]/div/div[1]/p').send_keys(Keys.ENTER)
time.sleep(2)

Terceira parte – Encaminha a mensagem para todos os contatos definidos na nossa lista:

from selenium.webdriver.common.action_chains import ActionChains

qtde_contatos = len(lista_contatos)

if qtde_contatos % 5 == 0:
    qtde_blocos = qtde_contatos / 5
else:
    qtde_blocos = int(qtde_contatos / 5) + 1

for i in range(qtde_blocos):
    # rodar o codigo de encaminhar
    i_inicial = i * 5
    i_final = (i + 1) * 5
    lista_enviar = lista_contatos[i_inicial:i_final]

    # selecionar a mensagem para enviar e abre a caixa de encaminhar
    lista_elementos = nav.find_elements('class name', '_2AOIt')
    for item in lista_elementos:
        mensagem = mensagem.replace("\n", "")
        texto = item.text.replace("\n", "")
        if mensagem in texto:
            elemento = item

    ActionChains(nav).move_to_element(elemento).perform()
    elemento.find_element('class name', '_3u9t-').click()
    time.sleep(0.5)
    nav.find_element('xpath', '//*[@id="app"]/div/span[4]/div/ul/div/li[4]/div').click()
    nav.find_element('xpath', '//*[@id="main"]/span[2]/div/button[4]/span').click()
    time.sleep(1)

    for nome in lista_enviar:
        # selecionar os 5 contatos para enviar
        # escrever o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(nome)
        time.sleep(1)
        # dar enter
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.ENTER)
        time.sleep(1)
        # apagar o nome do contato
        nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/div[1]/div/div/div[2]/div/div[1]/p').send_keys(Keys.BACKSPACE)
        time.sleep(1)

    nav.find_element('xpath', '//*[@id="app"]/div/span[2]/div/div/div/div/div/div/div/span/div/div/div/span').click()
    time.sleep(3)

Conclusão – Freela de 250 Dólares com Python – Automação de Whatsapp

Nessa aula, você aprendeu a construir um projeto de automação no WhatsApp usando Python para encaminhar uma mensagem para diversos contatos.

Embora tenha sido um processo um pouco extenso e trabalhoso, esse projeto poderia facilmente ser um trabalho freelancer pelo qual você poderia cobrar entre 250 e 500 dólares.

Em resumo, com prática, estudo e o domínio adequado das ferramentas, você pode desenvolver um projeto sólido e funcional que lhe proporcionará uma renda extra, como esse trabalho freela de 250 dólares com Python que desenvolvemos hoje.

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Diego Monutti

Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.