Python para tareas web: scraping, enlaces rotos, metadatos y auditorías básicas

Automatizar tareas web con Python es una de las formas más prácticas de ahorrar tiempo cuando administras, mantienes o auditas sitios web.

Muchas tareas repetitivas de un webmaster, desarrollador o responsable técnico se pueden convertir en scripts: revisar si varias URLs responden correctamente, detectar enlaces rotos, extraer títulos, leer metadescripciones, comprobar redirecciones, analizar un sitemap o generar pequeños reportes.

No necesitas construir una herramienta enorme desde el primer día. A veces un script de 30 líneas puede ahorrarte horas de revisión manual.

La idea no es reemplazar el criterio técnico, sino usar Python para recopilar información más rápido y tomar mejores decisiones.

Por qué automatizar tareas web

Tabla del contenido

Un sitio web requiere revisiones constantes. Algunas son visuales, otras editoriales y otras técnicas.

Por ejemplo:

comprobar si una página responde con código 200;
detectar errores 404;
revisar redirecciones;
validar enlaces internos;
extraer títulos y metadescripciones;
revisar si las páginas tienen etiquetas básicas;
analizar un sitemap;
guardar resultados en CSV;
comparar cambios después de una actualización.

Hacer esto manualmente en 5 URLs puede ser viable. Hacerlo en 50, 500 o 5,000 URLs ya no tiene sentido.

Ahí entra Python.

Python permite convertir una revisión repetitiva en un proceso reutilizable. Puedes ejecutar el mismo script cada semana, ajustar la lista de URLs, guardar resultados y comparar cambios con el tiempo.

Qué tareas web se pueden automatizar con Python

Algunas tareas útiles para empezar son:

revisar estados HTTP;
detectar páginas caídas;
identificar enlaces rotos;
extraer el contenido de etiquetas title;
extraer metadescripciones;
revisar encabezados básicos;
leer archivos sitemap.xml;
buscar URLs duplicadas;
analizar redirecciones;
exportar resultados a CSV;
hacer una mini auditoría técnica.

Estas tareas son especialmente útiles en sitios WordPress, blogs técnicos, sitios corporativos, landing pages y proyectos donde necesitas revisar muchas URLs sin depender siempre de herramientas externas.

Requisitos básicos

Para los ejemplos de este artículo puedes usar Python 3 y algunas librerías comunes.

Instalación recomendada:

pip install requests beautifulsoup4 pandas lxml

Usaremos principalmente:

requests para hacer peticiones HTTP;
BeautifulSoup para analizar HTML;
pandas para guardar resultados en tablas;
csv si prefieres no depender de pandas.

Revisar si una lista de URLs responde correctamente

Una de las tareas más simples y útiles es revisar códigos de estado HTTP.

Por ejemplo, puedes tener una lista de URLs y comprobar si responden con 200, 301, 404, 500 u otro estado.

import requests

urls = [
    "https://example.com/",
    "https://example.com/blog/",
    "https://example.com/contacto/"
]

for url in urls:
    try:
        response = requests.get(url, timeout=10)
        print(url, response.status_code)
    except requests.RequestException as error:
        print(url, "ERROR", error)

Este script hace algo básico pero muy útil: visita cada URL y muestra su código de estado.

Una respuesta 200 normalmente indica que la página carga correctamente.
Una respuesta 301 o 302 indica redirección.
Una respuesta 404 indica que la página no existe.
Una respuesta 500 indica un error del servidor.

Para una revisión rápida, esto puede ser suficiente.

Guardar los resultados en CSV

Ver los datos en la terminal está bien para pruebas, pero si quieres analizarlos después, conviene guardarlos en un archivo CSV.

import requests
import pandas as pd

urls = [
    "https://example.com/",
    "https://example.com/blog/",
    "https://example.com/contacto/"
]

resultados = []

for url in urls:
    try:
        response = requests.get(url, timeout=10)
        resultados.append({
            "url": url,
            "status_code": response.status_code,
            "final_url": response.url
        })
    except requests.RequestException as error:
        resultados.append({
            "url": url,
            "status_code": "ERROR",
            "final_url": "",
            "error": str(error)
        })

df = pd.DataFrame(resultados)
df.to_csv("revision_urls.csv", index=False)

print("Archivo generado: revision_urls.csv")

Con esto ya tienes un pequeño reporte que puedes abrir en Excel, Google Sheets o cualquier editor de datos.

Extraer títulos y metadescripciones

Otra tarea común es revisar si tus páginas tienen un buen title y una metadescripción.

Esto puede ayudarte a detectar páginas incompletas, títulos duplicados o metadescripciones vacías.

import requests
from bs4 import BeautifulSoup

url = "https://example.com/"

response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")

