How to Scrape eBay Reviews & Seller Feedback (2026)

The first time someone asks me how to scrape eBay reviews, my first question back is: which reviews? The phrase hides two different data types that sit at different URLs and behave differently when you point a scraper at them. One is the product review, the star rating block on a catalog listing. The other is seller feedback, the running log of buyer comments on a seller’s profile. Knowing how to scrape eBay reviews well starts with separating those two, because the answer for one is not the answer for the other.

I work on eBay data pipelines, so I ran every request in this guide against live eBay pages in July 2026. The short version of what I found: item pages return a hard 403, product reviews barely exist on most listings, and the seller feedback profile was the one surface that actually handed data back to a plain request. This walkthrough covers what each data type contains, why the blocks differ, the Python that pulled feedback for me, and the managed route I use when a job needs to run on a schedule.

What eBay review and feedback data can you actually scrape?

You can scrape two distinct data types from eBay: product reviews, which rate an item, and seller feedback, which rates a seller. They live at different URLs, carry different fields, and eBay treats them differently in its robots.txt, so it pays to decide up front which one your use case needs.

Product reviews attach to a catalog product, not to a single listing. When a listing is adopted to eBay’s catalog or is a multi-quantity listing, it can show the product’s star rating and written reviews, and every listing of that same product shares them. eBay documents this eligibility on its product reviews help page. The practical consequence is the important part: most individual used listings are not catalog-adopted, so they show no product reviews at all. If your targets are one-off or used items, the review block is usually just empty.

Seller feedback is the surface that is almost always populated. Every established seller has a feedback profile with a positive feedback percentage, a feedback score, and a scrollable list of individual entries. Here is how the two compare:

Each individual feedback entry is a small record: a rating polarity, a short comment, the date, the buyer who left it, and often the item it relates to. That entry shape (rating, text, date, buyer) is what most people actually mean when they say they want to scrape eBay reviews, and for the majority of listings it is the only review-style data available. Before writing a parser for either, it helps to see exactly where the request gets refused.

Why is eBay review data hard to pull?

eBay review data is hard to pull because the pages sit behind an anti-bot layer, the official API does not expose the text, and the two review surfaces have opposite robots rules. I hit all three in the same afternoon, so I will take them in order.

The anti-bot wall is the first. When I sent a plain requests.get to a live item URL from a datacenter IP in July 2026, eBay answered with an HTTP 403 and a server: AkamaiGHost header before any listing or review markup loaded. A search URL returned the same 403. That edge is Akamai Bot Manager, which scores the IP and TLS fingerprint of the connection before eBay serves HTML, so the product-review block on an item page is gated by the same layer as the price.

The official API does not rescue you here. eBay’s Browse API returns active-listing data such as title, price, and condition, but it does not expose product review text or seller feedback comments, and the older Finding and Shopping APIs were decommissioned on February 5, 2025. So the data most people want for review analysis is exactly the data the sanctioned API leaves out.

The robots.txt rules are the twist, because the two surfaces are treated in opposite ways. I read the live file, and the pattern is consistent with what eBay publishes:

So eBay’s robots.txt permits the product-review path while disallowing the feedback path, which is the reverse of what reachability suggested when I actually sent the requests. On top of robots.txt sits the contract: eBay’s User Agreement prohibits using “any robot, spider, scraper … or other automated means” to access the services without prior written permission. That policy applies to both surfaces regardless of which path robots.txt allows. With the walls mapped, the surprising result is which door actually opened.

How do you scrape eBay seller feedback with Python?

You scrape eBay seller feedback with Python by requesting the seller’s feedback profile and parsing the entries out of the returned page. This is the surface that worked for me on a plain request: in July 2026, https://www.ebay.com/fdbk/feedback_profile/<seller> returned HTTP 200 from a ebay-proxy-server header, not the AkamaiGHost 403 that item and search pages returned on the same machine. The page carried roughly 25 feedback entries, each with a rating polarity and a comment.

Here is the request and parse I ran. The rating polarity renders as an icon class (icon--feedback-positive, -neutral, or -negative), and the comment text is embedded in the page as a small JSON structure, so I read the polarity from the DOM and the comments from the embedded data:

