Cómo utilizar GoSpider: rastrear, depurar URL y extraer datos

GoSpider acepta un destino o una lista de destinos, solicita páginas, sigue los enlaces válidos e informa de las URL encontradas en HTML, scripts, mapas del sitio, archivos robots, subdominios o fuentes externas opcionales. Esto hace que el rastreador web GoSpider resulte útil para tareas de inventario, reconocimiento de seguridad en sistemas autorizados, comprobaciones de migración y la creación de una cola de entrada para su posterior extracción.

Por sí solo, no convierte páginas arbitrarias en registros de productos, artículos o tablas. GoSpider puede identificar /catalogue/a-light-in-the-attic_1000/index.html; el código de extracción debe seguir abriendo esa página, seleccionando el título y el precio, validándolos y serializando el resultado. Una guía que compare el web scraping con el web crawling resulta útil si tu equipo tiende a utilizar esos términos indistintamente.

La otra limitación es la representación. GoSpider puede inspeccionar archivos JavaScript en busca de cadenas similares a URL, pero no ejecuta una aplicación de página única como lo haría un navegador. Si los datos solo aparecen tras un clic, un desplazamiento, un proceso de inicio de sesión o una llamada a la API del lado del cliente, la detección de URL puede quedar incompleta. Utiliza GoSpider en primer lugar para superficies públicas, estáticas o renderizadas por el servidor. Recurre a otros métodos solo después de determinar si el fallo se debe al ámbito, al control de acceso o a la falta de ejecución en el navegador.

Este primer flujo de trabajo de «Cómo utilizar GoSpider» utiliza Books to Scrape, un sitio público de práctica, con poca profundidad y baja carga de solicitudes. El objetivo no es la máxima cobertura ni la velocidad. Se trata de un archivo de URL reproducible que puedes inspeccionar antes de ampliar el alcance. Mantén el comando inicial sin cambios el tiempo suficiente para establecer una línea de base y, a continuación, modifica un parámetro de control cada vez. Este enfoque permite explicar las diferencias en los resultados y la carga.

Instala una versión actual de Go siguiendo las instrucciones oficiales de instalación de Go y, a continuación, comprueba que la cadena de herramientas funciona:

go version
go env GOBIN
go env GOPATH

En el momento de redactar este artículo, el patrón de instalación de módulos esperado es:

go install github.com/jaeles-project/gospider@latest
gospider -h

El comando de instalación, la versión, los alias y los valores predeterminados requieren una comprobación del repositorio actual antes de la publicación. Considera gospider -h el binario que tengas instalado como de referencia para las instrucciones que siguen.

Si macOS o Linux no pueden encontrar el ejecutable y GOBIN está vacío, la documentación proporcionada coloca los binarios instalados por Go en el directorio GOPATH bin :

export PATH="$(go env GOPATH)/bin:$PATH"
gospider -h

Mantén esa exportación en el archivo de inicio de tu shell solo después de haber confirmado el directorio. En cualquier plataforma, una GOBIN tiene prioridad. Guarda la salida de go version, go env GOBINy gospider -h junto con tus notas de ejecución. Ese pequeño registro facilita mucho explicar por qué un comando se comporta de forma diferente en otra estación de trabajo o tras una actualización.

<!-- Se necesita investigación adicional: confirma las instrucciones actuales de GOBIN y PATH de Windows en la documentación actual de Go antes de añadir comandos específicos del sistema operativo. -->

Crea un directorio de trabajo y, a continuación, realiza un rastreo de solo un nivel de enlaces desde la página de inicio:

mkdir gospider-project
cd gospider-project

gospider   -s https://books.toscrape.com/   -d 1   -c 2   -k 1   -m 20   -o output   -q

En las versiones descritas en el resumen proporcionado, -s se establece un sitio, -d 1 mantiene la recursión superficial, -c 2 limita las solicitudes simultáneas para un dominio coincidente, -k 1 añade un retraso, -m 20 establece un tiempo de espera, -o almacena los resultados y -q reduce el ruido en la terminal. Comprueba cada opción con la salida de ayuda actual antes de utilizar el comando sin modificaciones.

