How to Scrape eBay Using Python (2025 Update)

<li class="s-item">
  <a class="s-item__link" href="https://www.ebay.com/itm/example">
    <span class="s-item__title">Product Title</span>
    <span class="s-item__price">$499.99</span>
  </a>
</li>

import re
from bs4 import BeautifulSoup

HIDDEN_STYLE = re.compile(r"(?:display\s*:\s*none|visibility\s*:\s*hidden)", re.I)
NOISE_TEXT = {"shop on ebay", "shop now"}

def is_hidden(node):
    """Return True when a node or one of its parents is hidden."""
    for current in [node, *node.parents]:
        if current.has_attr("hidden"):
            return True
        if current.get("aria-hidden", "").lower() == "true":
            return True
        if HIDDEN_STYLE.search(current.get("style", "")):
            return True
    return False

def clean_result_card(card):
    """Remove presentation-only nodes without changing the source document."""
    for node in list(card.find_all(True)):
        if is_hidden(node):
            node.decompose()
            continue

        if node.name in {"a", "button"}:
            label = node.get_text(" ", strip=True).casefold()
            if label in NOISE_TEXT:
                node.decompose()

def extract_visible_items(html):
    soup = BeautifulSoup(html, "html.parser")
    items = []

    for card in soup.select("li.s-item"):
        clean_result_card(card)
        title_node = card.select_one(".s-item__title")
        price_node = card.select_one(".s-item__price")
        link_node = card.select_one("a.s-item__link")

        title = title_node.get_text(" ", strip=True) if title_node else ""
        price = price_node.get_text(" ", strip=True) if price_node else ""
        url = link_node.get("href", "") if link_node else ""

        if title and title.casefold() not in NOISE_TEXT:
            items.append({"title": title, "price": price, "url": url})

    return items

html = open("ebay-results.html", encoding="utf-8").read()
for item in extract_visible_items(html):
    print(item)

<li class="s-item">
  <div class="s-item__image-section">
    <img class="s-item__image-img" src="image.jpg" />
  </div>
  <a class="s-item__link" href="https://www.ebay.com/itm/abc123">
    <h3 class="s-item__title">Apple iPhone 13 Pro Max</h3>
    <span class="s-item__price">$799.00</span>
    <span class="s-item__shipping">+$12.99 shipping</span>
  </a>
</li>

<li class="s-item s-item--sponsored">
  <a class="s-item__link" href="https://www.ebay.com/itm/xyz789">
    <span class="s-item__title">Samsung Galaxy S22 Ultra 5G</span>
    <span class="s-item__price">$999.00</span>
    <span class="s-item__subtitle">Sponsored</span>
  </a>
</li>

<li class="s-item s-item--explore-more">
  <span class="s-item__title">Explore similar items</span>
</li>

pip install requests beautifulsoup4

import requests
from bs4 import BeautifulSoup
from urllib.parse import quote_plus

def scrape_ebay(query):
    url = f"https://www.ebay.com/sch/i.html?_nkw={quote_plus(query)}"
    headers = {
        "User-Agent": "Mozilla/5.0"
    }

    try:
        response = requests.get(url, headers=headers, timeout=30)
        response.raise_for_status()
    except requests.RequestException as exc:
        raise RuntimeError(f"Could not fetch eBay results: {exc}") from exc

    soup = BeautifulSoup(response.text, "html.parser")
    results = []

    for item in soup.select(".s-item"):
        title = item.select_one(".s-item__title")
        price = item.select_one(".s-item__price")
        link = item.select_one(".s-item__link")
        if not title or not price or not link:
            continue
        results.append({
            "title": title.get_text(strip=True),
            "price": price.get_text(strip=True),
            "url": link.get("href")
        })

    return results

if __name__ == "__main__":
    items = scrape_ebay("iphone 14 pro")
    for item in items[:10]:
        print(item)

pip install playwright
playwright install

from urllib.parse import quote_plus
from playwright.sync_api import sync_playwright

def scrape_ebay_playwright(
    query,
    card_selector=".s-item",
    title_selector=".s-item__title",
    price_selector=".s-item__price",
    link_selector=".s-item__link",
):
    url = f"https://www.ebay.com/sch/i.html?_nkw={quote_plus(query)}"

    with sync_playwright() as pw:
        browser = pw.chromium.launch(headless=True)
        try:
            page = browser.new_page()
            page.goto(url, wait_until="domcontentloaded")
            page.wait_for_selector(card_selector)
            cards = page.locator(card_selector)
            results = []

            for i in range(cards.count()):
                card = cards.nth(i)
                if not card.locator(title_selector).count():
                    continue
                results.append({
                    "title": card.locator(title_selector).inner_text().strip(),
                    "price": (card.locator(price_selector).inner_text().strip()
                              if card.locator(price_selector).count() else None),
                    "url": card.locator(link_selector).get_attribute("href"),
                })
            return results
        finally:
            browser.close()

items = scrape_ebay_playwright("macbook pro")
for item in items[:10]:
    print(item)

pip install pandas

import pandas as pd

df = pd.DataFrame(items)
df.to_csv("ebay_results.csv", index=False)

import os
import random
import time
from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

SEARCH_URL = "https://www.ebay.com/sch/i.html?_nkw=mechanical+keyboard"
PROXIES = [
    value.strip()
    for value in os.environ.get("EBAY_PROXIES", "").split(",")
    if value.strip()
]

def fetch_results(proxy, attempts=2):
    with sync_playwright() as p:
        for attempt in range(attempts):
            browser = None
            try:
                launch_options = {"headless": True}
                if proxy:
                    launch_options["proxy"] = {"server": proxy}

                browser = p.chromium.launch(**launch_options)
                context = browser.new_context(
                    locale="en-US",
                    user_agent=(
                        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                        "AppleWebKit/537.36 (KHTML, like Gecko) "
                        "Chrome/131.0.0.0 Safari/537.36"
                    ),
                )
                page = context.new_page()
                stealth_sync(page)
                response = page.goto(
                    SEARCH_URL,
                    wait_until="domcontentloaded",
                    timeout=30_000,
                )

                if response is None or response.status >= 400:
                    raise RuntimeError(
                        f"request failed with status {response.status if response else 'unknown'}"
                    )

                page.wait_for_selector(".s-item", timeout=15_000)
                results = []
                for item in page.locator(".s-item").all():
                    title = item.locator(".s-item__title").inner_text().strip()
                    link = item.locator(".s-item__link").get_attribute("href")
                    price_locator = item.locator(".s-item__price")
                    price = (
                        price_locator.inner_text().strip()
                        if price_locator.count()
                        else None
                    )
                    if title and link:
                        results.append(
                            {"title": title, "price": price, "url": link}
                        )
                return results
            except Exception:
                if attempt + 1 == attempts:
                    raise
                time.sleep(2 ** attempt)
            finally:
                if browser:
                    browser.close()

if not PROXIES:
    PROXIES = [None]

proxy = random.choice(PROXIES)
for record in fetch_results(proxy):
    print(record)