Ir al contenido
Por Actualizado el 21 min lectura Desarrollo Web

JavaScript SEO: diagnóstico y soluciones en React, Next.js, Vue y Nuxt

Código SVG y CSS en un editor con fondo oscuro

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.

TipoDónde se genera el HTMLRiesgo para el SEOPara qué sirve
CSR (renderizado en cliente)En el navegador; el servidor envía una carcasa vacíaEl mayor. Contenido, enlaces y estado dependen de JavaScriptZonas con acceso privado, herramientas
SSR (renderizado en servidor)En el servidor, en cada peticiónBajo, si el servidor responde rápido y los códigos de error son correctosPáginas que cambian a menudo o según el usuario
SSG (generación estática)Al compilar, como archivo terminadoBajo. La actualización depende de la siguiente compilaciónGuías, documentación, páginas de aterrizaje
ISR (regeneración estática incremental)Estático, se regenera por tiempo o por eventoBajo. Ante un fallo, comprobar qué versión se está sirviendoCatá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:

  1. Rastreo. Googlebot consulta el robots.txt y pide la URL. Lee los enlaces del atributo href en la respuesta HTML.
  2. 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.
  3. 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.

¿De dónde sale esa frase en tus propios documentos?

Diagnóstico en cinco minutos

Este orden no cuesta nada y responde a casi todo.

  1. Ver el código fuente. Con Ctrl+U o con curl. Buscar una frase del contenido principal, el título y un enlace interno importante.
  2. 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.
  3. Comparar. Si la frase solo sale en la versión renderizada, depende de JavaScript.
  4. Comprobar el estado. Pedir una URL que no existe. Si responde 200 y no 404, hay un problema de soft 404.
  5. 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íntomaCausa probableCómo comprobarlo
Página indexada, falta parte del texto en el HTML renderizadoEl contenido llega tras una interacción o por WebSocketInspección de URLs, HTML renderizado
«Rastreada, sin indexar» en muchas páginas parecidasCarcasa vacía, todas las páginas se ven igualesComparar el código fuente de varias URL
Soft 404 en Search ConsolePágina de error con estado 200curl a una URL inventada
Google no encuentra páginas nuevasEnlaces sin href o rutas con almohadillaRevisar 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 StorageRecursos cargados en la Inspección de URLs
Google muestra contenido antiguo o errores tras publicarArchivo JavaScript antiguo en caché¿Hay huella en los nombres de archivo?
Canónica inesperadaJavaScript la cambia, o hay variasCó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
¿Cuáles de tus rutas pasan por un loading.tsx?

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-dom generan 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 nofollow solo 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, lastmod puede 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.

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ó.

Si eliges ZDS como fuente preferida, Google te mostrará nuestros artículos con más frecuencia en «Noticias destacadas».

Añádenos como fuente preferida en Google

¿Cómo aparece tu web en Google y en la IA?

Dinos tu dominio y te enviamos un primer diagnóstico: cómo aparece en Google y en asistentes de IA como ChatGPT. Gratis y sin compromiso.

Pide un primer diagnóstico
Manuel Riveiro

CEO & Digital Strategist — ZDS

20+ años de experiencia en SEO, performance marketing y herramientas de IA. Fundador de ZDS y B2 Performance, con sede en Barcelona y Herdecke.