import requests, re
from bs4 import BeautifulSoup

UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
      "(KHTML, like Gecko) Chrome/126.0 Safari/537.36")

seller = "musicmagpie"
url = f"https://www.ebay.com/fdbk/feedback_profile/{seller}"
r = requests.get(url, headers={"User-Agent": UA}, timeout=20)
print(r.status_code, r.headers.get("server"))   # -> 200 ebay-proxy-server (July 2026)

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

# Rating polarity is carried on an SVG icon class, one per feedback card
polarities = []
for icon in soup.select("svg[class*='icon--feedback-']"):
    m = re.search(r"icon--feedback-(positive|neutral|negative)", " ".join(icon.get("class", [])))
    if m:
        polarities.append(m.group(1))

# Comment text is embedded as JSON: "comment":{... "text":"..."}
comments = re.findall(
    r'"comment":\{"_type":"TextualDisplay","textSpans":\[\{"_type":"TextSpan","text":"(.*?)"',
    r.text,
)
ids = re.findall(r'"feedbackId":"?(\w+)', r.text)

print(len(ids), "entries,", len(polarities), "ratings,", len(comments), "comments")
# -> 25 entries, ~28 ratings, 25 comments on page 1 (July 2026)

When I ran that, the counts lined up: about 25 feedback IDs and 25 comments per page, with rating polarities read straight off the icons. To assemble clean records you zip the parts together and keep the fields you need:

records = []
for i, comment in enumerate(comments):
    records.append({
        "feedback_id": ids[i] if i < len(ids) else None,
        "rating": polarities[i] if i < len(polarities) else None,
        "comment": comment.encode().decode("unicode_escape"),
    })

for row in records[:3]:
    print(row["rating"], "-", row["comment"][:60])

Two caveats keep this honest. First, the class names and JSON keys above are eBay’s July 2026 markup, and eBay ships markup changes regularly, so a selector that works today can return empty next month. Second, and more important, eBay’s robots.txt disallows the /fdbk/ path for the default agent, so the fact that the page responded 200 does not mean scraping it is sanctioned. The buyer usernames in each entry are also personal data, which pulls GDPR into scope the moment you store them. Those two constraints are why I treat this snippet as a way to understand the surface, not a pipeline I would run at volume.

What fields does a feedback profile expose?

A feedback profile exposes the seller’s positive feedback percentage, the feedback score, the detailed seller ratings, and the individual entries. The percentage and score are computed by eBay and displayed on the page, so you read them rather than derive them.

The seller ratings help page describes how eBay builds those numbers, and it is worth knowing so you interpret the scraped values correctly:

• Feedback score: the number in brackets by the username. Positive ratings add 1, negative subtract 1, neutral ratings count as 0.
• Positive feedback percentage: positives divided by positives plus negatives over the last 12 months. Neutral ratings are excluded, as are repeat purchases from the same buyer in the same week.
• Detailed Seller Ratings (DSRs): anonymized 1-to-5-star averages across four criteria, item as described, communication, shipping time, and shipping charges. DSRs do not change the feedback score.

Reading those as fields rather than recomputing them saves you from mismatches with what buyers see on the page. That covers the seller side. The item side, product reviews, is a different collection problem.

How do you scrape eBay product (item) reviews?

You scrape eBay product reviews from the catalog listing or the standalone /urw/*/product-reviews/ page, but the first thing to check is whether the listing has any reviews at all, because most do not. Product reviews only appear on catalog-adopted or multi-quantity listings, and they belong to the catalog product rather than the individual listing. On a typical used or one-off listing, the review block is empty, and no scraper can pull data that the page does not render.

When reviews do exist, the collection problem is the same anti-bot wall as the rest of the item page. The review block loads on the /itm/ page that returned a 403 to my plain request, and eBay’s Browse API does not expose review text, so neither the raw fetch nor the sanctioned API gives you the review content directly. Reaching it means rendering the page through a clean residential session or sending the URL to a service that renders server-side. The robots position is friendlier here than for feedback: eBay’s robots.txt allows the /urw/*/product-reviews/ path, so the standalone review page is the surface to target when a product is catalog-backed.

