eBay Seller Scraper — Full Listings, Specifics & Shipping

eBay Scraper — Extract Seller Listings, Specifics and Shipping

eBay Seller Scraper — Full Listings, Specifics & Shipping turns any eBay seller profile URL into structured JSON: seller identity and feedback score, every live listing across the seller's full inventory (not just page one), and — per listing — condition, shipping, delivery, returns, a structured item-specifics table, full description, complete image gallery, and item number. Unlike scraping frameworks that return raw HTML, it returns typed JSON — ready for your model, your database, or your pipeline without any parsing. This guide covers the exact output shape and how teams deploy it for sourcing, monitoring, and dataset builds.

🧭 What Does eBay Seller Scraper — Full Listings, Specifics & Shipping Do?

It scrapes public eBay seller storefront pages (/usr/<seller> or, when the seller runs an eBay Store, /str/<seller>) and returns one dataset row per seller: name, feedback score, and the full list of that seller's live listings. No eBay account or login is required — the Actor reads only what any logged-out visitor can see on the page. When per-item enrichment is on, it also opens each listing's own item page to pull the fields the storefront card doesn't carry.

Key capabilities:

• Scrapes seller identity and reputation — display name and feedback score from the storefront header.
• Harvests every listing on the seller's page: title, price, deep link, item ID, and image, deduplicated by real eBay item ID.
• Pages through a seller's entire inventory (_pgn=1..N) instead of stopping at the first page, auto-detecting whether the seller uses the /str/ Store surface or the plain /usr/ profile surface.
• Enriches listings with condition, shipping, delivery, returns, item specifics, full description, image gallery, and item number by fetching each item's own page.
• Computes discountPercent and flags hasBestOffer once a listing's original price is actually present on the page.
• Stamps every row with a scrapedAt ISO timestamp and reports pagesScraped / totalListingsScraped per seller.

⚡ Features & Capabilities

The Actor's capabilities split into full-inventory harvesting, per-item enrichment, and reliability handling.

Core features

• Full-inventory pagination — walks _pgn=2,3,4… across a seller's storefront until no new listings appear, instead of the ~65-item single-page snapshot most seller scrapers return.
• Store vs. profile surface detection — probes /str/<seller> first; Store sellers paginate there, individual (non-Store) sellers are served from /usr/<seller> (their /str/ page returns HTTP 410).
• Per-item detail enrichment — one GET per listing's product_url, returning condition, shipping, delivery, returns, itemSpecifics (a label→value dictionary — brand, model, size, colour, and every other spec eBay shows), description, images, and itemNumber.
• Item-ID deduplication — listings are deduplicated on the real eBay item ID rather than (title, price), so two distinct items that happen to share both never silently merge.
• Session-warmed requests — one persistent HTTP session per seller means the storefront fetch (which every run already does) seeds the cookies the item-detail fetch needs, instead of a second cold request that eBay's bot manager blocks.
• Direct → datacenter → residential proxy ladder — escalates connection tier automatically when a fetch is blocked, on both the storefront and item-detail requests.
• Backward-compatible input — the legacy urls input key (from the base seller scraper) still works alongside the new sellerProfileLinks key.

eBay Seller Scraper — Full Listings, Specifics & Shipping within the Scrapio data stack

This Actor covers seller profiles and their full listings. For item- and search-level data instead of a specific seller's inventory — sold/completed comps, multi-page search pagination, and derived price-trend analytics (average, min/max, price-by-condition) — use eBay Scraper: Sold Listings & Price Trend Analytics, also in the Scrapio eBay lineup.

Why do developers and data teams scrape eBay?

Different teams pull different slices of the same seller/listing data. The audiences below are the ones that genuinely apply to a seller-inventory scraper.

🏢 E-commerce sourcing, dropshipping & competitor research

A sourcing or reseller team points sellerProfileLinks at a competitor's or supplier's storefront, turns on fetchFullItemDetails, and gets back every live listing with price, original_price, discountPercent, condition, and itemSpecifics in one pass. That output drops straight into a sourcing spreadsheet or pricing model — no manual page-by-page browsing of a seller with hundreds of items, and no missing items because of pagination.

📊 AI training data and RAG indexing

