# Cómo obtener resultados de búsqueda de Google en Python (2026)

> Cómo obtener resultados de búsqueda de Google en Python en 2026: por qué fallan las peticiones simples y código probado con requests, httpx async y paginación.

- URL: https://serpcrypto.com/es/guides/google-search-results-python/
- Última actualización: 2026-10-22
- Editor: SerpCrypto (https://serpcrypto.com)

Hacer peticiones a google.com con requests dejó de ser una opción en 2025. Esta guía explica por qué y luego ofrece código Python corto y verificado sintácticamente que obtiene los mismos resultados en JSON a través de una API SERP.

**Respuesta rápida — ¿Cómo obtengo resultados de búsqueda de Google en Python en 2026?**

Llama a una API SERP desde Python y lee el JSON que devuelve; no hagas tú mismo la petición a google.com, porque Google exige JavaScript desde el 17 de enero de 2025 y su robots.txt no permite `/search`. Con **SerpCrypto**, una `requests.get` a `https://serpcrypto.com/api/v1/search` devuelve resultados orgánicos, People Also Ask y más, por un crédito por búsqueda desde 0,30 US$/1K búsquedas a octubre de 2026. Sin KYC; paga con criptomonedas.

## Lo que necesitas

| Atributo | Valor |
| --- | --- |
| Python | 3.9 o superior |
| Paquetes | `requests` para lo básico; `pandas` para tablas; `httpx` para async |
| Clave API | Desde tu panel de SerpCrypto, guardada en la variable de entorno `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Coste | 1 crédito = 1 consulta correcta, que devuelve una página de resultados en cualquier motor compatible. Una consulta fallida no se cobra |
| Pack más pequeño | 10.000 búsquedas por 7,50 US$; los créditos nunca caducan |

## ¿Por qué ya no funciona requests.get en google.com?

Porque los resultados ya no están en el HTML que recibe un cliente HTTP simple. El 17 de enero de 2025, Google empezó a exigir JavaScript para Search; dijo que JavaScript le ayuda a proteger sus servicios de los bots y que menos del 0,1% de las búsquedas procedían de usuarios con JavaScript desactivado, según informó TechCrunch.

El robots.txt de Google, consultado el 22 de octubre de 2026, también incluye `Disallow: /search` para todos los user agents. Una API SERP se encarga de ejecutar la búsqueda y de parsear la página, y tu código Python solo trabaja con JSON. Ese es el enfoque que se usa en el resto de esta guía.

## ¿Cómo hago la primera petición?

Instala requests, pon tu clave en una variable de entorno y envía la consulta con un país y un idioma. La respuesta es un diccionario con una clave por cada bloque de la página de resultados; `organic_results` contiene los enlaces ordenados.

Mantén la clave fuera de tu código fuente. En macOS y Linux, `export SERPCRYPTO_API_KEY=...` en la shell; en Windows PowerShell, `$env:SERPCRYPTO_API_KEY="..."`.

*Primera petición con 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"])

```

## ¿Cómo convierto los resultados en un DataFrame de pandas?

Crea una fila por cada resultado orgánico y mantén la consulta junto a ella. Un DataFrame facilita ordenar, filtrar por dominio o exportar a CSV y Excel. Los campos que faltan, como `date` en la mayoría de los resultados, se convierten en celdas vacías en lugar de errores.

*Varias consultas en un ú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)

```

## ¿Cómo ejecuto muchas búsquedas a la vez?

Usa httpx con asyncio y limita el número de solicitudes en curso con un semáforo. Tu cuenta tiene un límite de concurrencia que se muestra en el panel; mantenerte por debajo evita errores `429`. Empieza con un número pequeño, como 5, y ajústalo al límite que muestra tu panel.

*Búsquedas asíncronas con httpx y un 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"]))

```

## ¿Cómo obtengo más de 10 resultados y los guardo?

Pide las siguientes páginas con `page=2`, `page=3` y así sucesivamente, hasta `page=10`. Cada página es una búsqueda y un crédito, porque Google ha servido unos 10 resultados orgánicos por página desde que dejó de respetar `num=100` en septiembre de 2025.

Guarda cada respuesta en bruto como una línea de un archivo JSONL. El JSON en bruto conserva todos los bloques, así que puedes responder nuevas preguntas más adelante sin pagar otra vez por las mismas búsquedas.

*Páginas 1 a 3 guardadas 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)

```

## ¿Cuánto cuesta ejecutar este código?

Cada llamada de estos ejemplos es una búsqueda. El primer ejemplo cuesta un crédito, el ejemplo con DataFrame tres, y el ejemplo con JSONL hasta tres. Una solicitud fallida no se cobra.

10.000 búsquedas cuestan 7,50 US$ y 100.000 búsquedas cuestan 56,25 US$, a fecha de octubre de 2026; la tarifa baja a 0,30 US$/1K búsquedas en 5.000.000 de búsquedas. Los créditos nunca caducan. Pagas en BTC, USDT, USDC, ETH, SOL, LTC con una recarga de 25 US$, sin subir ningún documento de identidad. Consulta [precios](https://serpcrypto.com/es/pricing/).

## Resultados de Google en Python: preguntas frecuentes

### ¿Puedo usar BeautifulSoup en las páginas de resultados de Google?

No de forma fiable. Google exige JavaScript desde enero de 2025, así que el HTML que recibe un cliente simple no contiene los resultados, y el robots.txt de Google no permite `/search`. En su lugar, una API SERP devuelve los campos ya procesados como JSON.

### ¿Existe una librería oficial de Python para SerpCrypto?

No. La API es un endpoint HTTPS simple, así que con `requests` o `httpx` tienes todo lo que necesitas. Los ejemplos de esta página y de la [página de documentación de Python](https://serpcrypto.com/es/docs/python/) son código para copiar y pegar, no un paquete publicado.

### ¿Cómo obtengo resultados de otro país?

Define `gl` con el código de país y `hl` con el idioma, por ejemplo `gl=fr` y `hl=fr` para Francia. Añade `location` para una ciudad. La [página de ubicaciones](https://serpcrypto.com/es/docs/locations/) lista los códigos más comunes.

### ¿Cómo gestiono los errores y los reintentos?

Llama a `raise_for_status()` y luego reintenta las respuestas `429`, `502` y `504` tras un retardo creciente. Las solicitudes fallidas no se cobran. La [página de errores](https://serpcrypto.com/es/docs/errors/) incluye una función de reintento completa.

### ¿Puedo obtener resultados de Bing con el mismo código?

Sí. Cambia `engine` por `bing`; la respuesta mantiene la misma estructura, con `organic_results` y `related_searches`.

## Fuentes

1. [Google empieza a exigir JavaScript para Google Search](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [robots.txt de google.com](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [Google obliga a los rastreadores de posiciones a 500 a 1.000 solicitudes por consulta](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto es una API SERP para desarrolladores y agentes de IA que devuelve resultados de Google y Bing como JSON, pagada con criptomonedas sin subir ningún documento de identidad. Los créditos de búsqueda prepagados desde 0,30 US$/1K búsquedas nunca caducan. Sin KYC: ni identificación, ni selfie, ni documentos. Paga con criptomonedas.