Como Criar Projetos em Python e Ganhar R$1.000

Aprenda a criar projetos em Python para automatizar processos e ganhar dinheiro com isso no mercado de freelancers.

Resposta rápida: um projeto de Python que se vende como freela resolve um problema concreto de quem paga, e o exemplo desta aula é um raspador que extrai dados de um site e organiza o resultado. O Beautiful Soup dá conta quando a página vem pronta do servidor; quando o conteúdo aparece só depois do JavaScript rodar, o Selenium é o caminho.

Introdução

Fala, impressionador!

Você quer ganhar dinheiro com Python fazendo projetos de freela? Neste guia completo, você vai aprender exatamente como construir um projeto profissional de web scraping do zero e descobrir as estratégias para se destacar em plataformas de freelancer.

Vamos criar juntos um projeto real de extração de dados que pode render até R$ 1.000, mostrando todas as decisões técnicas, ferramentas necessárias e até os erros que você pode encontrar pelo caminho.

Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:

Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.

Entendendo o projeto

Vamos construir um script que extrai automaticamente informações de contato (telefones) de múltiplos sites. Este é um projeto real que você pode encontrar em plataformas como Freelancer, onde clientes pagam entre US$ 175 e US$ 240 (cerca de R$ 900 a R$ 1.200).

Neste projeto, o cliente precisa de um script independente que funciona da seguinte forma:

1. Lê uma lista de URLs de sites a partir de um arquivo de texto;
2. Acessa cada site e extrai as informações de contato (telefones);
3. Usa Inteligência Artificial para encontrar os telefones mesmo que estejam em formatos diferentes;
4. Salva os resultados em um arquivo CSV organizado;
5. Funciona no Windows 11.

Entendendo o Desafio do Scraping

Para realizar a busca da informação requisitada, usaremos o processo de web scraping que ajuda a extrair dados de sites de forma automatizada. Porém, existem alguns obstáculos:

• Sites dinâmicos vs estáticos: Sites estáticos carregam todo o conteúdo de uma vez. Sites dinâmicos (como YouTube) carregam conteúdo conforme você rola a página;
• Variação de estrutura: Cada site organiza suas informações de forma diferente no código HTML;
• Bloqueios de scraping: Alguns sites detectam e bloqueiam tentativas de scraping automatizado.
• Informações escondidas: Telefones podem estar dentro de links, botões ou seções específicas do site.

Para nosso projeto, vamos testar com sites reais de instituições de ensino:

• Hashtag Treinamentos
• Finat
• FGV
• IBMEC
• PUC-Rio

Esses sites têm estruturas variadas, o que nos ajuda a criar uma solução robusta.

Ferramentas de Scraping: Beautiful Soup vs Selenium

Há duas ferramentas muito utilizadas para realizar web scraping em Python: Beautiful Soup e Selenium. Cada uma delas possui características próprias, vantagens e limitações, e por isso a escolha da ferramenta ideal depende muito do tipo de site que será analisado.

O Beautiful Soup é uma biblioteca focada na extração de dados a partir do HTML de páginas estáticas. Ela se destaca por ser extremamente rápida e leve, consumindo poucos recursos da máquina. Além disso, é simples de utilizar e oferece uma curva de aprendizado tranquila, o que a torna ideal para cenários onde o conteúdo da página já está completamente presente no HTML.

No entanto, suas limitações aparecem quando lidamos com sites dinâmicos. Ela não é capaz de executar JavaScript e, por isso, não consegue capturar elementos carregados apenas após a interação com a página ou por requisições assíncronas.

Caso queira conhecer o Beautiful Soup, você pode acessar a aula Introdução ao Beautiful Soup.

Por outro lado, o Selenium funciona como um navegador automatizado. Ele abre páginas da mesma forma que um usuário real faria e por isso consegue lidar muito bem com sites dinâmicos. Com o Selenium é possível executar JavaScript, aguardar carregamentos, clicar em botões, preencher campos e interagir com praticamente qualquer elemento da página.

Em compensação, por simular um navegador completo, ele é mais lento que o Beautiful Soup, consome mais recursos e ainda exige a instalação de um driver específico para o navegador escolhido (como ChromeDriver ou GeckoDriver).

Caso queira conhecer o Selenium, você pode acessar a aula Selenium - Automatize Qualquer Tarefa na Internet com Python.

