Como Extrair Dados de Buscas com Python: Guia Prático usando SerpAPI e Filtro de Vagas de Emprego

Entendendo SerpAPI, Web Scraping e Ciência de Dados: Filtrando Vagas de Emprego com Python

Introdução

Este artigo aborda como buscar e filtrar dados usando Python e a API SerpAPI para realizar buscas no Google. O foco será entender o funcionamento da API, explorar suas possibilidades e, ao final, aplicar um exemplo prático de pesquisa de vagas de emprego, refinando os resultados com base em palavras-chave relevantes.

O que é SerpAPI?

O SerpAPI é um serviço que oferece acesso programático aos resultados de busca de diversos mecanismos, como Google, Bing e Yahoo, por meio de uma API (Application Programming Interface). Ele simplifica a extração de informações da web, evitando desafios comuns do web scraping tradicional, como:

Bloqueios por CAPTCHA;
Limitações de requisições impostas pelos servidores;
Mudanças inesperadas na estrutura do HTML dos sites.

Principais Recursos do SerpAPI

✅ Busca com filtros personalizados (exemplo: localização, idioma, período de tempo);

✅ Resultados estruturados em JSON, facilitando a manipulação dos dados;

✅ Coleta de diversos tipos de dados, como imagens, notícias e ofertas de emprego;

✅ Acesso a resultados pagos e orgânicos, permitindo análise de anúncios;

✅ Informações detalhadas sobre geolocalização, úteis para buscas regionais.

Por que usar o SerpAPI em vez de Web Scraping manual?

O web scraping convencional, realizado com ferramentas como BeautifulSoup ou Selenium, pode ser problemático, pois os sites frequentemente alteram seus códigos-fonte e adicionam mecanismos de proteção. Além disso, o SerpAPI permite a integração de pesquisa e filtragem de dados em aplicações, com consultas a diferentes serviços, como Google, Bing Search, DuckDuckGo e eBay, utilizando parâmetros configuráveis. A API também possibilita a reorganização dos dados em formato JSON e pode ser integrada a sites ou aplicações.

O SerpAPI automatiza esse processo, retornando os dados já organizados, sem a necessidade de analisar HTML manualmente ou realizar convenções.

Configurando o SerpAPI no Python

Agora, veremos como instalar a biblioteca oficial do SerpAPI e realizar buscas no Google.

1. Instalação da Biblioteca

Antes de tudo, instale o pacote google-search-results via pip:

pip install google-search-results

Essa biblioteca permite que o Python interaja diretamente com a API.

