Sin KYC — sin ID, sin selfie, sin documentos. Paga con criptomonedas: BTC, USDT, USDC, ETH, SOL, LTC
Idioma: Español
Obtener una clave API

Guía · Python · código probado · a octubre de 2026

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

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.

Última actualización: · 6 min de lectura

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

Python3.9 o superior
Paquetesrequests para lo básico; pandas para tablas; httpx para async
Clave APIDesde tu panel de SerpCrypto, guardada en la variable de entorno SERPCRYPTO_API_KEY
EndpointGET https://serpcrypto.com/api/v1/search
Coste1 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ño10.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
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
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
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
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.

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 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 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 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 (3)
  1. Google empieza a exigir JavaScript para Google Search — TechCrunch (2025-01-17)
  2. robots.txt de google.com — Google (read 2026-10-22)
  3. Google obliga a los rastreadores de posiciones a 500 a 1.000 solicitudes por consulta — PPC Land (2026-08-27)

Desde 0,30 US$/1K búsquedas · sin KYC

Obtener una clave API