¿Cómo hacer web scraping en Python con BeautifulSoup?

¿Quiere sumergirse en el mundo de raspado web ¿pero sin enredarse en códigos complicados?

Con Python y la biblioteca BeautifulSoup, tu puedes fácilmente extraer y organizar datos d’un site web en quelques lignes seulement.

Requisitos previos para el scraping en Python con BeautifulSoup

✅ Avant de vous lancer, il est important d’avoir quelques fundamentos de programación. Esto le permitirá comprender mejor cómo funciona el código. Pas besoin d’être expert, mais savoir lire et exécuter un script Python vous aidera beaucoup.

A continuación, le indicamos lo que debe hacer en primer lugar hacer scraping en Python con BeautifulSoup :

pip install beautifulsoup4

pip install solicitudes

¿Cómo hacer web scraping con Python y BeautifulSoup?

Siga nuestro tutorial para realizar un sencillo proyecto de web scraping.

Proyecto : récupérer le titre d’une page et tous les liens qu’elle contient.

Paso 1: Recuperar el contenido de la página con Requests

Para llevar a cabo una Solicitud HTTP GET a una URL, utilice la función Solicitudes.

📌 Cuando envías una petición HTTP con Requests, el servidor siempre devuelve un código de estado. Estos códigos indican si la solicitud se ha realizado correctamente o no.

200 éxito.
301 / 302 redirección.
404 Página no encontrada.
500 error interno del servidor.

solicitudes de importación

# URL de destino
url = "https://bonjour.com"

# Enviar una petición GET
response = requests.get(url)

# Comprueba el código de estado
if response.status_code == 200:
    print("Éxito: ¡la página ha sido recuperada!")
    html = response.text # Contenido HTML de la página
    print("Extracto del contenido HTML:")
    print(html[:500]) # muestra sólo los 500 primeros caracteres
si no
    print(f "Error: código de estado {response.status_code}")
  

Paso 2: Analizar el código HTML con BeautifulSoup

from bs4 import BeautifulSoup
importar peticiones

url = "https://bonjour.com"
response = requests.get(url)
html = respuesta.texto

# Se recomienda especificar el analizador sintáctico
soup = BeautifulSoup(html, "html.parser")

Paso 3: Encontrar y extraer elementos

# Recuperar título <h1>
h1 = soup.find("h1")
print(h1.get_text())

# Recuperar todos los enlaces <a>
gravámenes = soup.find_all("a")
para lien en liens:
    print(lien.get_text(), lien.get("href"))

# Recuperar un div con un id específico
container = soup.find("div", id="main")

# Recuperar todos los enlaces con una clase específica
nav_links = soup.find_all("a", class_="nav-link")

# Todos los enlaces en los títulos de los artículos
article_links = soup.select("articulo h2 a")

# Todos <a> cuyo atributo href empiece por "http".
links_http = soup.select('a[href^="http"]')

Él Selectores CSS sont très puissants si vous voulez cibler exactement certaines parties d’une page sans parcourir tout le HTML manuellement.

Comment extraire des données d’un tableau HTML avec BeautifulSoup ?

Jusqu’ici, nous avons vu comment récupérer des titres, des liens ou encore du texte dans une page web.

⚠ Mais souvent, les vrais cas d’utilisation sont plus complexes : extracción de datos estructurados comme des tableaux ou des listes, la gestion de la pagination ou encore la résolution d’erreurs fréquentes liées au scraping. C’est exactement ce que nous allons voir ensemble.

Extraer tablas y listas