description (full free-text item description) and itemSpecifics (a structured label→value dictionary of brand, model, condition, and category-specific attributes) are the two fields that make eBay listing data useful for AI: description is high-information unstructured text for RAG retrieval, and itemSpecifics gives training pipelines consistently structured key-value pairs across records — usable directly for e-commerce entity extraction or product-attribute training data without further parsing.

📱 Competitive and market intelligence

Re-running the same sellerProfileLinks list on a schedule lets a team track how a seller's totalListingsScraped, price, and discountPercent move over time — catching new listings, delistings, and price cuts as they happen rather than relying on a one-time snapshot.

🔬 Research and academic use

itemSpecifics, condition, and price across many public seller storefronts support market-structure and pricing research. The Actor only ever reads what buyers can already see on public eBay pages — no login, no private data.

🎥 Product and SaaS development

Teams building a price-comparison tool, a seller-monitoring dashboard, or a catalog enrichment API can use this Actor as the data layer: point it at a list of sellers, store the returned listings[] array, and build the product logic on top of already-typed JSON.

🍚 Input Parameters

All parameters are optional — the Actor requires no auth, only at least one seller URL to do anything.

Parameter	Required	Type	Description	Example Value
sellerProfileLinks	No	array (string list)	One eBay seller profile URL per line. Supports a single seller or a list for bulk runs. Also accepts the base actor's urls key for backward compatibility. No functional default — an empty list makes the run log a warning and exit with nothing scraped.	["https://www.ebay.co.uk/usr/chrisjoh7639"]
fetchFullItemDetails	No	boolean	When true (default), fetches each listing's own item page for condition/shipping/delivery/returns/specifics/description/gallery/item number — one extra GET per listing. When false, only the storefront-card fields are collected, with zero extra requests.	true
maxListingsToEnrichPerSeller	No	integer, minimum 0	Caps how many listings per seller get the full item-detail fetch. Default 10. 0 = enrich every listing found (slower on very large sellers).	10
fetchAllListingPages	No	boolean	When true (default), pages through _pgn=2,3,4… until no more results appear. When false, only page 1 is scraped (matches the original base actor).	true
maxPagesPerSeller	No	integer, minimum 0	Safety cap on listing pages fetched per seller when fetchAllListingPages is on. Default 0 = no explicit cap, but an internal 50-page safety limit always applies so a run can never loop forever.	0
proxyConfiguration	No	object (Apify proxy editor)	Optional Apify Proxy settings. Default {"useApifyProxy": false} (no proxy) — the Actor works with seller URLs only and escalates to Apify Proxy automatically if a request is blocked. Do not select "Own proxies" and leave it empty.	{"useApifyProxy": false}

Example input

{
  "sellerProfileLinks": ["https://www.ebay.co.uk/usr/chrisjoh7639"],
  "fetchFullItemDetails": true,
  "maxListingsToEnrichPerSeller": 10,
  "fetchAllListingPages": true,
  "maxPagesPerSeller": 0,
  "proxyConfiguration": { "useApifyProxy": false }
}

Supported URL types and input formats

The Actor reads the seller username out of either a /usr/<username> path or an _ssn=<username> query parameter — any eBay domain (.com, .co.uk, etc.) that follows that URL shape works.

{ "sellerProfileLinks": ["https://www.ebay.co.uk/usr/chrisjoh7639"] }

Individual (non-Store) seller — served from /usr/; a single-page inventory since these accounts don't paginate.

{ "sellerProfileLinks": ["https://www.ebay.co.uk/usr/musicmagpie"], "fetchAllListingPages": true }

eBay Store seller — the Actor auto-detects the /str/ surface and pages through the full multi-page catalog.

{ "urls": ["https://www.ebay.co.uk/usr/chrisjoh7639"] }

Legacy input shape from the base seller scraper — still accepted unchanged.

📦 Output Format

Every run produces typed, normalized JSON with a stable field set — no HTML, no manual parsing. Results are available as JSON, CSV, Excel, XML, or RSS export from the Actor's Output tab (or the equivalent Apify API/dataset-download endpoint), and each pushed row is billed once under the row_result charged event.

Output for sellers

One dataset row per seller URL, bundling that seller's identity, run metadata, and full listing array:

