Principais Conclusões:

• Não existe um único comando que liste todas as páginas. Um inventário completo de URLs vem da combinação de métodos: o operador de busca site: para uma estimativa rápida, sitemap.xml e o índice do sitemap para o que o site publica, as diretrizes do Sitemap no robots.txt para os pontos de entrada, um crawler de SEO ou um crawler em Python para o que está realmente vinculado, e um navegador em nuvem para links do lado do cliente que aparecem apenas após a execução do JavaScript.
• Os sitemaps são a fonte autorizada mais rápida — quando existem e estão atualizados. Um simples requests.get("/sitemap.xml") mais uma navegação recursiva de qualquer índice de sitemap pode retornar centenas de URLs em uma única passada.
• Um crawler em largura encontra o que os sitemaps omitem. Os sitemaps são curados pelos autores e frequentemente desatualizados; uma navegação BFS de links internos <a href> descobre páginas órfãs, conteúdo com links profundos e qualquer coisa que o sitemap esqueceu. O crawler neste guia respeita as regras Disallow do robots.txt em cada URL antes de buscá-la.
• Links renderizados em JavaScript precisam de um navegador real. Aplicativos de página única e catálogos com scroll infinito pintam seus links internos do lado do cliente, então uma simples busca HTTP retorna uma casca quase vazia. O Scrapeless Scraping Browser renderiza a página em um navegador em nuvem, depois você coleta os âncoras do DOM hidratado — com egressos residenciais dos EUA fixados na sessão.
• Gratuito para começar. Novas contas Scrapeless incluem tempo de execução gratuito do Scraping Browser — inscreva-se em app.scrapeless.com.

Introdução: por que um inventário completo de URLs é mais difícil do que parece

Conhecer cada página de um site é a base para muito trabalho: uma auditoria técnica de SEO, uma migração de conteúdo, uma verificação de links quebrados, um pipeline de monitoramento de preços que precisa de cada URL de produto, ou um trabalho de ingestão de LLM que quer todo o corpus textual. O problema é que nenhum site lhe fornece uma lista garantida e completa. A página inicial se conecta à maioria das seções, o sitemap publica algumas páginas, e páginas órfãs — alcançáveis por link direto, mas não vinculadas na navegação — escorregam por ambas.

As opções existentes cobrem cada uma um pedaço. O operador site: do Google fornece uma estimativa pública rápida, mas limita os resultados e reflete apenas o que está indexado. Um sitemap.xml é autoritativo para o que o editor escolheu declarar, mas fica desatualizado e omite páginas que o CMS nunca registrou. Um crawler que segue links encontra o gráfico vinculado, mas um crawler HTTP simples retorna uma casca vazia em páginas pesadas em JavaScript, onde a navegação é renderizada do lado do cliente.

Este guia passa por seis métodos em ordem de custo e completude — baratos e rápidos primeiro, completos e renderizados por último. Os exemplos em Python usam requests e a biblioteca padrão para os níveis estáticos, e um navegador em nuvem através do Scrapeless Scraping Browser para o nível JavaScript, assim os links do lado do cliente se tornam descobertos. Fixe a saída dos EUA, renderize a página, colete os âncoras. Links cruzados para guias irmãos estão no final.

O Que Você Pode Fazer Com Isso

• Auditorias técnicas de SEO. Enumere cada URL indexável, em seguida, compare a captura com o sitemap para destacar páginas órfãs e páginas que o sitemap esqueceu.
• Migrações de conteúdo. Construa a lista completa de URLs de origem antes de uma mudança de plataforma, para que nada resulte em 404 após a transição, e mapeie caminhos antigos para novos.
• Verificações de links quebrados. Caminhe pelo gráfico de links internos, registre cada destino e sinalize aqueles que retornam um status não 200.
• Monitoramento de preços e catálogos. Descubra cada URL de produto em um varejista — incluindo aquelas renderizadas em JavaScript — e alimente-as em um pipeline de extração a jusante.
• Ingestão de corpus LLM. Produza o conjunto completo de URLs de conteúdo para que um trabalho de extração de texto possa puxar todo o corpus público sem perder artigos com links profundos.
• Mapeamento de conteúdo competitivo. Faça um inventário da estrutura de seção pública de um concorrente a partir de sitemaps e gráficos de links para dimensionar sua pegada de conteúdo.