title = soup.title.string.strip() if soup.title else ""

meta_description_tag = soup.find("meta", attrs={"name": "description"})
meta_description = meta_description_tag["content"].strip() if meta_description_tag and meta_description_tag.get("content") else ""

print("Title:", title)
print("Meta description:", meta_description)

Este ejemplo revisa una sola URL. Pero lo interesante es aplicarlo a muchas páginas.

import requests
import pandas as pd
from bs4 import BeautifulSoup

urls = [
    "https://example.com/",
    "https://example.com/blog/",
    "https://example.com/contacto/"
]

resultados = []

for url in urls:
    try:
        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")

        title = soup.title.string.strip() if soup.title else ""

        meta_description_tag = soup.find("meta", attrs={"name": "description"})
        meta_description = meta_description_tag["content"].strip() if meta_description_tag and meta_description_tag.get("content") else ""

        resultados.append({
            "url": url,
            "status_code": response.status_code,
            "title": title,
            "title_length": len(title),
            "meta_description": meta_description,
            "meta_description_length": len(meta_description)
        })

    except requests.RequestException as error:
        resultados.append({
            "url": url,
            "status_code": "ERROR",
            "title": "",
            "title_length": 0,
            "meta_description": "",
            "meta_description_length": 0,
            "error": str(error)
        })

df = pd.DataFrame(resultados)
df.to_csv("metadatos_web.csv", index=False)

print("Archivo generado: metadatos_web.csv")

Con este script puedes revisar rápidamente si tus páginas tienen títulos demasiado cortos, demasiado largos o metadescripciones vacías.

Leer un sitemap.xml con Python

En muchos sitios, especialmente WordPress, el sitemap contiene una lista de URLs importantes.

Puedes usar Python para leer ese sitemap y extraer las URLs.

import requests
from bs4 import BeautifulSoup

sitemap_url = "https://example.com/sitemap.xml"

response = requests.get(sitemap_url, timeout=10)
soup = BeautifulSoup(response.text, "xml")

urls = [loc.text for loc in soup.find_all("loc")]

for url in urls:
    print(url)

Esto te permite tomar las URLs reales del sitio y usarlas después en otros scripts.

Por ejemplo, puedes leer el sitemap y luego revisar estados HTTP, titles y metadescripciones de cada URL.

Detectar enlaces rotos en una página

Otra automatización útil es revisar los enlaces de una página y comprobar si alguno responde con error.

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin

url = "https://example.com/"

response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")

links = []

for link in soup.find_all("a", href=True):
    href = link["href"]
    absolute_url = urljoin(url, href)
    links.append(absolute_url)

for link in links:
    try:
        link_response = requests.get(link, timeout=10)
        print(link, link_response.status_code)
    except requests.RequestException:
        print(link, "ERROR")

Este script obtiene los enlaces de una página y revisa su estado.

No es una auditoría completa, pero puede servir como base para detectar enlaces rotos, redirecciones innecesarias o URLs problemáticas.

Scraping básico con requests y BeautifulSoup

El scraping consiste en extraer información de una página web de forma automatizada.

Un ejemplo simple sería extraer todos los encabezados h2 de una página.

import requests
from bs4 import BeautifulSoup

url = "https://example.com/articulo/"

response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")

h2_tags = soup.find_all("h2")

for h2 in h2_tags:
    print(h2.get_text(strip=True))

Esto puede ser útil para revisar la estructura de un artículo, analizar encabezados o comparar cómo están organizadas varias páginas.

También podrías extraer:

enlaces;
imágenes;
encabezados;
metadatos;
textos visibles;
datos estructurados;
elementos específicos por clase o ID.

Cuándo usar Selenium en lugar de requests

requests funciona muy bien cuando el contenido ya viene en el HTML.

Pero hay sitios donde parte del contenido se carga con JavaScript. En esos casos, requests puede no ser suficiente porque no ejecuta JavaScript como lo haría un navegador.

Ahí puede entrar Selenium.

Selenium permite automatizar un navegador real. Puede abrir páginas, hacer clic, esperar elementos, llenar formularios y extraer contenido después de que JavaScript cargue.

Pero no siempre deberías usar Selenium.

Usa requests cuando:

la página carga el contenido directamente en el HTML;
solo necesitas revisar estados HTTP;
quieres velocidad;
quieres scripts simples;
no necesitas interactuar con la página.

Usa Selenium cuando:

el contenido depende de JavaScript;
necesitas hacer clic;
necesitas iniciar sesión;
necesitas esperar elementos dinámicos;
necesitas simular una interacción más parecida a un usuario real.

Selenium es más potente, pero también más pesado. Para auditorías simples, requests suele ser suficiente.

Buenas prácticas al automatizar revisiones web

