How to Scrape eBay using Python (2026)

eBay is one of the largest eCommerce platforms in the world. Scraping publicly available data from eBay offers many benefits, like price monitoring and product trends.

In this detailed blog, you’ll learn how to scrape eBay with Python, the challenges faced while scraping eBay, and how to use HasData API to extract data from any website with a simple API call without the need for a proxy.

Introduction to eBay Data Scraping

eBay is one of the most popular choices for e-commerce data extraction because it provides rich information for analysis and decision-making. eBay’s business model differs from a standard retail platform (like Amazon) by its auction feature, where sellers list products at low prices and customers bid, leading to dynamic price changes.

Sellers can extract valuable data from eBay to improve their offerings and gain a competitive edge in various ways, such as:

• Price Monitoring: In e-commerce, prices fluctuate constantly, making it crucial to access competitor data on eBay to offer the most competitive pricing. Scraping this data can be incredibly valuable. It can reveal the current price range for your target products, allowing you to make informed decisions about your pricing.
• Market Research: E-commerce data offers valuable insights into market trends, consumer preferences, and buying patterns. Analyzing your customers’ shopping patterns can help you better predict their future purchases and identify broader market trends. Additionally, tracking customer locations can show where your products are performing well.
• Competitor Analysis: By gathering information about your competitors’ product prices, discounts, and promotions, you can make data-driven decisions about your product offerings. Consider reducing your prices to attract customers or bidders if many similar products are available.
• Sentiment Analysis: Reviews and ratings offer valuable insights into customer satisfaction and product feedback. By scraping them, you can understand your customers’ satisfaction and identify opportunities to enhance your product or service.

The official route covers less than most guides describe, because they describe it as it was. eBay decommissioned the Finding API and the Shopping API in early 2025 and points developers at the Browse API in their place, so the two APIs those guides recommend no longer answer. The Browse API searches listings by keyword, category, GTIN, product, charity, compatibility criteria or image. It authenticates with an application access token from the client credentials grant rather than a plain developer key, the default allowance is 5,000 calls a day across all its methods, and eBay’s own call-limits table notes that the Buy APIs need an additional licence on top of a developer account.

Structure of an eBay Page

eBay’s website includes both product and search results pages. A standard eBay product page, such as the Apple MacBook page shown below, contains useful information that can be scraped. This information contains the product title, description, image, rating, price, availability status, customer reviews, shipping cost, and delivery date.

When you search for a keyword like “MacBook” in the search bar, you’ll be directed to a search results page like the one below. You can extract all the listed products on this page, including their titles, product images, ratings, reviews, and more.

Here, you can see thousands of products that can be extracted, providing access to a wealth of information.

The rest of this guide walks through extracting that data from an eBay page with Python.

Setting Up Your Python Environment for Scraping

To set up your Python environment for web scraping, you must meet some system requirements and install the required libraries.

Prerequisites

Before starting, you need:

1. Install Python 3.11 or newer from the official Python website. That is the floor current pandas builds against.
2. Pick a code editor, such as Visual Studio Code, PyCharm, or Jupyter Notebook.

Next, create a directory called ebay-scraper, open it in your editor, and add a file named scraper.py.

Install Required Libraries

To perform web scraping with Python, you must install some essential libraries: Requests, BeautifulSoup, and Pandas.

• Pandas builds a DataFrame from the extracted data and writes it to a CSV file. Current releases need Python 3.11 or newer.
• Requests sends the HTTP requests and returns the HTML of a page. Current releases need Python 3.10 or newer.
• BeautifulSoup extracts data from the raw HTML content using tags, attributes, classes, and CSS selectors.

pip install beautifulsoup4 requests pandas

Those three cover the whole tutorial: requests for the fetch, beautifulsoup4 for the parse, pandas for the CSV.

What to Expect Before You Write the Scraper

A plain requests.get on a listing URL doesn’t return the listing. What comes back is a 2 KB error page carrying noindex,nofollow, so the code in the next sections assumes a client that renders the page and reaches eBay from a residential address. Everything below is about the markup once you have the real page in hand.