Por que Scrapeless Scraping Browser

A maior parte deste guia é executada na biblioteca padrão do Python e requests — sitemaps e robots.txt são texto simples e XML, e um crawler de link estático não precisa de mais nada. O Scrapeless Scraping Browser é um navegador em nuvem personalizável e anti-detecção, projetado para crawlers da web e agentes de IA; é o nível que você escolhe quando os links que precisa só existem após a execução do JavaScript. Para descoberta de URLs de todo o site especificamente, ele oferece:

• Renderização em JavaScript do lado da nuvem, para que os links internos em um aplicativo de página única, um catálogo de scroll infinito ou uma navegação React/Vue/Next.js apareçam no DOM que você lê — não como um <div id="root"> vazio.
• Egressos residenciais da EUA, fixados por sessão, para que sites georestritos apresentem a mesma estrutura de página que serviriam a um visitante dos EUA.
• Impressão digital anti-detecção em cada sessão, para que a página renderizada corresponda ao que o tráfego orgânico vê, em vez de um perfil de automação sinalizado.
• Continuidade da sessão em uma navegação de aquecimento e na página de destino, de modo que uma visita à homepage que define cookies carrega para a página que você realmente deseja enumerar.
• Um endpoint, CDP padrão, para que o Playwright (ou qualquer cliente do Protocolo do DevTools do Chrome) se conecte via WebSocket, sem um navegador local fazendo a renderização.

Obtenha sua chave de API no plano gratuito em app.scrapeless.com.

Pré-requisitos

• Python 3.10 ou mais recente.
• Uma conta Scrapeless e chave de API — inscreva-se em app.scrapeless.com.
• pip install requests playwright e playwright install chromium (o Chromium local é apenas o cliente do protocolo CDP; a renderização ocorre na nuvem da Scrapeless).
• Familiaridade básica com o terminal e HTTP.

Método 1 — O operador de pesquisa site: do Google

A primeira estimativa mais rápida não precisa de código. Digite isso no Google:

site:example.com

O Google retorna as páginas que indexou para esse host, e o cabeçalho de resultados mostra uma contagem aproximada. Restringa para mapear a estrutura da seção:

• site:example.com/blog — apenas URLs sob /blog.
• site:example.com inurl:product — URLs indexados cujo caminho contém product.
• site:example.com -inurl:tag — exclui um segmento de caminho que você não se importa.

Para que este método é bom: uma sensação de trinta segundos sobre quão grande é o site e quais seções existem. Para que ele não é bom: integridade. O operador site: reflete apenas as páginas que o Google escolheu indexar, a contagem de resultados é uma estimativa em vez de um número exato, e o operador limita quantos resultados você pode navegar. Trate-o como uma verificação de sanidade em relação aos métodos mais completos abaixo — se seu sitemap declara 5.000 URLs e site: mostra aproximadamente 200, essa diferença é, em si mesma, uma descoberta.

Método 2 — Analisar sitemap.xml e o índice do sitemap

Um sitemap é a declaração própria do editor de suas URLs, servido como XML em um caminho convencional como /sitemap.xml. É a única fonte autoritativa mais rápida quando existe e está atualizada. Duas formas são importantes:

• Um sitemap <urlset> lista as URLs das páginas diretamente, um <url><loc>…</loc></url> por página.
• Um <sitemapindex> lista outros sitemaps — sites grandes dividem suas URLs em arquivos filhos (pages_sitemap.xml, blog_sitemap.xml, e assim por diante) e os apontam a partir de um índice. Você percorre o índice e, em seguida, percorre cada filho.

Este script requests lida com ambas as formas com uma única função recursiva. Ele detecta a tag raiz, entra recursivamente em um índice de sitemap e coleta URLs de páginas de cada <urlset>:

import requests
import xml.etree.ElementTree as ET
from urllib.parse import urljoin