Será necessário criar um registro no site SerpAPI (https://serpapi.com/) e, em seguida, gerar sua chave de API para inseri-la no código. Assim, você poderá executar o script e personalizá-lo para realizar suas próprias buscas.

Além disso, é possível fazer consultas diretamente no site da Google Search API, permitindo uma visão geral de todas as suas funcionalidades e dos dados retornados.

2. Configuração da Busca

Aqui está um exemplo de código para realizar uma pesquisa no Google utilizando o SerpAPI:

from serpapi import GoogleSearch
import json


def serpapi_google_search(query, api_key):
  """
  Realiza uma busca no Google usando a API SerpAPI.


  Parâmetros:
  - query (str): Termo de pesquisa no Google.
  - api_key (str): Chave de API do SerpAPI.


  Retorna:
  - dict: Dicionário contendo os resultados da pesquisa.
  """
  params = {
      "q": query,               # Termo de busca (exemplo: "oportunidades de trabalho")
      "location": "Brazil",     # Define a busca para o Brasil
      "hl": "pt",               # Define o idioma como português
      "gl": "br",               # Especifica que a busca deve considerar o Brasil
      "google_domain": "google.com.br",  # Define o domínio do Google no Brasil
      "api_key": api_key,       # Sua chave de API
      "num": 100                # Define o máximo de resultados (até 100 por página)
  }


  search = GoogleSearch(params)
  results = search.get_dict()  # Obtém os resultados no formato de dicionário JSON
  return results




# Exemplo de chamada da função
query = "oportunidades de trabalho"
api_key = "sua_chave_de_api_aqui"
results = serpapi_google_search(query, api_key)


# Tratamento de Erros
if 'error' in results:
  print(f"Erro na API: {results['error']}")


# Salvando os Resultados em JSON
with open('resultados_busca.json', 'w') as f:
  json.dump(results, f, ensure_ascii=False, indent=2)


# Processamento dos Resultados
for i, resultado in enumerate(results['organic_results'][:5]):
  print(f"{i+1}. {resultado.get('title')}")
  print(f"Link: {resultado.get('link')}")

3. Explicação dos Parâmetros da Busca

q → Termo da busca (exemplo: "empregos Python").
location / gl / hl → Define a localização e idioma.
num → Controla a quantidade de resultados (máximo 100).
google_domain → Define o domínio do Google (no Brasil: google.com.br).
api_key → Chave pessoal da API (necessário criar uma conta no SerpAPI).

4. Tratamento de Erros

Sempre verifique se a API retornou um erro (exemplo: chave inválida, limite de uso excedido):

if 'error' in results:
  print(f"Erro na API: {results['error']}")

5. Salvando os Resultados em JSON

Após obter os dados, podemos armazená-los em um arquivo JSON para análises futuras:

import json
with open('resultados_busca.json', 'w') as f:
  json.dump(results, f, ensure_ascii=False, indent=2)

6. Processamento dos Resultados

Se quisermos exibir os 5 primeiros resultados da pesquisa no terminal:

for i, resultado in enumerate(results['organic_results'][:5]):
  print(f"{i+1}. {resultado.get('title')}")
  print(f"Link: {resultado.get('link')}")

Exemplo Prático: Filtrando Vagas de Emprego

Agora, aplicaremos o SerpAPI para buscar vagas de emprego no Google Jobs e filtrar os resultados conforme palavras-chave relevantes.

Código Completo

import json
from serpapi import GoogleSearch

def serpapi_google_jobs_search(query, api_key, keywords=None, location="Brazil"):
  """
  Busca por vagas de emprego no Google Jobs usando SerpAPI.

  Parâmetros:
  - query (str): Palavra-chave de busca (ex: "Python Developer").
  - api_key (str): Sua chave de API do SerpAPI.
  - keywords (list, opcional): Lista de palavras-chave para filtrar os resultados.
  - location (str, opcional): Localização da busca (padrão: "Brazil").

  Retorna:
  - dict: Resultados da busca formatados.
  """

  params = {
      "engine": "google_jobs",    # Define a busca para vagas de emprego
      "q": query,                 # Termo de pesquisa
      "location": location,        # Define a busca por região
      "hl": "pt",                  # Define o idioma como português
      "gl": "br",                  # Define o país como Brasil
      "api_key": api_key,          # Chave da API
      "chips": "date_posted:week"  # Filtro para vagas recentes (última semana)
  }

  search = GoogleSearch(params)
  results = search.get_dict()
  return results

# Configuração da pesquisa
token = "SUA_CHAVE_API_AQUI"
consulta = "Python Developer"
filtros = ["python", "cloud", "remoto"]

# Executa a busca
resultados = serpapi_google_jobs_search(consulta, token)

# Salva os resultados em JSON
if resultados:
  with open('vagas.json', 'w', encoding='utf-8') as f:
      json.dump(resultados, f, ensure_ascii=False, indent=2)
  
  # Processamento e exibição das vagas filtradas
  if 'jobs_results' in resultados:
      print(f"Vagas encontradas: {len(resultados['jobs_results'])}")
      
      for i, vaga in enumerate(resultados['jobs_results']):
          descricao = vaga.get('description', '').lower()
          
          # Filtra as vagas conforme as palavras-chave
          if filtros and not any(kw.lower() in descricao for kw in filtros):
              continue
          
          print(f"\n{i+1}. {vaga.get('title')}")
          print(f"Empresa: {vaga.get('company_name')}")
          print(f"Localização: {vaga.get('location')}")
          print(f"Postado em: {vaga.get('detected_extensions', {}).get('posted_at')}")
          print(f"Link: {vaga.get('related_links')[0]['link'] if vaga.get('related_links') else 'N/A'}")
          print(f"Descrição: {descricao[:200]}...")  # Exibe os primeiros 200 caracteres da descrição

Segundo Exemplo

Código Personalizado para Buscar Vagas com Filtros Avançados:

import json
from serpapi import GoogleSearch

def buscar_vagas_personalizadas(api_key, query, pais="Brasil", estado=None, linguagens=None):
  # Configuração de parâmetros avançados
  params = {
      "engine": "google_jobs",
      "q": query,
      "location": f"{pais}, {estado}" if estado else pais,  # Combina país e estado
      "hl": "pt",
      "gl": "br" if pais.lower() == "brasil" else "us",  # Código do país (BR/US/...)
      "api_key": api_key,
      "chips": "employment_type:full_time,remote:true",  # Filtros fixos
      "start": 0  # Paginação (0 = primeira página)
  }

  try:
      # Executa a busca
      search = GoogleSearch(params)
      resultados = search.get_dict()

      # Filtra por linguagens de programação
      vagas_filtradas = []
      if 'jobs_results' in resultados:
          for vaga in resultados['jobs_results']:
              descricao = vaga.get('description', '').lower()
              
              # Verifica se há correspondência com as linguagens
              if linguagens:
                  correspondencia = any(
                      lang.lower() in descricao 
                      for lang in linguagens
                  )
                  if not correspondencia:
                      continue  # Ignora vagas sem as linguagens
              
              # Adiciona dados relevantes
              vagas_filtradas.append({
                  "titulo": vaga.get('title'),
                  "empresa": vaga.get('company_name'),
                  "local": vaga.get('location'),
                  "remoto": "Sim" if "remote" in descricao else "Não",
                  "link": vaga.get('related_links')[0]['link'] if vaga.get('related_links') else None,
                  "linguagens": [lang for lang in linguagens if lang.lower() in descricao] if linguagens else []
              })

      return vagas_filtradas

  except Exception as e:
      print(f"Erro: {str(e)}")
      return []

# Configurações
CHAVE_API = "SUA_CHAVE_API"
VAGA = "desenvolvedor back-end"
PAIS = "Brasil"
ESTADO = "São Paulo"
LINGUAGENS = ["Python", "Java", "SQL"]  # Filtro opcional

# Executa a busca
vagas = buscar_vagas_personalizadas(
  api_key=CHAVE_API,
  query=VAGA,
  pais=PAIS,
  estado=ESTADO,
  linguagens=LINGUAGENS
)

# Salva e exibe resultados
if vagas:
  with open('vagas_filtradas.json', 'w', encoding='utf-8') as f:
      json.dump(vagas, f, ensure_ascii=False, indent=2)

  print(f"✅ {len(vagas)} vagas encontradas em {PAIS}/{ESTADO} (Full-Time, Remoto):")
  for i, vaga in enumerate(vagas):
      print(f"\n{i+1}. {vaga['titulo']}")
      print(f"   Empresa: {vaga['empresa']}")
      print(f"   Linguagens: {', '.join(vaga['linguagens']) if vaga['linguagens'] else 'Nenhuma correspondência'}")
      print(f"   Link: {vaga['link']}")
else:
  print("Nenhuma vaga encontrada com os filtros selecionados!")

Funcionalidades Adicionadas:

Filtro Geográfico Dinâmico:

Busca por país (pais) e estado (estado).
Exemplo: pais="Brasil", estado="São Paulo".

Filtros Obrigatórios:

employment_type:full_time: Apenas vagas de tempo integral.
remote:true: Apenas vagas remotas.

Filtro por Linguagens de Programação:

Lista personalizável (linguagens).
Exibe quais linguagens foram encontradas em cada vaga.

Saída Estruturada:

Dados limpos em JSON com apenas informações relevantes.
Identificação automática de "remoto".

Como Usar?

Personalize os Parâmetros:

VAGA = "cientista de dados"
PAIS = "Portugal"
ESTADO = "Lisboa"
LINGUAGENS = ["R", "Python", "TensorFlow"]

Adicione Paginação:

Altere "start": 10 para acessar a página 2 (10 resultados por página).

Modifique Filtros:

Para vagas híbridas, altere remote:true para remote:part_time.

Exemplo de Saída no Terminal:

✅ 8 vagas encontradas em Brasil/São Paulo (Full-Time, Remoto):

1. Desenvolvedor Back-End Python Sênior
 Empresa: TechInovação
 Linguagens: Python, SQL
 Link: https://empresax.com/vaga/123

2. Engenheiro de Dados Java
 Empresa: DataCloud
 Linguagens: Java, SQL
 Link: https://datacloud.com/vaga/456

Dicas para Análise de Dados:

Gere Estatísticas:

from collections import Counter

linguagens_contagem = Counter()
for vaga in vagas:
  linguagens_contagem.update(vaga['linguagens'])

print("Linguagens mais demandadas:", linguagens_contagem.most_common(3))

Mapa de Vagas Remotas:

import folium

mapa = folium.Map(location=[-23.5505, -46.6333])  # Coordenadas de SP
for vaga in vagas:
  if vaga['remoto'] == "Não":
      folium.Marker(...).add_to(mapa)
mapa.save('vagas.html')

Envio Automatizado para Planilha:

import pandas as pd

df = pd.DataFrame(vagas)
df.to_excel('vagas.xlsx', index=False)

O SerpAPI simplifica a obtenção de dados do Google, eliminando as barreiras do web scraping tradicional, que exigem a extração de seções do HTML e a configuração manual de trechos de código para sites específicos. Neste artigo, exploramos como utilizar a API com Python para coletar e filtrar dados do Google.

Referências: