Una aplicación hecha con AJAX que en el navegador se ve llena de contenido y en Google sale con dos URLs indexadas, sin título o con el texto de "Cargando...". Ese es el síntoma.
La versión antigua de este post explicaba el esquema #! con instantáneas en ?_escaped_fragment_=. Eso ya no sirve. Google lo dio por obsoleto en octubre de 2015 y dejó de usarlo en el segundo trimestre de 2018, cuando pasó a renderizar él mismo las URLs con #! (anuncio de diciembre de 2017).
Si todavía tenéis código que sirve instantáneas a _escaped_fragment_, Google ya no las pide. Lo que ve es lo que renderiza.
Cómo procesa Google hoy una página con JavaScript
Tres fases: rastrea el HTML, lo pone en cola de renderizado y, cuando lo renderiza con un Chromium actualizado (el Googlebot "evergreen"), indexa el resultado.
Según la documentación de JavaScript SEO, Google pone en cola de renderizado las páginas que responden 200. La espera puede ser de segundos o más. Y una página que responde 404 puede no renderizarse nunca.
Entonces el problema ya no es "Google no lee JavaScript". El problema es todo lo que puede salir mal entre el HTML inicial y el renderizado.
Descartad primero lo que no es
Antes de tocar la arquitectura, mirad qué ve Googlebot. En Search Console, Inspección de URLs, "Probar URL publicada" y luego "Ver página probada": ahí tenéis el HTML renderizado y la captura.
Si el contenido está en ese HTML renderizado, el problema no es el JavaScript. Será otra cosa: contenido duplicado, enlaces internos, calidad.
Si no está, los sospechosos habituales:
- Recursos bloqueados en robots.txt. Si el JS o la API que trae el contenido están bloqueados, Googlebot renderiza una página vacía.
- Contenido que solo aparece tras un clic, scroll o login. Googlebot no hace clic.
- Llamadas a la API que fallan o tardan. Lo veis en la pestaña de recursos de la página probada.
- Un
noindexen el HTML inicial que el JavaScript quita después. Google puede leer elnoindexy no renderizar. La documentación lo dice claro: si queréis que se indexe, no pongáisnoindexen el HTML original.
Más detalle sobre esta comprobación en Google no lee tu web como la ves tú.
Las URLs: adiós a la almohadilla
Aquí estaba el corazón del esquema antiguo, y aquí está lo que más cambia.
Google pide usar la History API para el enrutado en cliente y no usar fragmentos (#) para cargar contenido distinto, porque así Googlebot no puede extraer esas URLs.
Ejemplos:
/catalogo#/producto-42→ mal. Googlebot no lo trata como una URL propia./catalogo#!producto=42→ evitadlo. Google dijo que seguiría mostrando las#!heredadas, pero no es el camino para algo nuevo./catalogo/producto-42conhistory.pushState()→ bien. Es una URL propia.
Y esa URL tiene que funcionar si alguien entra directamente. Si al recargar /catalogo/producto-42 el servidor devuelve 404 o la portada, Google tampoco podrá con ella. Las URLs limpias son condición, no adorno.
Si venís de una aplicación con #! indexada y la pasáis a rutas reales, no podéis hacer una 301 desde el servidor, porque el fragmento no llega al servidor. Hay que hacerlo en JavaScript: leer location.hash y redirigir a la ruta nueva.
// Ejemplo: /#!/catalogo/producto-42 → /catalogo/producto-42
// Si vuestro formato antiguo era #!clave=valor, aquí va vuestra tabla de equivalencias
if (location.hash.startsWith('#!')) {
const ruta = location.hash.slice(2).replace(/^\/?/, '/');
location.replace(ruta);
}
Enlaces que Google pueda seguir
Google solo descubre enlaces que son elementos <a> con atributo href (enlaces rastreables).
<a href="https://www.ejemplo.es/catalogo/producto-42">→ lo sigue.<span onclick="ir(42)">→ no lo sigue.<a href="javascript:void(0)">→ no lo sigue.
Podéis interceptar el clic con JavaScript para no recargar la página. Lo importante es que el href real esté en el HTML.
Códigos de estado y soft 404
Una aplicación de una sola página suele responder 200 a todo, incluso a productos que no existen. Google lo detecta como soft 404, o peor, indexa páginas vacías.
Las dos salidas que da Google:
- Redirigir con JavaScript a una URL que el servidor sirva con 404.
- Insertar
<meta name="robots" content="noindex">en las páginas de error.
Lo mejor, si podéis, es que el servidor conozca las rutas y responda el código correcto desde el principio.
La solución de fondo: que el HTML ya traiga el contenido
Las instantáneas del esquema antiguo eran, al final, renderizado en servidor hecho a mano. La idea sobrevive con nombres nuevos:
- Renderizado en servidor (SSR): el servidor devuelve el HTML completo y luego el JavaScript toma el control (hidratación).
- Generación estática: el HTML de cada ruta se genera al publicar. Ideal si el contenido cambia poco.
- Renderizado dinámico: servir HTML prerenderizado solo a los bots. Google lo llama ya "un apaño, no una solución recomendada" y recomienda SSR, estático o hidratación.
Comparativa de técnicas en Rendering on the Web.
A mi entender, para webs de contenido (catálogos, blogs, fichas) la aplicación AJAX pura casi nunca compensa. HTML servido desde el servidor y JavaScript solo para lo interactivo. Se indexa mejor y carga antes. Si el problema de fondo es velocidad, eso entra en lo que hago en WPO.
Y luego están las IAs
Aquí el HTML inicial vuelve a importar, y mucho.
Google usa el mismo índice para AI Overviews y el Modo IA, así que lo que Google renderiza le sirve también ahí (guía de Google sobre IA generativa en la Búsqueda). Pero los rastreadores de otros asistentes son otra historia.
Un análisis de Vercel publicado en diciembre de 2024 sobre su propia red (The rise of the AI crawler) concluyó que ninguno de los grandes rastreadores de IA que midieron (los de OpenAI, Anthropic, Meta, Perplexity, entre otros) ejecutaba JavaScript. Es un estudio de un tercero y de una fecha concreta, no documentación de cada empresa. Pero la lectura práctica es la misma: si vuestro contenido solo existe después de ejecutar JavaScript, para esos bots la página está vacía.
Comprobación rápida desde la terminal:
curl -s https://www.ejemplo.es/catalogo/producto-42 | grep -i "texto que debería salir"
Si no aparece, Google quizá lo vea tras renderizar. ChatGPT y compañía, probablemente no. Esto lo trabajo en la parte de visibilidad en IAs.
Lista corta para una aplicación AJAX en 2026
- Inspección de URLs en Search Console: ¿está el contenido en el HTML renderizado?
curlsin JavaScript: ¿está en el HTML inicial?- Rutas con History API, sin
#!, que funcionen al entrar directamente. - Enlaces como
<a href>. - Título, descripción, canonical y datos estructurados presentes en el HTML renderizado.
- 404 de verdad para lo que no existe.
- Si hay que elegir arquitectura: SSR o estático antes que renderizado dinámico.
¿Sigue funcionando _escaped_fragment_?
No. Google dejó de usar el esquema AJAX en 2018 y renderiza la URL directamente. Las instantáneas que sirváis en esa ruta no las pide nadie.
¿Google indexa contenido cargado por AJAX?
Sí, si el contenido aparece al renderizar sin interacción del usuario y los recursos no están bloqueados. Comprobadlo con la Inspección de URLs.
¿Las URLs con #! siguen indexadas?
Google dijo en 2017 que seguiría mostrando esas URLs. Para webs nuevas, usad rutas reales con History API.
¿Vuestra aplicación pasa la prueba del curl, o el HTML inicial llega vacío?
¿Te ha servido? Si quieres que lo mire en tu web, aquí te cuento cómo trabajo el SEO o escríbeme.
¿Te queda alguna duda?
Pregúntamela y la respondo en el muro de preguntas, una vez al día.