SM_NS = "{http://www.sitemaps.org/schemas/sitemap/0.9}"
HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def walk_sitemap(url, seen=None):
    """Retorna toda URL de página acessível a partir de um sitemap ou índice de sitemap."""
    seen = seen if seen is not None else set()
    if url in seen:          # guarda contra um sitemap que faz referência a si mesmo
        return []
    seen.add(url)

    resp = requests.get(url, headers=HEADERS, timeout=30)
    resp.raise_for_status()
    root = ET.fromstring(resp.content)
    tag = root.tag.split("}")[-1]   # remove o namespace, mantém "sitemapindex" ou "urlset"

    urls = []
    if tag == "sitemapindex":
        # Um índice aponta para sitemaps filhos — recursivamente entra em cada um.
        for sm in root.findall(f"{SM_NS}sitemap"):
            loc = sm.findtext(f"{SM_NS}loc")
            if loc:
                urls.extend(walk_sitemap(loc.strip(), seen))
    else:
        # Um urlset lista as URLs das páginas diretamente.
        for u in root.findall(f"{SM_NS}url"):
            loc = u.findtext(f"{SM_NS}loc")
            if loc:
                urls.append(loc.strip())
    return urls

if __name__ == "__main__":
    pages = walk_sitemap("https://example.com/sitemap.xml")
    print(f"Descobriu {len(pages):,} URLs da árvore do sitemap")
    for u in pages[:10]:
        print(" ", u)

Executado contra um site cujo /sitemap.xml é um índice de sitemap apontando para sitemaps filhos, a caminhada recursiva retorna a união de cada sitemap filho em uma única passada.

Algumas notas sobre sitemaps na prática:

• O caminho é uma convenção, não uma garantia. /sitemap.xml é o local comum, mas um site pode nomeá-lo de qualquer forma e declarar o caminho real em robots.txt (Método 3). Sempre verifique robots.txt antes de presumir que o arquivo não existe.
• Sitemaps comprimidos existem. Alguns sites servem sitemap.xml.gz; requests não descomprime automaticamente um corpo .gz, então descompacte com o módulo gzip antes de analisar se você encontrar um.
• Os sitemaps ficam obsoletos. Eles refletem o que o CMS registrou no momento da geração. Páginas adicionadas desde a última construção, e páginas órfãs que o CMS nunca registrou, estarão faltando — que é exatamente o motivo pelo qual os Métodos 5 e 6 existem.

Método 3 — Ler as diretivas de Sitemap do robots.txt

Antes de rastrear qualquer coisa, busque /robots.txt. Ele serve a dois propósitos para a descoberta de URLs: frequentemente declara a(s) localização(ões) do sitemap com uma ou mais linhas de Sitemap:, e informa quais caminhos o site pede para os rastreadores evitarem (Disallow:). Ambos importam — o primeiro alimenta o Método 2, o segundo é uma obrigação de conformidade que você traz para o Método 5.

import requests
from urllib.parse import urljoin

HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def sitemaps_from_robots(base_url):
    """Extrair toda diretiva Sitemap: declarada em robots.txt."""
    resp = requests.get(urljoin(base_url, "/robots.txt"), headers=HEADERS, timeout=30)
    resp.raise_for_status()
    sitemaps = []
    for line in resp.text.splitlines():
        if line.lower().startswith("sitemap:"):
            sitemaps.append(line.split(":", 1)[1].strip())
    return sitemaps

if __name__ == "__main__":
    for sm in sitemaps_from_robots("https://example.com"):
        print("Sitemap declarado:", sm)

O robots.txt de um site frequentemente declara uma ou mais linhas Sitemap: — por exemplo, Sitemap: https://example.com/sitemap.xml. Alimente essas diretamente no walk_sitemap do Método 2 e você terá o conjunto completo de URLs declarado pelo publicador sem adivinhar o caminho.

O padrão combinado é a espinha dorsal da descoberta estática: leia robots.txt para encontrar o(s) sitemap(s) e os caminhos não permitidos, e então percorra cada sitemap declarado. O que quer que esses dois retornem é seu inventário inicial autoritativo. Tudo o que vier depois é sobre encontrar as páginas que eles perderam.

Obtenha sua chave de API no plano gratuito: app.scrapeless.com

Método 4 — Rastreador SEO (a opção sem código)

