Skip to main content
GuidesNovember 18, 2026 · 11 min read

Why your eBay scraper keeps breaking (and what to use instead)

eBay scraper returning 403 or empty listings? Learn what breaks and how to get structured eBay search, item, and seller data with Spidra.

Why your eBay scraper keeps breaking (and what to use instead)

The frustrating thing about an eBay scraper breaking is that you may not have changed a line of code. The same request that returned product listings yesterday now returns 403 Forbidden. Or it returns 200 OK, and your parser confidently reports zero products.

You can spend the afternoon tweaking headers and selectors, only to discover that the next piece of data you need lives on a different page entirely.

This is the problem with maintaining your own eBay scraper. Collecting product data isn't just a matter of requesting a URL and parsing HTML. You're also responsible for changes in how eBay serves pages, how listings are displayed, and where the fields you need can be found.

If you're building a price tracker, an ecommerce research tool, or a product catalog, that work can quickly become a project of its own. Let's look at what breaks and how to get the data through Spidra without building and maintaining that collection layer yourself.

Why eBay scrapers stop working

A broken eBay scraper doesn't always throw an error. Sometimes it returns a perfectly successful HTTP response with no useful data. There are several reasons for that, and they need different fixes.

eBay refuses the request

The most obvious failure is 403 Forbidden or an Access Denied page. Your script asked for listings, but the response never contained listing HTML.

eBay uses access controls and anti-automation checks on its web pages. Depending on the request and session, an automated client may get an error page rather than the content a person sees in their browser. Changing a User-Agent header doesn't necessarily change the result, because an HTTP request contains more signals than that one header.

The distinction matters: there's no point rewriting your Beautiful Soup selectors when the page you need was never returned.

A challenge arrives with HTTP 200

Another failure looks like success. The server responds with 200 OK, but the body contains a challenge or an interstitial such as Pardon Our Interruption, not the search results.

Code that checks only the status code will treat that response as a successful scrape. The parser then finds zero products, and a downstream job may incorrectly interpret that as an empty search result.

For a recurring data feed, this is worse than a visible error. If you overwrite yesterday's listings with today's empty array, your application might report that dozens of products have disappeared.

The listing markup changes

Even when the page loads, CSS selectors are a moving target. eBay scraping examples have historically relied on classes such as .s-item and .s-item__price. More recent implementations document other result-card structures, including .s-card and .su-card-container.

That doesn't mean there's one new selector you can paste in and forget. It means a selector tied to a particular layout needs to be checked whenever the markup changes. Search pages, individual items, seller pages, and sponsored results can also expose different structures.

And an extracted price without the right condition or seller isn't always useful. A refurbished headset, a used headset with no accessories, and a new retail unit should not silently become one comparable offer.

Some data isn't on the public search page

A search result may contain the title, price, condition, seller, shipping details, and item URL, but not the product identifier you need to match that listing against other stores.

Sold and completed-listing searches are a separate access problem. In the November 2026 research, eBay's sold-search URL required sign-in, rather than returning public results. Replacing the parser or switching browsers doesn't turn that restricted search into an ordinary public page.

So even a scraper that successfully reads search results may still need to open individual items, enrich records, and handle missing fields.

Let Spidra handle the collection layer

With Spidra, you send an eBay URL and get back page content or structured data through an API. Spidra handles browser-based collection and the extraction work, so your application doesn't need to maintain the same stack of page selectors, browser sessions, proxy setup, and scraping jobs.

ebay-result-table.jpg

For supported eBay pages, you can ask for JSON without defining a prompt or extraction schema. The response includes named fields appropriate to the page, such as search results, item details, catalog products, seller profiles, stores, or seller feedback.

ebay-result.jpg

You can also provide your own prompt or JSON Schema when you need a different shape.

You can use the general Scrape API with a URL, the Batch Scrape API with a list of URLs, or an eBay template when you want a ready-made search or item-details table. They're different ways to use the same platform, not competing solutions.

Here's what that looks like.

Get a complete eBay search response as JSON

Start with an ordinary eBay search URL. There's no need to find its product-card CSS classes first.

Install the Python SDK and put your API key in an environment variable:

pip install spidra
export SPIDRA_API_KEY="spd_YOUR_API_KEY"

Now request JSON from the search page:

# ebay_search.py
import os
from spidra import Spidra

client = Spidra(api_key=os.environ["SPIDRA_API_KEY"])
search = client.scrape(
    "https://www.ebay.com/sch/i.html?_nkw=espresso+machine",
    output="json",
)
print(search.content["itemCount"])
60

