Skip to content
Start free
Back to Blog

How to Scrape eBay for Price Intelligence: 2026 Guide

Gabriel CiociLast updated on 20 min read
How to Scrape eBay for Price Intelligence: 2026 Guide

eBay is one of the few places where new, used, refurbished, and auction prices for the same product sit side by side. That makes it a useful pricing signal if you sell those products, source them, or set resale prices. It also makes it easy to get wrong. A live bid isn't a sale price, a "free shipping" listing isn't cheaper until you add up the rest, and two listings with the same title may not be the same item.

This guide shows how to scrape eBay data for price intelligence the careful way. You'll see which pages hold price data, how to choose between eBay's Browse API, a structured data API, and DIY scraping, and how to turn each listing into a timestamped observation with sample Python code. Then you'll match products across sellers, set a refresh cadence, and catch price changes.

TL;DR: eBay's terms restrict automated access, so settle that before you collect anything. Use eBay's Browse API if its approval process and call limits work for you. Otherwise, use a structured data API for item-level JSON. Store each capture as a timestamped observation and keep auctions apart from fixed-price listings. Compare landed price for the same product, condition, and variant.

In short:

  • Check the rules first. eBay's terms restrict automated access, so settle that before you collect anything.
  • Collect observations, not pages. Every capture is a timestamped record you append, never overwrite.
  • Separate auctions from fixed-price listings. They measure different things.
  • Compare landed price. Item price plus shipping, or nothing.
  • Match before you compare. Same product, same condition, same variant.

What does eBay price intelligence actually measure?

eBay price intelligence measures what buyers are offered for a specific product, in a specific condition, at a specific time. It isn't one price per product. It's a history of offers from many sellers, each captured with its format, condition, shipping, and source, so you can compare like with like and see how prices move.

Listings, offers, and price observations

Three objects keep the data model straight:

  • Listing. One eBay item number and its page, with a title, category, seller, and format. It lives for days or months, then ends.
  • Offer. What the listing asks for at a given moment: price, currency, format, condition, shipping, and seller. A seller can change the offer many times.
  • Observation. One timestamped capture of an offer. When the price changes, you add a new observation instead of editing the old one.

Append observations, don't overwrite them. If you update one "current price" field in place, you lose the history: you can't see a price drop, measure how long a discount lasted, or audit where a number came from.

A good observation record carries identity, price, and provenance. Here's an illustrative shape modeled on our price intelligence workflow. Rename the fields to fit your schema.

Field

What it holds

Example (illustrative)

match_id

Your internal product key after matching

AR2-BLK-42

gtin

GTIN, UPC, or EAN when known

0123456789012

variant

Size, color, or capacity inside a multi-variation listing

{"color": "black"}

match_state

How sure the match is: matched, probable, or unmatched

matched

price

Current asking price or current bid, with currency

119.00 USD

regular_price

The struck-through "was" price, when shown

132.00

shipping

Shipping cost to your reference destination, or null

0.00

availability

In stock, limited, or ended

in_stock

seller

Seller name and feedback signal, when returned

seller-a

captured_at

UTC timestamp of the capture

2026-07-14T09:30:00Z

source_url

The listing URL you captured

https://www.ebay.com/itm/...

schema_version

Version of your record format

ebay_observation.v1

Why the listed price is not the market price

The number on a listing is what one seller asks, not what buyers pay. Four things separate the two:

  • Format. An auction's bid can rise sharply at the end, and a Best Offer listing may close below its asking price.
  • Shipping. A $20 item with $15 shipping costs more than a $30 item with free shipping.
  • Condition. "New," "Open box," and "Used" listings belong in different series.
  • Survivorship. Overpriced listings stay live longer, so active listings lean toward high prices.

Price intelligence on eBay is mostly about controlling for these. The eBay price scraper is the easy part.

eBay's own documents restrict automated access. Its User Agreement prohibits using "any robot, spider, scraper, data mining tools, data gathering and extraction tools, or other automated means" to access its services "except with the prior express permission of eBay." Its robots.txt file opens with a similar notice and disallows search result paths (/sch/) for all user agents. robots.txt follows the Robots Exclusion Protocol (RFC 9309). eBay's API License Agreement also lists using eBay content "to suggest or model prices for items listed on eBay Site" among its restricted activities.

What those terms mean for your project depends on your use case, your jurisdiction, and how you collect the data. Get a legal review before you start. For general context, see our web scraping legality framework and our responsible web data practices.

Which eBay pages hold price data?

