JavaScript no perjudica tu SEO por sí solo. Google lo ejecuta, incluso para títulos y canónicas. El riesgo aparece cuando el contenido importante solo existe tras el renderizado, cuando el servidor responde 200 a cualquier URL o cuando los enlaces no tienen una dirección real. Hay un segundo punto: no todos los bots ejecutan JavaScript. Saber si tienes un problema lleva cinco minutos, comparando el código fuente con la página renderizada.
Esta guía sirve a quien hace SEO y a quien desarrolla. Primero va el diagnóstico, después ocho fallos con código, y luego Next.js, Nuxt, Vue, React sin framework y Astro. Leímos la documentación el 5 de noviembre de 2026: Next.js 16.4, Nuxt 4.6 y React 19.3. Los ejemplos de código se ejecutaron ese día con Next.js 16.4.3, Nuxt 4.6.2, React 19.3.0 y Astro 7.4.2.
Qué riesgo tiene cada forma de renderizar
La pregunta que lo decide es si el contenido está en el HTML que envía el servidor. La columna «Riesgo para el SEO» es criterio nuestro, no una medición.
| Tipo | Dónde se genera el HTML | Riesgo para el SEO | Para qué sirve |
|---|---|---|---|
| CSR (renderizado en cliente) | En el navegador; el servidor envía una carcasa vacía | El mayor. Contenido, enlaces y estado dependen de JavaScript | Zonas con acceso privado, herramientas |
| SSR (renderizado en servidor) | En el servidor, en cada petición | Bajo, si el servidor responde rápido y los códigos de error son correctos | Páginas que cambian a menudo o según el usuario |
| SSG (generación estática) | Al compilar, como archivo terminado | Bajo. La actualización depende de la siguiente compilación | Guías, documentación, páginas de aterrizaje |
| ISR (regeneración estática incremental) | Estático, se regenera por tiempo o por evento | Bajo. Ante un fallo, comprobar qué versión se está sirviendo | Catálogos grandes |
Google escribe que renderizar en servidor o de antemano sigue siendo buena idea, porque acelera la web para usuarios y rastreadores, y porque no todos los bots pueden ejecutar JavaScript. El prerendering solo para bots, el llamado renderizado dinámico, lo describe como una solución provisional y no a largo plazo.
Cómo procesa Google el JavaScript
Lo básico está en la documentación de Google, actualizada el 4 de marzo de 2026. Muchos textos antiguos, también la versión anterior de este artículo, hablan de una «segunda ola» con esperas de días o semanas. Hoy Google dice otra cosa: la página puede quedarse en la cola unos segundos, aunque puede tardar más. No da una duración fiable, ni larga ni corta.
El proceso tiene tres fases:
- Rastreo. Googlebot consulta el robots.txt y pide la URL. Lee los enlaces del atributo
hrefen la respuesta HTML. - Renderizado. Todas las páginas con estado 200 entran en la cola, tengan JavaScript o no, salvo que una metaetiqueta o cabecera robots impida indexarlas. Un Chromium sin interfaz ejecuta el JavaScript cuando hay recursos.
- Indexación. Google usa el HTML renderizado, y los enlaces que encuentra ahí pasan a la cola de rastreo.
De aquí salen varias consecuencias prácticas:
- Estado distinto de 200: puede saltarse el renderizado, así que un 404 tiene que darlo ya el servidor.
- noindex en el HTML original: Google puede saltarse el renderizado y el JavaScript, de modo que quitarlo luego con un script puede no funcionar.
- Sin memoria: cada URL se carga sin estado. Local Storage, Session Storage y cookies se vacían entre cargas de página.
- Sin permisos: Googlebot rechaza las solicitudes de permiso, por ejemplo de la cámara.
- Solo HTTP: no admite WebSockets ni WebRTC. Lo que llega solo por ahí no lo ve.
- Caché: Googlebot guarda mucho en caché y puede ignorar las cabeceras. Por eso Google recomienda archivos con huella en el nombre, como
main.2bb85551.js. - Título y canónica con JavaScript: se puede, aunque Google prefiere la canónica en el HTML. JavaScript no debe cambiarla a un valor distinto del original.
Rastreadores de IA: lo que se puede demostrar y lo que no
Circula mucho la frase «no ejecutan JavaScript», casi siempre sin fuente. El 5 de noviembre de 2026 leímos las páginas de rastreadores de OpenAI, Anthropic y Perplexity. Hablan de nombres de rastreadores, rangos de IP y robots.txt. Sobre ejecutar JavaScript no dicen nada, ni a favor ni en contra.
Lo que sí está documentado son dos afirmaciones cercanas. Google dice en general que no todos los bots pueden ejecutar JavaScript. Y la documentación de Next.js trata a los «HTML-limited bots» como un grupo aparte, con facebookexternalhit como ejemplo.
Para trabajar basta con eso, porque la recomendación no depende de la pregunta abierta: si tu contenido está en el HTML del servidor, te da igual lo que pueda hacer cada bot. Si quieres saberlo en tu web, revisa los registros del servidor buscando rastreadores y peticiones a tus archivos JavaScript, con tres cautelas. Los bots guardan archivos en caché, los nombres se pueden falsificar y pocas peticiones no demuestran nada. Comprueba los rangos de IP que publican los proveedores, y lee cero peticiones como indicio y no como prueba.
Diagnóstico en cinco minutos
Este orden no cuesta nada y responde a casi todo.
- Ver el código fuente. Con
Ctrl+Uo concurl. Buscar una frase del contenido principal, el título y un enlace interno importante. - Ver la versión renderizada. La Inspección de URLs de Search Console muestra el código renderizado, los recursos cargados y la consola. Para páginas ajenas está la Prueba de resultados enriquecidos.
- Comparar. Si la frase solo sale en la versión renderizada, depende de JavaScript.
- Comprobar el estado. Pedir una URL que no existe. Si responde 200 y no 404, hay un problema de soft 404.
- Desactivar JavaScript. Lo que desaparece tampoco lo ve un bot que no lo ejecute.
#!/bin/sh
# Comprobación rápida: buscar una frase en el HTML del servidor
URL="$1"
FRASE="$2"
curl -s -o /dev/null -w 'Estado: %{http_code}\n' -A "Mozilla/5.0" "$URL"
curl -s -A "Mozilla/5.0" "$URL" | grep -o -F "$FRASE" | wc -l
curl -s -A "Mozilla/5.0" "$URL" | grep -i -o '<meta[^>]*name="robots"[^>]*>'
curl -s -A "Mozilla/5.0" "$URL" | grep -i -o '<link[^>]*rel="canonical"[^>]*>'
| Síntoma | Causa probable | Cómo comprobarlo |
|---|---|---|
| Página indexada, falta parte del texto en el HTML renderizado | El contenido llega tras una interacción o por WebSocket | Inspección de URLs, HTML renderizado |
| «Rastreada, sin indexar» en muchas páginas parecidas | Carcasa vacía, todas las páginas se ven iguales | Comparar el código fuente de varias URL |
| Soft 404 en Search Console | Página de error con estado 200 | curl a una URL inventada |
| Google no encuentra páginas nuevas | Enlaces sin href o rutas con almohadilla | Revisar los enlaces en el HTML renderizado |
| Falta contenido, aunque en tu navegador está | JavaScript bloqueado en robots.txt, o estado que se espera de una cookie o de Local Storage | Recursos cargados en la Inspección de URLs |
| Google muestra contenido antiguo o errores tras publicar | Archivo JavaScript antiguo en caché | ¿Hay huella en los nombres de archivo? |
| Canónica inesperada | JavaScript la cambia, o hay varias | Código fuente frente a HTML renderizado |
La tabla parte de la lista de problemas de Google. Asociar síntoma y causa es lectura nuestra: indica dónde mirar primero y no demuestra la causa.
Ocho fallos, con comprobación y solución
El orden no es una clasificación, y no hemos medido la frecuencia de cada fallo. Otros puntos de la lista de Google que no detallamos aquí: la carga diferida debe permitir a Google encontrar las imágenes, los datos estructurados se pueden insertar con JavaScript y hay que probarlos, y de los web components Google solo ve lo que queda visible en el HTML renderizado.
1. El contenido solo aparece tras una petición en el navegador
Síntoma: en el código fuente pone «Cargando…». Comprobación: buscar en el código una frase del contenido principal. Solución: obtener los datos en el servidor.
'use client'
import { useEffect, useState } from 'react'
export default function Producto({ slug }) {
const [producto, setProducto] = useState(null)
useEffect(() => {
fetch(`/api/productos/${slug}`).then((r) => r.json()).then(setProducto)
}, [slug])
if (!producto) return <p>Cargando…</p>
return <h1>{producto.nombre}</h1>
}
Google puede renderizarlo, pero dependes de la cola, de tu API y de que el bot ejecute JavaScript. Un componente de servidor, como el del apartado de Next.js, quita esas tres dependencias.
2. Faltan el título y la descripción en el head
Síntoma: todas las páginas tienen el mismo título en el código, o ninguno. Comprobación: buscar <title dentro del head. Solución: generar los metadatos en el servidor. Google lee títulos puestos con JavaScript, pero las redes sociales y otros bots quizá no.
#!/bin/sh
URL="$1"
rm -f pagina.html
curl -sf -A "Mozilla/5.0" "$URL" -o pagina.html || { echo "Fallo en la peticion"; exit 1; }
# solo la parte hasta el primer </head>
tr '\n' ' ' < pagina.html | sed 's#</head>.*##' > pagina_head.txt
grep -o -i '<title[ >]' pagina_head.txt | wc -l
grep -o -i 'name="description"' pagina_head.txt | wc -l
grep -o -i '<title[ >]' pagina.html | wc -l
Los dos primeros números cuentan dentro del head y el tercero en todo el documento. Un 0 arriba y un 1 abajo significa que el título está en el body.
3. JavaScript cambia la canónica
Síntoma: la canónica del código difiere de la renderizada. Comprobación: comparar ambas versiones y contar las etiquetas. Solución: ponerla en el HTML y una sola vez. Google avisa de que varias canónicas o contradictorias pueden dar resultados inesperados.
<link rel="canonical" href="https://example.com/productos/zapatilla-roja">
4. Enlaces sin dirección real
Síntoma: no se encuentran subpáginas, aunque la navegación funciona en el navegador. Comprobación: ¿son <a> con href? Solución: en general, Google solo puede rastrear enlaces así. Un onclick adicional no molesta.
<!-- Google puede seguirlos -->
<a href="/productos/zapatillas">Zapatillas</a>
<a href="/productos/zapatillas" onclick="irA('zapatillas')">Zapatillas</a>
<!-- Google no puede seguirlos de forma fiable -->
<a onclick="irA('zapatillas')">Zapatillas</a>
<span onclick="irA('zapatillas')">Zapatillas</span>
5. Rutas con almohadilla
Síntoma: direcciones como /#/productos. Comprobación: la barra de direcciones. Solución: Google no puede resolverlas de forma fiable y recomienda la History API.
<!-- Mal -->
<a href="#/productos">Productos</a>
<!-- Bien -->
<a href="/productos">Productos</a>
<script>
document.querySelector('a[href="/productos"]').addEventListener('click', (e) => {
e.preventDefault()
history.pushState({}, '', '/productos')
// aquí se carga la vista
})
</script>
Para que estas URL funcionen al abrirlas directamente, el servidor también tiene que conocerlas.
6. Página de error con estado 200
Síntoma: las URL inventadas responden 200. Comprobación: curl -I a una dirección inventada. Solución: lo correcto es un 404 del servidor. En una SPA pura, Google da dos salidas:
fetch(`/api/productos/${id}`)
.then((r) => r.json())
.then((producto) => {
if (!producto.existe) {
// Opción 1: ir a una URL que el servidor responde con 404
window.location.href = '/no-encontrado'
// Opción 2, en lugar de la anterior: marcar la página con noindex
// const m = document.createElement('meta')
// m.name = 'robots'
// m.content = 'noindex'
// document.head.appendChild(m)
}
})
7. Un noindex que JavaScript debería quitar
Síntoma: la página no entra en el índice, aunque el HTML renderizado parece correcto. Comprobación: la metaetiqueta robots en el código. Solución: si la página debe indexarse, no pongas noindex en el HTML original. De lo contrario, Google puede saltarse el renderizado.
<!-- Arriesgado -->
<meta name="robots" content="noindex">
<script>
document.querySelector('meta[name="robots"]').remove()
</script>
8. Archivos JavaScript bloqueados
Síntoma: la Inspección de URLs informa de recursos sin cargar. Comprobación: robots.txt y la lista de recursos. Solución: Google no renderiza JavaScript de archivos bloqueados.
# Mal
User-agent: *
Disallow: /_next/
Disallow: /assets/js/
# Mejor
User-agent: *
Disallow: /admin/
Next.js con App Router
En la documentación de Next.js 16, los metadatos se definen con metadata o con generateMetadata. Según esa documentación, notFound() muestra una página 404 y añade un noindex.
// app/productos/[slug]/page.tsx
import type { Metadata } from 'next'
import { notFound } from 'next/navigation'
import { getProducto } from '@/lib/productos'
type Props = { params: Promise<{ slug: string }> }
export async function generateMetadata({ params }: Props): Promise<Metadata> {
const { slug } = await params
const producto = await getProducto(slug)
if (!producto) return {}
return {
title: producto.nombre,
description: producto.resumen,
alternates: { canonical: `/productos/${slug}` },
}
}
export default async function Page({ params }: Props) {
const { slug } = await params
const producto = await getProducto(slug)
if (!producto) notFound()
return <h1>{producto.nombre}</h1>
}
Lo que mostró nuestra prueba
Ejecutamos los ejemplos el 5 de noviembre de 2026 con Next.js 16.4.3. Un slug desconocido dio estado 404 con noindex, como dice la documentación. Pero con un loading.tsx por encima, el estado fue 200 y solo quedó el noindex. La documentación de Next.js lo describe igual: la respuesta empieza a enviarse antes de que actúe notFound() y conserva el estado 200. Así que, si tienes un límite de carga, comprueba una URL inventada con curl -I en vez de fiarte del código.
Metadatos en el body: una sorpresa en las auditorías
Cuando generateMetadata es dinámico, Next.js puede enviar los metadatos en streaming tras la primera salida, y acaban en el <body> y no en el <head>. La documentación dice que lo ha verificado con bots que ejecutan JavaScript, como Googlebot. Para los «HTML-limited bots», como facebookexternalhit, Next.js sigue bloqueando y escribe las etiquetas en el head. Los detecta por el user agent.
En nuestra prueba, el título acabó en el body con un límite de Suspense como loading.tsx por encima, tanto con un navegador normal como con el nombre de Googlebot. Sin ese límite se quedó en el head, incluso con una fuente de datos retrasada 1,5 segundos. Así que fíjate en los límites de carga. Para Google no es un fallo, según la documentación. Si un rastreador de IA lee un título en el body, los proveedores no lo dicen. Para ir sobre seguro, usa htmlLimitedBots, que en nuestra prueba devolvió el título al head. La documentación avisa de que puede alargar los tiempos de respuesta, y considera suficiente la opción por defecto en la mayoría de los casos.
// next.config.ts
import type { NextConfig } from 'next'
const config: NextConfig = {
htmlLimitedBots: /.*/,
}
export default config
Nuxt
La documentación actual es de Nuxt 4, y leímos la versión 4.6. Si sigues ejemplos de Nuxt 3, compruébalos. Por defecto usa renderizado universal: el servidor entrega el contenido en el HTML y el navegador toma el control con la hidratación. La documentación señala useSeoMeta como la forma recomendada de añadir metaetiquetas.
<!-- pages/productos/[slug].vue -->
<script setup lang="ts">
const route = useRoute()
const { data: producto } = await useFetch(`/api/productos/${route.params.slug}`)
if (!producto.value) {
throw createError({ status: 404, statusText: 'No encontrado' })
}
useSeoMeta({
title: () => producto.value?.nombre,
description: () => producto.value?.resumen,
})
</script>
<template>
<h1>{{ producto?.nombre }}</h1>
</template>
Con routeRules decides el renderizado por ruta. Un ssr: false en una zona que deben ver los buscadores es el error que hay que buscar:
// nuxt.config.ts
export default defineNuxtConfig({
routeRules: {
'/guias/**': { prerender: true },
'/cuenta/**': { ssr: false },
},
})
Un límite de nuestra prueba con Nuxt 4.6.2: /guias/x se generó como archivo estático con nuxt build --prerender y un enlace a la página. Después de compilar, comprueba que el archivo está de verdad en la carpeta de salida.
Vue sin Nuxt
Vue Router tiene dos modos, y la diferencia decide tus URL. createWebHistory() produce direcciones normales y es el modo recomendado, según su documentación. createWebHashHistory() añade una almohadilla, y lo que va detrás no llega al servidor. Es el fallo 5 de arriba.
import { createRouter, createWebHistory } from 'vue-router'
const router = createRouter({
history: createWebHistory(),
routes: [],
})
El modo History necesita la configuración de servidor adecuada, o la visita directa a una subpágina dará un 404, avisa la documentación. Al revés, comprueba que el servidor no entregue la misma carcasa con estado 200 a cualquier dirección inventada. Sería el fallo 6.
La documentación de Vue va más lejos que Google sobre el renderizado. Dice que Google y Bing indexan bien aplicaciones JavaScript síncronas, pero que el rastreador no esperará al contenido que llega tras un indicador de carga. Google no lo describe así y solo dice que ejecuta JavaScript. Para tu decisión cambia poco: para unas pocas páginas de marketing, y para contenidos como documentación o blogs, Vue apunta a SSG antes que a SSR. La comparación entre código fuente y HTML renderizado te enseña lo que llega en tu caso.
React sin framework
Una aplicación de React pura, con Vite o similar, entrega una carcasa vacía. Para el contenido público hay tres caminos:
- Adoptar un framework. Lo más completo, y a menudo una reconstrucción.
- Prerenderizar al compilar. Para páginas que cambian poco. Las API de servidor de
react-domgeneran el HTML. - Separar la parte pública. Marketing y guías como páginas estáticas, con la aplicación detrás tal como está.
Desde React 19 puedes renderizar <title> y <meta> desde cualquier componente, y la documentación dice que React los coloca siempre en el head. En nuestra prueba con React 19.3.0 eso solo se cumplió cuando React renderizaba también el envoltorio. Al insertar el resultado de renderToString como fragmento en un <body> propio, título y meta se quedaron en el body. Con <html> y <head> dentro del árbol de React llegaron al head, aunque estén escritos en el componente:
// Ficha.jsx
export default function Ficha({ producto }) {
return (
<article>
<title>{producto.nombre}</title>
<meta name="description" content={producto.resumen} />
<h1>{producto.nombre}</h1>
</article>
)
}
// prerender.mjs. Antes: esbuild Ficha.jsx --jsx=automatic --format=esm --outfile=Ficha.js
import { writeFileSync } from 'node:fs'
import { createElement as h } from 'react'
import { renderToString } from 'react-dom/server'
import Ficha from './Ficha.js'
const producto = { nombre: 'Zapatilla roja', resumen: 'Ficha de ejemplo' }
const html = renderToString(
h('html', { lang: 'es' },
h('head', null, h('meta', { charSet: 'utf-8' })),
h('body', null, h(Ficha, { producto }))),
)
writeFileSync('zapatilla-roja.html', `<!doctype html>${html}`)
renderToString basta para este ejemplo sencillo. La documentación de React, eso sí, lo incluye entre las API heredadas, y no admite streaming ni espera de datos. Para esos casos remite a prerender, de react-dom/static, que no hemos ejecutado.
Astro en zds.es, y lo que enseña
Esta web también funciona con Astro. Según su documentación, Astro renderiza las páginas a HTML estático y solo carga JavaScript en las islas que marcas expresamente. Hay más sobre esa decisión en nuestro artículo sobre headless CMS y Astro.
---
// Sin client:* el componente se queda en HTML, sin JavaScript en el navegador
import Calculadora from '../components/Calculadora.jsx'
import Ficha from '../components/Ficha.astro'
---
<Ficha />
<Calculadora client:visible />
Hicimos la comparación del diagnóstico con nuestras propias páginas. El 5 de noviembre de 2026, nuestra entrada del glosario sobre JavaScript SEO tenía 2.567 palabras en el HTML del servidor y 2.591 renderizada. La diferencia de 24 palabras es sobre todo el aviso de cookies. Título, H1 y canónica coincidían en ambas versiones, y sin JavaScript el contenido seguía completo. La portada y un artículo dieron el mismo resultado.
Eso enseña cómo se ve esta prueba cuando no falta nada. No demuestra que Astro traiga mejores posiciones. También aquí hay fallos, en otros sitios. Tenemos cuatro documentados, y ninguno tiene que ver con JavaScript en el navegador:
- Código de error equivocado (31-8-2026): una avería del CMS dio 404 en lugar de 503, y eso podía haber sacado páginas del índice. La documentación de Google explica la diferencia: un 404 retira URL indexadas, y un 5xx frena primero el rastreo, y las URL indexadas solo acaban saliendo con el tiempo.
- Mayúsculas en las rutas (8-10-2026): respondían 200 con canónica propia, es decir, duplicados. La redirección que lo corrigió creó un bucle de 301 con la codificación por porcentaje, detectado el 30-10-2026. Un arreglo necesita la misma prueba que el fallo.
- Idiomas por caminos distintos (5-11-2026): un plugin de SEO ponía
nofollowsolo a través del filtro de contenido del CMS. El español pasaba por ahí; el inglés y el alemán salían de campos propios y no lo tenían. Una comprobación en un solo idioma no lo ve. - Sitemap en memoria: un servicio lo guarda hasta una hora. El 5 de noviembre de 2026 la cabecera marcaba 54 minutos. Tras una actualización,
lastmodpuede quedar antiguo un rato sin que haya nada roto.
Lista de comprobación
- ¿Hay una frase del contenido principal en el código fuente?
- ¿Título, descripción y canónica están en el head, una vez cada uno?
- ¿Todos los enlaces importantes son
<a href>con rutas reales? - ¿Una URL inventada devuelve 404?
- ¿No hay en el HTML original un noindex pensado para quitarse después?
- ¿JavaScript y CSS están libres de bloqueos en robots.txt?
- ¿Los archivos JavaScript llevan huella en el nombre?
- ¿El contenido carga sin interacción, permisos, cookies ni WebSockets?
- ¿El HTML renderizado en la Inspección de URLs es el que esperas?
Preguntas frecuentes
¿Google puede leer JavaScript?
Sí. Google ejecuta JavaScript con un Chromium actualizado y usa el HTML renderizado para indexar. Tiene límites: Googlebot no ve archivos bloqueados, contenido tras una interacción o por WebSockets, ni estado guardado en cookies. Por eso la Inspección de URLs sigue haciendo falta, aunque el contenido salga en tu navegador.
¿Cuánto espera una página para renderizarse?
Google dice que puede quedarse en la cola unos segundos, aunque puede tardar más. No hay un tiempo fijo. Las antiguas afirmaciones de días o semanas no están en la documentación actual, del 4 de marzo de 2026. No tenemos una medición propia sobre esto.
¿Necesito SSR para el SEO?
Para Google, no estrictamente, porque también renderiza páginas en cliente. Aun así recomienda renderizar en servidor o de antemano, porque es más rápido y no todos los bots ejecutan JavaScript. Para páginas públicas que quieres que se encuentren, SSR o SSG es lo seguro. Tras un inicio de sesión no hace falta.
¿Debo montar renderizado dinámico?
En proyectos nuevos, no. Google lo llama solución provisional y recomienda renderizado en servidor, estático o hidratación. Renderizado dinámico significa servir a los bots una versión distinta de la de los usuarios, y eso obliga a mantenerla y vigilarla de forma permanente.
¿ChatGPT y otros servicios de IA ejecutan JavaScript?
Las páginas de rastreadores de OpenAI, Anthropic y Perplexity, leídas el 5 de noviembre de 2026, no lo dicen. No podemos respaldar una afirmación en ningún sentido. Con el contenido en el HTML del servidor no necesitas la respuesta. En tu web, los registros del servidor dan indicios, no pruebas.
Fuentes
Consultadas el 5 de noviembre de 2026. Enlazamos la documentación de Google en inglés, porque la versión española es una traducción automática.
- Google: conceptos básicos de JavaScript SEO (actualizada el 4-3-2026, en inglés)
- Google: corregir problemas de JavaScript (en inglés)
- Google: renderizado dinámico como solución provisional (en inglés)
- Google: enlaces rastreables (en inglés)
- Google: códigos de estado HTTP y rastreo (en inglés)
- Next.js: generateMetadata y notFound
- Nuxt: useSeoMeta, renderizado y createError
- Vue Router: modos de historial y Vue: SSR
- React: title y renderToString
- Astro: islas
- OpenAI: rastreadores, Anthropic: rastreadores y Perplexity: rastreadores
Conceptos relacionados: JavaScript SEO, soft 404, canonical, noindex y análisis de logs.
Cómo se hizo este artículo
La primera versión es de marzo de 2026. Se reescribió en noviembre de 2026 con apoyo de IA, a partir de la documentación enlazada arriba y de una muestra propia de tres páginas, y se revisó antes de publicarlo. Los ejemplos de Next.js, Nuxt, React y Astro se ejecutaron en proyectos de prueba con Next.js 16.4.3, Nuxt 4.6.2, React 19.3.0 y Astro 7.4.2. Los fragmentos de HTML, robots.txt y scripts solo se comprobaron en sintaxis o con páginas de prueba, y el de Vue Router no se ejecutó.