Como coletar dados do eBay em grande escala: solução de proxy completa da Massive

Jason Grad

Co-founder

February 18, 2025

O eBay é um dos maiores mercados de comércio eletrônico do mundo, com bilhões de anúncios do ebay e atraindo milhões de visitantes diários. Para empresas, os dados de produtos do eBay oferecem uma grande quantidade de dados valiosos que podem ser inestimáveis para inteligência de negócios, pesquisa de mercado e análise competitiva. No entanto, o processo de captura na web para extrair dados do eBay em grande escala apresenta desafios técnicos significativos devido aos mecanismos avançados de anti-raspagem da plataforma.

Este guia passo a passo explica como criar um web scraper do eBay usando a rede proxy da Massive para extrair dados de listagens do eBay com eficiência e minimizar o risco de bloqueio.

Sem mais delongas, vamos começar!

Por que coletar dados do eBay?

Os dados brutos do site do ebay oferecem às empresas informações valiosas que impulsionam a tomada de decisões informadas e a vantagem competitiva. Veja como os dados publicamente disponíveis do eBay estão transformando as estratégias de negócios:

Pesquisa de mercado: Ao rastrear preços, promoções e preferências dos clientes da concorrência em tempo real, você pode identificar lacunas no mercado e ajustar sua estratégia para superar os concorrentes.
Preços inteligentes: O monitoramento das flutuações de preços no eBay permite que você ajuste seus preços para se manter competitivo e, ao mesmo tempo, manter margens saudáveis. Isso é particularmente útil em mercados de rápida evolução, onde os preços mudam com frequência ou durante os picos sazonais.
Decisões de produto: Aproveite os dados de vendas e feedback do eBay para validar suas opções de produtos antes de investir em novos estoques. Ao analisar o que vende bem e entender o feedback dos clientes, você pode refinar suas ofertas de produtos e programar seus lançamentos para obter o máximo impacto.
Gerenciamento de inventário: Os dados do eBay mostram padrões de demanda claros, permitindo que você mantenha os níveis ideais de estoque. Isso ajuda você a otimizar os níveis de estoque, evitar o excesso de estoque e evitar a falta de estoque.

Evite ser bloqueado ao raspar o eBay

Construir um raspador do eBay não é tão fácil quanto parece. Aproveitar o eBay em grande escala apresenta desafios significativos devido à limitação de taxas baseada em IP, CAPTCHAs, e medidas anti-raspagem rigorosas. Quando você excede os limites de solicitação do eBay, seu IP é bloqueado ou enfrenta CAPTCHAs.

Por que você precisa de proxies para o eBay Scraping?

Ao criar um raspador do eBay para coletar dados do eBay em grande escala, os proxies não são apenas úteis, eles são essenciais. O uso de proxies permite distribuir suas solicitações em vários endereços IP, ajudando você a:

Evite ser bloqueado ou estrangulado
Mantenha velocidades de raspagem consistentes
Evite a lista negra de IP (o que pode ser uma grande dor de cabeça para corrigir)
Dimensione sua coleta de dados de forma confiável

Por que escolher proxies massivos para raspar o eBay?

Como já discutimos acima, coletar dados do eBay não é simples. Você deve considerar o uso de algum tipo de proxies e proxies residenciais são os mais preferidos. Nosso uso de proxies residenciais IPs de computadores e dispositivos móveis reais, o que os torna altamente eficazes para contornar as medidas anti-scraping do eBay. Aqui está o que oferecemos:

Alta taxa de sucesso: Nossos IPs residenciais reduzem significativamente os riscos de bloqueio, permitindo a coleta confiável de dados em grande escala.
Acesso global: colete dados sem problemas de qualquer mercado do eBay em todo o mundo usando proxies específicos da região.
Dados locais precisos: segmente cidades ou países específicos para obter informações precisas do mercado e dados de preços.
Desempenho garantido: Desfrute de taxas de sucesso de 99% com tempos de resposta rápidos e monitoramento do tempo de atividade 24 horas por dia, 7 dias por semana.
Uso flexível: escolha entre várias opções de largura de banda para atender às suas necessidades de coleta, seja em pequena escala ou em nível corporativo.

