Guia de configuração de Sitemap e robots.txt no Next.js: acelere a indexação do seu site

O site ficou pronto e foi publicado. Você procura o nome dele no Google, cheio de expectativa, mas… nada aparece.

Depois de atualizar a página algumas vezes e testar outras palavras-chave, o resultado continua vazio. Ao abrir o Google Search Console, você vê que o Sitemap enviado está marcado como “Não foi possível buscar”. Dá um aperto: todo o trabalho foi em vão? Sem tráfego de busca, até o melhor conteúdo fica restrito a quem já conhece o site.

Eu já passei por isso. No meu primeiro projeto com Next.js, configurei o Sitemap seguindo um tutorial, mas o Google simplesmente não conseguia rastreá-lo. Passei uma semana tentando várias soluções até descobrir que o problema estava no robots.txt: eu tinha bloqueado o site inteiro. Foi frustrante perceber que tudo vinha de um erro tão básico.

Neste artigo, reuni os problemas que enfrentei, a documentação que consultei e as configurações que testei. Vou explicar de forma direta para que servem esses dois arquivos, apresentar três maneiras de gerar um Sitemap, mostrar os erros mais comuns e, por fim, contar um caso real de falha e recuperação. Se o seu site não está sendo indexado, o Sitemap apresenta erro ou você não sabe como configurar páginas dinâmicas, este guia pode poupar bastante tempo.

Por que você precisa de Sitemap e robots.txt?

Para que serve o Sitemap

O Sitemap funciona como um “mapa” para os mecanismos de busca. Ele informa quais páginas existem no site, com que frequência são atualizadas e quais são mais importantes. Sem um Sitemap, os mecanismos de busca dependem dos crawlers para descobrir as páginas aos poucos. Conteúdos profundos ou gerados dinamicamente podem levar meses para serem encontrados.

Segundo dados do setor, sites com Sitemap podem ser indexados cerca de 40% mais rápido. Para um site novo, a diferença fica ainda mais evidente: ele pode ser indexado em uma semana ou somente depois de um mês.

Para que serve o robots.txt

O robots.txt informa aos mecanismos de busca “o que pode e o que não pode ser rastreado”. Áreas administrativas, endpoints de API e arquivos de build, por exemplo, não precisam aparecer no índice. Ao configurar o robots.txt, você permite que os crawlers ignorem esse conteúdo e usem o orçamento de rastreamento nas páginas realmente importantes.

Mas há um detalhe essencial: é melhor não configurar o robots.txt do que configurá-lo de forma errada. Já vi muitos desenvolvedores tentarem bloquear um diretório específico e acabarem bloqueando o site inteiro, fazendo com que ele desaparecesse do Google. Por isso, teste a configuração. Depois, teste novamente.

Três formas de gerar um Sitemap no Next.js

Com a introdução do App Router no Next.js 13+, a forma de gerar um Sitemap também mudou. A seguir, apresento três opções, da mais simples à mais avançada.

Opção 1: sitemap.ts nativo do App Router

Quando usar: projetos com Next.js 13+ e poucas páginas, de dezenas a algumas centenas.

Essa é a opção recomendada oficialmente. A principal vantagem é não precisar instalar nenhuma dependência adicional. Crie um arquivo sitemap.ts no diretório 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,
    },
  ]
}

Depois da implantação, acesse https://yourdomain.com/sitemap.xml para visualizar o Sitemap gerado.

Vantagens:

• Tem suporte oficial, com boa estabilidade
• Não exige dependências adicionais
• Permite verificação de tipos com TypeScript

Desvantagens:

• Páginas estáticas precisam ser mantidas manualmente
• Páginas dinâmicas exigem que os dados sejam buscados no código

Opção 2: pacote next-sitemap

Quando usar: projetos que precisam de automação, suporte a vários ambientes ou um grande número de páginas.

O next-sitemap é a ferramenta da comunidade mais popular para gerar Sitemaps e oferece muitos recursos.

Instalação:

npm install next-sitemap

Arquivo de configuração next-sitemap.config.js:

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