Empieza con cautela, incluso en un sitio de prueba. La profundidad multiplica las rutas, la concurrencia multiplica el trabajo en curso y un rastreo sin retardo puede generar una carga evitable. Algunas versiones documentadas interpretan la profundidad 0 como una recursión ilimitada, así que no la utilices hasta que hayas vuelto a comprobar ese comportamiento y hayas definido un alcance estricto.

Para obtener un flujo rápido y limpio, captura las URL y deduplícalas:

gospider -s https://books.toscrape.com/ -d 1 -c 2 -k 1 -q   | grep -Eo 'https?://[^[:space:]]+'   | sort -u > urls.txt

Abre urls.txt y confirma que cada nombre de host y ruta pertenezcan al destino previsto. El archivo puede incluir URL de categorías, paginación y recursos, además de las páginas de productos. Esto es lo esperado en la fase de descubrimiento. No lo compenses aumentando la profundidad todavía. Primero identifica el patrón de ruta que representa las páginas que tu extractor puede procesar realmente.

Ejecuta el rastreo sin -q cuando necesites conocer la procedencia. En compilaciones documentadas, las etiquetas distinguen los recursos solicitados ([url]), enlaces analizados del HTML ([href]), archivos JavaScript ([javascript]) y las cadenas similares a URL encontradas al inspeccionar scripts ([linkfinder]). Vuelve a comprobar esas etiquetas en tu versión instalada.

La salida silenciosa es más fácil de canalizar, pero descarta contexto útil. Es preferible el formato JSON cuando otro programa necesita campos de tipo o de origen:

gospider -s https://books.toscrape.com/ -d 1 --json > crawl.jsonl
head -n 3 crawl.jsonl

No vincules el código de producción a un esquema JSON supuesto hasta que hayas inspeccionado una muestra actual y validado cómo se representan los errores. Los recursos estáticos o los enlaces excluidos pueden seguir apareciendo como hallazgos incluso cuando GoSpider no los solicite.

Una guía práctica sobre cómo utilizar GoSpider parte de cuatro decisiones: qué hosts están autorizados, hasta dónde pueden expandirse los enlaces, cuánta carga es aceptable y qué salida espera la siguiente etapa. Crea el comando a partir de esas decisiones en lugar de habilitar todos los parámetros de detección. Anota junto al comando el host deseado, la profundidad máxima, el número de trabajadores de destino, la concurrencia por dominio, el retraso y el formato de salida. Esos seis valores conforman un contrato de rastreo compacto que los revisores pueden comprender antes de la ejecución.

Utiliza -s para una URL de inicio y -S para un archivo que contenga varios objetivos. Mantén la lista de sitios explícita, con una URL aprobada por línea, y almacena cada ejecución en un directorio de salida con fecha para que no se mezclen los resultados de diferentes configuraciones.

printf '%s
'   'https://books.toscrape.com/'   'https://quotes.toscrape.com/' > sites.txt

gospider -S sites.txt -d 1 -c 2 -t 2 -o output-run-01

El descubrimiento de subdominios solo debe activarse cuando la autorización cubra dichos hosts. Decide si se permiten las redirecciones a otro host y mantén separada la salida de cada objetivo. Del mismo modo, las expresiones de la lista blanca y la lista negra deben limitar las solicitudes a rutas y tipos de archivo útiles. Un patrón como /catalogue/ puede conservar las páginas de productos, mientras que los recursos se pueden eliminar durante el posprocesamiento.

No des por sentado que el filtrado modifica lo que se muestra. En las versiones documentadas, una URL incluida en la lista negra puede seguir apareciendo como un enlace detectado aunque no se recupere. Valida tanto el comportamiento de las solicitudes como la salida generada en un pequeño entorno de prueba.

La profundidad es el número de niveles de enlaces seguidos desde cada URL de partida. -d 1 es una muestra de descubrimiento segura. Aumenta a -d 2 solo cuando los primeros resultados muestren que las páginas deseadas se encuentran un nivel más allá. Evita la profundidad ilimitada, ya que los calendarios, la navegación por facetas, los parámetros de seguimiento y las rutas duplicadas pueden hacer que el rastreo crezca indefinidamente.