The rest of what breaks a run is ordinary scraping work with nothing eBay-specific about it. Requests from datacenter ranges get refused far more often than residential ones. A long run drifts as the session ages, so the later pages aren’t gathered under the same conditions as the first ones. Result pages are numbered through the _pgn parameter, and reading the “next” link off the page is steadier than counting pages yourself. eBay’s terms of service govern what you may do with what you collect.

The markup itself costs more time than the blocking does. Roughly one card in forty on a results page is a “Shop on eBay” placeholder with a fake item id, which becomes a row in your CSV with no listing behind it unless you filter it out. Several class names that look like the obvious choice match more than once per card, which doubles one column and pushes it out of line with the others. Both are handled in the code below.

Scraping eBay Product Page

Scraping a page involves understanding its structure, downloading the raw HTML content, parsing HTML content to extract product details, and then storing the data for further analysis.

Analyzing the eBay Product Page

A product page contains various data elements that we can extract. We’ll scrape seven key attributes from the page, including:

• Images of the product
• Product Title
• Price
• Original price
• Discount
• Seller feedback rating
• Shipping charges

An eBay product page URL is https://www.ebay.com/itm/<ITM_ID>, where the item id is the unique identifier for one listing. Take the id from any listing you want to scrape. Listings expire, so an id copied from a guide is usually gone by the time you run the code, while one copied from a current search result works. The screenshots below come from one such listing.

Downloading and Parsing the Page

requests.get() takes the listing URL built from the item id and returns the page. raise_for_status turns a refused response into an exception, so an error page never reaches the parser as if it were data. Passing response.text to the BeautifulSoup() constructor with the ‘html.parser’ backend builds the Document Object Model (DOM) that everything below reads from.

url = f"https://www.ebay.com/itm/{item_id}"
response = requests.get(url)
response.raise_for_status()

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

find() and find_all() navigate the parse tree by tag and attribute. select_one() and select() take CSS selectors, and that’s the pair every extraction from here on uses.

Extracting Key Product Data

Each of the seven attributes comes out with its own selector, starting with the title.

Extract Product Title

The title is stored within the h1 tag with the class x-item-title__mainTitle. Within this h1 tag, there’s a span tag with two class names. We’ll use the .ux-textspans--BOLD class name to extract the title text. Therefore, the final selector for extracting the title is .x-item-title__mainTitle .ux-textspans--BOLD.

select_one returns the first element matching the selector, and the result goes into an item_data dictionary that collects all seven attributes. The guard matters on every field, because select_one answers with None when the layout moves and reading .text off None raises.

Extract Current Price

The price is located within a div tag with the class name x-price-primary. Inside this div tag, a span tag with the class name ux-textspans contains the price. To target this element using CSS accurately, the correct selector would be .x-price-primary .ux-textspans.

Prices arrive as text with the currency attached rather than as a number, so anything arithmetic has to parse the amount out of the string first.

Extract Actual Price

The strikethrough value indicates the actual price. This value can be easily extracted using the span tag class ux-textspans--STRIKETHROUGH.

The strikethrough shows up only on discounted listings, so this field is empty on most items.

Extract Saving/Discount

eBay no longer prints the saving as an element of its own. What the page carries is the previous price in the strikethrough span you just read, so the discount comes from comparing that with the current price. .ux-textspans--EMPHASIS still resolves on most listings, but it holds badges like “Most popular” rather than a percentage.

A to_amount helper strips everything but digits and the decimal point out of each price string and returns a float, and the saving is the difference when both parse and the older one is larger. Deriving it this way keeps the field working whether or not eBay labels the discount on the page.

Extract Shipping Price

The shipping price is located within a span tag with the class ux-textspans--BOLD. Notably, this span tag is nested within various div tags, but we’ll focus on the parent div tag that has the class ux-labels-values--shipping, as this div tag appears to have a unique class name. The scraping process involves these two steps:

1. Use soup.find('div', class_='ux-labels-values--shipping') to find the div tag with the specified class name.
2. Apply .find('span', class_='ux-textspans--BOLD').text to locate and extract the text content of the first matching span element with the class ux-textspans--BOLD within the identified div tag.

