🛍️ eBay Product Details Scraper

eBay Product Scraper — Extract Details, Pricing and Seller Data

eBay Product Scraper turns a list of eBay item page URLs into clean, structured JSON — product title, price, discount, stock, brand identifiers, category, seller info, images, item specifics, and the full listing description, in one pass per URL. Unlike scraping frameworks that return raw HTML, eBay Product Scraper returns typed JSON — ready for your model, your database, or your pipeline without any parsing. Point it at one item link or a few thousand and it fetches each page directly, escalating through proxy tiers only when eBay pushes back, then writes each listing to the dataset as soon as it's parsed. This guide covers every field returned and how teams run it — from one-off enrichment to scheduled price and stock monitoring.

🧭 What Does eBay Product Scraper Do?

eBay Product Scraper fetches individual eBay item pages — the pages you land on when you click a listing — and parses them into a consistent JSON record covering the product, its pricing, and its seller. No eBay account or login is required: it reads the same public page a logged-out visitor sees. It does not crawl eBay's search results or browse categories on its own; you supply the exact item URLs.

• 📌 Product identity — title, subtitle, condition, item number, canonical URL
• 💰 Pricing — current price, strikethrough "was" price, and computed discount percentage
• 📦 Stock signals — units sold and quantity available, where eBay shows them
• 🔖 Product identifiers — brand, MPN, GTIN, EAN, SKU, pulled from structured data and item specifics
• 🏪 Seller data — store name, feedback percentage, items-sold signal
• 🗂️ Category — the full breadcrumb path shown on the listing
• 📝 Descriptions — the full listing description as plain text and as raw HTML
• 🖼️ Images — the complete photo gallery at full resolution

⚡ Features & Capabilities

eBay Product Scraper's feature set splits into extraction depth, anti-blocking behavior, and where it fits inside a larger eBay data stack.

Core features

• Full item-page extraction in one request per listing: product_title, product_price, wasPrice, discountPercent, sold, quantityAvailable, product_condition, category, brand, mpn, gtin, ean, sku, itemLocation, item_specifics, product_image, item_description, item_description_html, detail_url
• Seller data included on every row — seller_name, seller_items_sold, positive_feedback — with no separate seller lookup needed
• Real-time dataset writes — each listing is pushed to the dataset the moment it's parsed, so the OUTPUT tab fills in during the run rather than at the end
• Uncharged error rows — invalid URLs, removed listings, and blocked requests are still written to the dataset for visibility, but only successful listings are billed under the row_result pay-per-event; filter success: true (or the absence of an errorReason field) to isolate the charged rows
• Typed JSON output — numeric fields (wasPrice, discountPercent, sold, quantityAvailable) are returned as numbers, not strings, so no parsing is needed downstream

What sets it apart