{
  "url": "https://www.ebay.co.uk/usr/exampleseller",
  "name": "exampleseller",
  "feedback_score": "99.1% positive",
  "pagesScraped": 2,
  "totalListingsScraped": 110,
  "scrapedAt": "2026-07-25T13:38:00+00:00",
  "listings": [ ]
}

url/name/feedback_score/listings[].{title,price} are unchanged from the base seller scraper this Actor extends; pagesScraped, totalListingsScraped, and scrapedAt are additions.

Output for listings

Each entry in listings[] carries every field this Actor can produce for a single item — the storefront-harvested fields plus, once enrichment runs, the full item-detail fields:

{
  "title": "Vintage 35mm Film Camera",
  "price": "£45.00",
  "product_url": "https://www.ebay.co.uk/itm/236039255082",
  "itemId": "236039255082",
  "condition": "New with box: This item is brand new and has never been used",
  "original_price": "£65.00",
  "image_url": "https://i.ebayimg.com/images/g/xyz/s-l500.jpg",
  "hasBestOffer": true,
  "discountPercent": 30.77,
  "shipping": "Will post to United States. Read item description or contact seller for postage",
  "delivery": "Estimated between Tue, 4 Aug and Fri, 7 Aug",
  "returns": "30 days return. Buyer pays for return postage.",
  "itemSpecifics": {
    "Brand": "Nikon",
    "Model": "F3",
    "Colour": "Black",
    "Type": "35mm Film Camera"
  },
  "description": "Experience comfort and style with this camera. Fully tested and working...",
  "images": [
    "https://i.ebayimg.com/images/g/abc123/s-l1600.jpg",
    "https://i.ebayimg.com/images/g/def456/s-l1600.jpg"
  ],
  "itemNumber": "236039255082",
  "detailFetched": true
}

That's 17 fields per listing plus the 6 seller-level fields above — 23 fields total per fully-enriched row. condition/shipping/delivery/returns/itemSpecifics/description/images/itemNumber stay empty (""/{}/[]) and hasBestOffer/discountPercent stay null until per-item enrichment actually runs on that listing — never fabricated. detailFetched tells you, per listing, whether that happened.

Schema stability and export options

Field names are stable across runs and don't change when eBay updates its front end — the Actor's parsing targets semantic markup (str-item-card, ux-labels-values, structured ld+json product data) rather than volatile CSS classes, and unchanged base-actor fields (url, name, feedback_score, listings[].{title,price}) are kept for backward compatibility. Export the dataset as JSON, CSV, Excel, XML, or RSS directly from the Output tab, or pull it programmatically via the Apify API/dataset endpoints.

💡 eBay Seller Scraper — Full Listings, Specifics & Shipping Strategy Guide

🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new seller URL enters your system — from a lead list, a marketplace search, or a partner feed. Call the Actor with that single URL in sellerProfileLinks, fetchFullItemDetails: true, and a small maxListingsToEnrichPerSeller for a fast response. Append the returned name, feedback_score, and each listing's condition/itemSpecifics/shipping to your CRM, PIM, or sourcing record, keyed on itemId. The response is typed JSON, so no HTML parsing sits between the Actor and your destination table — the enrichment call and the write-back can sit in the same request/response cycle as the event that triggered them.

🎯 Strategy 2: Scheduled monitoring and alerting

Run the same sellerProfileLinks list on a recurring Apify Scheduler job (e.g. daily). Diff each new run's listings[] against the previous run on itemId, comparing price, discountPercent, and totalListingsScraped. Alert on the deltas that matter to you: a new itemId appearing (new listing), an itemId disappearing (sold or delisted), or a price drop combined with a new non-null discountPercent. scrapedAt on each row gives you the exact comparison timestamp, so alerts can report not just what changed but when the change was first observed. Keep fetchFullItemDetails on for watchlists small enough to enrich fully, or cap maxListingsToEnrichPerSeller if you only need to track headline price and stock-count movement on very large sellers.

🎯 Strategy 3: Bulk dataset build