Item pages hold the price data you record. Each one shows a single listing's price, format, condition, shipping, and seller. Search results pages help you find listings but aren't a reliable price of record. Catalog product (ePID) pages group many listings under one product, and sold listings are no longer openly visible to signed-out visitors.

Item pages

An item page lives at a URL like https://www.ebay.com/itm/235022741770. The number at the end is the item number, and it's the unit of a price observation: one seller, one listing, one offer at a time, plus any variations inside it. Item pages carry the fields that matter, including price or bid, condition, shipping, seller, item specifics such as brand and MPN, and format.

Search results pages

Search results answer "which listings exist for this product right now?" They're how you find item numbers to watch, but they aren't a good price of record. Results are sorted and personalized, multi-variation prices show as ranges, and shipping is summarized. eBay's robots.txt also disallows the /sch/ search paths. For discovery, use the Browse API's item_summary/search method, which returns listings by keyword, category, GTIN, or ePID, then track each item number on its own.

Catalog product (ePID) pages

An ePID (eBay Product ID) is a catalog identifier, not a listing. One ePID represents a product, such as a specific phone model and storage size, and many listings from many sellers can link to it. That makes it your first matching key. Used, vintage, and handmade items often aren't linked to the catalog, so you'll need the fallbacks in the matching section.

Item pages show related products, such as "people who viewed this item also viewed." They surface substitutes and listings your keyword search missed. The eBay Data API response includes a related_products_also_viewed array when eBay shows it, so you can queue those listings for review. Treat them as candidates, not matches.

Sold and completed listings

Sold prices are the closest thing to a true market price on eBay, and they're the hardest to get. It's widely reported that sold and completed searches now send signed-out visitors to a sign-in page, so this data is no longer openly visible. eBay's own sold-data API, Marketplace Insights, is a limited-release Buy API available to approved developers only.

Until you have an approved source, your own captures of active and ending listings are the baseline.

Should you use eBay's Browse API, a data API, or a scraper?

Use eBay's Browse API when you can work within its approval process, call limits, and license terms. Use a structured data API when you want item-level JSON without maintaining parsers. Use a scraper with your own parser only for fields neither option returns. If you'd rather not run the pipeline at all, use managed delivery. If you also track Amazon prices, our comparison of Amazon scraping APIs walks through the same decision for Amazon.

Route

What you get

Who maintains parsing

Limits and approvals

Best fit

eBay Browse API

Official JSON for item search and item details

eBay

OAuth app token; default daily call limits; some Buy APIs need extra approval; API License terms apply

Teams approved by eBay that can work within its license

WebScrapingAPI eBay Data API

Structured JSON for eBay item pages

WebScrapingAPI

Quote-based pricing by sources, fields, volume, and refresh frequency

Price tracking without parser upkeep

Scraper API with your own parser

Raw HTML of the page

You

You handle selectors, page changes, and data quality

Fields missing from structured output

Managed data delivery

Delivered, validated records on a schedule

WebScrapingAPI

Scope, cadence, and delivery agreed up front

Teams that want data, not a pipeline

eBay Browse API

The Browse API is eBay's official way to search and read listings. It replaced the Finding and Shopping APIs, which eBay decommissioned in February 2025, so tutorials built on them no longer work.

Two methods matter here: item_summary/search finds listings by keyword, category, GTIN, or ePID, and getItem returns one listing's details, including price and quantity. Other methods cover item groups (variations) and lookups by legacy item number. You authenticate with an OAuth application token from the client credentials grant.

Know the limits before you build. The default Browse API limit is 5,000 calls per day at the time of writing, with higher limits through an application review, and many Buy APIs are a limited release for approved developers. The API License Agreement, including the price-modeling restriction quoted above, applies to everything you pull.

WebScrapingAPI eBay Data API

The eBay Data API returns eBay item pages as structured JSON: title, brand, categories, condition, price and regular price, and, when eBay shows them, seller, shipping, ratings, and related items. WebScrapingAPI handles access, extraction, and parser maintenance, so a layout change doesn't break your pipeline. Pricing is quote-based and depends on source pages, fields, volume, refresh frequency, and delivery.

Scraper API with your own parser

For a field no structured output returns, you can fetch raw HTML and parse it yourself. You get full control, and full responsibility for selectors, markup changes, and data quality. The raw HTML section below covers when that's worth it.

Managed data delivery

With managed data collection, WebScrapingAPI runs collection, validation, and delivery on an agreed schedule, and your team works with finished records. It fits when eBay is one source among many and you want a dataset, not a codebase.