Los sitios web suelen presentar sus datos en Tablas HTML (<table>, <tr>, <th>, <td>) o enumera (

/
,
1. ). Para transformar estas estructuras en datos utilizables, hay que aprender a recorrerlas línea a línea o elemento a elemento.

   Cuando quieras extraer una tabla HTMLEl principio es sencillo:

   • ✅ Recuperar cabeceras (<th>) para identificar los títulos de las columnas.
   • ✅ Examine cada línea (<tr>) y buscar celdas (<td>) que contienen los datos reales.
   • ✅ Almacenar información en una lista o diccionario.

   Para un Lista HTML (

   o
   con
   1. ) :
      • ✅ Localizar todas las etiquetas
      • con encontrar_todos.
      • ✅ Recuperar su contenido (texto o enlace) y añadirlo a una lista Python.

      En resumen :

      Las etiquetas <table>, <tr>, <th>, <td> se utilizan para reconstruir una tabla.
      Las etiquetas

      /
      ,
      1. se utilizan para transformar una lista HTML en una lista Python.

         He aquí un ejemplo con una tabla:

         html = """
         <table>
           <tr>
             <th>apellido</th>
             <th>Edad</th>
             <th>Pueblo</th>
           </tr>
           <tr>
             <td>Alicia</td>
             <td>25</td>
             <td>París</td>
           </tr>
           <tr>
             <td>Beto</td>
             <td>30</td>
             <td>Lyon</td>
           </tr>
         </table>
         """
         
         # Crear el objeto BeautifulSoup
         soup = BeautifulSoup(html, "html.parser")
         
         # Extraer las cabeceras del array
         headers = [th.get_text(strip=True) for th in soup.find_all("th")]
         print("Cabeceras:", cabeceras)
         
         # Extrae las filas de datos (omite la primera fila, ya que son las cabeceras)
         filas = []
         for tr in sop.find_all("tr")[1:]:
             celdas = [td.get_text(strip=True) for td in tr.find_all("td")]
             si celdas:
                 rows.append(cells)
         
         print("Líneas :", filas)
         

         Toma, find_all("th") recupera las cabeceras y find_all("td") recupera las celdas de cada fila. Hacemos un bucle sobre <tr> para reconstruir la tabla fila por fila.

         He aquí un ejemplo basado en una lista:

         from bs4 import BeautifulSoup
         
         html_list = """
         
           
         Manzana
           
         Plátano
           
         Naranja
         
         """
         
         soup = BeautifulSoup(html_list, "html.parser")
         
         # Recuperar elementos de la lista
         items = [li.get_text(strip=True) for li in soup.find_all("li")]
         print("Lista extraída:", items) # ["Manzana", "Plátano", "Naranja"]
         

         Aquí, cada

      2. se transforma directamente en un elemento de lista Python, dando como resultado ["Manzana", "Plátano", "Naranja"].

         Gestión de la paginación y los enlaces

         A menudo, los datos no caben en una sola página. Se reparten en varias páginas utilizando “page suivante” o un paginación numerada (?página=1, ?página=2, ...).

         📌 En ambos casos, debes rizo (navegar en bucle) para recuperar todas las páginas y combinar los datos.

         Ejemplo con un parámetro de página :

         tiempo de importación
         importar peticiones
         from bs4 import BeautifulSoup
         
         # Ejemplo de URL con paginación
         BASE_URL = "https://bonjour.com/articles?page={}"
         HEADERS = {"User-Agent": "Mozilla/5.0"}
         
         all_articles = []
         
         # Supongamos que hay 5 páginas para navegar
         for página in rango(1, 6):
             url = BASE_URL.format(página)
             r = requests.get(url, headers=HEADERS, timeout=20)
             if r.status_code == 200:
                 soup = BeautifulSoup(r.text, "html.parser")
                 # Extraer los títulos de los artículos
                 articles = [h2.get_text(strip=True) for h2 in soup.find_all("h2", class_="title")]
                 all_articles.extend(artículos)
             si no:
                 print(f "Error en la página {page} (código : {r.status_code})")
             time.sleep(1.0) # cortesía
         
         print("Artículos recuperados:", todos_los_artículos)

         Una breve explicación:

         • Préparer l’URL avec un emplacement {} pour insérer le numéro de la page.

         BASE_URL = "https://bonjour.com/articles?page={}

         • Certains sites bloquent les requêtes sans “identité de navigateur”. Ajouter un User-Agent évite d’être pris pour un bot.

         headers = {"User-Agent": "Mozilla/5.0"}
         requests.get(url, headers=cabeceras) 

         • Bucle de la página 1 a la 5.

         para página en rango(1, 6):

         • Recupera el HTML de la página.

         requests.get(url)

         • Limitar el tiempo de espera si el sitio no responde.

         requests.get(url, timeout=20)

         • Parser la page.

         BeautifulSoup(response.text, "html.parser")

         • Récupérer tous les titres d’articles.

         find_all("h2", class_="title")

         • Añade los elementos encontrados a una lista global.

         all_articles.extend(artículos)

         • Introduce una pausa entre cada petición para no sobrecargar el servidor y evitar ser baneado.

         time.sleep(1.0)

         • Después del bucle, todos_los_artículos contiene los 5 títulos de las páginas.

         Errores y retos comunes

         ❗ Le scraping, ce n’est pas toujours appuyer sur un bouton et tout est bon. Vous pourrez rencontrer des obstacles fréquents comme :

         • Errores HTTP

         404 página no encontrada
         403 sin acceso
         500 error del servidor

         Ejemplo :

         response = requests.get(url)
         si response.status_code == 200:
             # Página OK
             print("Página recuperada correctamente")
         elif response.status_code == 404:
             print("Error: página no encontrada")
         si no
             print("Código devuelto:", response.status_code)
         

         • Sitios que bloquean el scraping

         Certains détectent les requêtes automatiques et bloquent l’accès.

         • Páginas dinámicas (JavaScript)

         BeautifulSoup sólo lee HTML estático. Si la página carga su contenido con JavaScriptno verás nada.

         ✅ En este caso, utilice herramientas como Selenio Donde Dramaturgo.

         Sin embargo, si quieres hacer scraping de forma eficaz sin que te bloqueen o dañen el sitio, aquí tienes las mejores prácticas:

         • ✔ Respetar la archivo robots.txt d’un site web.
         • ✔ Puesta en marcha plazos entre peticiones para no sobrecargar el servidor (usando time.sleep()).
         • ✔ Uso apoderados y gíralos.
         • ✔ Cambie regularmente su Agente de usuario.

         ¿Cómo puedo scrapear la web con Selenium y BeautifulSoup?

         

         ⚠ Un recordatorio : BeautifulSoup est un excellent analyseur HTML, mais il ne peut pas exécuter JavaScript d’une page web. C’est là que Selenium devient votre allié !

         Básicamente, el selenio controlar un navegador realEjecuta JavaScript y muestra la página como si un humano estuviera navegando. BeautifulSoup analizará el código HTML una vez que la página esté completamente renderizada. Así que usted puede extraer lo que quieras.

         Paso 1: Instalar Selenium y BeautifulSoup

         Ici, au lieu d’utiliser la bibliothèque Request, on va utiliser Selenio. Pour l’installer, il faut passer par pip.

         pip install selenium beautifulsoup4 

         A continuación, debe descargar e instalar WebDriver que corresponde a la versión de su navegador (por ejemplo, ChromeDrive para Google Chrome).

         ✅ Vous pouvez soit le placer dans le même dossier que votre script Python, soit l’ajouter à la variable d’environnement PATH de su sistema.

         Paso 2: Configuración de Selenium

         En primer lugar, debe importar webdriver de Selenium para controlar un navegador.

         from selenium import webdriver
         from selenium.webdriver.common.by import By 

         On lance ensuite un navigateur. C’est lui qui ouvrira la page web et ejecutará el código JavaScript (Ejemplo: Chrome).

         controlador = webdriver.Chrome() 

         Usted indica al navegador qué página debe visitar.

         driver.get("https://www.exemple.com") 

         Si la page met du temps à afficher certains éléments, vous pouvez dire à Selenium d’attendre un peu.

         driver.implicitly_wait(10) 

         Paso 3: Recuperar el contenido de la página

         Una vez que se haya cargado la página, puede recuperar el archivo DOM completo (código fuente HTML tras la ejecución de JS).

         html_content = driver.page_source 

         Paso 4: Análisis HTML con BeautifulSoup

         Passez maintenant ce code source à BeautifulSoup pour pouvoir l’exploiter :

         from bs4 import BeautifulSoup # Crear un objeto BeautifulSoup soup = BeautifulSoup(html_content, 'html.parser') # Ejemplo: recuperar todos los títulos de la página titles = soup.find_all('h2') for title in titles: print(title.get_text()) 

         👉 BeautifulSoup ofrece potentes métodos como find(), find_all() y selectores CSS para objetivo y extraer elementos Código HTML.

         Paso 5: Cerrar el navegador

         Très important : fermez toujours votre navigateur après l’exécution pour libérer les ressources !

         driver.quit() 

         ✅ ¡Y ahí lo tienes! Ya puedes combinar la potencia de Selenium para simular la navegación humana (clics, défilements, etc.) avec l’efficacité de BeautifulSoup pour l’analyse du code HTML.

         preguntas frecuentes

         ¿Cuál es la mejor herramienta para el web scraping en Python?

         Il n’y a pas vraiment de meilleur outil universel, mais plutôt des solutions adaptées selon votre projet.

         🔥 BeautifulSoup Analizador HTML: sencillo y eficaz para analizar HTML y extraer contenidos rápidamente. Es ideal si estás empezando o si tienes proyectos pequeños.

         🔥 Chatarra : c’est un framework complet, pensé pour gérer de gros volumes de données avec des fonctionnalités avancées.

         🔥 Dramaturgo : parfait pour les sites complexes générés par JavaScript, car il simule un vrai navigateur et permet d’interagir avec la page comme un humain.

         Cómo utilizar BeautifulSoup para extraer contenido de una etiqueta <div> ?

         Con BeautifulSoup, puede apuntar a una baliza específica utilizando un Selector CSS. Para extraer el contenido de un <div>Estos son los pasos:

         1. Recupere la página con Requests, luego analícela con BeautifulSoup

         from bs4 import BeautifulSoup
         importar peticiones
         
         url = "URL_OF YOUR_SITE" # Sustituir por la URL real
         response = requests.get(url)
         html_content = response.text
         
         soup = BeautifulSoup(html_content, "html.parser")

         2. Utilice la seleccionar() pasándole el selector CSS para que apunte a la etiqueta <div>

         Para recuperar el primer elemento, utilice sopa.seleccionar_uno
