Guía de configuración de Sitemap y robots.txt en Next.js: que los buscadores indexen tu sitio rápido

Terminas de desplegar el sitio, buscas tu dominio en Google con ilusión y… nada.

Actualizas varias veces, pruebas otras palabras clave y sigue vacío. Abres Google Search Console y el Sitemap enviado muestra «no se puede obtener». Se te encoge el corazón: ¿todo ese trabajo para nada? Sin tráfico de búsqueda, el mejor contenido queda solo para ti.

Ya me pasó antes. En mi primer proyecto Next.js seguí un tutorial para configurar el Sitemap y Google no lo encontraba. Una semana probando de todo hasta descubrir que el problema era robots.txt: había bloqueado todo el sitio. Una sensación de impotencia por un error tan básico.

En este artículo recopilo los fallos que cometí, la documentación que consulté y las configuraciones que probé. Te explico con claridad para qué sirven estos dos archivos, tres formas de generar el Sitemap, los errores más habituales y un caso real de fracaso y cómo salir de él. Si tu sitio no se indexa, el Sitemap da error o no sabes cómo incluir páginas dinámicas, esto debería ahorrarte bastantes vueltas.

¿Por qué necesitas Sitemap y robots.txt?

Función del Sitemap

El Sitemap es como un «mapa» para los buscadores: indica qué páginas tienes, con qué frecuencia se actualizan y cuáles son más importantes. Sin Sitemap, el rastreador debe descubrir las páginas por su cuenta, sobre todo las profundas o generadas dinámicamente, que pueden tardar meses en aparecer.

Según datos del sector, los sitios con Sitemap se indexan un 40% más rápido. En sitios nuevos la diferencia es aún mayor: puede ser la diferencia entre indexarse en una semana o en un mes.

Función de robots.txt

robots.txt indica a los buscadores «qué pueden rastrear y qué no». El panel de administración, las APIs o los archivos de build no deben indexarse; con robots.txt el rastreador los omite y gasta la cuota en páginas que sí importan.

Pero hay un matiz importante: no configurar robots.txt suele ser mejor que configurarlo mal. He visto muchos casos en los que el desarrollador quería bloquear un directorio y acabó bloqueando todo el sitio, haciendo que desaparezca de Google. Por eso hay que probar, probar y volver a probar.

Tres métodos para generar el Sitemap en Next.js

Con App Router en Next.js 13+, la forma de generar el Sitemap cambió. Aquí van tres métodos, de simple a complejo.

Método 1: sitemap.ts nativo de App Router

Cuándo usarlo: proyectos Next.js 13+ con pocas páginas (decenas o cientos)

Es la opción oficial. La gran ventaja: no necesitas dependencias extra. Crea sitemap.ts en el directorio app:

// app/sitemap.ts
import { MetadataRoute } from 'next'

export default function sitemap(): MetadataRoute.Sitemap {
  return [
    {
      url: 'https://yourdomain.com',
      lastModified: new Date(),
      changeFrequency: 'yearly',
      priority: 1,
    },
    {
      url: 'https://yourdomain.com/about',
      lastModified: new Date(),
      changeFrequency: 'monthly',
      priority: 0.8,
    },
    {
      url: 'https://yourdomain.com/blog',
      lastModified: new Date(),
      changeFrequency: 'weekly',
      priority: 0.5,
    },
  ]
}

Tras el despliegue, visita https://yourdomain.com/sitemap.xml para ver el Sitemap generado.

Ventajas:

• Soporte oficial, estable
• Sin dependencias extra
• Comprobación de tipos con TypeScript

Inconvenientes:

• Las páginas estáticas hay que mantenerlas a mano
• Las dinámicas requieren obtener datos en código

Método 2: paquete next-sitemap

Cuándo usarlo: automatización, varios entornos o muchas páginas

next-sitemap es la herramienta más popular de la comunidad para generar Sitemaps.

Instalación:

npm install next-sitemap

Archivo de configuración next-sitemap.config.js:

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

