Cómo Scrapear AliExpress: Guía Práctica para Product Research en 2025

APIs móviles vs HTML de desktop: el trade-off fundamental

Si quieres scrapear AliExpress, el primer decisión es si parseas el HTML renderizado del sitio desktop o llamas directamente a las APIs móviles que alimentan la app. La diferencia no es menor: el HTML de desktop está protegido por múltiples capas de JavaScript ofuscado y CAPTCHAs, mientras que las APIs móviles devuelven JSON limpio con datos de producto, SKUs, precios de envío y métricas de ventas en un solo payload.

La regla práctica: usa las APIs móviles siempre que puedas. Reserva el parsing de HTML para datos que solo existen en la interfaz web (como ciertos badges de vendedor o descripciones en HTML rico). Esta guía se enfoca en el enfoque de API móvil con proxies residenciales de ProxyHat como infraestructura base.

Estructura de AliExpress: qué scrapear y por qué

AliExpress tiene cuatro superficies principales que interesan para AliExpress product research:

Páginas de búsqueda

La URL de búsqueda desktop es https://www.aliexpress.com/wholesale?keyword=QUERY, pero el endpoint móvil equivalente es mucho más estable:

https://m.aliexpress.com/api/search/items?keyword=wireless+earbuds&page=1&sortType=SALE_PRICE

Este endpoint devuelve hasta 50 items por página con título, precio, imagen, conteo de órdenes y rating. Los parámetros sortType útiles: SALE_PRICE (más vendidos), PRICE_ASC, PRICE_DESC, NEW_ARRIVAL.

Páginas de producto

En desktop la URL es https://www.aliexpress.com/item/PRODUCT_ID.html. La API móvil equivalente:

https://m.aliexpress.com/api/product/detail?itemId=PRODUCT_ID

El JSON resultante incluye variantes completas (colores, tallas), inventario por SKU, opciones de envío y datos del vendedor. Mucho más rico que el HTML.

Páginas de tienda

URL: https://www.aliexpress.com/store/STORE_ID. La API móvil:

https://m.aliexpress.com/api/store/info?storeId=STORE_ID
https://m.aliexpress.com/api/store/items?storeId=STORE_ID&page=1

Devuelve metadata de la tienda (rating, años activos, número de seguidores) y listado paginado de productos. Útil para auditorar vendedores antes de listar sus productos en tu tienda dropship.

Feeds de productos trending

AliExpress expone feeds de productos populares por categoría. El endpoint clave:

https://m.aliexpress.com/api/search/items?categoryId=100003070&page=1&sortType=SALE_PRICE

Los categoryId principales: 100003070 (Electrónica), 200000345 (Hogar), 1501 (Ropa), 200000406 (Belleza). Ordenar por SALE_PRICE (en realidad ordena por volumen de ventas) te da los productos trending en cada nicho.

El stack anti-bot del grupo Alibaba

AliExpress forma parte del grupo Alibaba, y comparte infraestructura de seguridad con propiedades como Taobao y 1688. El stack incluye:

• Alibaba Cloud WAF: filtra requests por firma TLS, orden de headers y patrones de tráfico. Los datacenter IPs son bloqueados mucho más rápido que las residenciales.
• Device fingerprinting: scripts como umami.js y ut.js generan fingerprints del navegador (canvas, WebGL, fuentes). En la API móvil, se valida el header User-Agent y X-Client-Device.
• AliCAPTCHA / slide verification: aparece tras ~80-120 requests desde la misma IP en desktop. En la API móvil el umbral es más alto (~200-300 requests/min con headers correctos), pero sigue existiendo.
• IP reputation scoring: las IPs de datacenter conocidos (AWS, DigitalOcean, OVH) tienen score de reputación bajo desde el inicio. Las IPs residenciales rotadas tienen mucha más longevidad.
• Behavioral analysis: patrones de navegación demasiado rápidos o secuenciales disparan flags. Un delay de 2-5 segundos entre requests reduce significativamente los bloqueos.

Regla práctica: si ves respuestas con status 429, 403 o HTML que contiene un formulario de CAPTCHA en vez de JSON, tu IP está bloqueada temporalmente. Rota IP y reduce tu cadencia.

APIs móviles: JSON más rico que el HTML de desktop