💡 Dica profissional: Sempre use proxies do seu país de destino ao acessar diferentes mercados do eBay. Isso garante que você obtenha dados reais de preços e disponibilidade locais. O Massive Proxies fornece IPs específicos de localização em todos os principais mercados do eBay para resultados consistentes.

Começando com proxies massivos

Se você é novo no Massive, inscreva-se em uma conta. Escolha um plano para suas necessidades.

Nota: Nós oferecemos um Teste gratuito de 2 GB para empresas. Para começar, preencha este formulário. Se você precisar de mais largura de banda, entre em contato com nossa equipe de vendas, e nós o ajudaremos.

Depois de se inscrever, acesse o Painel enorme para recuperar suas credenciais de proxy (nome de usuário e senha).

‍Etapas de configuração:

Visite o Início rápido seção para personalizar suas configurações de proxy:

Escolha seu protocolo preferido (HTTP, HTTPS ou SOCKS5)
Selecione entre proxies rotativos ou fixos
Defina preferências de segmentação geográfica (país, estado, cidade ou CEP)

Depois de configurado, você receberá um comando cURL pronto para uso para seu caso de uso específico.

Para recursos avançados, como segmentação com base em localização e sessões fixas, consulte o Documentação massiva. Os documentos fornecem instruções passo a passo para tirar o máximo proveito dos Massive Residential Proxies.

Com essa configuração, você pode usar Massive Proxies para coletar dados do eBay dos principais mercados, incluindo EUA, Reino Unido, Alemanha e Austrália.

Quais dados de produto você pode extrair do eBay?

Raspar o eBay pode fornecer uma grande variedade de informações sobre produtos. Aqui está uma análise abrangente dos dados disponíveis:

URL do produto: O link para a página do produto do eBay
Título: O nome do item
Subtítulo: Texto descritivo adicional
Preço atual: O preço de venda atual
Era o preço: O preço anterior (se disponível)
Desconto: A porcentagem ou o valor descontado
Disponibilidade: Quantidade disponível e status do estoque
Contagem de vendas: Número de itens vendidos
Detalhes de envio: Custo e tempo estimado de entrega
Localização: A origem do frete
Devoluções: Detalhes da política de devolução
Condição: Se o item é novo, usado ou recondicionado
Marca: Fabricante ou nome da marca
Tipo: A categoria ou o tipo de produto
Informações do vendedor:
- Nome do vendedor/loja
- Porcentagem de feedback do cliente
- Total de vendas do vendedor

Entradas de usuário necessárias

Para começar a copiar o eBay, você precisará especificar dois parâmetros principais:

País alvo: Você pode extrair dados de 10 domínios regionais do eBay:

"US": "https://www.ebay.com",
"GB": "https://www.ebay.co.uk",
"DE": "https://www.ebay.de",
"ES": "https://www.ebay.es",
"FR": "https://www.ebay.fr",
"IT": "https://www.ebay.it",
"CA": "https://www.ebay.ca",
"MX": "https://www.mx.ebay.com",
"NL": "https://www.ebay.nl",
"AU": "https://www.ebay.com.au"

‍Termos de pesquisa: Digite o que você deseja raspar (por exemplo, “cadeira reclinável”, “câmera drone”). Você pode inserir vários termos usando vírgulas.

Limite do item: (Opcional) Especifique quantos itens devem ser raspados. Ignore isso para coletar todos os dados disponíveis em todas as páginas.

Os dados extraídos serão salvos em um arquivo JSON estruturado.

Construindo um raspador de dados do eBay com proxies massivos

Este guia explora passo a passo como aproveitar o eBay em grande escala. Enquanto nos concentramos na raspagem eBay.com (Site dos EUA), os mesmos princípios se aplicam a sites do eBay específicos de outros países, com pequenos ajustes nos seletores.

Etapa #1: Configuração do projeto

Primeiro, certifique-se de ter o Python 3 instalado em seu sistema. Se não, baixe e instale.