For a research or training dataset, pass a large sellerProfileLinks list in one run with fetchAllListingPages: true and maxListingsToEnrichPerSeller: 0 to enrich every listing found, then export the dataset to CSV or load it into a database via the Apify API. Sellers are processed one after another within a run (not internally parallelized) — for very large seller lists, splitting the list across several parallel Actor runs shortens wall-clock time more than raising input caps on a single run. The internal 50-page-per-seller safety cap always applies regardless of maxPagesPerSeller, so even an unrealistically high cap value can't turn a single seller into a runaway job. Because listings dedupe on the real eBay item ID rather than title and price, repeated bulk runs against the same seller list stay safe to merge into one growing dataset without creating duplicate records for re-listed items.

Strategy comparison at a glance

Strategy	Best for	Run pattern	Output format
Real-time enrichment	Single new seller appearing in your system	On-demand, one URL per call	JSON row, written to your own store
Scheduled monitoring	Tracking known sellers over time	Recurring Apify Scheduler run, diffed on itemId	JSON, diffed against the previous run's dataset
Bulk dataset build	Research or training corpus across many sellers	One run, large sellerProfileLinks list, or multiple parallel runs	Dataset export to CSV/JSON via Apify API

🌴 Related eBay Scrapers & Tools

Scraper Name	What it extracts
eBay Scraper: Sold Listings & Price Trend Analytics	Sold/completed eBay search and item listings with derived price-trend analytics (average, min/max, price-by-condition) — item- and search-level rather than seller-level.
Amazon Seller Data Extractor	Seller profile data (name, ratings, feedback, policies) on Amazon — the cross-platform equivalent of this Actor's seller entity.
Extract Emails Contacts Socials: Verified Phone & Email List	General-purpose contact-detail scraper for any website — a complementary tool for enriching a seller's linked storefront or business site with contact information.

How to integrate eBay Seller Scraper — Full Listings, Specifics & Shipping with your stack

eBay Seller Scraper — Full Listings, Specifics & Shipping works with any language or tool that can call the Apify API — the two paths below are the ones this Actor genuinely supports.

Python

import csv
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

seller_urls = [
    "https://www.ebay.co.uk/usr/chrisjoh7639",
    "https://www.ebay.co.uk/usr/musicmagpie",
]

run_input = {
    "sellerProfileLinks": seller_urls,
    "fetchFullItemDetails": True,
    "maxListingsToEnrichPerSeller": 10,
    "fetchAllListingPages": True,
    "maxPagesPerSeller": 0,
}

run = client.actor("YOUR_USERNAME/ebay-seller-scraper-full-listings-specifics-and-shipping").call(
    run_input=run_input
)

rows = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    for listing in item.get("listings", []):
        rows.append({
            "seller": item.get("name"),
            "feedback_score": item.get("feedback_score"),
            "title": listing.get("title"),
            "price": listing.get("price"),
            "condition": listing.get("condition"),
            "itemNumber": listing.get("itemNumber"),
        })

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

print(f"Wrote {len(rows)} listing rows to ebay_seller_listings.csv")

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_API_TOKEN>' });