Los controles de paralelismo resuelven diferentes problemas:

Para tres sitios autorizados, -t 2 -c 2 puede activar dos destinos, permitiendo hasta dos solicitudes por dominio coincidente. Esto no significa que solo se puedan realizar dos solicitudes en total. Utiliza un retraso y un tiempo de espera moderado para que los servidores lentos no provoquen una avalancha de reintentos:

gospider -S sites.txt -d 1 -t 2 -c 2 -k 1 -m 20 -o output

La -c, -t, el retraso, el tiempo de espera y la semántica de profundidad cero dependen de la versión en los datos proporcionados. Anota tu versión binaria y prueba con un entorno local o controlado antes de una ejecución a gran escala. Supervisa la tasa de solicitudes en el servidor cuando lo controles. Los ajustes de concurrencia del lado del cliente son límites útiles, pero las redirecciones, los reintentos y los servidores recién descubiertos pueden hacer que el tráfico observado difiera de una simple -c × -t estimación.

Cada modo de expansión añade una fuente de semillas diferente:

• La inspección de JavaScript busca en el texto de los scripts descargados cadenas similares a URL. No ejecuta la aplicación.
• El procesamiento de robots y mapas del sitio puede revelar rutas declaradas que la navegación habitual pasa por alto.
• El descubrimiento de subdominios puede añadir nuevos hosts, lo que también amplía los problemas de autorización y carga.
• Las fuentes externas pueden devolver URL históricas procedentes de archivos o de índices de inteligencia sobre amenazas.

Una receta limitada puede combinar estos modos con una profundidad reducida, baja concurrencia y una lista blanca de hosts:

gospider   -s https://example.com/   -d 1 -c 1 -k 2 -m 20   --js --robots --sitemap   --whitelist 'https://([a-z0-9-]+\.)?example\.com/'   -o discovery

Añade la opción de subdominio o --other-source opción únicamente tras comprobar gospider -h y de que todos los hosts resultantes permanezcan dentro del ámbito de aplicación. Las semillas de los archivos pueden revelar rutas eliminadas, redirigidas o sensibles, por lo que el descubrimiento no implica permiso para solicitarlas.

Los metadatos de solicitud personalizados resultan útiles cuando un destino autorizado espera una configuración regional, una cuenta de prueba o un encabezado específico de la aplicación. Pasa los encabezados no confidenciales por separado:

gospider -s https://example.com/ -d 1   -H 'Accept-Language: en-US'   -H 'X-Test-Run: inventory-01'

En el caso de una cookie, lee el valor sin mostrarlo y bórralo tras la ejecución:

read -s SESSION_COOKIE
gospider -s https://example.com/account/ -d 1 --cookie "$SESSION_COOKIE"
unset SESSION_COOKIE

Los argumentos de la línea de comandos pueden ser visibles para otros procesos locales o herramientas de shell. Utiliza credenciales de prueba de corta duración, evita las máquinas compartidas, nunca guardes comandos que contengan tokens y no permitas que la autenticación amplíe el alcance de rastreo aprobado.

Las versiones documentadas aceptan un proxy con -p y salida estructurada con --json:

gospider -s https://example.com/ -d 1 -c 1   -p 'http://USER:PASS@proxy.example:8080'   --json > crawl.jsonl

Considera que la sintaxis del proxy, los nombres de los filtros, los alias, el análisis de encabezados, el manejo de cookies y los campos JSON dependen de la versión. Ejecuta una solicitud controlada que repita los encabezados permitidos antes de confiar en la autenticación o en el comportamiento del enrutamiento. Un proxy modifica la ruta de red, no tu autorización. Para una configuración más amplia del proyecto, una guía de web scraping en Go puede abarcar la gestión de secretos y el comportamiento del cliente HTTP más allá de esta CLI.