Diante disso, vamos iniciar o desenvolvimento utilizando Beautiful Soup, aproveitando sua velocidade e simplicidade. Caso o site analisado dependa fortemente de conteúdo dinâmico ou carregado via JavaScript, então partimos para o uso do Selenium, garantindo total controle sobre a interação com a página.

Configurando o Ambiente de Desenvolvimento

O primeiro passo é criar a estrutura para o projeto:

1. Na área de trabalho crie uma pasta para o projeto chamado "FreelaScrape", por exemplo;
2. Abra essa pasta no seu editor de código. Neste caso usaremos o VS Code e ao abrir a ferramenta, basta usar o atalho CTRL + O e selecionar a pasta desejada;
3. Dentro da pasta crie os seguintes arquivos:
4. main.py - Nosso código principal
5. sites.txt - Lista de sites para extrair

No arquivo "sites.txt", adicione os sites de cada uma das instituições de ensino que utilizaremos como exemplo para testar o código linha a linha:

https://www.hashtagtreinamentos.com

https://fnat.com.br

https://portal.fgv.br

https://www.ibmec.br

https://www.puc-rio.br

Usando IA para Acelerar o Desenvolvimento

Uma opção para acelerar o desenvolvimento do código é usar inteligência artificial.  Você pode usar o Chat GPT ou o Gemini para criar a estrutura inicial do código. Utilizaremos o seguinte prompt no Gemini para criar o código base que implementaremos nos próximos passos:

Preciso de um script independente que extrai telefones de sites usando OpenAI.

Como vai funcionar:
1. Vou inserir o endereço dos sites no arquivo sites.txt
2. Seu script encontrará o telefone em cada site e o extrairá
3. Você deve usar IA e Python para resolver isso
4. O script deve funcionar no Windows 11
5. Os sites não são padronizados - os telefones podem estar em qualquer lugar da página

Use para scraping o Beautiful Soup.

Caso use IA para criar o código inicial, é fundamental entender cada linha de código, para conseguir direcionar a inteligência artificial na resolução de problemas.

Python Impressionador

Você vai aprender a linguagem de Programação que mais cresce no Mundo para fazer automações incríveis, desenvolver sites, fazer análises de dados, trabalhar com Ciência de Dados, Inteligência Artificial, mesmo que você nunca tenha tido nenhum contato com Programação na vida.

Começar agora

Instalando as dependências

A resposta da IA traz o código completo organizado em arquivos, dois deles já foram criados inicialmente, que são: "main.py" e o "sites.txt". O novo arquivo que ainda precisamos criar é o "requirements.txt", responsável por armazenar todas as dependências do projeto. Ele terá os seguinte conteúdo:

openAI
beautifulsoup4
requests

Após criar esse arquivo, podemos usar o atalho CTRL + J  para abrir o terminal e instalá-las com o comando:

pip install -r requirements.txt

O código acima , vai olhar dentro do arquivo "requirements.txt" todas as dependências que estão em cada linha e vai instalar todas de uma vez com o -r.

Caso precise de ajuda para configurar o Python no VS Code, você pode acessar o vídeo Como Configurar VSCode para Python.

Construindo o Script de Extração

O próximo passo é pegar o código que a IA forneceu, entender cada passo e alterar o que for necessário. O resultado será mostrado abaixo:

Começaremos com as importações das bibliotecas. no arquivo "main.py", insira o seguinte código:

#Importação das bibliotecas

import os
import requests
from bs4 import BeautifulSoup
from openai import OpenAI

O próximo passo é definir as variáveis globais:

# Insira a chave de API da OpenAI abaixo
API_KEY = "SUA_CHAVE_API_AQUI"

# Arquivo de entrada com a lista de sites que serão consultados
INPUT_FILE = "sites.txt"

# Arquivo de saída com os resultados
OUTPUT_FILE = "resultado_telefones.csv"

# Modelo da OpenAI (gpt-4o-mini é mais barato e rápido para essa tarefa)
MODELO = "gpt-4o-mini"

É muito importante lembrar que você  nunca deve compartilhar sua chave da API da OpenAI publicamente. Para entregar o projeto ao cliente, substitua por um placeholder como "SUA_CHAVE_API_AQUI" como fizemos no código acima.

Na sequência, vamos inicializar a chave da openAi com o código:

client = OpenAI(api_key=API_KEY)