A missing shipping block means free shipping rather than missing data, which is why the fallback here is the string Free Shipping rather than None.

Extract Seller Feedback

The seller feedback rating is in an element carrying the data-testid attribute x-sellercard-atf__data-item, inside a container with the class x-sellercard-atf__data-item-wrapper.

The li and the anchor are gone from that wrapper, so the selector stops at the attribute: .x-sellercard-atf__data-item-wrapper [data-testid="x-sellercard-atf__data-item"]. The first match holds the feedback percentage.

The first match holds the feedback percentage, which reads like 99.5% positive.

Extract Product Images

All of the images are located within individual button tags that share the common class name ux-image-grid-item. The parent container for these button tags is a div tag with the class ux-image-grid-container.

To access the images, follow these steps:

1. Locate the div tag using the find method.
2. Apply the select method with the CSS selector .ux-image-grid-item img to retrieve a list of all matching image elements.

Reading img["src"] only when the attribute is present skips the grid entries that carry no URL of their own.

Export Data to JSON

Everything is now in the item_data dictionary, and json.dump writes it out with indent=4 so the file stays readable. The result looks like this.

Complete Code

Below is the complete code for the product data extraction. All you need is the item ID.

import json
import re

import requests
from bs4 import BeautifulSoup

def to_amount(text):
    digits = re.sub(r"[^\d.]", "", text or "")
    return float(digits) if digits else None

def fetch_ebay_item_info(item_id):
    url = f"https://www.ebay.com/itm/{item_id}"

    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an exception for bad requests
    except requests.exceptions.RequestException as e:
        print(f"Error: Unable to fetch data from eBay ({e})")
        return None
    soup = BeautifulSoup(response.text, "html.parser")

    item_data = {}

    try:
        current_price_element = soup.select_one(".x-price-primary .ux-textspans")

        current_price = (current_price_element.text if current_price_element else "Not available")

        original_price_element = soup.select_one(".ux-textspans--STRIKETHROUGH")

        original_price = (original_price_element.text if original_price_element else "Not available")

        was, now = to_amount(original_price), to_amount(current_price)

        savings = round(was - now, 2) if was and now and was > now else "Not available"

        shipping_parent_element = soup.find("div", class_="ux-labels-values--shipping")

        shipping_info = ("Free Shipping" if not shipping_parent_element else shipping_parent_element.find("span", class_="ux-textspans--BOLD").text)

        seller_feedback_element = soup.select_one('.x-sellercard-atf__data-item-wrapper [data-testid="x-sellercard-atf__data-item"]')
        seller_feedback = (seller_feedback_element.text if seller_feedback_element else "Not available")

        item_title_element = soup.select_one(".x-item-title__mainTitle .ux-textspans--BOLD")
        item_title = item_title_element.text if item_title_element else "Not available"

        image_grid_container = soup.find("div", class_="ux-image-grid-container")
        image_links = []

        if image_grid_container:
            img_elements = image_grid_container.select(".ux-image-grid-item img")
            image_links = [img["src"] for img in img_elements if "src" in img.attrs]
        item_data["Title"] = item_title
        item_data["Current Price"] = current_price
        item_data["Original Price"] = original_price
        item_data["Savings"] = savings
        item_data["Shipping Price"] = shipping_info
        item_data["Seller Feedback"] = seller_feedback
        item_data["Images"] = image_links

        return item_data
    except Exception as e:
        print(f"Error: Unable to parse eBay data ({e})")
        return None

def save_to_json(item_data, filename="product_info.json"):
    if item_data:
        with open(filename, "w") as file:
            json.dump(item_data, file, indent=4)
            print(f"Success: eBay item information saved to {filename}")

def main():
    item_id = input("Enter the eBay item ID: ")
    item_info = fetch_ebay_item_info(item_id)

    if item_info:
        save_to_json(item_info)

if __name__ == "__main__":
    main()

Run it, give it an item id, and it writes that listing to a JSON file.

Reading the Structured Data First