Se você preferir não escrever Python, um rastreador SEO de desktop ou na nuvem faz descoberta, mapeamento de grafos de links e relatórios em uma única ferramenta. Os comuns — Screaming Frog SEO Spider, Sitebulb e os rastreadores de auditoria de site integrados no Ahrefs e Semrush — todos fazem o mesmo trabalho central: fornecem uma URL inicial, seguem links internos em largura, e produzem uma tabela de cada URL encontrada junto com código de status, título, profundidade e contagem de links internos.

Essas ferramentas são a escolha certa quando:

• Você deseja um relatório visual e uma exportação CSV sem manter código.
• Você precisa que as colunas padrão de SEO (status, canônico, indexabilidade, cadeias de redirecionamento) sejam calculadas para você.
• O site é principalmente HTML renderizado pelo servidor, que os rastreadores de desktop lidam nativamente.

Suas limitações merecem ser conhecidas: os níveis gratuitos limitam a contagem de URLs (a edição gratuita do Screaming Frog para na 500 URLs), a renderização JavaScript é um modo opcional, mais lento, que nem todos os níveis habilitam, e as ferramentas de auditoria na nuvem cobram pelo tamanho do projeto. Para uma auditoria única de um site pequeno, elas são difíceis de superar; para um pipeline repetível que alimenta outro sistema, os métodos programáticos abaixo fornecem as URLs como dados em vez de um relatório. Os próximos dois métodos são esse caminho programático.

Método 5 — Um rastreador de links interno BFS em Python

Quando o sitemap está obsoleto ou ausente, você descobre páginas da maneira que um mecanismo de busca faz: comece na página inicial, analise todos os <a href> internos, coloque em fila os que você ainda não viu, e repita em largura até que a fronteira esteja vazia ou você atinja um limite de páginas. Isso encontra páginas órfãs e com links profundos que nenhum sitemap declara.

Duas responsabilidades são inegociáveis em um rastreador de links, e ambas estão incorporadas no código abaixo:

1. Honre o robots.txt. Verifique can_fetch para cada URL antes de solicitá-la, e pule qualquer coisa que o site desautorize. A biblioteca padrão urllib.robotparser lê e avalia as regras para você.
2. Mantenha-se no host e evite duplicatas. Coloque em fila apenas links cujo host corresponda ao host inicial, remova fragmentos de URL para que /page e /page#section sejam contados uma vez, e mantenha um conjunto seen para que um ciclo no grafo de links não loop eternamente.

import requests
from collections import deque
from html.parser import HTMLParser
from urllib.parse import urljoin, urldefrag, urlparse
from urllib.robotparser import RobotFileParser

HEADERS = {"User-Agent": "Mozilla/5.0 (link-discovery)"}

class LinkParser(HTMLParser):
    """Coletar todos os hrefs das tags <a> em uma página."""
    def __init__(self):
        super().__init__()
        self.links = []
    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for key, value in attrs:
                if key == "href" and value:
                    self.links.append(value)

def load_robots(base_url):
    rp = RobotFileParser()
    rp.set_url(urljoin(base_url, "/robots.txt"))

rp.read()           # analisa regras Disallow e qualquer crawl-delay
    return rp

def crawl(start_url, max_pages=200, user_agent="*"):
    """Caminhada em largura dos links internos, respeitando robots.txt."""
    host = urlparse(start_url).netloc
    robots = load_robots(start_url)

    seen = {start_url}
    queue = deque([start_url])
    found, skipped = set(), []

    while queue and len(found) < max_pages:
        url = queue.popleft()

        # Portão de conformidade: nunca buscar um caminho que o site desautoriza.
        if not robots.can_fetch(user_agent, url):
            skipped.append(url)
            continue

        try:
            resp = requests.get(url, headers=HEADERS, timeout=30)
            resp.raise_for_status()
        except requests.RequestException:
            # Um único URL ruim é registrado fora de banda, não perseguido Inline.
            continue
        if "text/html" not in resp.headers.get("Content-Type", ""):
            continue

        found.add(url)

        parser = LinkParser()
        parser.feed(resp.text)
        for href in parser.links:
            absolute = urldefrag(urljoin(url, href))[0]   # resolve + remove #fragmento
            if urlparse(absolute).netloc == host and absolute not in seen:
                seen.add(absolute)
                queue.append(absolute)

    return found, skipped

