Cómo raspar a los vendedores online de productos de Google con Python
Advanced Data Extraction Specialist
Introducción
En el competitivo panorama actual del comercio electrónico, el monitoreo de las listas de productos y el análisis del rendimiento de los vendedores online en plataformas como Google pueden proporcionar información valiosa. El scraping de las listas de productos de Google permite a las empresas recopilar datos en tiempo real para comparar precios, rastrear tendencias y analizar a la competencia. En este artículo, le mostraremos cómo raspar los vendedores online de productos de Google con Python, utilizando una variedad de métodos. También explicaremos por qué Scrapeless es la mejor opción para las empresas que buscan soluciones fiables, escalables y legales.
Comprensión de los desafíos del scraping de vendedores online de productos de Google
Al intentar raspar vendedores online de productos de Google, pueden surgir varios desafíos clave:
- Medidas anti-scraping: Los sitios web implementan CAPTCHAs y bloqueo de IP para evitar el scraping automatizado, lo que dificulta la extracción de datos.
- Contenido dinámico: Las páginas de productos de Google a menudo cargan datos usando JavaScript, que puede ser omitido por los métodos de scraping tradicionales como Requests & BeautifulSoup o Selenium.
- Limitación de velocidad: Las solicitudes excesivas en un período corto pueden provocar un acceso restringido, causando retrasos e interrupciones en el proceso de scraping.
Aviso de privacidad: Protegemos firmemente la privacidad del sitio web. Todos los datos de este blog son públicos y solo se utilizan como demostración del proceso de rastreo. No guardamos ninguna información ni datos.
Método 1: Scraping de vendedores online de productos de Google con la API de Scrapeless (Solución recomendada)
¿Por qué Scrapeless es una gran herramienta?
- Extracción de datos eficiente: Scrapeless puede omitir CAPTCHAs y medidas anti-bot, permitiendo un scraping de datos fluido e ininterrumpido.
- Precios asequibles: Con solo $0.1 por cada 1,000 consultas, Scrapeless ofrece una de las soluciones más económicas para el scraping de Google.
- Scraping multifuente: Además de raspar vendedores online de productos de Google, Scrapeless le permite recopilar datos de Google Maps, Google Hotels, Google Flights, Google News y más.
- Velocidad y escalabilidad: Maneje tareas de scraping a gran escala rápidamente, sin ralentizarse, lo que lo hace ideal para proyectos tanto pequeños como empresariales.
- Datos estructurados: La herramienta proporciona datos estructurados y limpios, listos para usar en sus análisis, informes o integración en sus sistemas.
- Facilidad de uso: Sin configuración compleja: simplemente integre su clave API y comience a raspar datos en minutos.
Cómo usar la API de Scrapeless:
- Registrarse: Regístrese en Scrapeless y obtenga su clave API. Al mismo tiempo, también puede obtener una prueba gratuita en la parte superior del Panel de control.
- Integrar API: Incluya la clave API en su código para iniciar solicitudes al servicio.
- Comenzar a raspar: Ahora puede enviar solicitudes GET con URL de productos o consultas de búsqueda, y Scrapeless devolverá datos estructurados que incluyen nombres de productos, precios, reseñas y más.
- Usar los datos: Aproveche los datos recuperados para el análisis de la competencia, el seguimiento de tendencias o cualquier otro proyecto que requiera información de Google.
Ejemplo completo de código:
python
import json
import requests
class Payload:
def __init__(self, actor, input_data):
self.actor = actor
self.input = input_data
def send_request():
host = "api.scrapeless.com"
url = f"https://{host}/api/v1/scraper/request"
token = "your_token"
headers = {
"x-api-token": token
}
input_data = {
"engine": "google_product",
"product_id": "4172129135583325756",
"gl": "us",
"hl": "en",
}
payload = Payload("scraper.google.product", input_data)
json_payload = json.dumps(payload.__dict__)
response = requests.post(url, headers=headers, data=json_payload)
if response.status_code != 200:
print("Error:", response.status_code, response.text)
return
print("body", response.text)
if __name__ == "__main__":
send_request()Prueba Scrapeless gratis y experimenta cómo nuestra API puede simplificar tu proceso de scraping de vendedores online de productos de Google. Comienza tu prueba gratuita aquí.
Únete a nuestra comunidad Discord para obtener soporte, compartir ideas y mantenerte actualizado sobre las últimas funciones. ¡Haz clic aquí para unirte!
Método 2: Scraping de listas de productos de Google con Requests & BeautifulSoup
En este enfoque, profundizaremos en cómo raspar las listas de productos de Google utilizando dos potentes bibliotecas de Python: Requests y BeautifulSoup. Estas bibliotecas nos permiten realizar solicitudes HTTP a las páginas de productos de Google y analizar la estructura HTML para extraer información valiosa.
Paso 1. Configurar el entorno
Primero, asegúrate de tener Python instalado en tu sistema. Y crea un nuevo directorio para almacenar el código de este proyecto. Luego, necesitas instalar beautifulsoup4 y requests. Puedes hacerlo a través de PIP:
language
$ pip install requests beautifulsoup4Paso 2. Usar requests para hacer una solicitud simple
Ahora, necesitamos rastrear los datos de los productos de Google. Tomemos el producto con el product_id 4172129135583325756 como ejemplo y rastreemos algunos datos de OnlineSeller.
Primero, usemos simplemente requests para enviar una solicitud GET:
def google_product():
headers = {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/jpeg,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
"Accept-Language": "en-US,en;q=0.9",
"Cache-Control": "no-cache",
"Pragma": "no-cache",
"Priority": "u=0, i",
"Sec-Ch-Ua": '"Not A(Brand";v="8", "Chromium";v="132", "Google Chrome";v="132"',
"Sec-Ch-Ua-Mobile": "?0",
"Sec-Ch-Ua-Platform": '"Windows"',
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "none",
"Sec-Fetch-User": "?1",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36",
}
response = requests.get('https://www.google.com/shopping/product/4172129135583325756?gl=us&hl=en&prds=pid:4172129135583325756,freeship:1&sourceid=chrome&ie=UTF-8', headers=headers)Como se esperaba, la solicitud devuelve una página HTML completa. Ahora necesitamos extraer algunos datos de la siguiente página:
Paso 3. Obtener datos específicos
Como se muestra en la figura, los datos que necesitamos están bajo tr[jscontroller='d5bMlb']:
online_sellers = []
soup = BeautifulSoup(response.content, 'html.parser')
for i, row in enumerate(soup.find_all("tr", {"jscontroller": "d5bMlb"})):
name = row.find("a").get_text(strip=True)
payment_methods = row.find_all("div")[1].get_text(strip=True)
link = row.find("a")['href']
details_and_offers_text = row.find_all("td")[1].get_text(strip=True)
base_price = row.find("span", class_="g9WBQb fObmGc").get_text(strip=True)
badge = row.find("span", class_="XhDkmd").get_text(strip=True) if row.find("span", class_="XhDkmd") else ""
link = f"https://www.google.com/{link}"
parse = urlparse(link)
direct_link = parse_qs(parse.query).get("q", [""])[0]
online_sellers.append({
'name' : name,
'payment_methods' : payment_methods,
'link' : link,
'direct_link' : direct_link,
'details_and_offers' : [{"text": details_and_offers_text}],
'base_price' : base_price,
'badge' : badge
})Luego usa BeautifulSoup para analizar la página HTML y obtener los elementos relevantes:
Código completo
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse, parse_qs
class AdditionalPrice:
def __init__(self, shipping, tax):
self.shipping = shipping
self.tax = tax
class OnlineSeller:
def __init__(self, position, name, payment_methods, link, direct_link, details_and_offers, base_price,
additional_price, badge, total_price):
self.position = position
self.name = name
self.payment_methods = payment_methods
self.link = link
self.direct_link = direct_link
self.details_and_offers = details_and_offers
self.base_price = base_price
self.additional_price = additional_price
self.badge = badge
self.total_price = total_price
def sellers_results(url):
headers = {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/jpeg,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
"Accept-Language": "en-US,en;q=0.9",
"Cache-Control": "no-cache",
"Pragma": "no-cache",
"Priority": "u=0, i",
"Sec-Ch-Ua": '"Not A(Brand";v="8", "Chromium";v="132", "Google Chrome";v="132"',
"Sec-Ch-Ua-Mobile": "?0",
"Sec-Ch-Ua-Platform": '"Windows"',
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "none",
"Sec-Fetch-User": "?1",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36",
}
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.content, 'html.parser')
online_sellers = []
for i, row in enumerate(soup.find_all("tr", {"jscontroller": "d5bMlb"})):
name = row.find("a").get_text(strip=True)
payment_methods = row.find_all("div")[1].get_text(strip=True)
link = row.find("a")['href']
details_and_offers_text = row.find_all("td")[1].get_text(strip=True)
base_price = row.find("span", class_="g9WBQb fObmGc").get_text(strip=True)
badge = row.find("span", class_="XhDkmd").get_text(strip=True) if row.find("span", class_="XhDkmd") else ""
link = f"https://www.google.com/{link}"
parse = urlparse(link)
direct_link = parse_qs(parse.query).get("q", [""])[0]
online_sellers.append({
'name' : name,
'payment_methods' : payment_methods,
'link' : link,
'direct_link' : direct_link,
'details_and_offers' : [{"text": details_and_offers_text}],
'base_price' : base_price,
'badge' : badge
})
return online_sellers
url = 'https://www.google.com/shopping/product/4172129135583325756?gl=us&hl=en&prds=pid:4172129135583325756,freeship:1&sourceid=chrome&ie=UTF-8'
sellers = sellers_results(url)
for seller in sellers:
print(seller)Los resultados de impresión de la consola son los siguientes:
Limitaciones
Por supuesto, podemos obtener los datos usando el ejemplo anterior de obtener datos parciales, pero existe el riesgo de bloqueo de IP. No podemos hacer grandes solicitudes, lo que activará el control de riesgos del producto de Google.
Método 3: Scraping de vendedores online de productos de Google con Selenium
En este método, exploraremos cómo usar Selenium, una poderosa herramienta de automatización web, para raspar las listas de productos de Google de los vendedores online. A diferencia de Requests y BeautifulSoup, Selenium nos permite interactuar con páginas dinámicas que requieren la ejecución de JavaScript, lo que lo hace perfecto para raspar listas de productos de Google que cargan contenido dinámicamente.
Paso 1: Configurar el entorno
Primero, asegúrate de tener Python instalado en tu sistema. Y crea un nuevo directorio para almacenar el código de este proyecto. Luego, necesitas instalar selenium y webdriver_manager. Puedes hacerlo a través de PIP:
pip install selenium
pip install webdriver_managerPaso 2: Inicializar el entorno de selenium
Ahora, necesitamos agregar algunos elementos de configuración de selenium e inicializar el entorno.
options = webdriver.ChromeOptions()
options.add_argument("--headless")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)Paso 3: Obtener datos específicos
Usamos selenium para obtener el producto con product_id 4172129135583325756 y obtener algunos datos de OnlineSeller
driver.get(url)
time.sleep(5) #esperar página
online_sellers = []
rows = driver.find_elements(By.CSS_SELECTOR, "tr[jscontroller='d5bMlb']")
for i, row in enumerate(rows):
name = row.find_element(By.TAG_NAME, "a").text.strip()
payment_methods = row.find_elements(By.TAG_NAME, "div")[1].text.strip()
link = row.find_element(By.TAG_NAME, "a").get_attribute('href')
details_and_offers_text = row.find_elements(By.TAG_NAME, "td")[1].text.strip()
base_price = row.find_element(By.CSS_SELECTOR, "span.g9WBQb.fObmGc").text.strip()
badge = row.find_element(By.CSS_SELECTOR, "span.XhDkmd").text.strip() if row.find_elements(By.CSS_SELECTOR, "span.XhDkmd") else ""Código completo
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager
import time
from urllib.parse import urlparse, parse_qs
class AdditionalPrice:
def __init__(self, shipping, tax):
self.shipping = shipping
self.tax = tax
class OnlineSeller:
def __init__(self, position, name, payment_methods, link, direct_link, details_and_offers, base_price, additional_price, badge, total_price):
self.position = position
self.name = name
self.payment_methods = payment_methods
self.link = link
self.direct_link = direct_link
self.details_and_offers = details_and_offers
self.base_price = base_price
self.additional_price = additional_price
self.badge = badge
self.total_price = total_price
def sellers_results(url):
options = webdriver.ChromeOptions()
options.add_argument("--headless")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=options)
try:
driver.get(url)
time.sleep(5)
online_sellers = []
rows = driver.find_elements(By.CSS_SELECTOR, "tr[jscontroller='d5bMlb']")
for i, row in enumerate(rows):
name = row.find_element(By.TAG_NAME, "a").text.strip()
payment_methods = row.find_elements(By.TAG_NAME, "div")[1].text.strip()
link = row.find_element(By.TAG_NAME, "a").get_attribute('href')
details_and_offers_text = row.find_elements(By.TAG_NAME, "td")[1].text.strip()
base_price = row.find_element(By.CSS_SELECTOR, "span.g9WBQb.fObmGc").text.strip()
badge = row.find_element(By.CSS_SELECTOR, "span.XhDkmd").text.strip() if row.find_elements(By.CSS_SELECTOR, "span.XhDkmd") else ""
parse = urlparse(link)
direct_link = parse_qs(parse.query).get("q", [""])[0]
online_seller = {
'name': name,
'payment_methods': payment_methods,
'link': link,
'direct_link': direct_link,
'details_and_offers': [{"text": details_and_offers_text}],
'base_price': base_price,
'badge': badge
}
online_sellers.append(online_seller)
return online_sellers
finally:
driver.quit()
url = 'https://www.google.com/shopping/product/4172129135583325756?gl=us&hl=en&prds=pid:4172129135583325756,freeship:1&sourceid=chrome&ie=UTF-8'
sellers = sellers_results(url)
for seller in sellers:
print(seller)Los resultados de impresión de la consola son los siguientes:
Limitaciones
Selenium es una herramienta poderosa para automatizar las operaciones del navegador web y se usa ampliamente en pruebas automatizadas y rastreo de datos web. Sin embargo, necesita esperar a que se cargue la página, por lo que es relativamente lento en el proceso de rastreo de datos.
Preguntas frecuentes
¿Cuáles son los mejores métodos para raspar listas de productos de Google a gran escala?
El método más eficaz para el raspado de productos de Google a gran escala es usar Scrapeless. Proporciona una API rápida y escalable, manejando contenido dinámico, bloqueo de IP y CAPTCHAs de manera eficiente, lo que lo hace ideal para las empresas.
¿Cómo puedo omitir las medidas anti-raspado de Google al raspar listas de productos?
Google emplea varias medidas anti-raspado, incluidos CAPTCHAs y bloqueo de IP. Scrapeless proporciona una API que omite estas medidas y asegura una extracción de datos fluida e ininterrumpida.
¿Puedo usar bibliotecas de Python como BeautifulSoup o Selenium para raspar listas de productos de Google?
Si bien BeautifulSoup y Selenium se pueden usar para raspar listas de productos de Google, tienen limitaciones como un rendimiento lento, riesgo de detección e incapacidad para escalar. Scrapeless ofrece una solución más eficiente que maneja todos estos problemas.
Conclusión
En este artículo, hemos discutido tres métodos para raspar vendedores online de productos de Google: Requests & BeautifulSoup, Selenium y Scrapeless. Cada método ofrece ventajas distintas, pero cuando se trata de manejar el raspado a gran escala, Scrapeless es sin duda la mejor opción para las empresas.
- Requests & BeautifulSoup son adecuados para tareas de raspado a pequeña escala, pero presentan limitaciones al tratar con contenido dinámico o al escalar. Estas herramientas también corren el riesgo de ser bloqueadas por medidas anti-raspado.
- Selenium es eficaz para páginas renderizadas con JavaScript, pero consume muchos recursos y es más lento que otras opciones, lo que lo hace menos ideal para el raspado a gran escala de listas de productos de Google.
Por otro lado, Scrapeless aborda todos los desafíos asociados con los métodos de raspado tradicionales. Es rápido, fiable y legal, lo que garantiza que pueda raspar de manera eficiente los vendedores online de productos de Google a escala sin preocuparse por ser bloqueado o encontrar otros obstáculos.
Para las empresas que buscan una solución optimizada y escalable, Scrapeless es la herramienta ideal. Omite todos los obstáculos de los métodos convencionales y proporciona una experiencia fluida y sin problemas para recopilar datos de productos de Google.
Prueba Scrapeless hoy con una prueba gratuita y descubre lo fácil que es escalar tus tareas de raspado de productos de Google. Comienza tu prueba gratuita ahora.
En Scrapeless, solo accedemos a datos disponibles públicamente y cumplimos estrictamente con las leyes, regulaciones y políticas de privacidad del sitio web aplicables. El contenido de este blog es sólo para fines de demostración y no implica ninguna actividad ilegal o infractora. No ofrecemos garantías y renunciamos a toda responsabilidad por el uso de la información de este blog o enlaces de terceros. Antes de realizar cualquier actividad de scraping, consulte a su asesor legal y revise los términos de servicio del sitio web de destino u obtenga los permisos necesarios.