How do you get eBay listing data with the eBay Data API?

Find the listing's item number, send it to the eBay Data API with engine=ebay and type=product, and read the JSON response. Send either the item number or the full listing URL, never both. Keep your API key in an environment variable, and treat any missing seller or shipping object as unknown, not zero.

Find the item number

For most listings, the item number is the numeric segment after /itm/ in the URL:

https://www.ebay.com/itm/235022741770

The Data API takes it in a parameter named epid. Despite the name, it expects the number from the /itm/ URL. If you already store full listing URLs, send the URL in the url parameter instead.

Send the request

The request is a GET to https://ecom.webscrapingapi.com/v1. The full parameter list is in the eBay Product endpoint reference.

Install requests, set your key as WSA_API_KEY, and use a function like this:

pip install requests
export WSA_API_KEY="your_api_key"
import os

import requests

ENDPOINT = "https://ecom.webscrapingapi.com/v1"

def fetch_listing(item_number=None, url=None, timeout=90):
    """Fetch one eBay listing as JSON. Send an item number or a URL, never both."""
    if (item_number is None) == (url is None):
        raise ValueError("Pass exactly one of item_number or url")

    params = {
        "api_key": os.environ["WSA_API_KEY"],
        "engine": "ebay",
        "type": "product",
    }
    if item_number is not None:
        params["epid"] = item_number
    else:
        params["url"] = url

    response = requests.get(ENDPOINT, params=params, timeout=timeout)
    response.raise_for_status()
    return response.json()

listing = fetch_listing(item_number="235022741770")

The guard enforces the one-identifier rule, and requests URL-encodes the parameters. A missing or invalid key returns HTTP 401, which raise_for_status() turns into an exception. Keep the timeout generous, since each call fetches and parses a live page.

Read the response

search_parameters echoes your request, including the marketplace and listing URL. product_results holds the data: product, condition, offer, and, when eBay shows them, seller, shipping, rating, reviews, and related_products_also_viewed.

Sample response, from the eBay Product documentation:

{
  "search_parameters": {
    "engine": "ebay",
    "type": "product",
    "epid": "235022741770",
    "ebay_domain": "ebay.com",
    "ebay_url": "https://www.ebay.com/itm/235022741770",
    "device": "desktop"
  },
  "product_results": {
    "product": {
      "title": "Autopilot APCEM2 Hydroponic Gardening CO2 RH Temperature Monitor and Data Logger",
      "brand": "Autopilot",
      "epid": "235022741770",
      "link": "https://www.ebay.com/itm/235022741770",
      "primary_image": {
        "link": "https://i.ebayimg.com/images/g/VqEAAOSw2sNkbQfo/s-l1600.jpg"
      },
      "categories": [
        {
          "name": "Home & Garden",
          "link": "https://www.ebay.com/b/Home-Garden/11700/bn_1853126"
        }
      ]
    },
    "condition": {
      "raw": "New",
      "is_new": true,
      "is_used": false
    },
    "offer": {
      "price": 121.99,
      "currency": "USD",
      "price_regular": 219.99,
      "price_is_discounted": true
    },
    "rating": {
      "score": 4.9,
      "rating_count": 20,
      "reviews_count": 12
    }
  }
}

The offer object carries the numbers you'll track: the current price, its currency, the regular price, and a discount flag. If nested JSON is new to you, our guide to parsing JSON in Python covers safe lookups and missing keys.

Handle missing fields

The sample has no seller and no shipping. That's normal. eBay item pages vary by marketplace, listing state, seller settings, and buyer location, so optional objects are absent when eBay doesn't show that data.

Treat an absent field as unknown. Missing shipping defaulted to zero makes a listing look cheaper than it is, and a missing seller defaulted to an empty string groups unrelated listings together. Store None, count unknowns separately, and check a representative sample of your own listings before you rely on any optional field.

How do you turn an eBay listing into a price observation?

Convert each response into a flat record. Parse prices as decimals, keep the currency next to every amount, map condition into a small set of buckets, and compute landed price only when shipping is known. Add the capture time and the source URL, then append the record to your history instead of overwriting the last one.

Normalize price, currency, and condition

Parse prices with Decimal, not floats or integers. A float stores 121.99 as an approximation, and an integer drops the cents. Both errors compound when you average or diff prices.

Condition needs a smaller vocabulary than eBay's. eBay defines numeric item condition IDs that stay consistent across marketplaces, from 1000 (New) through the refurbished grades (2000 to 2500) and used grades (3000 to 6000) to 7000 (For parts or not working). Display names vary by category, so map them to buckets you'll actually compare:

Bucket

eBay conditions it covers

new

New, New other (open box), New with defects

refurbished

Certified, Excellent, Very Good, and Good Refurbished; Seller refurbished

used

Like New, Used, Very Good, Good, Acceptable

for_parts

For parts or not working

unknown

Anything you can't map yet

Keep the raw condition text too, so you can rebuild buckets if the mapping changes. A sample to_observation() function for the response shape above:

from datetime import datetime, timezone
from decimal import Decimal

SCHEMA_VERSION = "ebay_observation.v1"

def to_decimal(value):
    return None if value is None else Decimal(str(value))

def condition_bucket(raw, is_new, is_used):
    text = (raw or "").lower()
    if "refurbished" in text:
        return "refurbished"
    if "for parts" in text:
        return "for_parts"
    if is_new:
        return "new"
    if is_used:
        return "used"
    return "unknown"

def to_observation(payload, run_id, shipping_cost=None, variant=None):
    params = payload.get("search_parameters") or {}
    results = payload.get("product_results") or {}
    product = results.get("product") or {}
    offer = results.get("offer") or {}
    condition = results.get("condition") or {}

    price = to_decimal(offer.get("price"))
    shipping = to_decimal(shipping_cost)
    landed = price + shipping if price is not None and shipping is not None else None

    return {
        "item_number": params.get("epid") or product.get("epid"),
        "variant": variant,
        "marketplace": params.get("ebay_domain"),
        "title": product.get("title"),
        "brand": product.get("brand"),
        "listing_format": None,  # record it when your sample exposes it
        "condition_raw": condition.get("raw"),
        "condition": condition_bucket(
            condition.get("raw"), condition.get("is_new"), condition.get("is_used")
        ),
        "price": None if price is None else str(price),
        "currency": offer.get("currency"),
        "regular_price": None if offer.get("price_regular") is None
        else str(to_decimal(offer["price_regular"])),
        "is_discounted": offer.get("price_is_discounted"),
        "shipping": None if shipping is None else str(shipping),
        "landed_price": None if landed is None else str(landed),
        "seller": results.get("seller"),  # None means unknown, not "no seller"
        "source_url": params.get("ebay_url") or product.get("link"),
        "captured_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
        "run_id": run_id,
        "schema_version": SCHEMA_VERSION,
    }

Decimals are stored as strings so they survive JSON without rounding, and run_id ties each record to the run that produced it.

Sample output for the documented response:

{
  "item_number": "235022741770",
  "variant": null,
  "marketplace": "ebay.com",
  "title": "Autopilot APCEM2 Hydroponic Gardening CO2 RH Temperature Monitor and Data Logger",
  "brand": "Autopilot",
  "listing_format": null,
  "condition_raw": "New",
  "condition": "new",
  "price": "121.99",
  "currency": "USD",
  "regular_price": "219.99",
  "is_discounted": true,
  "shipping": null,
  "landed_price": null,
  "seller": null,
  "source_url": "https://www.ebay.com/itm/235022741770",
  "captured_at": "2026-11-03T21:29:06+00:00",
  "run_id": "sample-run",
  "schema_version": "ebay_observation.v1"
}

Calculate the landed price

Landed price is item price plus shipping to a defined destination. Compare sellers on landed price, because they shift cost between the two freely.

Two rules keep it honest. Fix one reference destination, such as a ZIP code, since shipping varies by buyer location. And if shipping is unknown, landed price is unknown, which is why to_observation() takes shipping_cost as an argument and returns None without it.

The docs describe shipping as shipping options, delivery estimates, and cost metadata, but the sample response has none. Check the shipping objects in your own responses, pick the option for your reference destination, and pass its cost in.

Store observations instead of overwriting them

Write each observation as a new row. A JSON Lines file is enough to start:

import json

def append_observation(path, observation):
    with open(path, "a", encoding="utf-8") as fh:
        fh.write(json.dumps(observation) + "\n")

Key each row by item number, variant, and captured_at. "Current price" is just the latest row per item and variant, and every past price is still there.

How should you handle auctions, Buy It Now, and Best Offer?

Keep a separate price series for each listing format. An auction's current bid is not a price until the auction ends. A Buy It Now price is a fixed asking price. A Best Offer listing may sell below the price shown. Never average a live bid with fixed prices, because the result describes no real transaction.

The three formats answer different questions:

Format

What the shown price means

How to record it

Auction

The current high bid, which can still change