eBay Product Scraper's proxy logic is built around eBay's actual blocking behavior rather than a fixed retry count: every request starts direct (no proxy), only escalates to a datacenter proxy if that fails, and only reaches for residential proxies as a last resort — then stays on residential for the rest of the run once it works once. It also distinguishes a genuinely dead listing (eBay's "Discover error" 404) from a temporary anti-bot block that happens to render a similar-looking error page, so a listing that is merely rate-limited isn't miscategorized as removed. Every field that isn't present on a given listing is returned as null, not omitted or guessed.

When another tool might suit you better

If you're starting from search terms or category browsing rather than item links, this Actor isn't the right entry point — it takes URLs directly and does not perform keyword search or category crawling. For that workflow, use a search-oriented eBay Actor and feed its output URLs into this one. Likewise, if your workflow centers on a seller's whole storefront rather than individual items, a seller/store-focused Actor will get you there with fewer runs.

eBay Product Scraper within the Scrapio data stack

eBay Product Scraper covers individual item listings. For keyword search results and seller store pages, use Ebay Search Scraper & Seller Store Details. Chain the two: run the search Actor to discover item URLs for a query, then feed those URLs into eBay Product Scraper for full listing depth on each result.

Why do developers and data teams scrape eBay?

• 🏢 Resale, repricing and arbitrage

  Sellers and resale operators feed a watch-list of competitor or supplier item URLs through the Actor to pull product_price, wasPrice, discountPercent, and quantityAvailable on a schedule. The output lands in a spreadsheet or pricing database, where a repricing rule can flag any listing that dropped below a threshold or sold out (quantityAvailable hits zero) so a team can react before a resale window closes.

• 📊 AI training data and RAG indexing

  item_description, item_specifics, and product_title are the highest-information text fields for both use cases: item_description (plain text, HTML stripped) gives clean prose for a RAG index answering product questions, while item_specifics — a flat key/value spec table — gives consistently structured attributes (brand, model, size, color) that make good training examples without per-listing schema drift. Combined with category and product_condition, a corpus of listings becomes a queryable product knowledge base for an LLM.

• 📱 Competitive and market intelligence

  Tracking product_price and discountPercent across a competitor's catalog over repeated runs surfaces markdown patterns and pricing strategy changes. sold gives a rough demand signal per listing, useful for spotting which items in a competitor's assortment are actually moving versus sitting unsold.

• 🔬 Research and academic use

  Researchers studying online marketplace pricing, secondhand goods markets, or e-commerce listing behavior can build a dataset from public item pages only — no account access or private data is involved. category, product_condition, and pricing fields support price-dispersion and market-structure studies.

• 🎥 Product and SaaS development

  Catalog enrichment tools, price-comparison features, and marketplace monitoring dashboards can use this Actor as a backend data source: pass in item URLs collected elsewhere and get back a typed record ready to store, without building and maintaining an HTML parser against eBay's front end.

🍚 Input Parameters

eBay Product Scraper takes two inputs, read directly from the Actor's input schema:

Parameter	Required	Type	Constraints	Description
urls	Yes	array	editor: stringList	🔗 Your eBay listing URLs. Add one link or many — each should be a standard eBay item page (copy from the address bar). Bulk-friendly: drop your whole list here and go.
proxyConfiguration	No	object	editor: proxy	🌐 Proxy (optional). First request is always direct (no proxy). If Apify Proxy is on, the Actor can fall back to datacenter then residential (with retries), then stay on residential for the rest of the run. Turn off for direct-only.

JSON input example

{
  "urls": [
    "https://www.ebay.com/itm/276582090868",
    "https://www.ebay.com/itm/155512345678"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Supported URL types and input formats

• urls accepts a plain array of strings, or an array of { "url": "..." } objects — both are normalized to the same list before fetching.
• Each entry must contain ebay.com (case-insensitive) or it is rejected up front as invalid_url and never fetched — only .com item pages are matched; a listing URL from a country-specific eBay domain such as ebay.co.uk, ebay.de, or ebay.ca does not contain that substring and will be skipped as invalid.
• Standard item-page URLs work as-is, including with tracking query parameters — the Actor does not require a stripped or canonical URL.

{ "urls": ["https://www.ebay.com/itm/276582090868"] }

{ "urls": [{ "url": "https://www.ebay.com/itm/276582090868?hash=item...:g:abc" }] }

{ "urls": ["https://www.ebay.com/itm/234567890123", "https://www.ebay.com/itm/345678901234"] }

📦 Output Format

Every run produces one dataset row per input URL — a successful listing row, or an error row when the URL is invalid, the listing can't be found, or the request never got through. Both are typed JSON, and both land in the same dataset for a single export. Only successful listing rows are charged, under the row_result pay-per-event; error rows are pushed without that event, so they cost nothing. To pull only billed rows from an export or the API, filter on success: true.

Output for a product listing

Every key below is copied from the row-building code, not the default dataset view — the view surfaces 21 of these columns by default, but the actor pushes all of them:

{
  "seller_name": "techsurplus_outlet",
  "seller_items_sold": "12.4K",
  "positive_feedback": "99.2% positive",
  "product_title": "Apple iPhone 13 Pro 128GB Graphite Unlocked - Excellent Condition",
  "itemSubtitle": "Fully Tested & Certified Refurbished",
  "product_image": [
    "https://i.ebayimg.com/images/g/abcAAOSwexample1/s-l1600.jpg",
    "https://i.ebayimg.com/images/g/defAAOSwexample2/s-l1600.jpg"
  ],
  "product_price": "US $549.99",
  "wasPrice": 649.99,
  "wasPriceWithCurrency": "US $649.99",
  "discountPercent": 15.4,
  "sold": 87,
  "quantityAvailable": 14,
  "product_condition": "Certified - Refurbished",
  "category": ["Cell Phones & Accessories", "Cell Phones & Smartphones"],
  "brand": "Apple",
  "mpn": "A2483",
  "gtin": "194252707962",
  "ean": "0194252707962",
  "sku": "IP13P-128-GR-RF",
  "itemLocation": "Miami, Florida, United States",
  "shipping_info": "US $0.00 USPS Ground Advantage; Located in: Miami, Florida, United States",
  "delivery_info": "Estimated delivery Thu, Aug 6 to 33101",
  "return_policy": "30 days returns. Buyer pays for return shipping.",
  "item_number": "276582090868",
  "item_description": "This item has been fully tested and inspected by our certified technicians. Includes charging cable. Ships same or next business day.",
  "item_description_html": "<div>This item has been fully tested and inspected by our certified technicians...</div>",
  "item_specifics": {
    "Brand": "Apple",
    "Model": "iPhone 13 Pro",
    "Storage Capacity": "128 GB",
    "Color": "Graphite",
    "Network": "Unlocked"
  },
  "detail_url": "https://www.ebay.com/itm/276582090868",
  "source_url": "https://www.ebay.com/itm/276582090868",
  "success": true,
  "proxyMode": "direct",
  "scrapedAt": "2026-07-30T14:22:05.123456Z"
}

proxyMode on a successful row is one of "direct", "datacenter", or "residential", showing which connection tier actually retrieved that listing.

Output for a skipped or failed listing

An invalid URL never reaches eBay, so its row is narrower — it does not carry a proxyMode:

{
  "source_url": "https://www.ebay.co.uk/itm/155512345678",
  "success": false,
  "error": "Not an eBay URL",
  "errorReason": "invalid_url",
  "scrapedAt": "2026-07-30T14:22:07.001Z"
}

A listing that was reached but confirmed removed, or one that could not be fetched or parsed after proxy escalation, carries proxyMode as either "not_found" or "failed":

{
  "source_url": "https://www.ebay.com/itm/000000000000",
  "success": false,
  "error": "Item not found or no longer available",
  "errorReason": "not_found",
  "proxyMode": "not_found",
  "scrapedAt": "2026-07-30T14:22:10.998Z"
}

Schema stability and export options

Field names stay the same across runs regardless of which proxy tier fetched a given listing — proxyMode and errorReason exist to tell you how a row was produced, not to change its shape. Fields eBay doesn't show on a given listing return as null (or []/{} for list and object fields) rather than being omitted, so downstream schemas stay consistent. The dataset supports Apify's standard export formats — JSON, CSV, Excel, XML, and HTML table — directly from the OUTPUT tab or via the API.

💡 eBay Product Scraper Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger the Actor from your application whenever a new eBay URL needs enriching — a user pastes a link, or an inbound feed references an item number. Run with a single-item urls array, read product_title, product_price, brand, mpn, and item_specifics from the resulting row, and write them onto the record in your own database. Because rows land in the dataset as soon as they're parsed, a single-URL run returns as soon as that one listing is done — no batch wait.

🎯 Strategy 2: Scheduled monitoring and alerting

Run the same urls list on an Apify Schedule (hourly, daily, or whatever cadence fits) and diff each run's product_price, discountPercent, and quantityAvailable against the previous run's dataset for the same item_number. Alert when discountPercent crosses a threshold you care about, or when quantityAvailable drops to a low number or the listing starts returning errorReason: "not_found" — a real signal the item sold out or was pulled.

🎯 Strategy 3: Bulk dataset build

Feed a large urls array — sourced from a search Actor, an export, or your own list — in a single run, or split across parallel runs by URL range for a very large batch. The Actor processes listings sequentially within a run, writing each row as it finishes, so partial results are always visible in the OUTPUT tab even before the run completes. Export the finished dataset to CSV for loading into a warehouse or spreadsheet.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Single-item, on-demand lookups	One-off run, small urls array	JSON row, consumed immediately
Scheduled monitoring	Price/stock tracking on a watch-list	Apify Schedule, repeated urls	JSON, diffed against prior run
Bulk dataset build	Large one-time or periodic collection	Large urls array, one or more runs	CSV/JSON export from the dataset

🌴 Related eBay Scrapers & Tools

Scraper name	What it extracts
Ebay Search Scraper & Seller Store Details	Keyword search results and seller store pages on eBay — pairs with this Actor when you start from a search term instead of item links
Shein Search Products Scraper — Full Product Details	Product listings and specifics from Shein — a cross-platform alternative when your catalog spans marketplaces beyond eBay
Etsy Reviews Scraper (Photos, Translations & Buyer Trust Data)	Buyer reviews and trust signals from Etsy listings — a complementary source when your workflow also needs marketplace review data

How to integrate eBay Product Scraper with your stack

eBay Product Scraper works with any language or tool that can make an HTTP request, via the Apify API and the official apify-client SDKs.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "urls": [
        "https://www.ebay.com/itm/276582090868",
        "https://www.ebay.com/itm/234567890123",
    ],
    "proxyConfiguration": {"useApifyProxy": True},
}

run = client.actor("ebay-product-details-scraper").call(run_input=run_input)

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("success"):
        rows.append(item)

import csv
with open("ebay_listings.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=rows[0].keys())
    writer.writeheader()
    writer.writerows(rows)

Node.js

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<YOUR_APIFY_TOKEN>" });

const run = await client.actor("ebay-product-details-scraper").call({
  urls: [
    "https://www.ebay.com/itm/276582090868",
    "https://www.ebay.com/itm/234567890123",
  ],
  proxyConfiguration: { useApifyProxy: true },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const successful = items.filter((item) => item.success);
console.log(`Fetched ${successful.length} listing(s)`);

Async and scheduled pipelines

For large urls arrays, call the Actor with .call() (synchronous wait) or .start() (fire-and-forget) via apify-client, then poll the run status or dataset item count until it finishes. For recurring collection, use an Apify Schedule to trigger the Actor on a cron-style cadence against a stored urls list, and pull the new dataset via the API after each scheduled run completes.

🎯 Who Needs eBay Product Scraper? (Use Cases & Industries)

• 🏢 Resellers and repricing teams

  Pull product_price and quantityAvailable across a watch-list of source listings before setting or adjusting a resale price, catching a supplier's price drop or stockout the same day it happens.

• 📊 AI and data teams

  Build a RAG index or training set from item_description, item_specifics, and product_title across a category of listings, giving an LLM structured product knowledge without a custom HTML parser.

• 📱 Market and competitive analysts

  Track discountPercent and sold across a competitor's catalog over time to spot markdown timing and which listings actually move.

• 🔬 Researchers

  Build a dataset of public eBay listing prices, conditions, and categories for market-structure or pricing research, without touching any account-gated data.

• 🎥 Product and catalog-tool builders

  Use the Actor as the extraction backend for a price-comparison feature, catalog enrichment service, or marketplace monitoring dashboard, feeding it URLs collected by your own application.

Is it legal to scrape eBay?

Scraping publicly accessible web pages — pages that don't require a login — is generally lawful in the United States; in hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019), the Ninth Circuit held that scraping data not gated behind a login does not violate the Computer Fraud and Abuse Act. That precedent addresses federal computer-access law, not eBay's own contract terms. Separately, eBay's Terms of Service restrict automated data collection, and violating them is a matter of civil contract risk between you and eBay — not a criminal offense. eBay Product Scraper returns only publicly accessible listing, pricing, and store data — no eBay account is used and no personal buyer data is collected — so data protection frameworks like GDPR, which govern personal data, do not attach to this Actor's output. What you do with the data is your responsibility — consult legal counsel for commercial applications.

❓ Frequently asked questions

Does eBay Product Scraper work without an eBay account?

Yes. The Actor fetches each item page the same way a logged-out visitor would, with no eBay login, cookies, or API credentials required.

How does eBay Product Scraper handle eBay's anti-scraping measures?

It starts every request direct with no proxy, escalates to a datacenter proxy if that's blocked, then to a residential proxy for up to 3 attempts, and stays on residential for the rest of the run once a residential fetch succeeds. It also tells apart a confirmed-dead listing (a real 404 "Discover error" page) from a same-looking page that's actually a temporary anti-bot block, so a rate-limited listing isn't wrongly marked as removed.

Can I run eBay Product Scraper at scale without getting blocked?

There's no published throughput ceiling — the Actor processes listings one at a time within a run, pausing roughly half a second to a second between requests, and switches to residential proxies automatically if direct and datacenter connections stop working. No uptime or success-rate figure is published for this behavior.

How fresh is the data eBay Product Scraper returns?

Every run fetches the live item page at request time — nothing is cached or served from a prior run. The scrapedAt field on each row records exactly when that fetch happened.

Is scraping eBay's public listings legal?

Scraping publicly accessible pages is generally lawful under U.S. federal computer-access law, per hiQ Labs, Inc. v. LinkedIn Corp., 938 F.3d 985 (9th Cir. 2019) — but eBay's Terms of Service separately restrict automated collection, which is a civil contract matter, not a criminal one. See the legal section above for the full breakdown.

Which eBay fields work best for AI training and RAG indexing?

item_description gives clean plain-text prose for RAG retrieval, while item_specifics is a consistently structured key/value table (brand, model, size, color) that makes a reliable training feature set across listings. product_title and category add short, high-signal context for both. All fields return as typed primitives — strings, numbers, arrays, or objects — needing no normalization before use.

Does eBay Product Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes, as an HTTP endpoint callable by any agent framework through the Apify API — there is no dedicated MCP server for this Actor. Each response is typed JSON, so an agent can consume a listing's fields directly without parsing HTML or scraped text.

How does eBay Product Scraper compare to other eBay scrapers?

It's built specifically for individual item pages, not search results or seller stores — if you need search or storefront data, pair it with Ebay Search Scraper & Seller Store Details rather than expecting one Actor to do both. Within its scope, it distinguishes genuinely dead listings from temporary blocks and pushes error rows uncharged, which not every item-page scraper documents.

ℹ️ Disclaimer

eBay Product Scraper extracts only publicly available data from eBay. This tool is intended for lawful use cases only. Users are responsible for complying with eBay's terms of service and applicable data protection laws in their jurisdiction.