Estos comandos de GoSpider son plantillas, no recomendaciones sobre permisos o carga. Sustituye los destinos, verifica los parámetros actuales y ejecuta las recetas de «Cómo usar GoSpider» en un ámbito autorizado reducido antes de aumentar la profundidad o el paralelismo. Guarda cada comando en un manual de procedimientos indicando su finalidad y el nombre de host previsto. Si los resultados observados superan cualquiera de estos parámetros, detente e investiga en lugar de añadir filtros tras un rastreo de gran envergadura.

Un solo sitio, un nivel, baja presión:

gospider -s https://books.toscrape.com/ -d 1 -c 2 -k 1 -m 20 -o one-site

Varios sitios desde un archivo:

https://docs.example.org/
https://status.example.org/
https://support.example.org/

Guarda esas líneas como sites.txt, y a continuación ejecuta:

gospider -S sites.txt -d 1 -c 2 -t 2 -k 1 -m 20 -o many-sites

Aquí, -t 2 controla cuántos destinos de la lista se procesan en paralelo, mientras que -c 2 limita el trabajo simultáneo para cada dominio coincidente. Aumentar ambos valores multiplica la carga. Si un destino redirige a otro host, vuelve a comprobar el ámbito en lugar de dar por hecho que se aplica el mismo nivel de concurrencia o autorización. Ejecuta primero una muestra de dos objetivos y comprueba si el directorio de salida separa los resultados como se espera en tu versión. Si los archivos se fusionan o se nombran de forma inesperada, corrige la importación posterior antes de añadir más objetivos.

Rutas declaradas en archivos robots y mapas del sitio:

gospider -s https://example.com/ --robots --sitemap   -d 1 -c 1 -k 2 -o declared-paths

Subdominios autorizados, utilizando el indicador de subdominio que aparece en la ayuda instalada:

gospider -s https://example.com/ --subs   -d 1 -c 1 -k 2 -o subdomain-results

Fuentes históricas:

gospider -s https://example.com/ --other-source   -d 1 -c 1 -k 2 -o archive-results

Las fuentes de terceros pueden devolver muchas URL obsoletas o fuera del ámbito. Trata sus resultados como semillas no fiables, no como una cola para recuperar automáticamente. Filtra por host y ruta aprobados, elimina las URL que contengan información confidencial o identificadores de usuario, y comprueba los códigos de estado antes de solicitar cualquier resultado. Para las tres recetas, mantén una profundidad finita, ya que cada ruta recién introducida puede revelar otra capa de enlaces.

La salida sin procesar del rastreador es un registro de observación, no una cola de extracción fiable. En este proceso de «Cómo utilizar GoSpider», la limpieza es un paso independiente y determinista que conserva únicamente las URL HTTP válidas que coinciden con las páginas que pretendes rastrear. Mantén el archivo sin procesar inmutable, escribe las URL aceptadas en un nuevo archivo y versiona las reglas para que cada inclusión pueda reproducirse.

Un proceso compacto en shell puede extraer cadenas con formato de URL, eliminar fragmentos, conservar una sola familia de rutas y deduplicar:

grep -Eo 'https?://[^[:space:]]+' crawl.txt \
  | sed -E 's/#.*$//' \
  | grep -E '^https://books\.toscrape\.com/catalogue/' \
  | grep -Ev '/catalogue/category/' \
  | sort -u > urls.txt

Para obtener un filtro Go portátil con análisis explícito, guarda esto como filter.go:

package main

import (
	"bufio"
	"fmt"
	"net/url"
	"os"
	"regexp"
	"sort"
	"strings"
)

var findURL = regexp.MustCompile(`https?://[^\s"'<>()]+`)

func main() {
	seen := map[string]bool{}
	var keep []string
	s := bufio.NewScanner(os.Stdin)

	for s.Scan() {
		for _, raw := range findURL.FindAllString(s.Text(), -1) {
			raw = strings.TrimRight(raw, ".,);]")
			u, err := url.Parse(raw)
			if err != nil || u.Hostname() != "books.toscrape.com" {
				continue
			}
			if !strings.HasPrefix(u.Path, "/catalogue/") ||
				strings.HasPrefix(u.Path, "/catalogue/category/") {
				continue
			}
			u.Fragment = ""
			u.Scheme = strings.ToLower(u.Scheme)
			u.Host = strings.ToLower(u.Host)
			clean := u.String()
			if !seen[clean] {
				seen[clean] = true
				keep = append(keep, clean)
			}
		}
	}
	sort.Strings(keep)
	for _, u := range keep {
		fmt.Println(u)
	}
}