Record bid observations while live; record the final price separately once the listing ends

Buy It Now

A fixed price the buyer can pay now

Record as an asking price observation

Best Offer

An asking price the seller may accept less than

Record the asking price and flag that the final price may be lower

Auctions. The seller sets a starting price, buyers bid until the listing ends, and the highest bidder wins (see how bidding works). Buyers can set a maximum bid and let eBay bid for them up to that limit, and eBay is testing extended bidding in some categories, where a late bid resets the clock. A bid captured mid-auction is a lower bound, not a market price.

Buy It Now. The cleanest series. The price moves only when the seller moves it, so diffs here are real pricing decisions.

Best Offer. The listed price is a ceiling, and the accepted price is often private. Don't use these listings as evidence of what buyers paid.

Some listings combine formats, such as an auction with a Buy It Now option. Record the listing format when it's available. When it isn't, keep listing_format unknown and leave those rows out of format-specific reports.

How do you match the same product across eBay sellers?

Match listings with the strongest identifier you have, then fall back step by step. Use the ePID or a GTIN first, then brand plus manufacturer part number, then title similarity with a person reviewing the result. Record how each match was made, and keep uncertain matches out of price comparisons until someone confirms them.

Item numbers, ePIDs, GTINs, and MPNs

Each identifier answers a different question:

  • Item number: which listing? Unique per listing, useless across sellers.
  • ePID: which eBay catalog product? Strong when present.
  • GTIN (UPC, EAN, ISBN): which manufactured product? A GTIN is the GS1 barcode number and the best key for matching against other marketplaces and your catalog.
  • Brand + MPN: the manufacturer's part number, when sellers list it accurately.

The same ladder works outside eBay. If you also track Amazon, see our guide on matching the same product on Amazon, where ASINs play the role ePIDs play here.

Variations inside one listing

One listing can carry many variations, such as a T-shirt in six sizes and four colors, each with its own price. Key observations by item number alone and the price jumps between variations, so change detection fires on noise. Key by item number plus variant (size, color, capacity) instead, and match each variant separately.

Match states and manual review

Every observation should carry a match state, so you always know how far to trust a comparison:

  • matched: an exact identifier (ePID, GTIN, or brand plus MPN) agrees, and the variant agrees.
  • probable: the title and attributes are close, but no exact identifier confirms it.
  • unmatched: you can't tell yet.

By default, only matched records go into comparisons. Probable matches go to a review queue, and each decision is saved. Be wary of bundles, lots, and "for parts" listings. They share titles with the real product but aren't comparable.

How often should you refresh eBay prices?

Refresh each listing as often as the decision it feeds requires, and no more. Auctions near their end and fast-moving products need frequent captures. Stable fixed-price listings in the long tail usually need a daily or weekly check. Set tiers, assign every watched listing to one, and keep the total inside your budget and the source's limits.

A tiered schedule might look like this:

Tier

What goes in it

Cadence

Hot

Auctions in their final hours; your top sellers; products in a live price war

Several times a day

Warm

Active fixed-price listings for core products

Daily

Cold

Long-tail, stable listings and slow categories

Weekly

Start from the decision. If you reprice once a day, capturing every ten minutes adds cost and nothing else. Then check the math: on the Browse API, the daily call limit caps how many listings you can refresh, and on a data API, volume and frequency drive the quote.

Move listings between tiers automatically. Auctions move to hot as they near their end, listings with no price change in weeks drop to cold, and ended listings leave the schedule with their history intact.

How do you detect and alert on eBay price changes?

Compare each new observation with the previous one for the same item and variant. Flag changes in price, currency, condition, discount state, shipping, landed price, and seller. Then decide which changes deserve an alert, using thresholds tied to your pricing rules, and route those alerts to the people who act on them.

A sample diff() function:

WATCHED = ("price", "currency", "condition", "is_discounted", "shipping", "landed_price", "seller")

def diff(previous, current):
    return [
        {"field": field, "previous": previous.get(field), "current": current.get(field)}
        for field in WATCHED
        if previous.get(field) != current.get(field)
    ]

Here, the earlier record is an edited copy of the sample observation, with the price set to 134.99 and the discount flag set to false. Sample diff output:

[
  {
    "field": "price",
    "previous": "134.99",
    "current": "121.99"
  },
  {
    "field": "is_discounted",
    "previous": false,
    "current": true
  }
]