Agora, crie um diretório para seu projeto:

mkdir ebay_scraper

Abra a pasta do projeto em seu IDE preferido (como o VS Code) e crie um arquivo chamado usa_ebay.py. Esse arquivo conterá nossa lógica de coleta para coletar dados do eBay.

Você também precisará criar um arquivo.env para armazenar suas credenciais do Massive Proxy:

PROXY_USERNAME=your_username
PROXY_PASSWORD=your_password

Agora, a estrutura do seu projeto deve ficar assim:

ebay_scraper/
├── .env
└── usa_ebay.py

‍

Etapa #2: Instalando dependências

Para coletar dados do eBay com eficiência, você precisará usar várias bibliotecas importantes:

curl_cffi: Um cliente HTTP de alto desempenho que suporta impressão digital JA3/TLS e HTTP/2
linda sopa 4: Para análise de HTML
python-dotenv: Para gerenciamento de variáveis de ambiente
arquivos aio: Para operações de arquivo assíncronas

Agora, você pode instalar essas dependências usando o pip, conforme mostrado abaixo:

pip install curl-cffi beautifulsoup4 python-dotenv aiofiles

‍

Etapa #3: Configurando proxies massivos

Esta etapa configura um proxy para ativar a segmentação geográfica, garantindo que as solicitações sejam encaminhadas por países específicos para extrair dados do eBay com precisão:

def setup_proxy(self):
    """Configure proxy settings for geotargeted requests"""
    self.proxy_host = "network.joinmassive.com:65534"
    self.username = os.getenv("PROXY_USERNAME")
    self.password = os.getenv("PROXY_PASSWORD")
    self.proxy_auth = f"{self.username}-country-{self.domain}:{self.password}"

‍

Etapa #4: Solicitar configuração

Configurar solicitações HTTP usando o curl_cffi biblioteca. A configuração envolve dois métodos:

_get_proxy_config: formata as credenciais de autenticação do proxy e os detalhes do host
_fazer_solicitação: gerencia a execução de solicitações HTTP com recursos como limitação de taxa e emulação de navegador

def _get_proxy_config(self) -> Dict[str, str]:
    """Generate proxy configuration dictionary"""
    return {"https": f"http://{self.proxy_auth}@{self.proxy_host}"}


async def _make_request(self, session: AsyncSession, url: str, page_type: str):
    """Make HTTP request with proxy and browser emulation"""
    async with self.semaphore:
        response = await session.get(
            url,
            proxies=self._get_proxy_config(),
            impersonate="chrome124",
            timeout=self.page_timeout,
        )

‍

Etapa #5: Processando páginas de pesquisa

Este método _processar_página de pesquisa gerencia o processamento de páginas de resultados de pesquisa individuais. Ele usa uma sessão assíncrona, um número de página e um termo de pesquisa como entradas. Veja como funciona:

A função constrói o URL de pesquisa criando parâmetros de consulta que incluem:

A palavra-chave de pesquisa (_agora)
Número da página (_png)
Configuração de itens por página (_porco) otimizado para 240 itens

Em seguida, ele faz uma solicitação assíncrona usando o método de solicitação configurado anteriormente. Se o conteúdo for recuperado com sucesso, ele o analisará usando Sopa bonita com o lxml analisador. Em seguida, ele extrai os URLs do produto do HTML analisado e processa os URLs do produto extraídos em lotes.

async def _process_search_page(
    self, session: AsyncSession, page_num: int, search_term: str
):
    """Process a single search results page"""
    try:
        params = {
            "_nkw": search_term,
            "_pgn": page_num,
            "_ipg": 240,  # Maximum items per page
        }
        url = self.base_url + urlencode(params)

        status_code, html_content = await self._make_request(session, url, "search")
        if html_content:
            soup = BeautifulSoup(html_content, "lxml")
            urls = self._extract_product_urls(soup)

            logger.info(f"Found {len(urls)} products on page {page_num}")
            return await self._process_product_batch(session, urls)
    except Exception as e:
        logger.error(f"Error processing page {page_num}: {str(e)}")
        return False, False