Ejecútalo con:

go run filter.go < crawl.txt > urls.txt

La política de normalización depende de la aplicación. Eliminar fragmentos suele ser seguro para las solicitudes al servidor, pero omitir los parámetros de consulta puede fusionar páginas distintas. Decide si las barras finales, los puertos predeterminados, la codificación porcentual y los parámetros de seguimiento son equivalentes para tu objetivo y, a continuación, codifica esa política en las pruebas. Conserva la URL original junto a la clave normalizada cuando la auditabilidad sea importante. Recuerda también que los filtros de GoSpider pueden bloquear una solicitud sin suprimir el enlace detectado de la salida. Por lo tanto, sigue siendo necesario un posprocesamiento.

Inspecciona los primeros registros y analiza una pequeña muestra:

head -n 20 urls.txt

head -n 10 urls.txt | while read -r url; do
  curl -sS -o /dev/null \
    -w '%{http_code} %{content_type} %{url_effective}\n' "$url"
done

Busca hosts inesperados, variantes de URL duplicadas, redireccionamientos, contenido que no sea HTML, respuestas 403 y estructuras de ruta que no coincidan con tus selectores de extracción. Abre manualmente dos o tres páginas y confirma que los campos deseados existen en el HTML devuelto. No aumentes la profundidad de GoSpider ni el volumen de extracción hasta que esta muestra esté limpia.

GoSpider ya ha terminado su trabajo. El siguiente paso de la guía «Cómo usar GoSpider» pasa la lista de URL permitidas y depurada a Colly, que solicita cada página aprobada, ejecuta las funciones de llamada de selector CSS, valida los registros y genera un archivo CSV. Este límite permite que el descubrimiento de URL sea sustituible y que la lógica de extracción sea comprobable. También te permite volver a ejecutar selectores sobre el mismo conjunto de URL aprobadas sin necesidad de volver a rastrear el sitio, lo cual resulta útil cuando cambia el marcado de la página pero no el alcance del rastreo.

Inicializa un módulo de Go y añade Colly:

go mod init gospider-pipeline
go get github.com/gocolly/colly/v2

Guarda lo siguiente como scrape.go. Los selectores se dirigen a la página del producto «Books to Scrape» utilizada en la guía de inicio rápido:

package main

import (
	"bufio"
	"encoding/csv"
	"log"
	"os"
	"strings"
	"time"

	"github.com/gocolly/colly/v2"
)

func main() {
	input, err := os.Open("urls.txt")
	if err != nil { log.Fatal(err) }
	defer input.Close()

	out, err := os.Create("books.csv")
	if err != nil { log.Fatal(err) }
	defer out.Close()

	writer := csv.NewWriter(out)
	defer writer.Flush()
	_ = writer.Write([]string{"url", "title", "price", "image"})

	c := colly.NewCollector(
		colly.AllowedDomains("books.toscrape.com"),
	)
	_ = c.Limit(&colly.LimitRule{
		DomainGlob:  "*books.toscrape.com*",
		Parallelism: 2,
		Delay:       time.Second,
	})

	written := map[string]bool{}

	c.OnHTML("article.product_page", func(e *colly.HTMLElement) {
		pageURL := e.Request.URL.String()
		if written[pageURL] { return }

		title := strings.TrimSpace(e.ChildText("div.product_main h1"))
		price := strings.TrimSpace(e.ChildText("p.price_color"))
		image := e.Request.AbsoluteURL(e.ChildAttr("div.item.active img", "src"))
		if title == "" || price == "" {
			log.Printf("missing fields: %s", pageURL)
			return
		}

		_ = writer.Write([]string{pageURL, title, price, image})
		written[pageURL] = true
	})

	c.OnError(func(r *colly.Response, err error) {
		log.Printf("request failed: %s status=%d err=%v",
			r.Request.URL, r.StatusCode, err)
	})

	scanner := bufio.NewScanner(input)
	count := 0
	for scanner.Scan() && count < 20 {
		u := strings.TrimSpace(scanner.Text())
		if u == "" { continue }
		if err := c.Visit(u); err != nil {
			log.Printf("visit skipped: %s err=%v", u, err)
		}
		count++
	}
	if err := scanner.Err(); err != nil { log.Fatal(err) }
}