Las APIs móviles de AliExpress son el camino más eficiente para AliExpress product research. No solo evitas renderizar JavaScript — obtienes datos que simplemente no existen en el HTML:

• SKU completo: cada variante con su ID, precio, stock y atributos.
• Freight estimation: costos de envío por carrier y país destino.
• Trade count: número exacto de órdenes (en desktop a veces se muestra como rango).
• Store metrics: rating del vendedor, tiempo en la plataforma, tasa de disputas.

Ejemplo de respuesta truncada del endpoint de detalle de producto:

{
  "data": {
    "itemId": "1005006234567890",
    "title": "Wireless Earbuds TWS Bluetooth 5.3...",
    "price": {"minPrice": "8.99", "maxPrice": "15.99", "currency": "USD"},
    "tradeCount": "5234",
    "averageStar": "4.7",
    "skuInfo": {
      "skuList": [
        {"skuId": "120000345", "skuPrice": {"salePrice": "8.99"}, "inventory": 856,
         "propertyValues": [{"propertyName": "Color", "propertyValueName": "Black"}]},
        {"skuId": "120000346", "skuPrice": {"salePrice": "9.99"}, "inventory": 423,
         "propertyValues": [{"propertyName": "Color", "propertyValueName": "White"}]}
      ]
    },
    "storeInfo": {"storeId": "912345678", "storeName": "TechGadgets Official", "storeRating": "97.2%"},
    "freightList": [
      {"companyName": "AliExpress Standard Shipping", "freightAmount": {"value": "0.00"}, "estimateConsumeDay": "15-30"},
      {"companyName": "DHL", "freightAmount": {"value": "12.50"}, "estimateConsumeDay": "5-10"}
    ]
  }
}

Para acceder a estas APIs, necesitas imitar la app móvil de AliExpress. Los headers mínimos:

User-Agent: AliApp(AE/8.0.0)
X-Client-Device: android
X-Client-Version: 8.0.0
X-Client-Language: en

Ejemplo en Python: descubrir productos trending con proxies residenciales

Este script usa las APIs móviles de AliExpress con un AliExpress proxy residencial de ProxyHat para descubrir productos trending en tres categorías:

import requests
import time
from urllib.parse import quote

# Configuración de ProxyHat — proxy residencial con geo-targeting a EE.UU.
PROXY = "http://user-country-US:PASSWORD@gate.proxyhat.com:8080"
proxies = {"http": PROXY, "https": PROXY}

HEADERS = {
    "User-Agent": "AliApp(AE/8.0.0)",
    "X-Client-Device": "android",
    "X-Client-Version": "8.0.0",
    "X-Client-Language": "en",
}

CATEGORIES = {
    "electronics": 100003070,
    "home_garden": 200000345,
    "apparel": 1501,
}

def search_category(cat_id, page=1, sort="SALE_PRICE"):
    """Busca productos en una categoría por volumen de ventas."""
    url = (
        f"https://m.aliexpress.com/api/search/items"
        f"?categoryId={cat_id}&page={page}&sortType={sort}"
    )
    resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=15)
    resp.raise_for_status()
    return resp.json()

def get_product_detail(item_id):
    """Obtiene detalle completo de un producto."""
    url = f"https://m.aliexpress.com/api/product/detail?itemId={item_id}"
    resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=15)
    resp.raise_for_status()
    return resp.json()

def discover_trending(max_pages=3):
    """Descubre productos trending en todas las categorías."""
    trending = []
    for cat_name, cat_id in CATEGORIES.items():
        for page in range(1, max_pages + 1):
            try:
                data = search_category(cat_id, page)
                items = data.get("data", {}).get("items", [])
                for item in items:
                    trending.append({
                        "product_id": item["itemId"],
                        "title": item["title"],
                        "price": item["price"]["minPrice"],
                        "orders": item.get("tradeCount", "0"),
                        "rating": item.get("averageStar", "0"),
                        "category": cat_name,
                    })
                time.sleep(3)  # Rate limiting entre páginas
            except requests.exceptions.HTTPError as e:
                if e.response.status_code in (403, 429):
                    print(f"Bloqueado en {cat_name} página {page}. Rotando IP...")
                    time.sleep(10)
                    continue
                raise
    return sorted(trending, key=lambda x: int(x.get("orders", "0") or "0"), reverse=True)

