Cómo gestionar las URL de redireccionamiento de Google /goto y los tokens CAES en un rastreador de SERP

• Trata /goto?url=CAES... y /url?... como capas de redireccionamiento, no como destinos.
• No descifres CAES. Resuelve con GET y allow_redirects=False, y a continuación lee Location.
• Preferir la ruta A: JSON estructurado de la API SERP de WebScrapingAPI cuando los link son los destinos.
• Utiliza la ruta B: API de Scraper o API de navegador (solo HTML) cuando necesites el código sin procesar; a continuación, clasifica → elimina duplicados → resuelve.
• HTTP 200 no es una SERP utilizable. Valida los contenedores de resultados antes de analizarlos.
• Elimina duplicados de /goto dentro de una misma página; reutiliza las conexiones; limita la concurrencia.
• Almacena una huella digital de la solicitud (consulta, gl, hl, devicedominio, hora) con cada observación.
• El formato de enlaces de Google no es un contrato permanente. Diseña para URL directas, /goto, y /url.

Históricamente, los rastreadores solían leer el destino directamente del enlace de referencia orgánico. Hoy en día, el mismo resultado conceptual puede presentarse de varias formas:

/goto es un punto final de redireccionamiento alojado por Google. El url valor de la consulta suele empezar por CAES—, no porque «CAES» sea el nombre de un producto, sino porque así es como se ve una envoltura binaria habitual tras la codificación Base64URL. Al abrir el enlace, se solicita a Google una redirección al destino real.

/url es una ruta de redireccionamiento de Google más antigua (y que todavía se ve). Según se informa, algunos clientes reciben /url con una CAES carga útil en lugar de un destino en texto plano. La regla de rastreo es la misma en ambos casos: clasificar el enlace y, a continuación, conservar el destino directo o resolver el envoltorio. No des por sentado que los tokens opacos solo aparecen en /goto.

Google ha descrito las capas de redireccionamiento como parte de las medidas técnicas contra el abuso creciente de la Búsqueda. La lógica exacta de implementación no es de dominio público. Diseña para múltiples formatos.

La mayoría de los trabajos de seguimiento de posicionamiento y supervisión de SERP en producción necesitan URL de destino + títulos + fragmentos + posiciones, no el HTML de presentación de Google. Elige primero la ruta del producto.

Envía una consulta contextual de Google al punto final SERP de WebScrapingAPI y lee las colecciones analizadas:

• Punto final: https://serpapi.webscrapingapi.com/v2
• Requisitos: api_key, engine=google, q
• Controles opcionales comunes: device, domain, uule, hl, gl, start, num, tbm, ibp
• Alternativa asíncrona: engine=google_async, y a continuación, recuperarlos a través de la API de Snapshot

Páginas de productos: API de SERP · API
de Búsqueda de Google Documentación: Acceder a la API · Motor de búsqueda de Google