if __name__ == "__main__":
    pages, disallowed = crawl("https://example.com/", max_pages=200)
    print(f"Descobriu {len(pages):,} páginas; pulou {len(disallowed)} desautorizadas pelo robots.txt")

Uma execução ao vivo deste rastreador contra um catálogo de demonstração estático descobriu 40 páginas com o limite definido em 40 e nenhum URL pulado, porque o robots.txt desse site não desautoriza nada. Apontado para um site cujo robots.txt desautoriza um caminho, o mesmo rastreador corretamente recusou a URL desautorizada e a registrou na lista de skipped em vez de buscá-la — conformidade aplicada em cada URL, não como uma reflexão tardia.

Como isso se compõe com os métodos anteriores:

• O rastreador encontra o que o sitemap omite; o sitemap encontra o que o rastreador não consegue acessar por link. Execute ambos e leve a união para o inventário mais completo.
• Falhas ficam fora de banda. Um URL que apresenta erro é descartado nesta execução e o rastreio continua — uma página ruim nunca bloqueia toda a caminhada. Colete os URLs descartados separadamente para revisão.
• Limite a concorrência por educação. Um rastreador de thread única como o acima já é gentil. Se você paralelizar, mantenha em não mais do que 3 trabalhadores por host, e respeite qualquer Crawl-delay que o robots.txt declarar.
• O rastreador é apenas HTML. Links pintados por JavaScript após o carregamento são invisíveis para requests. Essa lacuna é exatamente o que o Método 6 fecha.

Método 6 — Renderizar páginas pesadas em JavaScript com Scrapeless Scraping Browser

Um rastreador baseado em requests lê os bytes que o servidor envia. Para um aplicativo de página única, um catálogo de rolagem infinita ou uma navegação React/Vue/Next.js, esses bytes são uma shell do aplicativo — <div id="root"></div> mais uma tag de script — e os links internos são pintados do lado do cliente assim que o pacote é executado. HTTP simples não pode vê-los; um navegador real pode.

O Scrapeless Scraping Browser renderiza a página em um navegador em nuvem e a expõe por meio do Protocolo DevTools do Chrome. Você se conecta com Playwright através de um ponto final WebSocket, aquece a página inicial para que a sessão carregue cookies, navega até o alvo e, em seguida, coleta os links do DOM hidratado — o análogo da página renderizada da etapa de análise de links no Método 5. A saída de egressos dos EUA é fixada na sessão para que sites geo-bloqueados sirvam sua estrutura padrão.

A conexão é um único URL WebSocket construído a partir da sua chave de API. Esta é a forma exata de conexão:

import os
from urllib.parse import urlencode
from playwright.sync_api import sync_playwright

def scraping_browser_url(proxy_country="US", session_ttl=240):
    params = urlencode({
        "token": os.environ["SCRAPELESS_API_KEY"],
        "sessionTTL": session_ttl,
        "proxyCountry": proxy_country,
    })
    return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

Com o ponto final em mãos, renderize o alvo e colha seus links internos:

from urllib.parse import urljoin, urldefrag, urlparse

def discover_rendered_links(start_url, proxy_country="US"):
    """Renderize uma página pesada em JS no navegador em nuvem e colete links do mesmo host."""
    host = urlparse(start_url).netloc
    homepage = f"{urlparse(start_url).scheme}://{host}/"

    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(scraping_browser_url(proxy_country))
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.pages[0] if context.pages else context.new_page()

        # Aqueça a página inicial primeiro para que a sessão carregue cookies, depois vá para o alvo.
        page.goto(homepage, wait_until="domcontentloaded", timeout=60_000)
        page.goto(start_url, wait_until="networkidle", timeout=60_000)

Leia os hrefs do DOM hidratado, após a renderização do lado do cliente ter sido executada.

    hrefs = page.eval_on_selector_all(
        "a[href]", "els => els.map(e => e.getAttribute('href'))"
    )
    browser.close()

links = set()
for href in hrefs:
    if not href:
        continue
    absolute = urldefrag(urljoin(start_url, href))[0]
    if urlparse(absolute).netloc == host:
        links.add(absolute)
return links

if name == "main":
found = discover_rendered_links("https://example.com/app/catalog")
print(f"Descobertos {len(found):,} links do lado do cliente após a renderização")
for u in sorted(found)[:10]:
print(" ", u)