Em seguida, a IA fornece três principais funções: limpar_html, extrair_telefone_com_ia e processar_sites. Cada uma responsável por uma funcionalidade específica na automação que está descrita na tabela abaixo:

A estrutura que a IA apresenta inicialmente é uma excelente opção para seguirmos. Contudo, ela insere várias linhas de código que podemos deletar, pois não contribuem para a automação e funcionalidade de cada função.

Por isso, é extremamente importante revisar o código fornecido pela IA para conseguir criar um código otimizado e de qualidade.

Após tratar cada uma das funções, obtemos o seguinte código para cada uma:

1. Função limpar_html

def limpar_html(html_content):
    """
    Limpa o HTML removendo elementos desnecessários.
    """

    # Converte o HTML em um objeto BeautifulSoup
    soup = BeautifulSoup(html_content, 'html.parser')

    # Só aplica limpeza pesada se o texto for grande
    if len(soup.text) > 2000:
        # Remove tags que não têm texto útil
        for element in soup(["script", "style", "meta", "noscript", "header", "svg", "path"]):
            element.extract()

    # Retorna o HTML limpo
    return soup

2. Função extrair_telefone_com_ia

def extrair_telefone_com_ia(texto_site, url):
    """
    Envia o conteúdo do site para a IA e retorna o telefone encontrado.
    """

    # Define as instruções que orientam a IA sobre como extrair o telefone
    prompt_sistema = (
        "Você é um assistente especialista em extração de dados. "
        "Sua tarefa é encontrar o número de telefone principal no HTML fornecido. "
        "Prefira celulares ou fixos locais e também verifique números dentro de links. "
        "Retorne apenas o número formatado ou 'Não encontrado'."
    )

    # Monta o texto enviado para a IA com a URL e o conteúdo do site
    prompt_usuario = f"URL do site: {url}\n\nConteúdo do site:\n{texto_site}\n\nExtraia o telefone:"

    try:
        # Faz a requisição para a OpenAI usando o modelo configurado
        response = client.chat.completions.create(
            model=MODELO,
            messages=[
                {"role": "system", "content": prompt_sistema},
                {"role": "user", "content": prompt_usuario}
            ],
        )

        # Retorna o texto da resposta da IA, sem espaços extras
        return response.choices[0].message.content.strip()

    except Exception as e:
        # Retorna o erro caso a chamada à IA falhe
        return f"Erro na IA: {e}"

3. Função processar_sites

def processar_sites():
    # Verifica se o arquivo de entrada existe
    if not os.path.exists(INPUT_FILE):
        print(f"Erro: Arquivo '{INPUT_FILE}' não encontrado.")
        return

    # Lê a lista de sites do arquivo
    with open(INPUT_FILE, 'r', encoding='utf-8') as file:
        sites = [line.strip() for line in file.readlines() if line.strip()]

    print(f"Iniciando extração de {len(sites)} sites...")

    # Cria o arquivo de saída com o cabeçalho
    with open(OUTPUT_FILE, 'w', encoding='utf-8') as file_out:
        file_out.write("URL;Telefone Extraido\n")

    # Define um User-Agent para evitar bloqueios ao acessar os sites
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }

    for site in sites:
        # Garante que a URL tem http/https
        url_alvo = site if site.startswith('http') else f'https://{site}'
        print(f"Processando: {url_alvo}...", end="\r")

        try:
            # 1. Baixa o HTML do site
            response = requests.get(url_alvo, headers=headers, timeout=15)
            response.raise_for_status()

            # 2. Limpa o HTML removendo tags inúteis
            texto_limpo = limpar_html(response.content)
            
            # 3. Extrai o telefone usando IA
            telefone = extrair_telefone_com_ia(texto_limpo, url_alvo)
            print(f"[OK] {url_alvo} -> {telefone}")

            # 4. Salva o resultado no arquivo CSV
            with open(OUTPUT_FILE, 'a', encoding='utf-8') as file_out:
                file_out.write(f"{url_alvo};{telefone}\n")

        # Caso haja erro ao acessar o site
        except requests.exceptions.RequestException as e:
            print(f"[ERRO DE CONEXÃO] {url_alvo}: {e}")
            with open(OUTPUT_FILE, 'a', encoding='utf-8') as file_out:
                file_out.write(f"{url_alvo};Erro de acesso ao site\n")

        # Qualquer outro erro inesperado
        except Exception as e:
            print(f"[ERRO GERAL] {url_alvo}: {e}")
            with open(OUTPUT_FILE, 'a', encoding='utf-8') as file_out:
                file_out.write(f"{url_alvo};Erro desconhecido\n")

