---
title: "Como extrair dados do AliExpress com Python"
slug: how-to-scrape-aliexpress
date: 2026-02-23T09:54:31+00:00
modified: 2026-02-23T09:54:33+00:00
permalink: https://brightdata.com.br/blog/dados-do-site/how-to-scrape-aliexpress
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [Dados do site](https://brightdata.com.br/blog/dados-do-site)
[Dados do site](https://brightdata.com.br/blog/dados-do-site)
# Como extrair dados do AliExpress com Python
Domine a extração de dados do AliExpress com Python: recupere dados de produtos, preços e avaliações de forma eficiente neste guia passo a passo.
14 min de leitura
[  ](https://brightdata.com/blog/authors/leslie-gyamfi)
[Leslie Gyamfi
](https://brightdata.com/blog/authors/leslie-gyamfi)
Neste guia, você aprenderá o seguinte:
- O que é um Scraper do AliExpress e como ele funciona
- Os tipos de dados que você pode recuperar automaticamente do AliExpress
- Como criar um script de scraping do AliExpress usando Python
Vamos começar!
## O que é um Scraper do AliExpress?
Um [scraper do AliExpress](/products/web-scraper/aliexpress) recupera automaticamente dados específicos das páginas do AliExpress. Ele navega pelas páginas do AliExpress imitando os hábitos de navegação do usuário. Ele transforma o conteúdo da página da web em um formato utilizável, como CSV ou JSON, e controla interações como paginação. Seu objetivo final é recuperar informações estruturadas, como imagens de produtos, detalhes de produtos, feedback de clientes, preços e muito mais.
Se você quiser saber mais sobre como criar scrapers da web, leia nosso guia sobre [como criar um bot de scraping de dados](/blog/how-tos/what-is-a-scraping-bot).
## Dados que você pode extrair do AliExpress: guia passo a passo
O AliExpress contém uma grande quantidade de informações, como:
- **Detalhes do produto**: nomes, descrições, imagens, faixas de preço, informações do vendedor e muito mais.
- **Feedback dos clientes**: avaliações, comentários sobre produtos e muito mais.
- **Categorias e tags**: categorias de produtos, tags relevantes ou rótulos.
É hora de aprender como coletá-los!
## Extraindo dados do AliExpress em Python
Esta seção do tutorial fornece um guia passo a passo sobre como criar um Scraper do AliExpress.
O objetivo é orientá-lo na escrita de um script Python que extraia automaticamente informações da [página “cadeira ergonômica” do AliExpress](https://www.aliexpress.us/w/wholesale-ergonomic-chair.html?spm=a2g0o.productlist.search.0):
### Etapa 1: Configuração do projeto
Certifique-se de que você tenha o Python 3 instalado no seu computador local. Caso contrário, [baixe-o da documentação oficial](https://www.python.org/downloads/) e siga o assistente de instalação para configurá-lo.
Em seguida, use o comando abaixo para criar o diretório do seu projeto:
```none
mkdir aliexpress-scraper
```
Este diretório conterá seu código Python.
Entre no diretório no seu terminal e crie um [ambiente virtual](https://docs.python.org/3/library/venv.html) dentro dele:
```none
cd aliexpress-Scraper
python -m venv env
```
Vá em frente e carregue a pasta do projeto em seu IDE Python preferido, como [o Visual Studio Code com a extensão Python](https://code.visualstudio.com/docs/languages/python).
No terminal do seu IDE, ative o ambiente virtual. Execute o seguinte comando se estiver usando macOS ou Linux:
```none
.env/bin/activate
```
Da mesma forma, no Windows, use este comando:
```none
env/Scripts/activate
```
Ótimo!
No diretório raiz do seu projeto, crie um arquivo `scraper.py.` Seu projeto agora deve ter esta estrutura de pastas:
Ótimo! Seu ambiente Python para Scraping de dados do AliExpress está pronto.
### Etapa 2: selecione a biblioteca de scraping
O objetivo atual é determinar se o AliExpress emprega páginas dinâmicas ou estáticas. Navegue até a página do AliExpress desejada no modo privado ou anônimo do seu navegador. Em seguida, clique com o botão direito do mouse em um espaço vazio no fundo da página da web, escolha a opção “Inspect” (Inspecionar), navegue até a guia “Network” (Rede), aplique o filtro “Fetch/XHR” e atualize a página:
Verifique se a página faz alguma consulta dinâmica nesta seção DevTools. Depois de atualizar a página, você notará várias solicitações Fetch/XHR. Isso indica que a página usa solicitações dinâmicas para carregar conteúdo adicional. Se você der uma olhada no DOM da página em comparação com o documento HTML retornado pelo servidor, também verá que o AliExpress usa renderização JavaScript.
Para fazer o scraping do AliExpress de maneira eficaz, você precisará de uma ferramenta de automação de navegador como [o Selenium](https://www.selenium.dev/), pois a página de destino depende do JavaScript para renderização. Nosso blog sobre [o Scraping de dados com Selenium](/blog/how-tos/using-selenium-for-web-scraping) é um excelente recurso para iniciantes.
Com o Selenium, você pode manipular um navegador da web, imitar interações do usuário e fazer scraping de conteúdo renderizado em JavaScript. Instale-o e comece a usá-lo!
### Etapa 3: Instale e configure o Selenium
No ambiente virtual ativado, instale o Selenium com este comando:
```none
pip install -U selenium
```
No arquivo `scraper.py`, importe `o WebDriver` do Selenium e inicialize-o.
```none
from selenium import webdriver
# Inicialize o driver do Chrome
driver = webdriver.Chrome()
# lógica de extração...
# Feche o driver
driver.quit()
```
Um [`WebDriver`](https://selenium-python.readthedocs.io/api.html#module-selenium.webdriver.chrome.webdriver) é inicializado no código acima para lidar com uma instância do Chrome. Vale a pena notar que o AliExpress possui medidas anti-scraping que podem impedir que navegadores headless acessem o site.
Portanto, não é aconselhável definir o [sinalizador`--headless`](https://developer.chrome.com/docs/chromium/headless). Em vez disso, considere uma opção alternativa, como [o Playwright Stealth](/blog/how-tos/avoid-bot-detection-with-playwright-stealth).
Agora que você está totalmente configurado para começar a fazer scraping do AliExpress, vamos examinar como se conectar à página de destino.
### Etapa 4: conecte-se à página de destino
Use o método [`get()`](https://selenium-python.readthedocs.io/api.html#selenium.webdriver.remote.webdriver.WebDriver.get) exposto pelo objeto Selenium WebDriver para visitar a página de destino. O arquivo `scraper.py` agora deve ficar assim:
```none
from selenium import webdriver
# Inicializar o driver do Chrome
driver = webdriver.Chrome()
# URL da página de destino
url = "https://www.aliexpress.com/w/wholesale-ergonomic-chair.html?spm=a2g0o.productlist.search.0"
# Conecte-se à página de destino
driver.get(url)
# lógica de raspagem...
# Feche o driver
driver.quit()
```
Coloque um ponto de interrupção de depuração na linha final e inicie o script com o depurador. O navegador Chrome controlado deve abrir automaticamente, conforme mostrado abaixo:
Ótimo! A notificação “O Chrome está sendo controlado por um software de teste automatizado” indica que o Selenium está controlando o Chrome com sucesso, conforme configurado.
### Etapa 5: Selecione os elementos do produto
Como a página de produtos do AliExpress contém vários produtos, você deve primeiro inicializar uma estrutura de dados para armazenar os dados coletados. Para isso, uma matriz funcionará perfeitamente:
```none
produtos = []
```
Para garantir que seu Scraper continue funcionando mesmo quando o layout do site mudar, você deve criar uma função auxiliar que torne seus seletores mais resistentes a essas mudanças:
```none
def find_element_smart(parent, by_list):
"""Tente vários seletores até que um elemento seja encontrado"""
for by_type, selector in by_list:
try:
element = parent.find_element(by_type, selector)
if element.is_displayed():
return element
except:
continue
return None
```
A função `find_element_smart()` itera por uma lista de estratégias de seletor `by_list` para localizar um elemento dentro de um determinado elemento pai. Ela tenta cada par `` até encontrar um elemento visível, retornando-o se for bem-sucedida. Caso contrário, ela retorna `None` se nenhum elemento correspondente for encontrado.
Em seguida, inspecione os elementos HTML dos produtos na página para entender como selecioná-los, identificar o tipo de dados que eles contêm e determinar como extrair esses dados.
É óbvio que cada elemento do produto é um nó `.list-–gallery—-C2f2tvm`.
Observe que `list--gallery--C2f2tvm` pode mudar a qualquer momento, pois contém uma string gerada aleatoriamente. Portanto, você não deve confiar nessa classe para a seleção de elementos. Em vez disso, você deve começar encontrando produtos com base em sua estrutura, como elementos `div` que contêm imagens e links. Se isso não funcionar, tente procurar produtos com base em seu conteúdo ou concentre-se em elementos HTML mais específicos.
Implemente a lógica de seleção de produtos conforme abaixo:
```none
# Encontre produtos usando padrões estruturais primeiro e, em seguida, recorra a padrões de classe
product_selectors = [
(By.XPATH, "//div[.//img and .//a[contains(@href, 'item')]]"),
(By.XPATH, "//div[.//img and .//*[contains(text(), '$')]]"),
(By.CSS_SELECTOR, "div[class*='gallery']")
]
# Aguardar e obter produtos
wait.until(EC.presence_of_all_elements_located((By.CSS_SELECTOR, "div[class*='gallery']")))
produtos_encontrados = []
para tipo_seletor, seletor em seletores_de_produtos:
tente:
elementos = espere.até(EC.presence_of_all_elements_located((tipo_seletor, seletor)))
se elementos:
produtos_encontrados = elementos
break
exceto:
continue
```
O código acima aplica a estratégia do seletor para recuperar elementos na página com [seletores CSS](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors) genéricos.
Inclua a seguinte importação em seu script Python:
```none
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
```
Em seguida, introduza uma instância `WebDriverWait` logo após inicializar o `WebDriver`, mas antes de qualquer interação com a página:
```none
wait = WebDriverWait(driver, 20)
```
Em vez de localizar imediatamente os elementos em uma página ao fazer a extração de sites dinâmicos como o AliExpress, `o WebDriverWait` instrui o Scraper a ser paciente e aguardar até o tempo especificado (20 segundos, neste caso) para que os elementos apareçam. Isso é importante porque as páginas da web carregam elementos em velocidades diferentes e, sem a espera adequada, o Scraper pode trabalhar com elementos que ainda não foram carregados, causando erros.
Agora você está um passo mais perto de fazer o scraping completo do AliExpress!
### Etapa 6: extraia os elementos do produto do AliExpress
Inspecione um elemento do produto para entender sua estrutura HTML:
É evidente que você pode extrair a imagem do produto, URL, nome ou título, preço e desconto.
Antes de extrair cada produto, verifique se ele está visível na janela de visualização:
```none
wait.until(EC.visibility_of(product))
```
Agora, configure seletores para extrair os dados de cada produto. Em vez de usar nomes de classe específicos que podem quebrar, use padrões como estes:
```none
# Obter imagem - procurar imagens do produto por padrões de fonte
img_element = find_element_smart(product, [
(By.XPATH, ".//img[contains(@src, 'item') or contains(@src, 'product')]"),
(By.CSS_SELECTOR, "img[src*='item']"),
(By.CSS_SELECTOR, "img[class*='image']")
])
# Obter URL - procurar links do produto
url_element = find_element_smart(product, [
(By.CSS_SELECTOR, "a[href*='item']"),
(By.XPATH, ".//a[contains(@href, 'product')]")
])
# Obter título - procurar primeiro o elemento de texto mais longo
price_element = find_element_smart(product, [
(By.CSS_SELECTOR, "*[class*='price-sale']"),
(By.CSS_SELECTOR, "*[class*='price']"),
(By.XPATH, ".//*[contains(@class, 'price')]")
])
# Obter preço - procurar símbolos/padrões de moeda
elemento_preço = find_element_smart(produto, [
(By.XPATH, ".//*[contém(texto(), '$') ou contém(texto(), 'US') ou contém(texto(), 'GHS')]"),
(By.XPATH, ".//*[contém(@class, 'preço')]")
])
# Tente obter desconto, se disponível
discount_element = find_element_smart(product, [
(By.XPATH, ".//*[contains(text(), '%') or contains(text(), 'OFF')]"),
(By.CSS_SELECTOR, "[class*='discount']")
])
```
A função `find_element()` retorna o primeiro elemento que corresponde ao seletor CSS especificado. Você pode então usar o atributo text para extrair seu conteúdo de texto.
Adicione os dados coletados à matriz de produtos e use-os para preencher um dicionário de produtos:
```none
products.append({
"image_url": img_element.get_attribute("src"),
"product_url": url_element.get_attribute("href"),
"product_title": title_element.text.strip(),
"product_price": price_element.text.strip(),
"product_discount": discount_element.text.strip() if discount_element else "N/A"
})
```
Sua lógica de extração de dados está concluída e pronta para uso.
### Etapa 7: Exporte os dados extraídos para CSV
Na sua configuração atual, os dados coletados são armazenados na matriz de produtos. Para torná-los compartilháveis e acessíveis a outras pessoas, você precisa exportá-los para um formato legível, como um arquivo CSV. Veja como você pode criar e preencher um arquivo CSV com os dados coletados:
```none
# Gravar dados em CSV
csv_file_name = "aliexpress_products.csv"
with open(csv_file_name, mode="w", newline="", encoding="utf-8") as csv_file:
fieldnames = ["image_url", "product_url", "product_title", "product_price", "product_discount"]
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
writer.writeheader()
for product in products:
writer.writerow(product)
```
Este código cria um arquivo CSV que funciona como uma planilha – cada produto recebe sua própria linha, e diferentes detalhes sobre o produto (imagem, URL, título, preço e qualquer desconto) vão para colunas separadas. Ao abrir o arquivo final `aliexpress_products.csv`, você verá todas as informações dos produtos do AliExpress coletadas organizadas em colunas.
Por último, a partir da Biblioteca Padrão do Python, importe a biblioteca [`csv`](https://docs.python.org/3/library/csv.html) em seu script:
```none
import csv
```
### Etapa 8: Junte tudo
Esta é a aparência do seu script de extração final depois de juntar todo o código:
```none
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import csv
def find_element_smart(parent, by_list):
"""Tente vários seletores até encontrar um elemento"""
para by_type, selector em by_list:
tente:
elemento = pai.find_element(by_type, selector)
se elemento.is_displayed():
retorne elemento
exceto:
continue
retorne None
# Inicialize o driver
driver = webdriver.Chrome()
wait = WebDriverWait(driver, 20)
# URL de destino
url = "https://www.aliexpress.com/w/wholesale-ergonomic-chair.html?spm=a2g0o.productlist.search.0"
driver.get(url)
# Aguardar o carregamento dos produtos iniciais
wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "div[class*='gallery']")))
# Onde armazenar os dados coletados
products = []
# Encontre os produtos usando padrões primeiro e, em seguida, recorra aos padrões de classe
seletores_de_produtos = [
(By.XPATH, "//div[.//img e .//a[contém(@href, 'item')]]"),
(By.XPATH, "//div[.//img e .//*[contém(texto(), '$')]]"),
(By.CSS_SELECTOR, "div[class*='gallery']")
]
# Aguardar e obter produtos
wait.until(EC.presence_of_all_elements_located((By.CSS_SELECTOR, "div[class*='gallery']")))
produtos_encontrados = []
para tipo_seletor, seletor em seletores_de_produtos:
tente:
elementos = esperar.até(EC.presença_de_todos_os_elementos_localizados((tipo_seletor, seletor)))
se elementos:
produtos_encontrados = elementos
break
exceto:
continuar
# Iterar sobre o produto encontrado e extrair dados dele
para produto em produtos_encontrados:
# Esperar até que o produto esteja visível e interativo
wait.until(EC.visibility_of(product))
# Obter imagem - procurar imagens do produto por padrões de fonte
img_element = find_element_smart(product, [
(By.XPATH, ".//img[contains(@src, 'item') or contains(@src, 'product')]"),
(By.CSS_SELECTOR, "img[src*='item']"),
(By.CSS_SELECTOR, "img[class*='image']")
])
# Obter URL - procurar links do produto
url_element = find_element_smart(product, [
(By.CSS_SELECTOR, "a[href*='item']"),
(By.XPATH, ".//a[contains(@href, 'product')]")
])
# Obter título - procurar primeiro o elemento de texto mais longo
title_element = find_element_smart(product, [
(By.XPATH, ".//div[string-length(text()) > 20]"),
(By.XPATH, ".//*[contains(@class, 'title')]"),
(By.CSS_SELECTOR, "[class*='name']")
])
# Obter preço
price_element = find_element_smart(product, [
(By.CSS_SELECTOR, "*[class*='price-sale']"),
(By.CSS_SELECTOR, "*[class*='price']"),
(By.XPATH, ".//*[contains(@class, 'price')]")
])
if all([img_element, url_element, title_element, price_element]):
# Obter desconto, se disponível
elemento_desconto = find_element_smart(produto, [
(By.XPATH, ".//*[contém(texto(), '%') ou contém(texto(), 'OFF')]"),
(By.CSS_SELECTOR, "[class*='desconto']")
])
products.append({
"image_url": img_element.get_attribute("src"),
"product_url": url_element.get_attribute("href"),
"product_title": title_element.text.strip(),
"product_price": price_element.text.strip(),
"product_discount": discount_element.text.strip() se discount_element, caso contrário "N/A"
})
# Salvar resultados
csv_file_name = "aliexpress_products.csv"
com open(csv_file_name, mode="w", newline="", encoding="utf-8") como csv_file:
writer = csv.DictWriter(csv_file, fieldnames=["image_url", "product_url", "product_title", "product_price", "product_discount"])
writer.writeheader()
writer.writerows(products)
driver.quit()
```
Agora, inicie o Scraper com o seguinte comando:
```none
python Scraper.py
```
O script deve ser executado com sucesso, e o arquivo `aliexpress_products.csv` deve conter os dados extraídos, conforme mostrado:
Existem várias etapas adicionais que você pode realizar após montar um script de raspagem funcional. Isso inclui automatizar o processo de execução e implementar otimizações para garantir que o Scraper continue a fornecer dados valiosos ao longo do tempo.
## Conclusão
Neste guia, você explorou o que é um Scraper do AliExpress e os tipos de dados que ele pode extrair. Você também aprendeu como criar um script Python para extrair produtos do AliExpress com o mínimo de código.
No entanto, o scraping do AliExpress apresenta vários desafios. A plataforma implementa proteções anti-bot rigorosas e usa recursos como paginação, o que adiciona complexidade ao processo de scraping. Desenvolver uma solução formidável de scraping do Alibaba pode ser bastante desafiador.
Nossa [API AliExpress Scraper](/products/web-scraper/aliexpress) oferece uma solução especializada que permitirá que você elimine esses desafios. Com chamadas de API diretas, você pode obter dados do site de destino de maneira integrada, mitigando o risco de ser bloqueado. Precisa dos dados rapidamente?
Quer experimentar nossas APIs de Scraper ou [explorar nossos Conjuntos de dados](/products/datasets)? Crie uma conta Bright Data hoje mesmo e comece seu Teste grátis!
Contate-nosTeste grátis
Índice
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Como+extrair+dados+do+AliExpress+com+Python&u=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-aliexpress) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Como+extrair+dados+do+AliExpress+com+Python&url=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-aliexpress) [ ](http://www.reddit.com/submit?title=Como+extrair+dados+do+AliExpress+com+Python&url=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-aliexpress)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI
Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.
09-Sep-2026
14 min de leitura
](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")
[Dados do site
Antonello Zanini
Technical Writer
### Scraping de Dados Multimodal com MiniMax
Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.
09-Sep-2026
5 min de leitura
](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")
[AI
Daniel Shashko
Web Data & AI Expert
### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas
As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.
06-Sep-2026
24 min de leitura
](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)