Ejecuta go run scrape.goy, a continuación, inspecciona books.csv. En este ejemplo compacto, el recopilador procesa el archivo de forma sincrónica, mientras que la regla de límite añade control de ritmo y deja margen para adoptar la recopilación asíncrona más adelante. Si habilitas las visitas asíncronas, protege los mapas compartidos y las escrituras en CSV, o canaliza los registros a través de una única goroutine de escritura. La OnHTML se activa para los elementos que coinciden, por lo que un archivo vacío suele significar que el selector, el contenido de la respuesta o el filtro de URL son incorrectos. Si tu objetivo real es tabular, una guía para extraer tablas HTML en Golang con Colly es la siguiente referencia lógica.

Mantén el límite inicial en 20 URL. Valida los encabezados, el recuento de filas, la codificación, los campos obligatorios, el comportamiento ante duplicados y las URL de las imágenes antes de eliminar el límite. Registra los códigos de estado y las URL fallidas, pero nunca registres cookies ni encabezados de autorización.

Utiliza AllowedDomainsun retraso y un bajo paralelismo, aunque la entrada ya haya sido filtrada. Añade reintentos solo para fallos transitorios, como tiempos de espera agotados o determinadas respuestas 5xx, con un límite estricto de intentos y un tiempo de espera. No reintentes ciegamente las respuestas 403 o 404. En producción, escribe en un archivo CSV temporal y cámbiale el nombre solo después de que la ejecución haya superado la validación, para que la salida parcial no se confunda con un conjunto de datos completo. Añade un manifiesto de ejecución que contenga el hash de entrada, la versión del selector, la hora de inicio, el recuento de éxitos y el recuento de fallos. Esto permite medir una nueva ejecución en lugar de depender de los registros de la terminal.

Un buen diagnóstico de «Cómo usar GoSpider» comienza por clasificar el fallo. Comprueba primero la instalación y el alcance del rastreo, luego el acceso HTTP y, por último, la representación. Cambiar de herramienta antes de identificar la capa en cuestión suele añadir complejidad sin resolver la causa. Captura una URL que falle, el comando exacto, el código de estado, el tipo de respuesta y si el elemento que falta existe en el HTML sin procesar. Esa evidencia suele apuntar a la rama correcta en cuestión de minutos.

Depura con una URL y salida etiquetada antes de cambiar varios indicadores. Si funciona una página sencilla renderizada por el servidor, es probable que la instalación esté bien. Compara una URL que sepas que funciona con otra que falla utilizando los mismos parámetros, de modo que solo cambies una variable cada vez. Si se encuentran las URL pero predominan las rutas incorrectas, corrige el ámbito o limpia el código. Si las solicitudes devuelven un 403, investiga el acceso. Si el HTML carece de contenido visible en el navegador, investiga la renderización.

Una respuesta HTTP 403 significa que el servidor ha entendido la solicitud, pero la ha rechazado. Puede indicar falta de permisos, la necesidad de una sesión autenticada, una regla de política, limitación de tasa o controles antibots. No es prueba de que un proxy sea la solución correcta.

Sigue este orden:

1. Confirma que el rastreo está autorizado y que la URL está dentro del ámbito.
2. Solicita una URL con salida etiquetada o curl e inspecciona las redirecciones y los encabezados de respuesta.
3. Comprueba si el sitio requiere un inicio de sesión, una cookie, un referer, una configuración regional o un agente de usuario documentado.
4. Reduce la concurrencia y añade un retraso. Un rastreo en ráfagas puede activar controles que una solicitud manual no activa.
5. Si se confirma que el problema radica en la reputación de la IP o la ubicación geográfica, utiliza un proxy autorizado con credenciales de corta duración.
6. Si la gestión de reintentos, la rotación de proxies y el manejo de CAPTCHA quedan fuera del alcance del proyecto, evalúa una API genérica de scraping.

No intentes eludir los permisos de cuenta, los muros de pago ni los controles de acceso explícitos. Una guía detallada sobre cómo realizar scraping web sin ser bloqueado puede ayudar a mantener la «higiene» de las solicitudes, pero la autorización sigue siendo el primer requisito.

Encontrar una URL dentro de un paquete de JavaScript es un análisis de texto. Representar una página implica ejecutar scripts, mantener el estado del navegador, esperar a que haya actividad en la red y, en ocasiones, hacer clic o desplazarse. La opción de detección de JavaScript de GoSpider aborda la primera tarea, no la segunda.

Utiliza una prueba de tres pasos:

• Si el enlace y los datos deseados están presentes en la respuesta HTTP original, basta con GoSpider y Colly.
• Si el HTML es principalmente una carcasa de aplicación, pero un punto final JSON público proporciona los datos, rastrea los puntos finales aprobados y extrae la información de sus respuestas.
• Si el contenido solo aparece tras la ejecución o la interacción del navegador, utiliza la automatización del navegador o un servicio de navegador alojado.
• Si la página es estática pero se bloquea sistemáticamente en la capa de solicitud, plantéate utilizar una API de solicitudes gestionada en lugar de la automatización del navegador.

Compara la opción «Ver código fuente» con el DOM del navegador e inspecciona el panel de red en una prueba autorizada. Elige la herramienta menos compleja que reproduzca la respuesta requerida. Los navegadores se encargan de la visualización y la interacción, pero consumen más memoria y requieren gestión del ciclo de vida, de los tiempos de espera y de las sesiones.

A nivel de categoría, GoSpider y hakrawler son herramientas de descubrimiento de URL orientadas a la CLI; Colly es un marco de trabajo programable en Go para el rastreo y la extracción; y los rastreadores basados en navegador ejecutan código del lado del cliente. La elección adecuada depende del traspaso que necesites:

A la hora de decidir cómo utilizar GoSpider, opta por él cuando la amplitud de la exploración y la composición de la línea de comandos sean importantes. Opta por Colly cuando prevalezcan las reglas de extracción y la validación de registros. Utiliza un navegador solo cuando el objetivo requiera realmente ejecución o interacción.

Antes de cada ejecución:

• Obtenga autorización y defina los hosts, rutas, cuentas y campos permitidos.
• Utiliza una profundidad finita, baja concurrencia, retrasos, tiempos de espera y un límite reducido de URL.
• Revisa los términos y el Protocolo de Exclusión de Robots. Las reglas de los robots guían a los rastreadores, pero no otorgan permiso legal.
• Detén el rastreo si se producen errores, latencia o un aumento inesperado de la carga del servidor.
• Mantén las cookies, los tokens y las credenciales de proxy fuera del código y de los registros.
• No recopiles datos sensibles simplemente porque una URL sea accesible.
• Registra la versión, el comando, la hora y la política de salida para facilitar la auditoría.

Un marco legal y de cumplimiento para el web scraping puede convertir estas comprobaciones en una revisión repetible.

El comportamiento de GoSpider depende de la versión instalada, el destino y los modos de descubrimiento habilitados. Antes de la puesta en producción, guarda gospider -h, anota la versión del módulo o el commit y conserva un pequeño rastreo de prueba con los resultados esperados. La última sección de preguntas frecuentes se centra en los límites conceptuales que siguen siendo útiles incluso cuando cambian los alias individuales, los valores predeterminados, las etiquetas o los campos JSON. Además, evita presentar los valores predeterminados específicos de cada versión como una guía atemporal.

