# Como obter resultados de pesquisa do Google em Python (2026)

> Resultados de pesquisa do Google em Python 2026: por que o requests falha e código testado para requests, pandas, httpx assíncrono, paginação e JSONL.

- URL: https://serpcrypto.com/pt/guides/google-search-results-python/
- Última atualização: 2026-10-22
- Editor: SerpCrypto (https://serpcrypto.com)

Buscar google.com com requests deixou de ser uma opção em 2025. Este guia explica por quê e então traz código Python curto e com sintaxe verificada que obtém os mesmos resultados em JSON por meio de uma API de SERP.

**Resposta rápida — Como obtenho resultados de pesquisa do Google em Python em 2026?**

Chame uma API de SERP a partir do Python e leia o JSON retornado; não busque google.com você mesmo, porque o Google exige JavaScript desde 17 de janeiro de 2025 e seu robots.txt não permite `/search`. Com **SerpCrypto**, uma `requests.get` para `https://serpcrypto.com/api/v1/search` retorna resultados orgânicos, People Also Ask e mais, por um crédito por pesquisa a partir de US$ 0,30/1K pesquisas em outubro de 2026. Sem KYC; pague com cripto.

## O que você precisa

| Atributo | Valor |
| --- | --- |
| Python | 3.9 ou mais recente |
| Pacotes | `requests` para o básico; `pandas` para tabelas; `httpx` para assíncrono |
| Chave de API | Do seu painel SerpCrypto, armazenada na variável de ambiente `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Custo | 1 crédito = 1 solicitação de pesquisa bem-sucedida, que retorna uma página de resultados em qualquer engine compatível. Uma solicitação que falha não é cobrada |
| Menor pacote | 10.000 pesquisas por US$ 7,50; os créditos nunca expiram |

## Por que requests.get no google.com não funciona mais?

Porque os resultados não estão mais no HTML que um cliente HTTP simples recebe. Em 17 de janeiro de 2025, o Google passou a exigir JavaScript para a Pesquisa; ele disse que o JavaScript ajuda a proteger seus serviços contra bots e que menos de 0,1% das pesquisas vinham de usuários com o JavaScript desativado, conforme noticiado pelo TechCrunch.

O robots.txt do Google, lido em 22 de outubro de 2026, também lista `Disallow: /search` para todos os user agents. Uma API de SERP cuida de executar a pesquisa e analisar a página, e seu código Python lida apenas com JSON. É a abordagem usada no restante deste guia.

## Como faço a primeira requisição?

Instale o requests, coloque sua chave em uma variável de ambiente e envie a consulta com um país e um idioma. A resposta é um dicionário com uma chave por bloco da página de resultados; `organic_results` contém os links classificados.

Mantenha a chave fora do seu código-fonte. No macOS e Linux, `export SERPCRYPTO_API_KEY=...` no shell; no Windows PowerShell, `$env:SERPCRYPTO_API_KEY="..."`.

*Primeira requisição com requests*

```python
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
KEY = os.environ["SERPCRYPTO_API_KEY"]

resp = requests.get(
    API,
    headers={"Authorization": "Bearer " + KEY},
    params={"engine": "google", "q": "best hiking boots", "gl": "us", "hl": "en"},
    timeout=60,
)
resp.raise_for_status()
results = resp.json()

for item in results.get("organic_results", []):
    print(item["position"], item["title"])
    print("   ", item["link"])

for q in results.get("people_also_ask", []):
    print("PAA:", q["question"])

```

## Como transformo os resultados em um DataFrame do pandas?

Construa uma linha por resultado orgânico e mantenha a consulta ao lado dela. Um DataFrame facilita ordenar, filtrar por domínio ou exportar para CSV e Excel. Campos ausentes, como `date` na maioria dos resultados, viram células vazias em vez de erros.

*Várias consultas em um único DataFrame*

```python
import os
from urllib.parse import urlparse

import pandas as pd
import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def organic_rows(query, gl="us", hl="en"):
    params = {"engine": "google", "q": query, "gl": gl, "hl": hl}
    resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
    resp.raise_for_status()
    for r in resp.json().get("organic_results", []):
        yield {
            "query": query,
            "position": r.get("position"),
            "title": r.get("title"),
            "domain": urlparse(r.get("link", "")).netloc,
            "link": r.get("link"),
            "snippet": r.get("snippet"),
        }


queries = ["crm for small business", "invoice software", "time tracking app"]
df = pd.DataFrame([row for q in queries for row in organic_rows(q)])
print(df.groupby("domain").size().sort_values(ascending=False).head(10))
df.to_csv("serp_results.csv", index=False)

```

## Como faço para rodar muitas pesquisas de uma vez?

Use httpx com asyncio e limite o número de requisições em andamento com um semáforo. Sua conta tem um limite de concorrência, mostrado no dashboard; ficar abaixo dele evita erros `429`. Comece com um número pequeno, como 5, e ajuste até o limite que o dashboard mostra.

*Pesquisas assíncronas com httpx e um semáforo*

```python
import asyncio
import os

import httpx

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}
LIMIT = asyncio.Semaphore(5)