The fields you get from a populated product review mirror what a shopper sees: a star rating, a review title, the review text, a date, the reviewer name, and sometimes a seller or manufacturer reply. The gap between “this field exists in eBay’s schema” and “this listing actually has it” is the whole story for product reviews. For the large share of listings where the review block is empty, seller feedback from the previous section is the realistic substitute. When you need both surfaces reliably, the managed route handles the rendering and the blocks for you.

How do you scrape eBay reviews and feedback at scale without getting blocked?

A scraper API removes the blocking and rendering work: you send an eBay URL, and the service routes the request through rotating residential proxies, renders the page if needed, parses it, and returns JSON. There is no Akamai 403 to retry, no /fdbk/ markup to re-learn when eBay renames a class, and no residential proxy pool to rent. This is the setup I default to for review and feedback collection on any schedule, because it turns three different surfaces into one authenticated GET.

The request takes an eBay URL and your API key as query parameters. The same url parameter accepts item, search, and seller URLs, so a seller feedback profile goes in exactly like an item URL does. Here is the call shape against ChocoData’s eBay product endpoint:

curl "https://chocodata.com/api/v1/ebay/product?url=https://www.ebay.com/fdbk/feedback_profile/musicmagpie&api_key=$CHOCO_API_KEY"

The same pattern in Python, which is what I actually schedule for feedback pulls:

import requests

CHOCO_API_KEY = "your_api_key"

resp = requests.get(
    "https://chocodata.com/api/v1/ebay/product",
    params={
        "url": "https://www.ebay.com/fdbk/feedback_profile/musicmagpie",
        "api_key": CHOCO_API_KEY,
    },
    timeout=60,
)
data = resp.json()
print(data.get("seller"), data.get("feedback_score"), data.get("positive_percent"))

When I probed the endpoint without a key in July 2026, it returned 404 NOT_FOUND, which is the expected gate: the request only resolves once a valid api_key is attached, so the key does the auth and the routing. Swap the url for an item URL and the same endpoint returns the listing with its review block; swap it for a seller URL and it returns the feedback profile. Because the proxy rotation and parsing run server-side, the failure modes from the earlier sections mostly disappear, and you get parsed fields instead of the regex-and-icon dance the raw feedback page needs. You can start on the free tier from ChocoData, which covers 1,000 requests before you pay anything.

For review and feedback jobs specifically, I point at the dedicated endpoints rather than the generic product one, since each targets a different slice:

Is it legal to scrape eBay reviews and feedback?

Scraping public eBay pages sits in a gray zone, and reviews and feedback add a personal-data wrinkle on top. US courts have generally treated scraping of public data as outside the Computer Fraud and Abuse Act after hiQ Labs v. LinkedIn, but eBay’s User Agreement separately prohibits automated access, and eBay has enforced that in the past. The contract question is independent of the criminal one, and it applies to feedback and reviews the same as to listings.

The personal-data angle is sharper for this data than for prices. Feedback comments are written by identifiable buyers, and their usernames tie to real people, so collecting and storing them brings GDPR and UK GDPR into scope even though the page is public. EU regulators have repeated that “publicly available does not mean free to process.” The clean pattern is to scope collection to the aggregate signals (feedback score, positive percentage, DSRs, review star distributions) and drop individual buyer identities at the parsing stage unless you have a documented basis to keep them. I walk through the policy, robots.txt, and case law in detail in is scraping eBay legal; treat this section as an engineer’s summary, not legal advice.

Which method should you use?

The right method depends on which review surface you need and how much of it, so here is the decision I make in practice. There is no single best route for every job, because product reviews and seller feedback are different collection problems.

Whichever surface you target, three habits keep you out of trouble: keep the request rate low and human-like, collect the aggregate signals rather than individual buyer identities, and honor the robots.txt Disallow on /fdbk/ even though the page responds. If you are building the wider pipeline, my Python walkthrough covers the Akamai 403 and parsing in depth, and my comparison of the best eBay scrapers in 2026 ranks the managed tools head to head.