The SDK handles job submission and waiting. The page data is available in search.content, instead of requiring you to parse the page's HTML yourself.

Here's a shortened response from an eBay search for espresso machine. The original response contained 60 listings; one is shown below.

{
  "type": "search",
  "marketplace": "ebay.com",
  "query": "espresso machine",
  "totalResults": 25000,
  "itemCount": 60,
  "sponsoredCount": 42,
  "page": 1,
  "hasNextPage": true,
  "items": [
    {
      "itemId": "127591681213",
      "title": "AIRMSEN BCM2316 Espresso Machine w/Grinder, Brushed Stainless Steel",
      "price": 94,
      "currency": "USD",
      "condition": "Open Box",
      "buyingFormat": "buyItNow",
      "soldCount": 213,
      "shippingText": "Free delivery in 2-4 days",
      "seller": {
        "name": "vipoutlet",
        "feedbackPercent": 97.2,
        "feedbackScore": 1000000
      }
    }
  ]
}

Values are from an actual collected example and will change as listings change. The response has been shortened to one item.

The search response gives you the results and the context around them. There's an item ID you can use for enrichment, a separate currency field, the listing's condition and buying format, and seller feedback. You also get pagination information and a count of sponsored listings.

If you're building a price tracker, you can store those as fields instead of repeatedly parsing price strings and guessing which label belongs to which product. A market-research app can filter out sponsored results, group offers by condition, and preserve the seller alongside each price.

The same Scrape API accepts individual item URLs, eBay product pages, and seller pages. You aren't limited to whatever inputs a template exposes. If your system expects a custom JSON object, Spidra's structured output lets you specify a schema instead.

Search by keyword without assembling URLs

If your application starts with product keywords or categories, the ready-made eBay search results template is convenient. Give it a keyword, marketplace, sorting preference, and page count; it returns the listings as rows.

The template is available from the Spidra dashboard or through the same Python SDK:

# Continue using the same client
run = client.run_template("ebay-search-results", {
    "keyword": ["Sony WH-1000XM5"],
    "marketplace": "com",
    "pages": 1,
})
print(run.status, len(run.rows))
completed 240

A completed search in the November 17 research returned 240 listings. Here's one real row, including details that become relevant the moment you compare competing sellers:

{
  "itemId": "278359701353",
  "title": "Sony WH1000XM5/B Wireless Noise Canceling Bluetooth Headphones Over-Ear Style",
  "url": "https://www.ebay.com/itm/278359701353",
  "condition": "Certified - Refurbished",
  "price": 159.99,
  "currency": "USD",
  "shippingCost": 0,
  "shippingText": "Free delivery in 2-4 days",
  "soldCount": 545,
  "location": "United States",
  "seller": {
    "name": "secondipity",
    "feedbackPercent": 99.8,
    "feedbackScore": 155700
  },
  "rating": 4.5,
  "epid": null
}

This isn't simply a search hit for Sony headphones. It's an offer for a certified refurbished unit from a particular seller, with its own price and delivery terms.

The epid value is also null. That's a useful reminder that search results are for discovering listings, not necessarily for identifying an exact product variation. For matching products across retailers, you may need information from the item page.

The eBay search template also has a Full details option for opening individual listings. If you need only a few items, collecting the search first and enriching a shortlist gives you more control over how many pages to open.

Get the product identifiers from item pages

The eBay item details template accepts individual item URLs or item numbers. It returns additional fields such as product identifiers, availability, item specifics, seller information, and returns details, when the item has them.

ebay-templates.jpg

Continuing with the Sony listing:

item_run = client.run_template("ebay-item-details", {
    "items": ["https://www.ebay.com/itm/278359701353"]
})
item = item_run.rows[0]

The item-details research collected four Sony listings. Here are the identifiers and prices from those records:

eBay item

Condition / variation

Price

GTIN / UPC

MPN

278359701353

WH1000XM5/B, certified refurbished

$159.99

0027242923232

WH-1000XM5

318849109603

WH1000XM5/S, certified refurbished

$159.99

027242923249

WH1000XM5-S

267780728627

WH-1000XM5/L, certified refurbished

$147.26

027242923911

WH1000XM5/L

267359443809

Used, headphones only

$123.67

027242923249

WH1000XM5-S, WH-1000XM5

All four records contained a product identifier and manufacturer part number. Their prices and conditions were different, however, so treating the cheapest listing as the cheapest equivalent product would have been misleading.