/** @type {import('next-sitemap').IConfig} */
module.exports = {
  siteUrl: process.env.SITE_URL || 'https://yourdomain.com',
  generateRobotsTxt: true, // Gera o robots.txt automaticamente
  sitemapSize: 50000, // Máximo de 50.000 URLs por Sitemap
  exclude: ['/admin/*', '/api/*', '/secret'], // Exclui determinados caminhos
  robotsTxtOptions: {
    policies: [
      {
        userAgent: '*',
        allow: '/',
        disallow: ['/admin', '/api'],
      },
    ],
    additionalSitemaps: [
      'https://yourdomain.com/server-sitemap.xml', // Sitemap dinâmico
    ],
  },
}

Adicione um script ao package.json:

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

Assim, o Sitemap será gerado automaticamente após cada execução de npm run build.

Vantagens:

• Muitos recursos, incluindo divisão em vários Sitemaps
• Geração automática de robots.txt
• Suporte a rotas dinâmicas
• Configuração para vários ambientes

Desvantagens:

• Exige uma dependência adicional
• A configuração é um pouco mais complexa

Opção 3: geração manual por uma rota de API

Quando usar: quando você precisa de personalização total ou de atualização do Sitemap em tempo real.

No App Router, use um Route Handler:

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

export async function GET() {
  // Busca os dados no banco de dados ou 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',
    },
  })
}

Vantagens:

• Controle total
• Possibilidade de gerar o arquivo em tempo real
• Suporte a lógica complexa

Desvantagens:

• Você precisa escrever o XML
• A otimização de desempenho fica sob sua responsabilidade
• O cache precisa ser tratado manualmente

Comparação entre as três opções

Na maioria dos meus projetos, uso o next-sitemap. Basta configurá-lo uma vez, e os recursos atendem bem às necessidades do dia a dia.

Rotas dinâmicas na prática: Sitemap de um blog

Esse é o cenário mais comum: como adicionar ao Sitemap conteúdos dinâmicos, como posts de blog, páginas de produto e perfis de usuário?

Usando a opção nativa do 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,
    },
  ]

  // Busca dinamicamente todos os posts
  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]
}

// Define o intervalo de revalidação (ISR)
export const revalidate = 3600 // Gera novamente a cada hora

Pontos importantes:

1. changeFrequency e priority precisam da asserção de tipo as const
2. Use export const revalidate para ativar a regeneração estática incremental (ISR)
3. Em lastModified, prefira a data real de atualização do post

Sites grandes: o que fazer com mais de 50.000 URLs?

O Google limita cada Sitemap a 50.000 URLs. Se o site ultrapassar esse número, será necessário dividi-lo em vários Sitemaps.

Use a função generateSitemaps:

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

// Gera vários Sitemaps
export async function generateSitemaps() {
  const totalPosts = await getTotalPostsCount()
  const sitemapsCount = Math.ceil(totalPosts / 50000)

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

// Gera o conteúdo 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,
  }))
}

Isso gera vários Sitemaps:

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

O Next.js gera automaticamente um arquivo de índice sitemap.xml com links para todos os Sitemaps secundários.

Configuração completa do robots.txt

Exemplo de configuração básica

O robots.txt mais simples é:

# Permite que todos os crawlers rastreiem todo o conteúdo
User-agent: *
Allow: /

# Informa a localização do Sitemap
Sitemap: https://yourdomain.com/sitemap.xml

Em um projeto real, porém, precisamos de uma configuração mais detalhada:

User-agent: *
Allow: /

# Impede o rastreamento destes diretórios
Disallow: /_next/
Disallow: /api/
Disallow: /admin/
Disallow: /dashboard/

