---
title: "Tutorial de Scraping Web HTML"
slug: html-web-scraping
date: 2026-02-22T07:24:07+00:00
modified: 2026-08-26T19:33:39+00:00
permalink: https://brightdata.es/blog/procedimientos/html-web-scraping
type: blog
---
[ Blog ](https://brightdata.es/blog "Blog") / [Procedimientos](https://brightdata.es/blog/procedimientos)
[Procedimientos](https://brightdata.es/blog/procedimientos)
# Tutorial de Scraping Web HTML
Descubre cómo dominar el scraping web HTML para recopilar datos de sitios web de forma eficiente, perfecto para mejorar tus proyectos y estrategias.
17 min de lectura
[  ](https://brightdata.com/blog/authors/naman-bansal)
[Naman Bansal
](https://brightdata.com/blog/authors/naman-bansal)
Si estás interesado en el scraping web, entender HTML es clave porque todos los sitios web están construidos con él. El scraping web puede usarse en todo tipo de escenarios y puede ayudar a recopilar datos de sitios web sin APIs, monitorear precios de productos, crear listas de leads, realizar investigaciones académicas y más.
En este artículo, aprenderás los conceptos básicos de HTML y cómo extraer, parsear y procesar datos usando Python.
¿Interesado en una guía detallada de scraping web con Python? [Haz clic aquí](/blog/how-tos/web-scraping-with-python).
## Cómo hacer Scraping de Sitios Web y Extraer HTML
Antes de comenzar este tutorial, tomemos un momento para revisar los componentes esenciales del HTML.
### Introducción a HTML
HTML es una colección de etiquetas que le indican a un navegador la estructura y los elementos de un sitio web. Por ejemplo, `
Text
` le indica a un navegador que el texto que sigue a la etiqueta es un encabezado, y ` link ` identifica un hipervínculo.
Un atributo HTML proporciona información adicional sobre una etiqueta. Por ejemplo, el atributo `href` de la etiqueta `` te da información sobre la URL de la página a la que apunta el atributo.
[Las clases e IDs](https://www.scaler.com/topics/html/class-and-id-in-html/) son atributos críticos para identificar con precisión los elementos de una página. Las clases agrupan elementos similares para darles estilo de forma consistente con CSS o manipularlos uniformemente con JavaScript. Las clases se seleccionan usando `.class-name`.
En el sitio web de W3Schools, los grupos de clases se ven así:
```none
London
London is the capital of England.
Paris
Paris is the capital of France.
Tokyo
Tokyo is the capital of Japan.
```
Puedes ver cómo cada título y bloque de ciudad está envuelto con un `div` que tiene la misma clase `city`.
En cambio, los IDs son únicos para cada elemento (es decir, dos elementos no pueden tener el mismo ID). Por ejemplo, los siguientes H1s tienen IDs únicos y pueden ser estilizados/manipulados de forma única:
```none
Hello World!
Lorem Ipsum Dolor
```
La sintaxis para seleccionar elementos con IDs es `#id-name`.
Ahora que conoces los conceptos básicos de HTML, comencemos con el scraping web.
## Configura tu Entorno de Scraping
Este tutorial utiliza Python ya que ofrece muchas bibliotecas de scraping HTML y el lenguaje es fácil de aprender. Para verificar si Python está instalado en tu computadora, ejecuta el siguiente comando en PowerShell (Windows) o en tu terminal (macOS):
```none
python3
```
Si Python está instalado, verás tu número de versión; si no, recibirás un error. Adelante, [instala Python](https://www.python.org/downloads/) si aún no lo tienes.
A continuación, crea una carpeta llamada `WebScraper` y crea un archivo dentro de la carpeta `WebScraper` llamado `scraper.py`. Luego ábrelo en tu entorno de desarrollo integrado (IDE) de preferencia. [Visual Studio Code](https://code.visualstudio.com/) se usa aquí:
Un IDE es una aplicación multipropósito que permite a los programadores escribir código, depurarlo, probar programas, automatizar compilaciones y más. Lo usarás aquí para codificar tu scraper HTML.
A continuación, necesitas separar tu instalación global de Python de tu proyecto de scraping creando un entorno virtual. Esto ayuda a evitar conflictos de dependencias y mantiene toda la aplicación organizada.
Para hacerlo, instala la biblioteca `virtualenv` usando el siguiente comando:
```none
pip3 install virtualenv
```
Navega a tu carpeta de proyecto:
```none
cd WebScraper
```
Luego crea un entorno virtual:
```none
python -m venv
```
Este comando crea una carpeta para todos los paquetes y scripts dentro de tu carpeta de proyecto:
Ahora necesitas activar el entorno virtual usando uno de los siguientes comandos (según tu plataforma):
```none
source /bin/activate #In MacOS and Linux
/Scripts/activate.bat #In CMD
/Scripts/Activate.ps1 #In Powershell
```
Tras una activación exitosa, verás el nombre de tu entorno virtual en el lado izquierdo de la pantalla:
Ahora que tu entorno virtual está activado, necesitas instalar una biblioteca de scraping web. Hay numerosas opciones, incluyendo [Playwright](https://playwright.dev/), [Selenium](https://www.selenium.dev/), [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) y [Scrapy](https://scrapy.org/). Aquí utilizarás [Playwright](https://playwright.dev/python/docs/intro) porque es fácil de usar, admite múltiples navegadores, puede manejar contenido dinámico y ofrece un modo sin cabeza (scraping sin interfaz gráfica de usuario (GUI)).
Ejecuta `pip install pytest-playwright` para instalar Playwright; luego instala los navegadores requeridos con `playwright install`.
Después de instalar Playwright, estás listo para comenzar con el scraping web.
## Extraer HTML de un Sitio Web
El primer paso de cualquier proyecto de scraping web es identificar el sitio web que deseas raspar. Aquí utilizarás [este sitio de prueba](https://webscraper.io/test-sites/e-commerce/static).
A continuación, necesitas identificar la información que deseas extraer de la página. En este caso, es el contenido HTML completo de la página.
Una vez que hayas identificado la información que intentas extraer, puedes comenzar a codificar el scraper. En Python, el primer paso es [importar las bibliotecas requeridas para Playwright](https://playwright.dev/python/docs/library). Playwright te permite importar dos tipos de APIs: [sync y async](https://stackoverflow.com/questions/65439214/what-are-the-differences-between-python-playwright-sync-vs-async-apis). La biblioteca async se usa solo al escribir código asíncrono, por lo que importas la biblioteca sync con el siguiente comando:
```none
from playwright.sync_api import sync_playwright
```
Después de importar la biblioteca sync, necesitas declarar una función Python usando el siguiente fragmento de código:
```none
def main():
#Rest of the code will be inside this function
```
Como puedes ver en la nota anterior, escribes tu código de scraping web dentro de esta función.
Normalmente, para obtener información de un sitio web, abrirías un navegador web, crearías una nueva pestaña y visitarías ese sitio web. Para hacer scraping del sitio, necesitas traducir estas acciones en código, que es para lo que usarás Playwright. Su [documentación](https://playwright.dev/python/docs/library) muestra que puedes llamar a la `sync_api` importada anteriormente y abrir un navegador con este fragmento:
```none
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
```
Al agregar `headless=False` dentro de los paréntesis, puedes ver el contenido del sitio web.
Después de abrir tu navegador, abre una nueva pestaña y visita la URL objetivo:
```none
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
```
> **Nota:** Las líneas anteriores deben añadirse debajo de las líneas previas que iniciaron el navegador. Todo este código va dentro de la función main y dentro de un solo archivo.
Este fragmento de código envuelve la función `goto()` dentro de un [bloque try-except](https://www.w3schools.com/python/python_try_except.asp) para un mejor manejo de errores.
Cuando ingresas la URL de un sitio en la barra de búsqueda, debes esperar a que cargue. Para imitar eso en el código, puedes usar lo siguiente:
```none
page.wait_for_timeout(7000) #millisecond value in brackets
```
> **Nota:** Estas líneas anteriores deben añadirse debajo de las líneas previas.
Finalmente, es momento de extraer todo el contenido HTML de la página usando esta línea de código:
```none
print(page.content())
```
El código completo para extraer el HTML de una página se ve así:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
page.wait_for_timeout(7000)
print(page.content())
main()
```
En Visual Studio Code, el HTML extraído se ve así:
## Extraer HTML Usando Atributos Específicos
Anteriormente, extrajiste todos los elementos de la página web del Scraper Web; sin embargo, el scraping web no es útil a menos que te limites a extraer solo la información que necesitas. En esta sección, extraerás solo los títulos de todos los portátiles en la primera página del sitio web:
Para extraer elementos específicos, necesitas entender la estructura del sitio web objetivo. Puedes hacerlo haciendo clic derecho y seleccionando la opción **Inspeccionar** de esta manera:
Alternativamente, puedes usar estos atajos de teclado:
- Para macOS, usa **Cmd + Option + I**
- Para Windows, usa **Control + Shift + C**
Aquí está la estructura de la página objetivo:
Puedes ver el código de un elemento específico en una página usando la herramienta de selección en la parte superior izquierda de la ventana **Inspeccionar**:
Selecciona uno de los títulos de portátiles en tu ventana **Inspeccionar**:
Puedes ver que el título está dentro de una etiqueta ``, que está envuelta por una etiqueta `h4`, y el enlace tiene una clase de `title`. Eso significa que buscas etiquetas `` (URLs) dentro de etiquetas `
`) y tiene el texto interno `2`:
Eso significa que puedes usar el selector `get_by_role()` para encontrar un elemento de lista y un selector `get_by_text()` para encontrar un elemento con `2` como texto.
Así es como codificarlo en tu archivo:
```none
page.get_by_role("listitem").get_by_text("2", exact=True)
```
Esto encuentra un elemento que coincide con dos condiciones: primero, debe ser un elemento de lista, y segundo, debe tener `2` como texto.
`exact=True` es un argumento de función para encontrar el elemento con el texto dado.
Para hacer clic en el botón, modifica el código anterior para que se vea así:
```none
page.get_by_role("listitem").get_by_text("2", exact=True).click()
```
En este código, la función `click()` hace clic en el elemento dado.
Espera a que la página cargue y extrae todos los títulos nuevamente:
```none
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
```
Tu bloque de código completo debería verse así:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static/computers/laptops")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
page.get_by_role("listitem").get_by_text("2", exact=True).click()
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
main()
```
## Extraer HTML y Escribirlo en un CSV
Si no almacenas y analizas los datos que extraes, son inútiles. En esta sección, crearás un programa avanzado que toma como entrada del usuario el número de páginas de portátiles a extraer, extrae los títulos y los almacena en un archivo CSV en tu carpeta de proyecto.
Para este programa, necesitas una biblioteca CSV preinstalada, que se puede importar usando el siguiente comando:
```none
import csv
```
Después de instalar la biblioteca CSV, necesitas descubrir cómo visitarás un número variable de páginas dependiendo de la entrada del usuario.
Si observas la estructura de URL del sitio web, notarás que cada página de portátiles se indica usando un parámetro de URL. Por ejemplo, la URL de la segunda página en el directorio de portátiles es https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page=2.
Puedes visitar diferentes páginas modificando el parámetro de URL `?page=2` con diferentes valores numéricos. Eso significa que necesitas pedirle al usuario que ingrese el número de páginas a extraer con el siguiente comando:
```none
pages = int(input("enter the number of pages to scrape: "))
```
Para visitar cada página desde 1 hasta el número de páginas ingresado por el usuario, usas un bucle `for` así:
```none
for i in range(1, pages+1):
```
Dentro de esta función `range`, usas `1` y `pages+1` como argumentos de función para representar los valores donde el bucle comienza y termina. El segundo argumento de función está excluido del bucle. Por ejemplo, si la función range es `range(1,5)`, el programa haría un bucle de 1 a 4 solamente.
A continuación, necesitas visitar cada página ingresando el valor `i` como parámetro de URL en la iteración. Puedes añadir variables a una cadena usando [f-strings de Python](https://www.geeksforgeeks.org/formatted-string-literals-f-strings-python/).
Al generar una cadena, prefijas las comillas con una `f` para indicar que es un f-string. Dentro de las comillas, puedes usar llaves para indicar variables.
Aquí hay un ejemplo de cómo puedes usar f-strings para imprimir variables junto con cadenas:
```none
print(f"The value of the variable is {variable_name_goes_here}")
```
Volviendo al scraper, puedes utilizar f-strings escribiendo este bloque de código en el archivo:
```none
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
```
Espera a que la página cargue con una función de tiempo de espera y extrae los títulos usando lo siguiente:
```none
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
```
Una vez que tengas todos los elementos de título, necesitas abrir tu archivo CSV, recorrer cada título, extraer el texto requerido y escribirlo en tu archivo.
Para abrir un archivo CSV, usa la siguiente sintaxis:
```none
with open("laptops.csv", "a") as csvfile:
```
Aquí, abres el archivo `laptops.csv` con el modo de anexar (`a`). Usas el modo de anexar aquí porque no quieres perder datos antiguos cada vez que se abre el archivo. Si el archivo no existe, la biblioteca crea uno en la carpeta del proyecto. [CSV ofrece varios modos](https://www.learnbyexample.org/reading-and-writing-csv-files-in-python/) para abrir un archivo, incluyendo los siguientes:
- **r** es la opción predeterminada que se usa si no se especifica nada. Abre el archivo solo para lectura.
- **w** abre un archivo solo para escritura. Cada vez que se abre un archivo, los datos anteriores se sobrescriben.
- **a** abre un archivo para añadir datos. Los datos anteriores no se sobrescriben.
- **r+** abre un archivo tanto para lectura como para escritura.
- **x** crea un nuevo archivo.
Debajo del código anterior, necesitas [declarar un objeto `writer`](https://docs.python.org/3/library/csv.html#csv.writer) que te permita manipular el archivo CSV:
```none
writer = csv.writer(csvfile)
```
A continuación, recorre cada elemento de título y extrae el texto con lo siguiente:
```none
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
```
Esto te da múltiples arrays, cada uno conteniendo el título de portátiles individuales. Para rechazar arrays vacíos, escribe el siguiente código condicional en el archivo CSV:
```none
if len(laptop) == 1:
writer.writerow([laptop[0]])
```
La función `writerow` te permite escribir nuevas filas en un archivo CSV.
Aquí está el código completo del programa:
```none
from playwright.sync_api import sync_playwright
import csv
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
pages = int(input("enter the number of pages to scrape: "))
for i in range(1, pages+1):
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
with open("laptops.csv", "a") as csvfile:
writer = csv.writer(csvfile)
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
writer.writerow([laptop[0]])
browser.close()
main()
```
Después de ejecutar este código, tu archivo CSV debería verse así:
## Conclusión
En este artículo, aprendiste cómo extraer, parsear y almacenar HTML usando Python.
Si bien este tutorial fue relativamente sencillo, en un escenario del mundo real, probablemente te encontrarías con varios obstáculos al hacer scraping, incluyendo CAPTCHAs, límites de velocidad, cambios en el diseño del sitio web o requisitos regulatorios. Afortunadamente, [Bright Data](/) puede ayudar. Bright Data ofrece herramientas como [proxies residenciales avanzados](/proxy-types/residential-proxies) para mejorar tu scraping, un [IDE de Web Scraper](/products/web-scraper) para construir scrapers a escala, y un [Web Unlocker](/products/web-unlocker) para desbloquear sitios web públicos, incluyendo la [resolución de CAPTCHAs](/products/web-unlocker/captcha-solver). Estas herramientas pueden ayudarte a recopilar datos precisos a escala y superar obstáculos. Además, el compromiso de Bright Data con el scraping ético garantiza que te mantengas dentro de los términos de servicio del sitio web y las regulaciones legales.
Con la infraestructura repleta de funciones de Bright Data, puedes concentrarte en extraer los datos valiosos que necesitas, dejando atrás las complejidades del scraping web. ¡Comienza tu prueba gratuita hoy!
Contactar ventasPrueba gratuita
Tabla de Contenidos
[ ](https://news.ycombinator.com/submitlink?t=Tutorial+de+Scraping+Web+HTML&u=https://brightdata.es/blog/procedimientos/html-web-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Tutorial+de+Scraping+Web+HTML&url=https://brightdata.es/blog/procedimientos/html-web-scraping) [ ](http://www.reddit.com/submit?title=Tutorial+de+Scraping+Web+HTML&url=https://brightdata.es/blog/procedimientos/html-web-scraping)
## Usted también puede estar interesado en
[  ](https://brightdata.es/blog/datos-web/best-html-parsers "Las mejores bibliotecas de parseo HTML para el Scraping web")
[Datos web
Antonello Zanini
Technical Writer
### Las mejores bibliotecas de parseo HTML para el Scraping web
Descubra los mejores analizadores HTML para el Scraping web y la extracción de datos, incluidos httpx, AIOHTTP y urllib.
24-Mar-2024
8 min de lectura
](https://brightdata.es/blog/datos-web/best-html-parsers)
[  ](https://brightdata.es/blog/datos-web/cheerio-vs-puppeteer "Cheerio vs. Puppeteer para raspado de datos web")
[Datos web
Gints Dreimanis
### Cheerio vs. Puppeteer para raspado de datos web
Una mirada a las diferencias entre Puppeteer y Cheerio al construir un raspador web con ambos.
09-Feb-2023
12 min de lectura
](https://brightdata.es/blog/datos-web/cheerio-vs-puppeteer)
[  ](https://brightdata.es/blog/101-proxy/how-to-bypass-an-ip-ban "Cómo Eludir un Bloqueo de IP: 7 Métodos Probados (Guía 2026)")
[Proxy 101
Aviv Besinsky
### Cómo Eludir un Bloqueo de IP: 7 Métodos Probados (Guía 2026)
Aprende 7 métodos probados para eludir bloqueos de IP, desde proxies residenciales (95-99% de éxito) hasta VPNs y rotación de IP.
11-Aug-2022
31 min de lectura
](https://brightdata.es/blog/101-proxy/how-to-bypass-an-ip-ban)