const run = await client.actor('YOUR_USERNAME/ebay-seller-scraper-full-listings-specifics-and-shipping').call({
  sellerProfileLinks: ['https://www.ebay.co.uk/usr/chrisjoh7639'],
  fetchFullItemDetails: true,
  maxListingsToEnrichPerSeller: 10,
  fetchAllListingPages: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const seller of items) {
  console.log(`${seller.name} (${seller.feedback_score}) — ${seller.totalListingsScraped} listings`);
}

Async and scheduled pipelines

Runs started via the API are asynchronous by default — call .call() (or its start-and-poll equivalent) and poll the run status, or use waitForFinish in the client SDKs, rather than expecting a synchronous response. For recurring collection, use the Apify Scheduler to trigger this Actor on a cron interval and read the latest dataset from each run; the Actor itself has no built-in webhook delivery, so poll-on-completion or a scheduled-run pattern is the supported path for fire-and-forget large jobs.

🎯 Who Needs eBay Seller Scraper — Full Listings, Specifics & Shipping? (Use Cases & Industries)

🏢 E-commerce sourcing, dropshipping & competitor research

A reseller pulls a supplier's or competitor's full listings[] — price, original_price, discountPercent, condition — to spot underpriced stock or track how a rival's catalog changes, without manually opening hundreds of item pages.

📊 AI/ML teams building training data and RAG pipelines

Teams indexing e-commerce data for retrieval or fine-tuning pull description (rich unstructured text) and itemSpecifics (consistently structured attributes) straight from the dataset — both already typed, with no HTML to strip.

📱 Marketplace analysts and competitive intelligence teams

Analysts schedule recurring runs against a watchlist of sellers and track totalListingsScraped and per-item price/discountPercent over time to catch new stock, price cuts, and delistings as they happen.

🔬 Researchers

Academics and market researchers use itemSpecifics, condition, and price across public seller storefronts for pricing- and market-structure studies, working only from data already visible to any logged-out visitor.

🎥 SaaS and product builders

Teams building a price-comparison tool, seller-monitoring dashboard, or catalog-enrichment product use this Actor as their eBay data layer, storing the returned JSON directly instead of building and maintaining their own eBay parser.

Is it legal to scrape eBay?

Scraping publicly accessible web pages is generally lawful in the US — hiQ Labs, Inc. v. LinkedIn Corp. (9th Cir. 2019) held that scraping data a website makes available to logged-out visitors does not violate the Computer Fraud and Abuse Act. That precedent covers the technical act of scraping; it does not override eBay's own Terms of Service, which separately restrict automated access — a ToS violation is a civil contract matter between you and eBay, not a criminal one. This Actor returns seller display names, feedback scores, and listing/item data that eBay already shows to any visitor; it does not collect emails, phone numbers, or physical addresses, so standard personal-data-protection obligations largely don't apply to its output — though an individual (non-Store) seller's storefront may display a general location string as part of the listing/shipping text, which you should treat with the same care as any other public business-facing data. eBay Seller Scraper — Full Listings, Specifics & Shipping returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

❓ Frequently asked questions

Does eBay Seller Scraper — Full Listings, Specifics & Shipping work without an eBay account?

No account or login is required. The Actor fetches only the public seller storefront pages (/usr/ or /str/) and public item pages that any logged-out visitor can view.

How does it handle eBay's anti-scraping measures?

Every fetch runs through a direct → datacenter → residential proxy escalation ladder when blocked, using a persistent per-seller HTTP session so item-page requests inherit the bot-manager cookies the storefront fetch already picked up. Responses are also checked against known Akamai challenge-page markers (not just HTTP status), so a "200 OK" soft-block page is detected and retried rather than parsed as real data.

Can I run it at scale without getting blocked?

The proxy ladder and challenge-page detection reduce blocking, but there's no published uptime or success-rate guarantee. Within a run, sellers and their listings are processed one at a time rather than in parallel, and an internal 50-page-per-seller cap always applies; for large-scale collection, splitting a long seller list across multiple parallel Actor runs scales better than one very large run.

How fresh is the data this Actor returns?

Every run performs a live fetch of the seller's current storefront and item pages — nothing is cached or reused from a prior run. Each row carries its own scrapedAt timestamp for exactly that reason.

Which fields work best for AI training and RAG indexing?

For RAG, description is the high-information free-text field worth embedding. For training data, itemSpecifics gives the most consistently structured attributes across records (brand, model, colour, and category-specific specs as label→value pairs). Every field returns as a typed primitive — string, number, boolean, or nested object/array — requiring no normalization before use.

Does this Actor collect seller personal data?

No. It returns the seller's public display name, feedback score, and listing data — never an email address, phone number, or physical address. Some individual sellers' storefronts display a general shipping-from location as free text; that's public listing data, and lawful basis for any further storage or use sits with you as the operator.

Does it 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. Every response is typed JSON, so it can be passed directly into an LLM context window without a parsing step.

What happens to listings beyond maxListingsToEnrichPerSeller?

Every listing on the page is still returned, but only the first maxListingsToEnrichPerSeller (default 10) get the extra item-detail fetch. Listings beyond that cap keep the storefront-only fields (title, price, product_url, image_url) with condition/shipping/delivery/returns/itemSpecifics/description/images/itemNumber left blank and detailFetched: false — never filled with guessed values.

Does full-inventory pagination work for every seller?

It depends on the seller type. eBay Store sellers paginate through their /str/ storefront, and the Actor pages through their full catalog there. Individual (non-Store) sellers only have the single-page /usr/ profile, which doesn't paginate — for those sellers, page 1 already is the full inventory.

ℹ️ Disclaimer

eBay Seller Scraper — Full Listings, Specifics & Shipping 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.