O padrão que torna isso confiável:

• Aqueça a página inicial, depois navegue. O primeiro goto para / permite que a sessão capture cookies e passe pelas verificações de primeira carga do site; o segundo goto leva à página que você realmente quer enumerar. Ir diretamente para uma URL profunda em uma sessão fria é mais provável que gere um desafio.
• wait_until="networkidle" no alvo dá ao roteador do lado do cliente tempo para montar seus links antes de você ler o DOM. Para páginas de rolagem infinita, role para baixo em um loop (page.mouse.wheel) até que a contagem de links pare de crescer e, em seguida, colete.
• A renderização ocorre na nuvem da Scrapeless, não na sua máquina. O comando local playwright install chromium é apenas o cliente CDP que se comunica com o endpoint wss://browser.scrapeless.com/....
• Alimente o resultado de volta na união. Os links renderizados se juntam ao conjunto do sitemap e ao conjunto de rastreamento estático; elimine duplicatas da coleção combinada por URL normalizada para o inventário final.

Para conectar isso a um rastreador completo, troque o corpo do requests.get no Método 5 por discover_rendered_links nos hosts que você sabe que são pesados em JavaScript, e mantenha o caminho requests econômico para a maioria renderizada no servidor. Essa divisão baseada em HTTP primeiro, navegador em segundo lugar, mantém o uso do navegador em nuvem nas páginas que realmente precisam dele.

O Que Você Recebe de Volta

Cada método emite um conjunto de URLs absolutas; o inventário final é a união deduplicada de todos eles. Um registro mesclado para um host se parece com isto:

// O esquema reflete a união dos quatro métodos programáticos.
// As contagens são amostras ilustrativas, não um instantâneo congelado de nenhum site hoje.
{
  "host": "example.com",
  "discovered_at_methods": ["sitemap", "robots", "bfs_crawl", "rendered"],
  "counts": {
    "from_sitemap": 226,
    "from_bfs_crawl": 40,
    "from_rendered": 18,
    "union_unique": 248
  },
  "sample_urls": [
    "https://example.com/",
    "https://example.com/blog",
    "https://example.com/blog/how-to-scrape-bbb-business-listings",
    "https://example.com/app/catalog?page=2"
  ],
  "skipped_by_robots": [
    "https://example.com/private/"
  ]
}

Algumas observações honestas sobre a descoberta de URLs de sites inteiros, que vale a pena saber antes de executar em grande escala:

• A união supera qualquer fonte única. Sitemaps declaram o que o editor registrou; o rastreamento BFS encontra órfãos vinculados; a passagem renderizada encontra links do lado do cliente. A cobertura é a união de todos os três menos os caminhos não permitidos.
• Elimine duplicatas em URLs normalizadas. Remova fragmentos, decida se barras finais e parâmetros de consulta ?utm_* são significativos para seu caso de uso e normalize antes de contar — caso contrário, /page e /page/ inflarão o total.
• Sitemaps ficam atrás do conteúdo. Uma página publicada após a última construção do sitemap só aparece nas camadas do rastreamento. Se um inventário completo for importante, execute sempre um rastreamento junto com a leitura do sitemap.
• Links do lado do cliente são invisíveis para HTTP. Se um rastreamento com requests de um site conhecido e grande retornar apenas um punhado de URLs, a navegação é quase certamente renderizada do lado do cliente — escale esse host para o Método 6.
• Respeite a lista de não permitir de ponta a ponta. O array skipped_by_robots não é uma lista de tarefas. Esses caminhos ficam fora do inventário.

Conclusão: construa um inventário completo de URLs

Encontrar cada página se reduz a quatro movimentos programáticos empilhados em cima de uma verificação manual: estime o tamanho com site:, leia robots.txt para a localização do sitemap e os caminhos não permitidos, caminhe pela árvore do sitemap para os URLs declarados, rastreie o gráfico de links internos para os órfãos e renderize os hosts pesados em JavaScript em um navegador em nuvem para os links do lado do cliente. Pegue a união, elimine duplicatas em URLs normalizadas, e esse é o inventário.
Para a camada de proxy que roteia a camada renderizada, veja O que é um Proxy SSL?. A página do produto Scraping Browser e a página de preços cobrem a camada de navegador em nuvem; a referência completa do SDK está em docs.scrapeless.com. Fixe a saída dos EUA na camada renderizada, aqueça a página inicial antes da página-alvo, respeite o robots.txt em cada URL e trate a lista final como a união de todos os métodos.