Para recuperar todos los elementos, utilice sopa.seleccionar

         Ejemplo HTML:

         <div class="article">
           <h2>Título del artículo</h2>
           <p>Esto es lo que dice el párrafo.</p>
         </div>

         Ejemplo con CSS :

         # Recuperar el primer div con la clase "article
         div_article = soup.select_one("div.article")
         
         # Mostrar su contenido de texto
         if div_article:
         print(div_article.get_text(strip=True))

         En este caso, el selector CSS es div.artículo.

         3. Extraire des éléments à l’intérieur de la <div>

         # Recuperar el título dentro del div
         title = soup.select_one("div.articulo h2").get_text()
         
         # Recuperar el párrafo dentro del div
         paragraph = soup.select_one("div.articulo p").get_text()
         
         print("Título:", título)
         print("Párrafo:", párrafo)

         ¿Cómo pueden utilizarse conjuntamente Requests y BeautifulSoup?

         Estas dos bibliotecas se complementan mutuamente.

         1. Requests récupère le contenu d’une page web avec une requête HTTP.

         Envía una petición HTTP al sitio de destino y descarga el código HTML sin procesar de la página.

         solicitudes de importación
         
         url = "https://sitecible.com"
         response = requests.get(url) # Petición HTTP
         print(response.text) # muestra el HTML sin procesar

         En esta fase, todo lo que tienes es un enorme texto lleno de etiquetas (<html>,<div><p>etc.).

         2. BeautifulSoup analiza este contenido HTML para extraer lo que le interesa.

         Elle prend le HTML brut et le transforme en une structure organisée. Grâce à ça, vous pouvez naviguer facilement à l’intérieur du HTML : faire du repérage, extraire et récupérer les données.

         from bs4 import BeautifulSoup
         
         soup = BeautifulSoup(response.text, "html.parser") # analiza el HTML
         title = soup.find("h1").get_text() # extrae el contenido de a <h1>
         print(título)

         ¿Por qué mi código de web scraping no funciona en algunos sitios?

         Es posible que su script no recupere nada, porque algunos sitios no proporcionan todo el contenido directamente en HTML.

         Ces sites utilisent JavaScript pour charger dynamiquement les données. Or, BeautifulSoup ne permet pas d’analizar los datos generados por JavaScript.

         En este caso, debe recurrir a herramientas como Dramaturgo Donde Selenio.

         ¿Qué papel desempeña BeautifulSoup en el web scraping?

         BeautifulSoup joue le rôle d’Analizador HTML.

         Il prend le code source d’une page sous forme de texte brut et le transforme en un objet structuré que vous pouvez parcourir facilement.

         Sin esta biblioteca, verá un enorme bloque de texto ilegible. En pocas palabras, BeautifulSoup es el traductor entre la librería HTML plano y su Código Python.

         Web scraping: ¿BeautifulSoup vs Scrapy?

         BeautifulSoup y Chatarra son muy diferentes, aunque ambos se utilizan para el web scraping.

         BeautifulSoup	Chatarra
         Una biblioteca sencilla utilizada únicamente para analizar HTML y extraer datos.	Un marco completo que gestiona todo el proceso de scraping (consultas, seguimiento de enlaces, paginación, exportación de datos, gestión de errores).

         Pour tout résumé, BeautifulSoup facilite l’Extracción de datos HTML en Python. Esta biblioteca es perfecta para principiantes, ya que hace que el scraping sea rápido y sencillo.

         De lo contrario, si no desea sin codificación, l’outil complet Datos brillantes es también una excelente solución para el web scraping.

         👉 ¡Ahora cuéntanos en los comentarios qué has conseguido rascar!