# Impede o rastreamento de alguns tipos de arquivo
Disallow: /*.json$
Disallow: /*.xml$
Disallow: /*?*  # URLs com parâmetros de consulta

# Informa o Sitemap
Sitemap: https://yourdomain.com/sitemap.xml

Observações importantes:

1. /_next/: arquivos de build do Next.js que não precisam ser rastreados
2. /api/: endpoints de API que não devem ser indexados
3. /admin/ e /dashboard/: áreas administrativas que não devem aparecer no índice
4. /*.json$: arquivos JSON que não precisam ser indexados
5. A linha do Sitemap é essencial: não se esqueça dela, pois é assim que os mecanismos de busca descobrem onde está o arquivo

Gerando o robots.txt dinamicamente no Next.js

No App Router, use robots.ts:

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

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

  // Bloqueia todos os crawlers no ambiente de desenvolvimento
  if (process.env.NODE_ENV === 'development') {
    return {
      rules: {
        userAgent: '*',
        disallow: '/',
      },
    }
  }

  // Configuração do ambiente de produção
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: [
          '/_next/',
          '/api/',
          '/admin/',
          '/dashboard/',
        ],
      },
      {
        userAgent: 'GPTBot', // Bloqueia o crawler da OpenAI
        disallow: ['/'],
      },
    ],
    sitemap: `${baseUrl}/sitemap.xml`,
  }
}

Por que usar configurações diferentes por ambiente?

Ambientes de desenvolvimento e preview não devem ser indexados pelos mecanismos de busca. Controlar o acesso por variáveis de ambiente evita que conteúdo de teste apareça no índice.

Quero reforçar um ponto: muitas pessoas usam o mesmo arquivo de configuração em produção e desenvolvimento, o que representa um risco sério. Recomendo fazer assim:

// 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'

  // Fora da produção: bloqueia todos os crawlers
  if (!isProduction || isDeployPreview) {
    return {
      rules: {
        userAgent: '*',
        disallow: '/',
      },
    }
  }

  // Permite crawlers somente no ambiente de produção
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: [
          '/_next/',
          '/api/',
          '/admin/',
          '/dashboard/',
          '/*.json$',
        ],
      },
      {
        userAgent: 'GPTBot',
        disallow: ['/'],
      },
    ],
    sitemap: `${baseUrl}/sitemap.xml`,
  }
}

Assim, você evita tanto a indexação acidental de conteúdo de teste quanto o bloqueio involuntário do ambiente de produção.

Como evitar erros comuns

Erro 1: bloquear o site inteiro por engano

# ❌ Configuração incorreta
User-agent: *
Disallow: /

Essa regra bloqueia o site inteiro. A forma correta é:

# ✅ Configuração correta
User-agent: *
Allow: /
Disallow: /admin/

Erro 2: esquecer a referência ao Sitemap

Muitas pessoas configuram o Sitemap, mas não o declaram no robots.txt. Com isso, os mecanismos de busca não sabem onde encontrá-lo.

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

# ❌ Esta linha está ausente
Sitemap: https://yourdomain.com/sitemap.xml

Erro 3: usar um formato de caminho incorreto

# ❌ Incorreto: o caminho não começa com /
Disallow: _next/

# ✅ Correto: o caminho deve começar com /
Disallow: /_next/

Erro 4: restringir demais

# ❌ Restrição excessiva: bloqueia todas as imagens
Disallow: /*.jpg$
Disallow: /*.png$

Imagens também fazem parte do conteúdo e devem ser rastreadas, a menos que exista um motivo específico para bloqueá-las.

Como testar:

1. Acesse https://yourdomain.com/robots.txt e confira o conteúdo
2. Use a ferramenta de teste de robots.txt do Google Search Console
3. Teste se uma URL específica pode ser rastreada

Integração e validação no Google Search Console

Depois de configurar o Sitemap e o robots.txt, envie o Sitemap ao Google Search Console para que o Google descubra e indexe o site mais rapidamente.

Adicionar o site ao Search Console

1. Acesse o Google Search Console
2. Clique em “Adicionar propriedade”
3. Escolha o método de verificação “Domínio” ou “Prefixo do URL”

Recomendo a verificação por DNS:

• Adicione um registro TXT no provedor do domínio
• Aguarde alguns minutos até a propagação do DNS
• Volte ao Search Console e clique em verificar

Outra opção é usar um arquivo HTML:

Coloque no diretório public o arquivo de verificação fornecido pelo Google, por exemplo, google1234567890abcdef.html.

Enviar o Sitemap

Depois de concluir a verificação:

1. Clique em “Sitemaps” no menu lateral
2. Informe a URL do Sitemap: sitemap.xml
3. Clique em “Enviar”

Prazo de processamento:

• O Google não processa o arquivo imediatamente após o envio
• O rastreamento costuma começar em 1 a 7 dias
• Você pode acompanhar o status no Search Console

Solução de erros comuns

Erro 1: “Não foi possível buscar o Sitemap”

Esse é o problema mais comum. Há várias causas possíveis:

Causa 1: o Middleware bloqueou o Googlebot

Se você usa o Middleware do Next.js para autenticação, ele pode estar bloqueando o Googlebot também.

Solução:

// 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') || ''

  // Verifica se o acesso vem de um crawler de mecanismo de busca
  const isBot = /googlebot|bingbot|slurp|duckduckbot|baiduspider|yandexbot/i.test(
    userAgent
  )

  // Sitemap e robots.txt devem ser acessíveis para todos, inclusive crawlers
  if (
    pathname === '/robots.txt' ||
    pathname === '/sitemap.xml' ||
    pathname.startsWith('/sitemap-')
  ) {
    return NextResponse.next()
  }

  // Libera o acesso geral para crawlers
  if (isBot) {
    return NextResponse.next()
  }

  // Lógica de autenticação para usuários comuns
  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).*)'],
}

Essa configuração garante que os crawlers possam acessar o Sitemap e o robots.txt normalmente, sem alterar a autenticação aplicada aos usuários comuns.

Causa 2: problemas de cache

O Google Search Console armazena em cache as tentativas de rastreamento que falharam. Mesmo depois da correção, ele ainda pode exibir “Não foi possível buscar”.

Soluções:

1. Adicione um parâmetro de data e hora à URL do Sitemap: sitemap.xml?v=20231220
2. Aguarde alguns dias para o Google rastrear novamente
3. Ou remova o envio antigo e envie o Sitemap de novo

Causa 3: formato XML inválido

Verifique se o XML do Sitemap está correto:

<?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>

Atenção:

• A declaração XML da primeira linha deve começar com <?xml, e não com <xml
• O valor de lastmod deve seguir o formato ISO 8601: YYYY-MM-DD ou um timestamp completo

Você pode conferir o formato com um validador de XML online.

Erro 2: “Enviado, mas não indexado”

O Sitemap foi enviado com sucesso, mas as páginas continuam fora do índice. As possíveis causas são:

1. O robots.txt bloqueia a página: verifique se há alguma regra incorreta
2. Problemas de qualidade da página: conteúdo curto, duplicado ou considerado de baixa qualidade
3. O site é muito novo: sites novos precisam de tempo para construir reputação
4. Não há backlinks: um site sem nenhum link externo pode ser mais difícil de indexar

Soluções:

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

1. Use a ferramenta “Inspeção de URL” do Google Search Console para entender como o Google vê a página
2. Verifique se existe uma metatag noindex
3. Garanta que a página tenha conteúdo relevante, com pelo menos 300 palavras
4. Tente conseguir alguns backlinks

Monitorar a indexação

Depois do envio, consulte o status de indexação regularmente:

1. Relatório de cobertura: mostra quais páginas foram indexadas e quais apresentam problemas
2. Status de indexação: mostra o total de páginas indexadas
3. Status do Sitemap: informa se o Sitemap foi lido corretamente

Se alguma página não for indexada, use a ferramenta “Inspeção de URL” para solicitar um novo rastreamento ao Google.

Caso real: um erro que enfrentei

Para tornar tudo mais concreto, quero compartilhar uma experiência real. No ano passado, assumi um site de e-commerce que já estava no ar havia três meses, mas nenhuma página aparecia nos resultados do Google.

Minha primeira reação foi verificar o robots.txt. Encontrei isto:

User-agent: *
Disallow: /

O site inteiro estava bloqueado. E o pior: essa configuração estava em produção havia três meses. Perguntei ao colega responsável pela implantação, e ele disse que não tinha feito a alteração. No fim, descobrimos que um desenvolvedor temporário havia criado a regra para impedir o rastreamento do ambiente de teste e reutilizado a mesma configuração em produção.

O mês seguinte foi especialmente difícil. Removi o robots.txt incorreto, gerei um Sitemap válido, enviei-o ao Google Search Console e esperei. O site só começou a aparecer nos resultados uma semana depois.

Desde então, adotei um hábito: antes de cada implantação, reviso o Sitemap e o robots.txt e uso configurações separadas por ambiente. Desenvolvimento recebe uma configuração; produção, outra.

Em outra ocasião, o problema estava no Middleware. Eu havia adicionado uma camada de autenticação JWT ao site, mas ela também bloqueava o Googlebot. O Search Console mostrava repetidamente “Não foi possível buscar o Sitemap”. Passei bastante tempo procurando um erro no formato do arquivo até perceber que o Middleware era o responsável.

SEO pode parecer simples, mas os detalhes fazem toda a diferença. Um pequeno erro de configuração pode fazer o site desaparecer dos resultados de busca.

Diagnóstico e otimização

Checklist de testes

Antes da implantação, revise esta lista:

• O Sitemap está acessível (https://yourdomain.com/sitemap.xml)
• O formato XML do Sitemap está correto
• O robots.txt está acessível (https://yourdomain.com/robots.txt)
• O robots.txt não bloqueia páginas importantes
• O robots.txt contém a referência ao Sitemap
• O Sitemap inclui todas as páginas importantes
• As páginas dinâmicas são atualizadas automaticamente no Sitemap
• O site foi verificado com sucesso no Search Console
• O Sitemap foi enviado ao Search Console
• O Middleware não bloqueia os crawlers dos mecanismos de busca

Otimização de desempenho

Estratégia de cache do Sitemap

Se você gera o Sitemap com uma rota de API, adicione cache:

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

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

Atualização incremental ou reconstrução completa

• Sites pequenos (menos de 1.000 páginas): faça uma reconstrução completa a cada vez; é mais simples
• Sites médios (de 1.000 a 10.000 páginas): use ISR e revalide por hora ou por dia
• Sites grandes (mais de 10.000 páginas): divida o conteúdo em vários Sitemaps e atualize apenas as partes alteradas

Configuração de CDN

Se você usa uma CDN como a Cloudflare, garanta que o Sitemap e o robots.txt também sejam armazenados em cache:

1. Defina cabeçalhos Cache-Control adequados
2. Permita que a CDN armazene arquivos XML e TXT em cache
3. Limpe o cache da CDN após atualizar o conteúdo

Conclusão

Vamos recapitular o processo completo:

1. Escolha uma forma de gerar o Sitemap:

   • Use a opção nativa do App Router em projetos pequenos
   • Use next-sitemap em projetos médios e grandes
   • Use uma rota de API quando precisar de personalização avançada

2. Configure o robots.txt:

   • Bloqueie diretórios que não devem ser indexados
   • Adicione a referência ao Sitemap
   • Bloqueie o rastreamento no ambiente de desenvolvimento

3. Envie ao Google Search Console:

   • Verifique a titularidade do site
   • Envie o Sitemap
   • Monitore o status de indexação

4. Diagnostique os problemas mais comuns:

   • Não deixe o Middleware bloquear os crawlers
   • Garanta que o formato XML esteja correto
   • Resolva problemas de cache com um parâmetro de data e hora

Configurar Sitemap e robots.txt não é uma tarefa tecnicamente complexa, mas envolve muitos detalhes e qualquer descuido pode causar problemas. Na primeira vez que fiz essa configuração, também enfrentei vários erros e só percebi um mês depois que o robots.txt estava bloqueando o site inteiro.

Hoje, sempre que publico um projeto novo, reviso este checklist. Desde que adotei esse processo, quase não tenho mais problemas. Espero que este guia ajude você a evitar os mesmos erros e a indexar seu site mais rapidamente.

Se você encontrou outro problema ou quer compartilhar uma experiência, deixe um comentário!