if __name__ == "__main__":
    products = discover_trending()
    for p in products[:20]:
        print(f"{p['title'][:55]:55} | ${p['price']:>7} | {p['orders']:>6} orders | ★{p['rating']}")

Notar el time.sleep(3) entre páginas y el manejo de 403/429. Con un AliExpress proxy residencial rotativo (cada request obtiene una IP nueva vía ProxyHat), puedes incrementar la cadencia, pero siempre es prudente mantener delays. Más adelante cubrimos cadencias óptimas.

Manejo de variantes SKU, costos de envío y reputación del vendedor

Variantes y SKUs

Los productos de AliExpress suelen tener múltiples variantes (color, talla, material). Cada variante es un SKU distinto con su propio precio, stock y ID. Para dropshipping, necesitas mapear estas variantes correctamente.

def parse_variants(product_data):
    """Extrae SKUs variantes del JSON de producto móvil."""
    variants = []
    for sku in product_data.get("skuInfo", {}).get("skuList", []):
        attrs = {
            attr["propertyName"]: attr["propertyValueName"]
            for attr in sku.get("propertyValues", [])
        }
        variants.append({
            "sku_id": sku["skuId"],
            "price": sku.get("skuPrice", {}).get("salePrice", "N/A"),
            "stock": sku.get("inventory", 0),
            "attributes": attrs,
        })
    return variants

# Ejemplo de uso
detail = get_product_detail("1005006234567890")
variants = parse_variants(detail.get("data", {}))
for v in variants:
    print(f"SKU {v['sku_id']}: {v['attributes']} — ${v['price']} — stock: {v['stock']}")

Punto clave para dropshippers: el SKU ID es lo que necesitas para automatizar pedidos vía la API de AliExpress o el portal de afiliados. No uses el itemId genérico — es ambiguo cuando hay variantes.

Costos de envío por destino

El envío es el factor que más afecta el margen en dropshipping. La API móvil te da estimaciones por país:

def estimate_shipping(product_id, dest_country="US"):
    """Consulta costo de envío estimado vía API móvil."""
    url = (
        f"https://m.aliexpress.com/api/shipping/freight"
        f"?itemId={product_id}&country={dest_country}"
    )
    resp = requests.get(url, headers=HEADERS, proxies=proxies, timeout=15)
    resp.raise_for_status()
    data = resp.json()
    options = []
    for method in data.get("data", {}).get("freightList", []):
        options.append({
            "carrier": method.get("companyName"),
            "cost": method.get("freightAmount", {}).get("value"),
            "days_min": method.get("estimateConsumeDay", "?").split("-")[0] if "-" in str(method.get("estimateConsumeDay", "")) else method.get("estimateConsumeDay"),
            "days_max": method.get("estimateConsumeDay", "?").split("-")[-1] if "-" in str(method.get("estimateConsumeDay", "")) else method.get("estimateConsumeDay"),
        })
    return sorted(options, key=lambda x: float(x["cost"]) if x["cost"] else 999)

# Ejemplo: comparar envío a 3 destinos
for country in ["US", "DE", "BR"]:
    rates = estimate_shipping("1005006234567890", country)
    cheapest = rates[0] if rates else None
    if cheapest:
        print(f"{country}: {cheapest['carrier']} ${cheapest['cost']} ({cheapest['days_min']}-{cheapest['days_max']} días)")

Esto te permite calcular márgenes reales por mercado antes de listar un producto. Un producto de $3 con envío gratis a EE.UU. puede costar $8 de envío a Brasil — matando tu margen.

Reputación del vendedor

La API de store info te da métricas clave para filtrar vendedores:

• storeRating: porcentaje de feedback positivo (busca >95%).
• yearsOnPlatform: más de 3 años es una buena señal.
• disputeRate: si está disponible, evita vendedores con tasa >5%.
• followerCount: indica legitimidad y volumen.

Para product research serio, filtra productos donde el vendedor tenga storeRating < 95% o menos de 1 año en la plataforma. Esto reduce problemas de calidad y disputas.

Frescura de datos: cadencia de scraping

Los datos de AliExpress cambian a diferentes velocidades:

Dato	Frecuencia de cambio	Cadencia de scraping recomendada
Precio	Varias veces al día (flash sales, cupones)	Cada 4-6 horas
Stock / inventario	Horas (productos populares se agotan)	Cada 2-4 horas
Conteo de órdenes	Diario (se actualiza en lote)	1 vez al día
Rating / reseñas	Semanal	1-2 veces por semana
Opciones de envío	Semanal (cambios de carriers)	1 vez por semana
Nuevos productos	Continuo	Cada 12-24 horas (discovery)

Estrategia recomendada: ejecuta un pipeline de discovery diario que identifica productos nuevos y trending, y un pipeline de monitoreo cada 4-6 horas que actualiza precios y stock de los productos que ya rastreas. Esto te da frescura sin saturar rate limits.

Con proxies residenciales rotativos de ProxyHat, una cadencia de ~3-5 segundos entre requests por IP te da un throughput de ~720-1,200 requests/hora. Para monitorear 10,000 SKUs cada 6 horas, necesitas ~1,667 requests por ciclo — factible con 2-3 IPs residenciales rotando.

Comparación de tipos de proxy para AliExpress

Tipo de proxy	Velocidad	Tasa de éxito en AliExpress	Casos de uso
Residencial rotativo	Media (~2-5s)	95-99%	Product research, monitoreo de precios, discovery
Datacenter	Alta (~0.5-1s)	30-50%	Solo para endpoints no protegidos, pruebas rápidas
Móvil (4G/5G)	Baja (~5-10s)	99%+	Acciones sensibles (login, compra automatizada), evasión anti-bot máxima

Para la mayoría de escenarios de product research, los proxies residenciales rotativos ofrecen el mejor balance entre velocidad y confiabilidad. Los datacenter son bloqueados rápidamente por el WAF de Alibaba. Los móviles son excesivos para scraping de APIs públicas, pero indispensables si necesitas interactuar con la plataforma como usuario autenticado.

Con ProxyHat puedes configurar el tipo de proxy y el geo-targeting en el username:

# Residencial rotativo — EE.UU.
http://user-country-US:PASSWORD@gate.proxyhat.com:8080

# Residencial sticky (sesión de 30 min) — Alemania, Berlín
http://user-country-DE-city-berlin-session-abc123:PASSWORD@gate.proxyhat.com:8080

# SOCKS5 para casos que lo requieran
socks5://user-country-US:PASSWORD@gate.proxyhat.com:1080

Las sesiones sticky son útiles cuando necesitas mantener la misma IP para múltiples requests (por ejemplo, navegar por varias páginas de un mismo vendedor sin disparar checks de seguridad).

Key Takeaways

• Usa APIs móviles, no HTML de desktop. El JSON es más completo, más estable y más fácil de parsear.
• Imita headers de la app móvil (AliApp(AE/8.0.0)) para acceder a los endpoints de API.
• Proxies residenciales son obligatorios para scraping sostenido. Los datacenter IPs son bloqueados en minutos.
• Mapea SKUs variantes — el skuId es la unidad fundamental, no el itemId.
• Calcula envío por destino antes de listar productos. El envío gratis a EE.UU. no significa envío gratis a todo el mundo.
• Cadencia inteligente: discovery diario, monitoreo de precios cada 4-6 horas, con delays de 3-5s entre requests.
• Filtra vendedores por rating >95% y antigüedad >1 año para reducir disputas.

Conclusión y próximos pasos

Scrapear AliExpress para product research es perfectamente viable si usas el enfoque correcto: APIs móviles + proxies residenciales + cadencia responsable. No intentes parsear el HTML de desktop — es una batalla perdida contra el WAF de Alibaba que se actualiza constantemente.

Si estás construyendo una herramienta de dropshipping o un tracker de productos trending, empieza con el script de discovery de este artículo y añade capas de monitoreo según tus necesidades. Para volúmenes altos (+50,000 SKUs monitoreados), considera usar sesiones sticky de ProxyHat para mantener conexiones estables y reducir la tasa de bloqueos.

Puedes ver más casos de uso en nuestra guía de web scraping o consultar las opciones de proxies residenciales de ProxyHat para encontrar el plan que se ajuste a tu volumen.