Automatizar no significa lanzar cientos de peticiones sin cuidado.

Algunas buenas prácticas:

respeta el archivo robots.txt;
no hagas demasiadas peticiones por segundo;
usa timeout para evitar que el script se quede colgado;
identifica claramente qué estás revisando;
evita scrapear contenido sensible o privado;
no intentes saltarte sistemas de protección;
guarda logs o resultados;
prueba primero con pocas URLs;
revisa manualmente los casos importantes.

Python puede ayudarte a recopilar datos, pero el criterio sigue siendo tuyo.

Una automatización mal pensada puede generar errores, datos falsos o incluso afectar el rendimiento de un sitio si haces demasiadas solicitudes.

Mini auditoría web con Python

Un caso práctico sería crear un pequeño script que revise:

código de estado;
URL final;
title;
longitud del title;
metadescripción;
longitud de la metadescripción.

import requests
import pandas as pd
from bs4 import BeautifulSoup

urls = [
    "https://example.com/",
    "https://example.com/blog/",
    "https://example.com/contacto/"
]

resultados = []

for url in urls:
    try:
        response = requests.get(url, timeout=10)
        soup = BeautifulSoup(response.text, "html.parser")

        title = soup.title.string.strip() if soup.title else ""

        meta_tag = soup.find("meta", attrs={"name": "description"})
        meta_description = meta_tag["content"].strip() if meta_tag and meta_tag.get("content") else ""

        resultados.append({
            "url": url,
            "status_code": response.status_code,
            "final_url": response.url,
            "title": title,
            "title_length": len(title),
            "meta_description": meta_description,
            "meta_description_length": len(meta_description)
        })

    except requests.RequestException as error:
        resultados.append({
            "url": url,
            "status_code": "ERROR",
            "final_url": "",
            "title": "",
            "title_length": 0,
            "meta_description": "",
            "meta_description_length": 0,
            "error": str(error)
        })

df = pd.DataFrame(resultados)
df.to_csv("mini_auditoria_web.csv", index=False)

print("Mini auditoría generada: mini_auditoria_web.csv")

Este script ya funciona como una pequeña herramienta de revisión técnica.

No reemplaza una auditoría completa, pero te da una base para detectar problemas rápidos.

Qué podrías mejorar después

Una vez que tengas una versión básica, puedes ampliarla.

Ideas:

leer URLs desde un archivo CSV;
revisar encabezados h1, h2 y h3;
detectar páginas sin title;
detectar metadescripciones vacías;
encontrar enlaces internos rotos;
diferenciar enlaces internos y externos;
revisar imágenes sin atributo alt;
detectar redirecciones;
generar un reporte en Excel;
programar la revisión cada semana;
enviar alertas por correo o Telegram.

La ventaja de Python es que puedes empezar pequeño y mejorar el script según tus necesidades.

Errores comunes al automatizar tareas web

Algunos errores frecuentes son:

no usar timeout;
no controlar excepciones;
asumir que todas las páginas tienen la misma estructura;
hacer demasiadas solicitudes muy rápido;
no revisar redirecciones;
mezclar URLs internas y externas sin control;
no guardar resultados;
no validar manualmente los hallazgos;
confundir scraping con auditoría completa.

Un script puede encontrar datos, pero no siempre puede interpretarlos correctamente.

Por ejemplo, una metadescripción vacía puede ser un problema en una página importante, pero quizá no sea prioritario en una URL secundaria. Un 301 puede ser correcto si forma parte de una migración, pero puede ser un problema si aparece dentro de enlaces internos antiguos.

La automatización ayuda a encontrar señales. La decisión técnica sigue dependiendo del contexto.

Conclusión

Automatizar tareas web con Python es una habilidad muy útil para cualquier persona que administre, mantenga o audite sitios web.

No necesitas empezar con un sistema complejo. Puedes comenzar con scripts pequeños para revisar estados HTTP, extraer metadatos, leer un sitemap o detectar enlaces rotos.

Con el tiempo, esos scripts pueden convertirse en herramientas propias para auditorías, mantenimiento web, SEO técnico y revisión de proyectos.

Python no sustituye el criterio de un webmaster o desarrollador, pero sí permite trabajar con más velocidad, más orden y menos tareas repetitivas.

La clave está en usar la automatización para recopilar información y luego aplicar criterio técnico para decidir qué hacer con esos datos.

Tarea	Librería recomendada
Revisar estados HTTP	`requests`
Extraer HTML	`BeautifulSoup`
Leer sitemap	`BeautifulSoup` + parser XML
Exportar reportes	`pandas`
Automatizar navegador	`Selenium`
Procesar URLs	`urllib.parse`
Programar tareas	`cron` o programador del sistema