• Utilice GoSpider para descubrir URL y, a continuación, realice la normalización, la validación y la extracción estructurada como etapas independientes.
• Comienza con una profundidad finita, una baja concurrencia por dominio, un retraso y un pequeño conjunto de destinos autorizados.
• -c controla la concurrencia de solicitudes a nivel de dominio, mientras que -t controla el procesamiento paralelo entre los objetivos de una lista de sitios, sujeto a la verificación de la versión.
• Considera que los modos «quiet», «JSON», los filtros, los modos de descubrimiento y los indicadores de proxy dependen de la versión. Pruébalos con un entorno de prueba controlado.
• Diagnostica el ámbito, el acceso HTTP y la representación del navegador por separado antes de cambiar de herramienta.

GoSpider es principalmente un rastreador web. Descubre y sigue URL, mapea la estructura del sitio y puede extraer enlaces de varias fuentes. Por lo general, no convierte páginas arbitrarias en registros validados de productos, artículos o tablas. Ese paso de extracción estructurada corresponde al código del analizador sintáctico, a un marco de extracción de datos u otra capa de extracción de datos.

-c controla las solicitudes simultáneas asociadas a un dominio concreto, mientras que -t controla cuántos sitios de destino de una lista se pueden procesar en paralelo en las versiones documentadas. Combinarlas multiplica las posibilidades de actividad. Dado que la semántica y los valores predeterminados pueden cambiar, comprueba ambas opciones con la ayuda instalada y una prueba controlada en varios sitios.

No. La función de JavaScript documentada inspecciona los scripts en busca de cadenas similares a URL, en lugar de ejecutar un motor de navegador. Puede revelar puntos finales o rutas incrustadas en paquetes, pero no reproducirá actualizaciones del DOM, clics, desplazamiento infinito ni el estado de la aplicación creado al ejecutar JavaScript.

Un filtro puede impedir que GoSpider solicite una URL coincidente sin borrar el hecho de que el enlace se haya detectado en HTML u otra fuente. Como resultado, la URL puede seguir apareciendo como un registro de detección. Comprueba el comportamiento en tu versión y, a continuación, aplica un filtro de salida independiente antes de la extracción.

Combínalo con Colly para la extracción estructurada de HTML accesible, con un proxy autorizado cuando la ubicación de la red o la reputación de la IP sean un obstáculo confirmado, con una API de solicitud cuando la gestión de bloqueos resulte demasiado costosa desde el punto de vista operativo, y con un navegador cuando el contenido requiera la ejecución de JavaScript o interacción. Las comprobaciones de autorización y ámbito deben realizarse antes de considerar cualquier opción.

La respuesta fiable a cómo utilizar GoSpider es considerarlo como la fase de descubrimiento de un proceso. Instálalo a través de la cadena de herramientas de Go, comprueba la salida de ayuda actual y comienza con un rastreo superficial y pausado. Utiliza -S, -cy -t de forma deliberada al ampliar el alcance a otros objetivos, y habilita los mapas del sitio, los archivos robots, los scripts, los subdominios o las fuentes externas solo cuando dichas fuentes se mantengan dentro del ámbito aprobado.

Los resultados del rastreador aún requieren trabajo de ingeniería. Normaliza las URL, elimina los duplicados, aplica reglas de host y ruta, y toma una muestra de los códigos de estado antes de enviar la lista a Colly. En la fase de extracción, utiliza listas de dominios permitidos, un bajo nivel de paralelismo, validación de campos y gestión atómica de la salida. Cuando falle una ejecución, clasifícala como un problema de ámbito, un problema de acceso HTTP o un problema de renderización antes de recurrir a otra herramienta.

Si las páginas renderizadas por el servidor están bloqueadas de forma sistemática y deseas mantener el proceso centrado en el HTML sin procesar más el análisis de Colly, la API Scraper de WebScrapingAPI puede gestionar la rotación de proxies, los CAPTCHAs y el bloqueo de solicitudes detrás de un único punto final. Utiliza ese traspaso solo después de confirmar que el problema se encuentra en la capa de solicitud, y no en una falta de interacción con el navegador o en permisos insuficientes.