Ao final do arquivo temos o comando responsável por executar o processamento quando o script é iniciado:

if __name__ == "__main__":
    processar_sites()

Integrando a API da OpenAI

Já temos o código, agora precisamos da chave de API da OpenAI para conseguir integrá-la à automação que estamos construindo. Para ter acesso à essa chave, você precisa;

1. Acessar o site da plataforma da OpenAI;
2. Clique no ícone de engrenagem no canto superior direito da tela ao lado do avatar de perfi;

3. No menu lateral clique na opção API Key;
4. Clique no botão Create new secret Key;

5. Preencha o campo Name com o nome da chave de API;
6. Selecione no campo Project um projeto para associar à essa chave de API;
7. Clique no botão Create Secret Key;

8. Clique no botão Copy para copiar a chave de API;

Resultado ao executar o código

Ao executar o código é possível trazer a maior parte dos números de telefone dos sites inseridos no arquivo "sites.txt".

Alguns sites como o da FGV, por exemplo, podem reconhecer um scraping e impedir a conexão, o que leva ao erro apresentado na imagem acima.

Outras opções como usar RPAs para simular o comportamento de um navegador real podem contornar essas restrições, pois esse tipo de ferramenta consegue respeitar políticas de cookies e replicar interações humanas, evitando bloqueios mais rígidos aplicados contra requisições automatizadas.

Conclusão

Construir projetos de Python para freela é uma excelente forma de ganhar dinheiro enquanto desenvolve suas habilidades. O segredo está em:

1. Escolher projetos adequados ao seu nível;
2. Usar IA para acelerar o desenvolvimento, mas entender o código;
3. Entregar valor além do esperado (projeto pronto antes da contratação);
4. Comunicar profissionalmente;
5. Iterar e melhorar com cada projeto.

Este projeto de web scraping com OpenAI é apenas um exemplo. Você pode aplicar o mesmo processo para:

• Automação de planilhas;
• Bots de Telegram/Discord;
• Análise de dados;
• Integração de APIs;
• Scripts de produtividade.

Lembre-se: o conhecimento técnico é importante, mas a capacidade de entregar soluções completas e se comunicar bem são diferenciais ainda maiores no mercado de freelas.

Se você quer aprender mais sobre Python de forma prática e focada no mercado atual, conheça nosso Curso Python Impressionador.

Além disso, se preferir esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Hashtag Treinamentos

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

Posts mais recentes de Python

• 
  Curso Básico de Python: Saia do Zero em 10 Aulas Grátis18 de setembro de 2026
  Aprenda com o curso básico de Python gratuito da Hashtag: 10 aulas práticas, exercícios e projetos reais para sair do zero em programação.
• 
  Agentes RAG com Python: como criar um assistente de IA17 de setembro de 2026
  Aprenda a criar Agentes RAG com Python do zero: LangChain, FAISS e OpenAI para montar um assistente de IA que responde com base nos seus documentos.
• 
  25 Tipos de Gráficos em Python: Guia Completo com Código26 de agosto de 2026
  Aprenda a criar os principais tipos de gráficos em Python com Plotly: barras, pizza, mapas e mais, com código pronto para copiar e usar.

Posts mais recentes da Hashtag Treinamentos

• 
  Planilha de Controle de Notas Fiscais no Excel [Grátis]2 de outubro de 2026
  Baixe a planilha de controle de notas fiscais no Excel grátis: calcule ISS e retenções, veja o que está em aberto e gere a cobrança de cada nota de serviço.
• 
  Qual IA usar na empresa: ChatGPT, Claude ou Perplexity?2 de outubro de 2026
  Qual IA usar na empresa: veja as diferenças entre ChatGPT, Claude e Perplexity e quando cada um rende mais em cada área da sua equipe.
• 
  Apostilas Gratuitas em PDF: Excel, Power BI, Python e IA30 de setembro de 2026
  Baixe apostilas gratuitas em PDF de Excel, Power BI, Python, Claude e agentes de IA, com exercícios e gabarito. Escolha a sua e comece hoje.