Plenty of eBay listings publish a Product block in application/ld+json, and where it exists it carries most of what the selectors above dig out of the DOM.

import json

def product_schema(soup):
    for tag in soup.select('script[type="application/ld+json"]'):
        try:
            payload = json.loads(tag.string or "")
        except (json.JSONDecodeError, TypeError):
            continue
        for block in (payload if isinstance(payload, list) else [payload]):
            if block.get("@type") == "Product":
                return block
    return None

Picking by @type matters more than it looks. A listing page carries several of these blocks and the set changes between listings, so one item answered with ItemPage and Product while another carried a BreadcrumbList and an object that parses to nothing. Code that grabs the first block gets the category path on half the pages it visits.

Here is where each field lives, next to the selector the sections above use for the same value.

Prices are the reason to try this route first. offers.price arrives as "249.0" and goes straight into float(), where the same number in the DOM reads $249.00 and needs the currency stripped before you can do arithmetic on it.

Some fields still need the DOM. mpn and gtin13 came back as “Does Not Apply” on the listing above, since sellers fill those in by hand and most don’t bother, and there’s no seller rating in the block at all, so feedback still comes from .x-sellercard-atf__data-item-wrapper. Listings that skip the Product block entirely, and the search results page, which carries no structured data of any kind, are why the selector path stays in the script as the fallback rather than as the alternative.

Scraping eBay Search

When you search for a keyword, eBay automatically redirects you to a specific URL containing your search results. For example, searching for ‘kubernetes cluster’ takes you to a URL similar to https://www.ebay.com/sch/i.html?_nkw=kubernetes+cluster&_sacat=0.

This URL uses several parameters to define your search query. Here are some of them:

• _nkw: The search keyword itself.
• _sacat: Any category restriction you applied.
• _sop: The chosen sorting type, like “best match” or “newly listed.”
• _pgn: The current page number of the search results.
• _ipg: The number of listings displayed per page (defaults to 60).

You’ll get several results for the search keyword. To successfully scrape the data, you have to go through all listings on the page and handle the pagination until you reach the last page.

eBay Listings

A search result page puts every listing in its own li, and inside each one the card the parser wants is a div with the class su-card-container. Stripped of the tracking attributes, one card looks like this.

<li class="s-card s-card--horizontal">
  <div class="su-card-container su-card-container--horizontal">
    <div class="su-card-container__header">
      <a class="s-card__link" href="https://www.ebay.com/itm/235837179895">
        <div class="s-card__title">13" Apple MacBook Air 128GB SSD 8gb 2.7Ghz i5</div>
      </a>
    </div>
    <div class="s-card__attribute-row">
      <span class="su-styled-text s-card__price">$249.00</span>
    </div>
  </div>
</li>

soup.select("div.su-card-container") returns every card as a list, and each one goes to an extract_product_details function. The title is in a div with the class s-card__title and the price in a span with the class s-card__price. The link to the listing is .su-card-container__header a.s-card__link. .s-card__link on its own matches twice in every card, so a list built on it comes back at double length and stops lining up with the titles, and the header alone is not enough either, because a card showing a star rating puts a second anchor inside it. Prices behave the same way. A card advertising a range carries three s-card__price spans rather than one, the low value, the word “to” and the high value. None of that matters while you read one card at a time, and all of it matters below, where the selectors run against the whole page at once.

Inside extract_product_details, select_one on each of those three selectors returns the element for that card, or None for anything the card doesn’t carry.

Seller name, shipping cost and listing date each had their own class on the old card markup. The results page no longer carries them, so those fields come from the item page instead.

Handling Pagination

A single page needs nothing beyond the loop above. eBay spreads results over numbered pages, though, and the page number rides in the URL. You can easily observe how the URL changes by clicking “Next”: the _pgn parameter simply increments by one.

To handle pagination, we can implement a while loop that continues until no next page is available. After scraping each page, you need to extract the URL of the next page. Below is a rough code snippet:

def extract_page_data(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, "html.parser")

    products = [
        extract_product_details(item) for item in soup.select("div.su-card-container")
    ]

    next_page_button = soup.select_one("a.pagination__next")
    next_page_url = next_page_button["href"] if next_page_button else None

    return products, next_page_url