‍

Etapa #6: Extraindo URLs de produtos

Esse método realiza a tarefa crucial de extrair URLs de produtos das páginas de resultados de pesquisa. Veja como funciona a extração do URL do produto:

O _extrair urls do produto O método aceita um objeto BeautifulSoup que contém o conteúdo HTML analisado e retorna uma lista de URLs de produtos válidos. Ele implementa uma abordagem focada na extração de URL:

Usa o seletor CSS a.s-item__link para encontrar todos os elementos do link do produto
Itera por meio de cada elemento de link para extrair o atributo href
Valida URLs verificando a presença de item/ no caminho do URL
Cria uma lista filtrada contendo somente URLs de produtos válidos

def _extract_product_urls(self, soup: BeautifulSoup) -> List[str]:
    """Extract product URLs from search results page"""
    urls = []
    for link in soup.select("a.s-item__link"):
        url = link.get("href", "")
        if url and "itm/" in url:
            urls.append(url)
    return urls

‍

Etapa #7: Raspar os detalhes do produto

O método _extract_product_details extrai sistematicamente as informações do produto das páginas de produtos do eBay. Ele processa um objeto BeautifulSoup e retorna um objeto ProductDetails contendo dados estruturados.

def _extract_product_details(self, soup: BeautifulSoup, url: str) -> ProductDetails:
    """Extract all product details from page"""
    details = ProductDetails(url=url)

    try:
        details.store_info = DataExtractor.extract_store_info(soup)

        # Title section
        if title_div := soup.select_one("div.x-item-title"):
            if title := title_div.select_one("h1.x-item-title__mainTitle span"):
                details.title = title.text.strip()
            if subtitle := title_div.select_one("div.x-item-title__subTitle span"):
                details.subtitle = subtitle.text.strip()

        # Price section
        if price_section := soup.select_one("div.x-price-section"):
            if current_price := price_section.select_one("div.x-price-primary span"):
                details.current_price = current_price.text.strip()
            if was_price := price_section.select_one(
                "span.ux-textspans--STRIKETHROUGH"
            ):
                details.was_price = was_price.text.strip()

            # Discount calculation
            discount = None
            if emphasis_discount := price_section.select_one(
                "span.ux-textspans--EMPHASIS"
            ):
                discount = emphasis_discount.text.strip()
            elif secondary_discount := price_section.select_one(
                "span.ux-textspans--SECONDARY"
            ):
                discount = secondary_discount.text.strip()
            if discount and (percentage_match := re.search(r"(\d+)%", discount)):
                details.discount = percentage_match.group(1) + "%"

        # Quantity section
        if quantity_div := soup.select_one("div.x-quantity__availability"):
            spans = quantity_div.select("span.ux-textspans")
            if spans:
                details.availability = spans[0].text.strip()
                if len(spans) > 1:
                    details.sold_count = spans[1].text.strip()

        # Shipping section
        if shipping_div := soup.select_one("div.d-shipping-minview"):
            if shipping_section := shipping_div.select_one(
                "div.ux-labels-values__values-content"
            ):
                details.shipping, details.location = (
                    DataExtractor.extract_shipping_info(shipping_section)
                )

        # Returns section
        if returns_div := soup.select_one("div.x-returns-minview"):
            if returns_section := returns_div.select_one(
                "div.ux-labels-values__values-content"
            ):
                details.returns = DataExtractor.extract_returns_info(returns_section)

        # Additional details
        if condition_span := soup.select_one(
            "div.x-item-condition-max-view .ux-section__item > span.ux-textspans"
        ):
            details.condition = condition_span.text.strip().split(".")[0] + "."
        if (brand_dl := soup.select_one("dl.ux-labels-values--brand")) and (
            brand_value := brand_dl.select_one("dd .ux-textspans")
        ):
            details.brand = brand_value.text.strip()
        if (type_dl := soup.select_one("dl.ux-labels-values--type")) and (
            type_value := type_dl.select_one("dd .ux-textspans")
        ):
            details.type = type_value.text.strip()
    except Exception as e:
        logger.error(f"Error extracting details from {url}: {str(e)}")
    return details