/** @type {import('next-sitemap').IConfig} */
module.exports = {
  siteUrl: process.env.SITE_URL || 'https://yourdomain.com',
  generateRobotsTxt: true, // Genera robots.txt automáticamente
  sitemapSize: 50000, // Máximo 50000 URL por Sitemap
  exclude: ['/admin/*', '/api/*', '/secret'], // Excluir ciertas rutas
  robotsTxtOptions: {
    policies: [
      {
        userAgent: '*',
        allow: '/',
        disallow: ['/admin', '/api'],
      },
    ],
    additionalSitemaps: [
      'https://yourdomain.com/server-sitemap.xml', // Sitemap dinámico
    ],
  },
}

Añade el script en package.json:

{
  "scripts": {
    "build": "next build",
    "postbuild": "next-sitemap"
  }
}

Así, cada npm run build genera el Sitemap automáticamente.

Ventajas:

• Muy potente, admite varios Sitemaps
• Genera robots.txt automáticamente
• Soporta rutas dinámicas
• Configuración multi-entorno

Inconvenientes:

• Dependencia adicional
• Configuración algo más compleja

Método 3: generación manual con API Route

Cuándo usarlo: personalización extrema o Sitemap en tiempo real

En App Router con Route Handler:

// app/sitemap.xml/route.ts
import { NextResponse } from 'next/server'

export async function GET() {
  // Obtener datos de base de datos o CMS
  const posts = await fetchAllPosts()

  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://yourdomain.com</loc>
    <lastmod>${new Date().toISOString()}</lastmod>
    <priority>1.0</priority>
  </url>
  ${posts.map(post => `
  <url>
    <loc>https://yourdomain.com/blog/${post.slug}</loc>
    <lastmod>${post.updatedAt}</lastmod>
    <priority>0.7</priority>
  </url>
  `).join('')}
</urlset>`

  return new NextResponse(sitemap, {
    status: 200,
    headers: {
      'Content-Type': 'application/xml',
      'Cache-Control': 'public, s-maxage=3600, stale-while-revalidate',
    },
  })
}

Ventajas:

• Control total
• Generación en tiempo real
• Lógica compleja posible

Inconvenientes:

• Debes escribir el XML a mano
• Optimización de rendimiento por tu cuenta
• Caché manual

Comparativa de los tres métodos

En la mayoría de mis proyectos uso next-sitemap: lo configuras una vez y olvidas, y las funciones bastan.

Rutas dinámicas en la práctica: Sitemap de artículos de blog

Es el escenario más habitual: ¿cómo meter en el Sitemap el blog, fichas de producto, perfiles de usuario y otro contenido dinámico?

Con el método nativo de App Router

// app/sitemap.ts
import { MetadataRoute } from 'next'
import { getAllPosts } from '@/lib/posts'

export default async function sitemap(): MetadataRoute.Sitemap {
  // Páginas estáticas
  const staticPages = [
    {
      url: 'https://yourdomain.com',
      lastModified: new Date(),
      changeFrequency: 'yearly' as const,
      priority: 1,
    },
    {
      url: 'https://yourdomain.com/about',
      lastModified: new Date(),
      changeFrequency: 'monthly' as const,
      priority: 0.8,
    },
  ]

  // Obtener todos los artículos dinámicamente
  const posts = await getAllPosts()
  const postPages = posts.map(post => ({
    url: `https://yourdomain.com/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.7,
  }))

  return [...staticPages, ...postPages]
}

// Tiempo de revalidación (ISR)
export const revalidate = 3600 // Regenerar cada hora

Puntos clave:

1. changeFrequency y priority necesitan la aserción as const
2. Usa export const revalidate para ISR
3. lastModified conviene que sea la fecha real de actualización del artículo

Sitios grandes: ¿más de 50.000 URL?

Google limita un Sitemap a 50.000 URL como máximo. Si superas eso, hay que dividirlo en varios.

Usa la función generateSitemaps:

// app/sitemap.ts
import { MetadataRoute } from 'next'

// Generar varios Sitemaps
export async function generateSitemaps() {
  const totalPosts = await getTotalPostsCount()
  const sitemapsCount = Math.ceil(totalPosts / 50000)

  return Array.from({ length: sitemapsCount }, (_, i) => ({
    id: i,
  }))
}