Pronto para Construir Seu Pipeline de Dados Potencializado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que estão construindo pipelines de descoberta de URL e rastreamento: Discord · Telegram.

Inscreva-se em app.scrapeless.com para obter tempo de execução gratuito do Scraping Browser e adapte os padrões acima aos sites, sitemaps e regiões que o pipeline necessita.

FAQ

P: É legal rastrear um site para encontrar todas as suas páginas?

A descoberta em si lê URLs visíveis publicamente, mas a legalidade depende do que você acessa, de onde e sob quais termos. Respeite o robots.txt do site, revise seus termos de serviço, evite áreas privadas ou autenticadas e consulte um advogado para casos de alto risco. A Scrapeless acessa apenas dados disponíveis publicamente.

P: Sitemap ou rastreamento — qual fornece a lista completa?

Nenhum dos dois sozinho. Um sitemap é a declaração do editor e muitas vezes está desatualizado ou é parcial; um rastreamento encontra o gráfico vinculado, mas perde páginas que nenhum link aponta. O inventário completo é a união da caminhada do sitemap (Método 2) e do rastreamento BFS (Método 5), com a camada renderizada (Método 6) adicionada para links do lado do cliente.

P: Por que meu rastreador encontra apenas um pequeno número de páginas em um grande site?

O site quase certamente renderiza sua navegação do lado do cliente. Uma recuperação simples de requests retorna o shell do aplicativo antes de o JavaScript ser executado, então não há links a seguir. Renderize esses hosts com o Scrapeless Scraping Browser (Método 6) e colete os âncoras do DOM hidratado.

P: Preciso de um proxy para descoberta de URL?

Para uma leitura de sitemap de um único host e um rastreamento estático educado, muitas vezes não é necessário. Um proxy garante seu espaço quando o site geo-bloqueia conteúdo (você precisa de saída dos EUA para ver a estrutura dos EUA), quando seu IP é limitado por taxa, ou quando a camada renderizada precisa de saída residencial para corresponder ao tráfego orgânico. A conexão Scrapeless no Método 6 fixa a saída com proxy_country="US".

P: Como consigo uma renderização limpa quando uma página apresenta um desafio de acesso?

Fixe a saída residencial dos EUA na sessão e aqueça a sessão — navegue até a página inicial do site primeiro na mesma sessão de navegador antes da página alvo, como faz o código do Método 6, para que os cookies sejam definidos e a página profunda carregue em um contexto já confiável. Um salto frio direto para uma URL profunda é mais provável de gerar um desafio.

P: O que acontece quando o site muda sua estrutura HTML ou de links?

O rastreador estático se baseia no elemento genérico <a href>, portanto, mudanças na marcação raramente o quebram. Se você restringiu o seletor da camada renderizada a um contêiner específico, verifique-o novamente quando a marcação mudar e amplie-o de volta para a[href] se o site reorganizar sua navegação.

P: Como evito sobrecarregar o site enquanto rastreio?

O rastreador de thread única no Método 5 já é gentil. Se você paralelizar, mantenha a concorrência em não mais do que 3 trabalhadores por host, respeite qualquer diretiva Crawl-delay no robots.txt e nunca enfileire um caminho que as regras de desautorização cobrem.

P: Como desduplico o conjunto final de URLs?

Normalize antes de contar: remova #fragments, decida se uma barra final e parâmetros de consulta de rastreamento (?utm_*) são significativos para seu caso de uso, e armazene URLs em um set com base na forma normalizada. Cada método já retorna um set; tome a união de todos eles e os duplicados colapsam.

P: Posso descobrir URLs sem um agente de IA ou qualquer SDK?

Sim. Os Métodos 1–5 usam apenas a biblioteca padrão do Python e requests. O Método 6 adiciona Playwright conectando-se ao endpoint do Scrapeless Scraping Browser através do CDP — nenhum framework de agente necessário, apenas a URL WebSocket construída a partir da sua chave de API.