Most changes don't need an alert. Rules worth setting:

  • Percent change. Price or landed price moves more than a set percentage.
  • Below floor. A matched listing drops below your minimum or a MAP threshold you review.
  • Out of stock or ended. A key competitor listing ends, which can open room to raise your price.
  • Currency or condition change. Treat these as data issues first, such as a capture from the wrong marketplace.

Send alerts to email or a chat channel, batch low-priority changes into a daily digest, and link the source URL and both observations in each alert.

What if you need the raw eBay page HTML?

Sometimes you need a field structured output doesn't return, such as an unusual item specific or text from a seller's description. Then you can fetch the raw page and parse it yourself. The Scraper API for raw HTML at https://api.webscrapingapi.com/v2 returns the page HTML, with options such as render_js for pages that build content in the browser and country for geotargeted requests.

That route moves maintenance to you. You own the selectors, and any eBay markup change can quietly turn a price into a blank or a wrong number, so build checks that catch it. If you go this way, read our guide to avoiding blocks when you scrape before you build the collector.

The rules covered earlier apply to every route. Raw HTML doesn't change what eBay's terms say, so settle the legal review before you collect anything.

How do you keep an eBay price pipeline reliable?

Data quality is part of the pipeline, not a cleanup job. Check required fields on every run, validate currencies and marketplaces, guard against outliers, version your schema, and keep the source URL for every record. Then re-match listings when they change, so old matches don't quietly drift out of date.

Check these on every run:

  • Null rates. Track the share of observations missing price, currency, condition, or source URL. A sudden jump usually means a source change, not a market change.
  • Currency and locale. Confirm every price has the currency of the marketplace you expected. eBay.com and eBay.de are different markets.
  • Outlier guard. Flag 10x jumps for review instead of publishing them. Misplaced decimals and "for parts" listings are the usual cause.
  • Schema version and run ID. Bump schema_version when field meanings or mapping rules change, and use run_id to rerun or discard one bad batch.
  • Source URL. Every number in a report should trace back to a listing URL and capture time.
  • Re-matching. Sellers edit titles and relist items, so re-run matching on changed listings.

If a check fails beyond your threshold, hold the batch back from reports and alerts. A quiet day of missing data beats a loud day of wrong prices.

FAQ

Does eBay allow web scraping?

eBay's User Agreement prohibits using robots, scrapers, and other automated tools to access its services without eBay's prior express permission. Its robots.txt file carries a similar notice and disallows search result paths. eBay offers official APIs, such as the Browse API, under its API License Agreement. Get a legal review for your specific use case.

Can you scrape eBay without getting blocked?

eBay uses technical measures against automated traffic, and its User Agreement prohibits circumventing them. Rather than fighting that, start with structured routes: eBay's Browse API if you're approved, or a data API that handles access and parsing for you. Whichever route you choose, eBay's terms still apply, so check them before collecting.

Can you scrape eBay sold listings?

Sold and completed listings are no longer openly visible to signed-out visitors, according to widespread reports, and eBay's sold-data API, Marketplace Insights, is limited to approved developers. For most teams, the practical options are an approved data source or the ended-auction and price history you capture yourself from active listings.

What is the difference between an eBay item number and an ePID?

An item number identifies one listing from one seller, and it appears in the listing URL after /itm/. An ePID identifies a product in eBay's catalog, and many listings from many sellers can link to the same ePID. Use item numbers to track listings and ePIDs to match them.

Is the eBay Browse API free?

You can apply for Browse API access through the eBay Developers Program, but it isn't unlimited. You need a developer account and an OAuth token, calls are capped by daily limits, and some Buy APIs require extra approval. Use is subject to eBay's limits and license, including its restrictions on price modeling.

How do you scrape eBay prices with Python?

Call a structured eBay endpoint with the requests library, passing the listing's item number and an API key from an environment variable. Parse the price with Decimal, keep the currency, condition, and shipping, and save each result as a timestamped observation. Compare observations over time to detect price changes.

Start collecting eBay price data

Get structured eBay listing data, including price, condition, seller, and shipping when eBay shows them, without maintaining parsers. Pricing depends on the sources, fields, volume, refresh frequency, and delivery you need, so start with a sample of the listings you track.

Request eBay sample data

About the Author

Gabriel Cioci, Full-Stack Developer @ WebScrapingAPI

Gabriel Cioci

Full-Stack Developer

Gabriel Cioci is a Full Stack Developer at WebScrapingAPI, building and maintaining the websites, user panel, and the core user-facing parts of the platform.

Start Building

Ready to Scale Your Data Collection?

Join 2,000+ companies using WebScrapingAPI to extract web data at enterprise scale with zero infrastructure overhead.