// Contenido de cada Sitemap
export default async function sitemap({
  id,
}: {
  id: number
}): Promise<MetadataRoute.Sitemap> {
  const start = id * 50000
  const end = start + 50000

  const posts = await getPosts(start, end)

  return posts.map(post => ({
    url: `https://yourdomain.com/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    priority: 0.7,
  }))
}

Esto genera varios Sitemaps:

• sitemap/0.xml
• sitemap/1.xml
• sitemap/2.xml
• …

Next.js genera automáticamente un índice sitemap.xml con enlaces a todos los sub-sitemaps.

Configuración completa de robots.txt

Ejemplo básico

El robots.txt más simple:

# Permitir a todos los rastreadores todo el contenido
User-agent: *
Allow: /

# Indicar la ubicación del Sitemap
Sitemap: https://yourdomain.com/sitemap.xml

En proyectos reales suele hacer falta algo más fino:

User-agent: *
Allow: /

# Prohibir rastrear estos directorios
Disallow: /_next/
Disallow: /api/
Disallow: /admin/
Disallow: /dashboard/

# Prohibir ciertos tipos de archivo
Disallow: /*.json$
Disallow: /*.xml$
Disallow: /*?*  # URL con parámetros de consulta

# Indicar el Sitemap
Sitemap: https://yourdomain.com/sitemap.xml

Notas importantes:

1. /_next/: archivos de build de Next.js, no hace falta que los indexen
2. /api/: las APIs no deben indexarse
3. /admin/ y /dashboard/: el panel de administración, obviamente, tampoco
4. /*.json$: los JSON no necesitan indexarse
5. La línea del Sitemap importa: no la olvides, así el buscador sabe dónde está tu Sitemap

Generar robots.txt dinámicamente en Next.js

En App Router con robots.ts:

// app/robots.ts
import { MetadataRoute } from 'next'

export default function robots(): MetadataRoute.Robots {
  const baseUrl = 'https://yourdomain.com'

  // En desarrollo, bloquear todos los rastreadores
  if (process.env.NODE_ENV === 'development') {
    return {
      rules: {
        userAgent: '*',
        disallow: '/',
      },
    }
  }

  // Configuración de producción
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: [
          '/_next/',
          '/api/',
          '/admin/',
          '/dashboard/',
        ],
      },
      {
        userAgent: 'GPTBot', // Bloquear el rastreador de OpenAI
        disallow: ['/'],
      },
    ],
    sitemap: `${baseUrl}/sitemap.xml`,
  }
}

Ventaja de la configuración multi-entorno:

Los entornos de desarrollo y preview no deben indexarse; controlarlo con variables de entorno evita que se indexe contenido de prueba.

Quiero insistir en esto: mucha gente usa la misma configuración en producción y desarrollo, y es un riesgo serio. Yo haría algo así:

// app/robots.ts
import { MetadataRoute } from 'next'

export default function robots(): MetadataRoute.Robots {
  const baseUrl = process.env.NEXT_PUBLIC_SITE_URL || 'https://yourdomain.com'
  const isProduction = process.env.NODE_ENV === 'production'
  const isDeployPreview = process.env.NEXT_PUBLIC_VERCEL_ENV === 'preview'

  // Fuera de producción: bloquear por completo
  if (!isProduction || isDeployPreview) {
    return {
      rules: {
        userAgent: '*',
        disallow: '/',
      },
    }
  }

  // Solo en producción permitir rastreo
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: [
          '/_next/',
          '/api/',
          '/admin/',
          '/dashboard/',
          '/*.json$',
        ],
      },
      {
        userAgent: 'GPTBot',
        disallow: ['/'],
      },
    ],
    sitemap: `${baseUrl}/sitemap.xml`,
  }
}

Así evitas que el buscador rastree pruebas o que producción quede bloqueada por accidente.

Errores habituales que debes evitar

Error 1: bloquear todo el sitio por error

# ❌ Incorrecto
User-agent: *
Disallow: /

Eso bloquea todo el sitio. Forma correcta:

# ✅ Correcto
User-agent: *
Allow: /
Disallow: /admin/

Error 2: olvidar la referencia al Sitemap

Muchos configuran el Sitemap pero no lo declaran en robots.txt, y el buscador no sabe dónde buscarlo.

Alibaba Cloud - Opción preferida para desarrolladores, 15 % de descuento exclusivo en Lighthouse

Obtener 15% dto. →Anuncio

# ❌ Falta esta línea
Sitemap: https://yourdomain.com/sitemap.xml

Error 3: formato de ruta incorrecto

# ❌ Incorrecto: la ruta no empieza por /
Disallow: _next/

# ✅ Correcto: la ruta debe empezar por /
Disallow: /_next/

Error 4: restricciones excesivas

# ❌ Demasiado restrictivo: bloqueas las imágenes
Disallow: /*.jpg$
Disallow: /*.png$

Las imágenes también son contenido; deja que el buscador las rastree salvo que tengas un motivo claro.

Cómo probar:

1. Visita https://yourdomain.com/robots.txt y revisa el contenido
2. Usa la herramienta de prueba de robots.txt en Google Search Console
3. Comprueba si una URL concreta está permitida

Integración y verificación en Google Search Console

Tras configurar Sitemap y robots.txt, envíalos en Google Search Console para que Google descubra e indexe tu sitio antes.

Añadir el sitio a Search Console

1. Visita Google Search Console
2. Haz clic en «Añadir propiedad»
3. Elige verificación por «dominio» o «prefijo de URL»

Recomiendo verificación DNS:

• Añade un registro TXT en tu proveedor de dominio
• Espera unos minutos a que propague el DNS
• Vuelve a Search Console y verifica

O verificación con archivo HTML:

Coloca en public el archivo que te da Google, por ejemplo google1234567890abcdef.html.

Enviar el Sitemap

Tras verificar:

1. En el menú izquierdo, «Sitemaps»
2. Introduce la URL del Sitemap: sitemap.xml
3. Haz clic en «Enviar»

Tiempos de espera:

• Google no lo procesa al instante
• Suele empezar a rastrear en 1-7 días
• Puedes ver el estado en Search Console

Resolución de errores habituales

Error 1: «No se puede obtener el Sitemap»

Es el más común. Posibles causas:

Causa 1: Middleware bloquea a Googlebot

Si usas Middleware de Next.js para autenticación, puede bloquear también a Googlebot.

Solución:

// middleware.ts
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl
  const userAgent = request.headers.get('user-agent') || ''

  // Detectar si es un rastreador
  const isBot = /googlebot|bingbot|slurp|duckduckbot|baiduspider|yandexbot/i.test(
    userAgent
  )

  // Sitemap y robots.txt deben ser accesibles para todos, incluidos rastreadores
  if (
    pathname === '/robots.txt' ||
    pathname === '/sitemap.xml' ||
    pathname.startsWith('/sitemap-')
  ) {
    return NextResponse.next()
  }

  // Si es rastreador, dejar pasar
  if (isBot) {
    return NextResponse.next()
  }

  // Lógica de autenticación para usuarios normales
  const token = request.cookies.get('session-token')
  if (!token && pathname.startsWith('/dashboard')) {
    return NextResponse.redirect(new URL('/login', request.url))
  }

  return NextResponse.next()
}

export const config = {
  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
}

Así el rastreador accede al Sitemap y robots.txt y la autenticación sigue aplicando a usuarios normales.

Causa 2: problemas de caché

Search Console puede cachear intentos fallidos. Aunque lo arregles, puede seguir mostrando «no se puede obtener».

Solución:

1. Añade un parámetro de fecha al Sitemap: sitemap.xml?v=20231220
2. Espera unos días a que Google vuelva a rastrear
3. O elimina el envío antiguo y vuelve a enviar uno nuevo

Causa 3: XML mal formado

Comprueba que el XML del Sitemap sea válido:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://yourdomain.com</loc>
    <lastmod>2024-12-20</lastmod>
  </url>
</urlset>

Atención:

• La declaración XML debe empezar por <?xml (no <xml)
• lastmod debe ser ISO 8601 (YYYY-MM-DD o timestamp completo)

Puedes validar el formato con una herramienta XML online.

Error 2: «Enviado pero no indexado»

El Sitemap se envió bien pero las páginas no se indexan. Posibles causas:

1. robots.txt bloquea la página: revisa si está mal configurado
2. Calidad de la página: poco contenido, duplicado o percibido como baja calidad
3. Sitio muy nuevo: hace falta tiempo para ganar confianza
4. Sin enlaces externos: un sitio sin ningún enlace externo cuesta mucho indexarlo

Soluciones:

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

1. Usa «Inspección de URLs» en Search Console para ver cómo ve Google la página
2. Comprueba si hay meta noindex
3. Asegura contenido con valor real, al menos 300 palabras
4. Intenta conseguir algunos enlaces externos

Monitorizar la indexación

Tras el envío, revisa el estado con regularidad:

1. Informe de cobertura: qué páginas están indexadas y cuáles tienen problemas
2. Estado del índice: cuántas páginas hay indexadas en total
3. Estado del Sitemap: si se lee correctamente

Si alguna página no se indexa, usa «Inspección de URLs» para pedir un nuevo rastreo.

Caso real: mis tropiezos

Quiero contarte algo que me pasó. El año pasado asumí una tienda online lleva 3 meses en línea y en Google no aparecía ninguna página.

Lo primero fue revisar robots.txt:

User-agent: *
Disallow: /

Todo el sitio estaba bloqueado. Peor: llevaba así 3 meses. El compañero de despliegue dijo «yo no lo toqué»; al final salió que un desarrollador temporal usó la misma config de prueba también en producción para evitar que Google rastreara el entorno de test.

El mes siguiente fue duro. Borré el robots.txt erróneo, generé el Sitemap correcto, lo envié a Search Console y a esperar. Una semana después el sitio empezó a aparecer en resultados.

Desde entonces tengo la costumbre: antes de cada despliegue reviso Sitemap y robots.txt y separo entornos. Desarrollo una cosa, producción otra.

Otra vez fue el Middleware. Añadí autenticación JWT y Googlebot quedó bloqueado. Search Console seguía con «no se puede obtener el Sitemap»; pensé que era el formato del XML hasta que vi que era el Middleware.

El SEO parece simple, pero los detalles importan. Un pequeño error de configuración puede hacer desaparecer tu sitio de los resultados.

Diagnóstico y optimización

Checklist de pruebas

Antes de desplegar, repasa esta lista:

• El Sitemap es accesible (https://yourdomain.com/sitemap.xml)
• El XML del Sitemap es válido
• robots.txt es accesible (https://yourdomain.com/robots.txt)
• robots.txt no bloquea páginas importantes
• robots.txt incluye la referencia al Sitemap
• El Sitemap incluye todas las páginas importantes
• Las páginas dinámicas se actualizan en el Sitemap
• Search Console verificó el sitio correctamente
• El Sitemap está enviado en Search Console
• El Middleware no bloquea a los rastreadores

Optimización de rendimiento

Estrategia de caché del Sitemap

Si generas el Sitemap con API Route, añade caché:

// app/sitemap.xml/route.ts
export const revalidate = 3600 // Caché de 1 hora

export async function GET() {
  // ...generar Sitemap
  return new NextResponse(sitemap, {
    headers: {
      'Content-Type': 'application/xml',
      'Cache-Control': 'public, s-maxage=3600, stale-while-revalidate',
    },
  })
}

Actualización incremental vs reconstrucción total

• Sitios pequeños (< 1000 páginas): reconstruir todo cada vez, simple
• Sitios medianos (1000-10000): ISR, revalidar por hora o por día
• Sitios grandes (> 10000): varios Sitemaps, actualizar solo lo que cambia

Configuración de CDN

Si usas Cloudflare u otro CDN, asegura que Sitemap y robots.txt también se cacheen:

1. Define cabeceras Cache-Control adecuadas
2. Permite cachear XML y TXT en el CDN
3. Tras actualizar contenido, purga la caché del CDN

Resumen

Repaso del flujo completo:

1. Elige el método de Sitemap:

   • Proyectos pequeños: App Router nativo
   • Medianos y grandes: next-sitemap
   • Personalización extrema: API Route

2. Configura robots.txt:

   • Bloquea directorios que no deben indexarse
   • Añade la referencia al Sitemap
   • Prohíbe el rastreo en desarrollo

3. Envía a Google Search Console:

   • Verifica la propiedad del sitio
   • Envía el Sitemap
   • Monitoriza la indexación

4. Errores habituales:

   • El Middleware no debe bloquear rastreadores
   • El XML debe ser correcto
   • Para caché, usa parámetros de fecha

Configurar Sitemap y robots.txt no es rocket science, pero hay muchos detalles y un descuido basta para liarla. La primera vez yo también tropecé: el sitio entero bloqueado un mes por robots.txt.

Ahora, en cada proyecto nuevo, paso este checklist y casi no fallo. Espero que te ahorre vueltas y tu sitio se indexe pronto.

Si tienes otros problemas o quieres compartir experiencia, ¡déjalo en los comentarios!