That's a useful pattern for an e-commerce product: search pages find offers, while item pages tell you what those offers actually are. The extraction is handled by Spidra, while your application decides how to match products and which conditions are comparable. Keep GTINs as strings so you don't lose leading zeros.

You can follow the same approach without templates by sending item URLs to the general Scrape API. And if your database needs its own field names, you can supply a JSON Schema rather than reshaping every response afterward.

Here's another real item extraction, this time for a wireless mouse. The requested schema produced the fields below, including availability, seller feedback, shipping and item specifications:

{
  "title": "Portable Wireless Mouse, 2.4GHz Silent with USB Receiver, Optical USB Mouse",
  "price": 7.95,
  "original_price": null,
  "currency": "USD",
  "condition": "New",
  "availability": "3 available",
  "item_number": "125575167955",
  "seller_name": "butrad-0",
  "seller_feedback": 99.3,
  "seller_feedback_count": 15446,
  "shipping_cost": "US $15.54",
  "returns_accepted": null,
  "location": "Flushing, NY, United States",
  "features": [
    {"label": "Maximum DPI", "value": "1600"},
    {"label": "Connectivity", "value": "Wireless"}
  ]
}

That's a separate custom-schema example, not the default Sony template response. Notice that returns_accepted is null, rather than false: the extraction couldn't establish the answer, so it doesn't invent one. That distinction matters when the results feed a real product.

The full eBay scraping tutorial includes the schema and further examples of search pagination and item collection.

Collect several item pages with Batch Scrape

Opening every item one by one isn't practical when you're building a catalog or monitoring many listings. Once you have the URLs, Batch Scrape processes them as separate jobs and returns an individual result for each page.

# Collect known item URLs
urls = [
    "https://www.ebay.com/itm/278359701353",
    "https://www.ebay.com/itm/318849109603",
]
batch = client.batch_scrape(urls, output="json")

successful_pages = [
    page for page in batch.items if page.status == "completed"
]

Here, successful_pages contains the completed items, which you can save without treating an unsuccessful item as a valid empty result.

The important difference is in the result shape. Scrape is for one page or a small set of pages combined into an answer. Batch gives each URL its own result, so you can save successful items separately. For eBay pages, it can include the structured page data without requiring a custom schema.

This fits a typical data product well: discover listings, select the item URLs that matter, collect their details, and update your database. Your application still owns product matching, historical storage, and rules such as whether an item marked Used belongs in the same price comparison as New.

For ongoing research, Spidra Monitors can rerun a template or saved source on a schedule and check for newly added or changed listings.

ebay-monitor.jpg

That lets you move from one-off extraction to a recurring watch without building the scheduling and comparison system yourself. The first check creates a baseline, and later checks look for changes.

What about eBay's official APIs?

If you're building an application with eBay's authorized data access, its Browse API is worth evaluating. It supports item searches by keyword, category, and product identifiers, with filtering and OAuth authentication.

The Browse API is different from reading eBay's public pages. It has its own access requirements, endpoints, data coverage, and usage limits. eBay also retired the older Finding and Shopping APIs in February 2025, so code built around those endpoints needs to migrate rather than retry them.

Spidra is useful when your product needs a web-data workflow across eBay pages and potentially other sources, with consistent ways to scrape URLs, collect batches, request structured data, and monitor changes. The official API may be the right starting point when its supported fields and terms cover your entire use case.

One boundary matters whichever route you choose: eBay's User Agreement restricts automated access without prior express permission. A working extraction request isn't, by itself, permission to collect or reuse the data commercially. Check the terms and permissions for your application; our web scraping legal guide explains the broader considerations.

Spend time on the product, not the scraper

A homemade eBay scraper can work for a small experiment. The cost shows up when it becomes infrastructure: checking whether a page loaded, updating selectors, collecting item details, and maintaining repeat jobs as the site changes.

Spidra gives you a different boundary to work with. Your code requests eBay data as JSON, and you choose what to build on top of it. Use Scrape when you already have a URL, the eBay templates when you want a ready-made search or item-details table, and Batch when you have a list of pages to collect. No approach can guarantee access to every page, but the page-reading machinery doesn't have to live in your application.

Try Spidra with an eBay search URL or product keyword, inspect the structured result, and see how much of your existing scraping code you can remove.

Frequently asked questions

A 403 means your request was refused rather than served the product page. It can result from eBay's access controls or request checks; it isn't evidence that your CSS selector is wrong. Check the response you actually received before changing parsing code.

Share this article

You build the product.
Spidra handles the data work.

Start with 300 free credits, about 300 pages. No credit card required.