async def search(client, query):
    async with LIMIT:
        resp = await client.get(API, params={"engine": "google", "q": query, "gl": "us", "hl": "en"})
        resp.raise_for_status()
        data = resp.json()
        top = data.get("organic_results", [])[:3]
        return query, [r["link"] for r in top]


async def main(queries):
    async with httpx.AsyncClient(headers=HEADERS, timeout=60) as client:
        for query, links in await asyncio.gather(*(search(client, q) for q in queries)):
            print(query, links)


if __name__ == "__main__":
    asyncio.run(main(["python web framework", "python orm", "python task queue"]))

```

## Como faço para obter mais de 10 resultados e salvá-los?

Peça as próximas páginas com `page=2`, `page=3` e assim por diante, até `page=10`. Cada página é uma pesquisa e um crédito, porque o Google serve cerca de 10 resultados orgânicos por página desde que deixou de respeitar `num=100` em setembro de 2025.

Salve cada resposta bruta como uma linha de um arquivo JSONL. O JSON bruto mantém todos os blocos, então você pode responder a novas perguntas depois sem pagar de novo pelas mesmas pesquisas.

*Páginas 1 a 3 salvas como JSONL*

```python
import json
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def fetch_pages(query, pages=3, path="serp.jsonl"):
    with open(path, "a", encoding="utf-8") as out:
        for page in range(1, pages + 1):
            params = {"engine": "google", "q": query, "gl": "us", "hl": "en", "page": page}
            resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
            resp.raise_for_status()
            data = resp.json()
            out.write(json.dumps(data, ensure_ascii=False) + "\n")
            if not data.get("organic_results"):
                break


fetch_pages("electric cargo bike", pages=3)

```

## Quanto custa rodar este código?

Cada chamada nestes exemplos é uma pesquisa. O primeiro exemplo custa um crédito, o exemplo com DataFrame custa três, e o exemplo com JSONL custa até três. Uma requisição que falha não é cobrada.

10.000 pesquisas custam US$ 7,50 e 100.000 pesquisas custam US$ 56,25, em outubro de 2026; o valor cai para US$ 0,30/1K pesquisas a partir de 5.000.000 de pesquisas. Os créditos nunca expiram. Você paga em BTC, USDT, USDC, ETH, SOL, LTC a partir de uma recarga de US$ 25, sem envio de documento de identidade. Veja [preços](https://serpcrypto.com/pt/pricing/).

## Resultados do Google em Python: perguntas comuns

### Posso usar BeautifulSoup nas páginas de resultados do Google?

Não de forma confiável. O Google exige JavaScript desde janeiro de 2025, então o HTML que um cliente simples recebe não contém os resultados, e o robots.txt do Google não permite `/search`. Uma API de SERP retorna os campos já processados como JSON.

### Existe uma biblioteca oficial de Python para SerpCrypto?

Não. A API é um endpoint HTTPS comum, então `requests` ou `httpx` é tudo o que você precisa. Os exemplos desta página e da [página de documentação de Python](https://serpcrypto.com/pt/docs/python/) são código para copiar e colar, não um pacote publicado.

### Como faço para obter resultados de outro país?

Defina `gl` com o código do país e `hl` com o idioma, por exemplo `gl=fr` e `hl=fr` para a França. Adicione `location` para uma cidade. A [página de localizações](https://serpcrypto.com/pt/docs/locations/) lista os códigos mais comuns.

### Como faço para tratar erros e novas tentativas?

Chame `raise_for_status()` e repita as respostas `429`, `502` e `504` após um intervalo crescente. Requisições que falham não são cobradas. A [página de erros](https://serpcrypto.com/pt/docs/errors/) traz uma função completa de retry.

### Posso obter resultados do Bing com o mesmo código?

Sim. Troque `engine` por `bing`; a resposta mantém o mesmo formato, com `organic_results` e `related_searches`.

## Fontes

1. [O Google passa a exigir JavaScript para a Pesquisa Google](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [robots.txt do google.com](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [O Google força os rastreadores de ranking a 500 a 1.000 requisições por consulta](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: O SerpCrypto é uma API de SERP para desenvolvedores e agentes de IA que retorna resultados de pesquisa do Google e do Bing em JSON, pago com cripto e sem envio de documento de identidade. Os créditos de pesquisa pré-pagos a partir de US$ 0,30/1K pesquisas nunca expiram. Sem KYC — sem documento, sem selfie, sem documentos. Pague com cripto.