‍

Etapa #8: Manipulando a paginação

O _tem_página_próxima O método usa duas abordagens diferentes para verificar a paginação:

Primeiro, ele procura um link para a próxima página pesquisando por uma tag âncora com type="próximo” atributo. Se este link existir e tiver um valor válido href atributo, ele confirma a presença de uma próxima página.
Como mecanismo de fallback, ele também verifica o próximo elemento de botão. Isso procura um botão com type="próximo” e verifica se não está desativado verificando a com deficiência ariana atributo. Se o botão existir, mas não estiver desativado, isso indica que há mais páginas disponíveis.

def _has_next_page(self, soup: BeautifulSoup) -> bool:
    """Determine if there is a next page of results"""
    next_link = soup.select_one('a[type="next"]')
    if next_link and next_link.get("href"):
        return True
    next_button = soup.select_one('button[type="next"]')
    return not (next_button and next_button.get("aria-disabled") == "true")

‍

Etapa #9: Armazenamento de dados

Por fim, salve os dados extraídos em um arquivo JSON:

class FileHandler:
    """Handle file operations with error handling and backups"""

    @staticmethod
    async def save_to_file(filename: str, data: Dict):
        """Save data with automatic backup creation"""
        temp_file = f"{filename}.temp"
        backup_file = f"{filename}.backup"

        try:
            # Create directory structure
            os.makedirs(os.path.dirname(filename), exist_ok=True)

            # Save to temporary file
            async with aiofiles.open(temp_file, "w", encoding="utf-8") as f:
                await f.write(json.dumps(data, indent=2, ensure_ascii=False))

            # Create backup of existing file
            if os.path.exists(filename):
                os.replace(filename, backup_file)

            # Replace with new file
            os.replace(temp_file, filename)

            logger.info(f"Data successfully saved to {filename}")
        except Exception as e:
            logger.error(f"Error saving data: {str(e)}")
            raise

‍

Etapa #10: Execute o raspador

A implementação completa para agrupar o eBay em 10 domínios de mercado está disponível em GitHub. O raspador extrai dados do produto e gera um arquivo JSON estruturado, com cada entrada contendo:

{
    "url": "https://www.ebay.com/itm/294701001393",
    "title": "Manual Recliner Armchair PU Sofa Chair w/ Adjustable Leg Rest & 135° Reclining",
    "subtitle": "Comfortable & Easy to Clean & 360° Swivel & Steel Frame",
    "current_price": "US $228.99",
    "was_price": "US $651.99",
    "discount": "65%",
    "availability": "More than 10 available",
    "sold_count": "93 sold",
    "shipping": "Free shipping - Arrives by Christmas",
    "location": "Wilsonville, Oregon, United States",
    "returns": "30 days returns Buyer pays for return shipping",
    "condition": "A brand-new, unused, unopened, undamaged item in its original packaging (where packaging is applicable).",
    "brand": "Homcom",
    "type": "Recliner Armchair",
    "store_info": {
        "name": "Aosom-Direct",
        "feedback": "97.5% positive feedback",
        "sales": "482K items sold",
    },
}

‍

Conclusão

Este guia mostrou como criar um raspador do eBay que funciona em diferentes mercados do eBay. Ao usar proxies residenciais, você pode coletar dados precisos do produto e, ao mesmo tempo, minimizar os riscos de bloqueio. A abordagem que abordamos possibilita a coleta confiável de dados dos vários sites regionais do eBay.

Se precisar de mais detalhes sobre a configuração do proxy ou as melhores práticas, você encontrará tudo na documentação.

Pronto para começar? Inscreva-se hoje mesmo no Massive Proxies 🚀

Como coletar dados de produtos da Amazon usando proxies massivos

Raspe a Amazon como um profissional! Aprenda a coletar dados de produtos da Amazon usando proxies massivos para evitar bloqueios e obter informações precisas sobre preços e mercado.