while current_url:
    products_on_page, next_page_url = extract_page_data(current_url)
    current_url = next_page_url

The above code snippet uses CSS selectors to find the first anchor element with the class pagination__next, which typically represents the “next page” button. If such a button is found, it extracts the value of the href attribute.

Every page the loop walks ends up in one CSV file.

Complete Code

The script takes a search query and a sorting preference (‘best_match’, ‘ending_soonest’ or ‘newly_listed’), walks the result pages, and writes what it finds to a CSV. The last filter drops the “Shop on eBay” placeholder cards, which carry a fake item id and would otherwise land in the file as rows with no listing behind them.

import os

import requests
from bs4 import BeautifulSoup
import pandas as pd
from urllib.parse import urlencode

def extract_product_details(item):
    title = item.select_one(".s-card__title")
    price = item.select_one(".s-card__price")
    url = item.select_one(".su-card-container__header a.s-card__link")

    return {
        "Title": title.text.strip() if title else "Not available",
        "Price": price.text.strip() if price else "Not available",
        "URL": url["href"].split("?")[0] if url else "Not available",
    }

def extract_page_data(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, "html.parser")

    products = [
        extract_product_details(item) for item in soup.select("div.su-card-container")
    ]

    next_page_button = soup.select_one("a.pagination__next")
    next_page_url = next_page_button["href"] if next_page_button else None

    return products, next_page_url

def write_to_csv(products, filename="product_info.csv"):
    df = pd.DataFrame(products)
    mode = "a" if os.path.exists(filename) else "w"
    df.to_csv(filename, index=False, header=(mode == "w"), mode=mode)
    print(f"Data has been written to {filename}")

def make_request(query, sort, items_per_page=60):
    base_url = "https://www.ebay.com/sch/i.html?"
    query_params = {
        "_nkw": query,
        "_ipg": items_per_page,
        "_sop": SORTING_MAP[sort],
    }
    return base_url + urlencode(query_params)

def scrape_ebay(search_query, sort):
    current_url = make_request(search_query, sort, 240)
    total_products = []

    while current_url:
        products_on_page, next_page_url = extract_page_data(current_url)
        total_products.extend(products_on_page)
        current_url = next_page_url
    total_products = [
        product for product in total_products if "Shop on eBay" not in product["Title"]
    ]
    write_to_csv(total_products)

SORTING_MAP = {
    "best_match": 12,
    "ending_soonest": 1,
    "newly_listed": 10,
}

user_search_query = input("Enter eBay search query: ")
sort = input("Choose one ('best_match', 'ending_soonest', 'newly_listed'): ")
scrape_ebay(user_search_query, sort)

The script asks for a query and a sort order, walks every result page, and appends each one to product_info.csv.

Scraping eBay with HasData API

Let’s see how easily the web scraping API can extract product information from e-commerce websites with just a simple API call without the need for a proxy.

To get started, you need to get an API key. You can find it in your account after signing up on HasData. In addition, you’ll receive 1,000 free credits when you register to test our features.

Advantages of Using HasData for eBay Scraping

eBay, like most online platforms, has a negative view of bot scraping. Scraping large amounts of data in a short period of time can lead to increased website traffic, which can impact performance and availability. This can slow down response times for other users and lead to lost potential buyers. While not all scrapers harm the site during data collection, eBay may take steps to limit such bots if they are detected.

The practical effect on a scraper is the one this guide opened with. The fetch has to render the page and reach eBay from a residential address, and both of those are infrastructure rather than parsing code.

That infrastructure is what a scraping API supplies. The rest of this section rewrites the same scraper against HasData’s web scraping API, which maintains the proxy pool and the residential exits, renders the page, and returns either the HTML or the fields named in the extract rules.

Implementing HasData API in Your Project

HasData lets users directly obtain targeted data in JSON format, simplifying the data extraction process and eliminating the need for HTML parsing. Here are the steps for implementing HasData API in your project:

1. Specify the HasData API URL.
2. Define the payload, which carries the request data in JSON format.
   • The target URL is the website address you want to scrape.
   • The extraction rules say how to reach each element with a CSS selector. For example, {"Title": ".product-title-css-selector"} pulls the title out of the element that selector matches, and the same form covers price, seller, shipping cost and the rest.
   • The headers carry your API key for authentication.
3. Send a POST request with the API URL, headers, and payload.
4. Read the response, which holds every data point the extraction rules named.

Nothing here parses HTML. You choose a name for each data point and give the CSS selector that reaches it, and the response comes back as JSON with those names as keys.

The rules for this scraper map Title to .s-card__title, Price to .s-card__price:first-child, URL to .su-card-container__header a.s-card__link @href, and next to a.pagination__next @href. The @href suffix asks for the attribute rather than the text, and :first-child on the price is what keeps a range card from answering with three values where every other column answers with one. The response arrives under extractedData, keyed by the names you chose.

Here’s the complete code for implementing the HasData API in your project.

import json
import os

import requests
import pandas as pd
from urllib.parse import urlencode

def extract_page_data(url):
    api_url = "https://api.hasdata.com/scrape/web"

    payload = json.dumps(
        {
            "url": url,
            "jsRendering": True,
            "extractRules": {
                "Title": ".s-card__title",
                "Price": ".s-card__price:first-child",
                "URL": ".su-card-container__header a.s-card__link @href",
                "next": "a.pagination__next @href",
            },
            "proxyType": "residential",
            "proxyCountry": "US",
        }
    )
    headers = {
        # Put HasData API key here
        "x-api-key": "YOUR_API_KEY",
        "Content-Type": "application/json",
    }

    full_response = requests.request(
        "POST", api_url, headers=headers, data=payload)
    extracted = json.loads(full_response.text).get("extractedData") or {}

    columns = {name: extracted.get(name) or [] for name in ("Title", "Price", "URL")}
    lengths = {len(values) for values in columns.values()}
    if len(lengths) != 1 or lengths == {0}:
        print(f"Nothing usable from {url}: columns {[len(v) for v in columns.values()]}")
        return pd.DataFrame(), extracted.get("next")

    products = pd.DataFrame(columns)
    products = products[~products["Title"].str.contains("Shop on eBay")]
    products["URL"] = products["URL"].str.split("?").str[0]

    return products, extracted.get("next")

def make_request(query, sort, items_per_page=60):
    base_url = "https://www.ebay.com/sch/i.html?"
    query_params = {
        "_nkw": query,
        "_ipg": items_per_page,
        "_sop": SORTING_MAP[sort],
    }
    return base_url + urlencode(query_params)

def write_to_csv(products, filename="product_info.csv"):
    mode = "a" if os.path.exists(filename) else "w"
    products.to_csv(filename, index=False, header=(mode == "w"), mode=mode)
    print(f"Data has been written to {filename}")

def scrape_ebay(search_query, sort):
    current_url = make_request(search_query, sort, 240)

    while current_url:
        products_on_page, next_page_url = extract_page_data(current_url)
        if not products_on_page.empty:
            write_to_csv(products_on_page)
        current_url = next_page_url

SORTING_MAP = {
    "best_match": 12,
    "ending_soonest": 1,
    "newly_listed": 10,
}

user_search_query = input("Enter eBay search query: ")
sort = input("Choose one ('best_match', 'ending_soonest', 'newly_listed'): ")
scrape_ebay(user_search_query, sort)

The output is the same CSV as before, built from the fields the API extracted rather than from a local parse. Each rule returns its own flat list for the whole page, so the three lists only line up while every card carries all three fields. :first-child on the price keeps the range cards from adding two extra entries each, and the length check drops a page rather than writing rows whose price belongs to the listing above.

Conclusion

This tutorial walked through scraping data elements from eBay. The requests library downloads the raw HTML, BeautifulSoup parses it, the built-in methods pull the fields out of the tree, and the results land in a JSON file for a single listing and a CSV for a search. The last version swaps the fetch for the HasData API, which maintains the proxy pool and the residential exits, renders the page, and returns the fields the extract rules name.