Lo que muestran hoy en día los documentos públicos: los ejemplos de resultados orgánicos utilizan link campos que parecen URL de destino final (por ejemplo https://www.history.com/ o https://en.wikipedia.org/wiki/History), no google.com/goto envuelturas. La documentación de los campos describe link como la URL de destino.

Comprueba el link campo en tu propia respuesta en tiempo real:

• Antes de basarte únicamente en la ruta A, comprueba los link de una consulta de SERP con fecha en tu cuenta.
• La documentación pública muestra ejemplos que parecen indicar el destino link ; si tus respuestas en producción en tiempo real incluyen algún resultado en /goto es algo que solo tu propia muestra puede indicarte; no des nada por sentado a partir de este artículo.

Ten en cuenta también una doble nomenclatura en el esquema de la documentación: algunas páginas muestran un organic matriz (link, display_link, rank), mientras que el documento sobre resultados orgánicos muestra organic_results (link, displayed_link, position). Ambos documentos link como destino. Analiza de forma conservadora ambas formas y valida el resultado con una respuesta real.

Utiliza HTML cuando necesites selectores personalizados, análisis del diseño o un flujo de trabajo que el motor de SERP estructurado no cubra:

• API de scraper: https://api.webscrapingapi.com/v2 con api_key + url
• Set render_js=1 cuando el objetivo requiera JavaScript del lado del cliente antes de recibir el cuerpo
• API del navegador: cuando necesites tiempos de espera documentados, interacciones o controles del estado del navegador

Valida una SERP utilizable. Una solicitud HTTP 200 puede seguir siendo un intersticial, una pantalla de consentimiento, un CAPTCHA o una ventana de «activar JavaScript». Antes de extraer enlaces, comprueba que existan contenedores de resultados reconocibles (por ejemplo, enlaces bajo #rso / #searcho marcadores equivalentes que utilices). Si la validación falla, vuelve a intentarlo con la representación, ajusta la configuración regional o el contexto del dispositivo, o recurre a la opción A: no almacenes en silencio posiciones vacías.

Después de extraer /goto las URL del HTML, resuélvelas mediante HTTP sin formato (véase más abajo). Por lo general, no necesitas otro crédito de rastreo renderizado por cada enlace orgánico.

La resolución es el núcleo de la Ruta B —y una red de seguridad si alguna vez aparece un contenedor en la salida estructurada—.

import requests

def resolve_google_goto(url: str, timeout: float = 10.0) -> str:
    """Resolve a Google /goto (or similar) redirect without following to the destination site."""
    response = requests.get(
        url,
        allow_redirects=False,
        timeout=timeout,
        headers={"User-Agent": "Mozilla/5.0"},
    )
    if response.status_code != 302:
        raise RuntimeError(f"Expected 302, got {response.status_code} for {url[:80]}...")
    location = response.headers.get("Location")
    if not location:
        raise RuntimeError("Redirect response has no Location header")
    return location  # keep full value, including #:~:text= fragments when present

Reglas importantes en producción:

1. allow_redirects=False — lo que quieres es el Location, no un segundo paso hacia el editor.
2. Prefiere GET a HEAD. Según informes públicos, HEAD puede devolver 200 sin un Location encabezado, mientras que GET devuelve 302 con el destino. Tómalo como una recomendación del sector; confirma el comportamiento de HEAD frente a GET en un /goto de tu propio proceso antes de codificar el método de forma fija.
3. Mantén Location tal cual. Google puede devolver fragmentos de texto como #:~:text=.... Elimínalos solo si tu producto necesita explícitamente URL canónicas.
4. Resuelve fuera de la API de scraping cuando el token sea portátil: recógelo mediante HTML de Scraper/navegador y resuélvelo con una sesión de cliente normal.

Patrón cURL mínimo:

curl -sS -o /dev/null -D - \
  "https://www.google.com/goto?url=CAES..." \
  | grep -i '^location:'

No utilices -L si solo necesitas el destino de la redirección.

Nunca construyas el analizador en torno a la subcadena CAES por sí sola. Clasifica primero la URL absoluta:

from urllib.parse import parse_qs, urljoin, urlparse

GOOGLE_BASE_URL = "https://www.google.com/"

def is_google_host(host: str) -> bool:
    host = (host or "").lower()
    return host == "google.com" or host.endswith(".google.com")

def classify_google_link(href: str) -> tuple[str, str]:
    absolute = urljoin(GOOGLE_BASE_URL, href)
    parsed = urlparse(absolute)
    host = parsed.hostname or ""

    if is_google_host(host) and parsed.path == "/goto":
        token = parse_qs(parsed.query).get("url", [""])[0]
        if token.startswith("CAES"):
            return "goto", absolute
        return "goto", absolute  # still a /goto wrapper even if token shape changes

    if is_google_host(host) and parsed.path == "/url":
        return "google_url", absolute

    if parsed.scheme in {"http", "https"} and not is_google_host(host):
        return "direct", absolute

    return "other", absolute

Manejo recomendado:

Canal de HTML → URL:

SERP fetch (SERP API JSON or Scraper/Browser HTML)
        ↓
validate usable payload (JSON modules or SERP DOM)
        ↓
extract candidate hrefs / link fields
        ↓
classify → direct | goto | google_url | other
        ↓
dedupe wrappers (same token often repeats in one SERP)
        ↓
resolve with GET, bounded concurrency, connection reuse
        ↓
merge destinations + store request fingerprint + outcome codes

Una página de resultados de búsqueda (SERP) suele repetir el mismo /goto token tanto en el título como en los enlaces de sitio. Resolver cada enlace supone un desperdicio de solicitudes. Conservar el orden al hacer que sean únicos:

unique_goto_urls = list(dict.fromkeys(goto_urls))

Utiliza un grupo reducido de trabajadores y uno requests.Session por trabajador para que se pueda reutilizar TCP/TLS. El número exacto de trabajadores depende del entorno: ajústalo en función de tu latencia y tus tasas de error, en lugar de copiar las cifras de referencia de otros proveedores.

Los datos comparables de la SERP necesitan contexto además de las URL:

• q, gl, hl, device, domain, uule (si se utiliza), start, num, tbm/ibp
• marca de tiempo de la observación y versión del esquema
• Ruta de obtención (serp_api frente a scraper_html frente a browser_html)
• Recuentos: directo / goto / google_url / resuelto / fallido

Esto se ajusta a las directrices sobre datos web responsables de WebScrapingAPI: conservar el contexto de la observación para que los equipos posteriores puedan interpretar cada registro.

Respuesta breve: considéralo como algo condicional, no como una regla fija.

Varios artículos de terceros (incluido el análisis en profundidad de ScrapingBee de septiembre de 2026) han informado /goto en Chrome y Edge utilizados manualmente, en sesiones de Playwright y en HTML obtenido a través de API de scraping, mientras que algunos navegadores orientados a la privacidad seguían mostrando destinos directos y Safari a veces mostraba /url con CAES. Se trata de observaciones comunicadas por la competencia, no de nuevas ejecuciones de WebScrapingAPI, y no constituyen un compromiso por parte de Google. En esas pruebas se informó de que los cambios de IP o de país por sí solos resultaban insuficientes para forzar enlaces directos; de nuevo, hay que matizar y no sobreajustar.

Supuestos seguros para la producción:

• La automatización no es el único factor desencadenante.
• El motor del navegador por sí solo no es un indicador fiable.
• La geolocalización por sí sola no es un indicador fiable.
• Tu rastreador debe aceptar enlaces directos, /gotoy /url a lo largo del tiempo.

Si necesitas una matriz de navegadores para tu propio informe de cumplimiento, realiza una pequeña prueba interna y fíjala en el tiempo; no publiques reglas sin verificar como si fueran hechos.

No necesitas esta sección para lanzar un rastreador que funcione. Existe para que los equipos dejen de dedicar tiempo a callejones sin salida.

A grandes rasgos, los análisis del sector describen:

1. La decodificación Base64URL del CAES... parámetro → binario
2. Una envoltura compacta similar a protobuf (normalmente un campo constante más un blob delimitado por su longitud)
3. Una carga útil protegida cuyos bytes externos se asemejan al prefijo de salida de una biblioteca criptográfica
4. Sin destino de texto plano recuperable para fines prácticos de scraping

Política de «resolver primero»: decodifica por curiosidad o para investigar malware si es necesario; para productos SERP, llama a /goto y lee Location. Intentar revertir el blob protegido es plantearse el problema equivocado.

Python:

import os
import requests

api_key = os.environ["WSA_API_KEY"]

response = requests.get(
    "https://serpapi.webscrapingapi.com/v2",
    params={
        "api_key": api_key,
        "engine": "google",
        "q": "best trail shoes",
        "gl": "us",
        "hl": "en",
        "device": "mobile",
    },
    timeout=120,
)
response.raise_for_status()
payload = response.json()

# Docs may use organic or organic_results — support both.
organic = payload.get("organic") or payload.get("organic_results") or []

for row in organic:
    link = row.get("link")
    title = row.get("title")
    # Check link on your live response; if it looks like google.com/goto or /url, classify + resolve.
    print(title, "→", link)

Node.js:

const apiKey = process.env.WSA_API_KEY;
if (!apiKey) throw new Error("WSA_API_KEY is required");

const parameters = new URLSearchParams({
  api_key: apiKey,
  engine: "google",
  q: "best trail shoes",
  gl: "us",
  hl: "en",
  device: "mobile",
});

const response = await fetch(
  "https://serpapi.webscrapingapi.com/v2?" + parameters,
  { signal: AbortSignal.timeout(120_000) }
);
if (!response.ok) {
  throw new Error("Google Search API status " + response.status);
}
const payload = await response.json();
const organic = payload.organic || payload.organic_results || [];
for (const row of organic) {
  console.log(row.title, "→", row.link);
}

cURL:

: "${WSA_API_KEY:?WSA_API_KEY is required}"
curl --get --fail-with-body --max-time 120 \
  "https://serpapi.webscrapingapi.com/v2" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "engine=google" \
  --data-urlencode "q=best trail shoes" \
  --data-urlencode "gl=us" \
  --data-urlencode "hl=en" \
  --data-urlencode "device=mobile"

Para las cargas de trabajo en cola, utiliza engine=google_async y el flujo de recuperación de instantáneas documentado, en lugar de bloquear el motor síncrono.

from __future__ import annotations

import os
import threading
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import urlencode

import requests
from bs4 import BeautifulSoup

# reuse classify_google_link + resolve_google_goto from earlier sections

SCRAPER_API = "https://api.webscrapingapi.com/v2"
GOOGLE_SEARCH = "https://www.google.com/search"
_thread_local = threading.local()


def fetch_google_html(query: str, api_key: str) -> str:
    target = GOOGLE_SEARCH + "?" + urlencode({"q": query, "hl": "en"})
    response = requests.get(
        SCRAPER_API,
        params={
            "api_key": api_key,
            "url": target,
            "render_js": "1",  # enable when Google returns a JS shell instead of a SERP
        },
        timeout=120,
    )
    response.raise_for_status()
    return response.text


def assert_usable_serp(html: str) -> None:
    soup = BeautifulSoup(html, "html.parser")
    if not soup.select("#rso a[href], #search a[href]"):
        raise RuntimeError("No recognizable Google search results found (unusable SERP body)")


def extract_links(html: str) -> tuple[list[str], list[str], list[str]]:
    soup = BeautifulSoup(html, "html.parser")
    direct, goto, google_url = [], [], []
    for anchor in soup.select("#rso a[href], #search a[href]"):
        href = anchor.get("href") or ""
        kind, url = classify_google_link(href)
        if kind == "direct":
            direct.append(url)
        elif kind == "goto":
            goto.append(url)
        elif kind == "google_url":
            google_url.append(url)
    return direct, goto, google_url


def get_worker_session() -> requests.Session:
    session = getattr(_thread_local, "session", None)
    if session is None:
        session = requests.Session()
        _thread_local.session = session
    return session


def resolve_goto(url: str) -> tuple[str, str | None]:
    session = get_worker_session()
    try:
        response = session.get(url, allow_redirects=False, timeout=10)
    except requests.RequestException:
        return url, None
    if response.status_code != 302:
        return url, None
    return url, response.headers.get("Location")


def resolve_many(urls: list[str], workers: int = 5) -> dict[str, str]:
    unique_urls = list(dict.fromkeys(urls))
    with ThreadPoolExecutor(max_workers=workers) as executor:
        results = executor.map(resolve_goto, unique_urls)
    return {src: dest for src, dest in results if dest}


def main() -> None:
    api_key = os.environ["WSA_API_KEY"]
    html = fetch_google_html("best trail shoes", api_key)
    assert_usable_serp(html)

    direct, goto, google_url = extract_links(html)
    direct = list(dict.fromkeys(direct))
    goto = list(dict.fromkeys(goto))

    resolved = resolve_many(goto, workers=5)
    # Optionally add handlers for google_url wrappers here.

    destinations = list(dict.fromkeys(direct + list(resolved.values())))
    for url in destinations:
        print(url)

    # Persist fingerprint + counts in your store:
    # path=scraper_html, q, hl, render_js=1, n_direct, n_goto, n_resolved, n_failed


if __name__ == "__main__":
    main()

Instalación: pip install requests beautifulsoup4. Mantén WSA_API_KEY en el entorno; nunca lo codifiques de forma estática.

Las URL públicas de los resultados de búsqueda siguen siendo datos web. Antes de ampliar la recopilación:

1. Especifica el objetivo empresarial (seguimiento de posiciones, visibilidad de la competencia, investigación).
2. Define el alcance de las fuentes públicas (dominios de Google, mercados, dispositivos, exclusiones).
3. Conserva un registro mínimo útil: no todos los campos que muestra Google son necesarios.
4. Asigna responsables de las fases posteriores para el acceso, la conservación y la toma de decisiones.
5. Conserva el contexto de observación para que los resultados sigan siendo interpretables.

Lee el resumen operativo de WebScrapingAPI: Datos web responsables. Tu equipo es responsable de la finalidad, el alcance de las fuentes y el uso posterior; WebScrapingAPI gestiona la ruta de la API seleccionada. Este artículo no constituye asesoramiento jurídico ni es una guía para eludir los controles de seguridad: se trata de un proceso práctico de gestión de URL para la observación legítima de búsquedas públicas.

No. Para el scraping y el seguimiento de posiciones, GET la /goto URL con las redirecciones desactivadas y la lectura Location. La decodificación local de Base64URL/protobuf no proporciona un destino práctico en texto plano.

Prefiero GET. Según informes públicos, HEAD puede devolver 200 sin Location mientras GET devuelve 302 con el destino. Confirma la diferencia entre HEAD y GET en un /goto de tu propio pipeline antes de fijar el comportamiento del cliente.

Ambos son puntos finales de redireccionamiento de Google que pueden situarse entre la SERP y el destino. /goto suele incluir un CAES... url parámetro. /url es un envoltorio de estilo antiguo que aún puede aparecer (a veces con tokens opacos). Clasifica ambos; resuelve lo que no puedas analizar como un destino directo.

Da preferencia a la API de la SERP de Búsqueda de Google cuando los resultados orgánicos estructurados se ajusten a tu esquema: menor fragilidad del HTML y una huella de solicitud más clara. Utiliza la API de Scraper o la API del navegador cuando necesites el marcado sin procesar o una interacción personalizada. Los ejemplos de la documentación muestran link ; comprueba el link campo en tu propia respuesta en tiempo real y anota la fecha antes de dar por hecho el formato bajo el /goto .

Los informes de terceros sugieren que los tokens pueden seguir resolviéndose durante más de un día y pueden funcionar fuera de la sesión original del navegador. Se desconoce su vida útil máxima. Trátalos como redireccionamientos temporales opacos, no como identificadores permanentes. (Informado por la competencia; no se ha vuelto a comprobar aquí).

No de forma fiable como única causa. Las pruebas comunicadas por la competencia observaron /goto tanto en Chrome manual como en Chromium automatizado. No incorpores la regla «Playwright = /goto, Brave = directo» en la lógica de producción.

Los informes del sector describen tokens que podrían recopilarse en un entorno y resolverse posteriormente con un cliente HTTP sencillo. Esto resulta útil para separar la obtención de HTML de la resolución de redireccionamientos, pero no es una garantía para todas las variantes futuras de tokens. Instrumenta los fallos.

Google ha enmarcado las medidas contra las redirecciones como parte de la protección de la Búsqueda frente a los abusos en constante evolución. La lógica exacta de selección no es de dominio público. Desde la perspectiva de un rastreador, los destinos ya no siempre son texto sin formato en HTML.

Trátala como un cuerpo de SERP inutilizable. Activa render_js=1 cuando sea oportuno, confirma la URL de destino y la configuración regional, o cambia a la API de SERP estructurada. Nunca te fíes únicamente de los códigos de estado.

Almacena los destinos con la huella digital de la solicitud (q, gl, hl, device, dominio, desplazamientos, ruta de obtención y marca de tiempo). Esto se ajusta a las prácticas de observación responsables y evita falsos «cambios en la clasificación» provocados por la mezcla de configuraciones regionales o dispositivos.

1. Llama al motor síncrono de Google en https://serpapi.webscrapingapi.com/v2 junto con api_key, engine=google, y q.
2. Inspecciona los link en una respuesta en tiempo real desde tu cuenta y anota la fecha.
3. Si sigues utilizando HTML, realiza la clasificación → deduplicación → resolución antes de ampliar el volumen de palabras clave.
4. Revisa los datos web pertinentes con los responsables de los datos.

Empieza con la API de Búsqueda de Google, compara motores de la API de SERP u obtén el código HTML de la página a través de la API de Scraper o la API del navegador cuando los resultados estructurados no sean suficientes.