# eBay Scraper — Listings, Prices & Sold Items API (`logiover/ebay-scraper`) Actor Scrape eBay listings by keyword, category, seller or item URL. Extract title, price, shipping, condition, seller, bids, sold count, ratings and more — including SOLD/completed listings for price research. No API key, no login. - **URL**: https://apify.com/logiover/ebay-scraper.md - **Developed by:** [Logiover](https://apify.com/logiover) (community) - **Categories:** E-commerce - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## eBay Scraper — Listings, Prices, Sold Items & Seller Data (No API Key) Scrape eBay listings at scale without an API key, a developer account or a login. This eBay Scraper turns eBay's own search and item pages into clean, structured **JSON, CSV or Excel** data — with real numeric prices, shipping costs, seller feedback, bid counts, sold quantities and **SOLD/completed listings** for price research. Point it at a keyword, a category, a seller or an item URL and export hundreds to thousands of rows per run. Whether you are tracking competitor prices, building a resale pricing model, feeding a product catalog, or researching what an item actually sells for, this actor gives you eBay product data that you can drop straight into a spreadsheet, a database or an AI agent. --- ### What does the eBay Scraper do? The actor talks directly to eBay's public **search results HTML** (`/sch/i.html`) and item pages using `got-scraping` for realistic browser TLS and header fingerprinting, routed through Apify Proxy so eBay serves the same page a normal shopper sees. It parses each listing card with `cheerio`, extracts 25+ fields, and stores **numbers as real numbers** and **booleans as booleans** — no messy `"$1,299.00"` strings when you want to sort or sum. Each results page returns up to **240 listing cards** (`_ipg=240`), and the scraper paginates (`_pgn`) until it hits your `maxResults` or a built-in time budget, so a single run can yield **hundreds to thousands** of items. It supports five modes — keyword search, category browse, **sold/completed listings**, seller inventory, and deep item-detail lookups — and works across 16 eBay marketplaces (US, UK, DE, AU, FR, IT, ES, CA and more). No API key, no OAuth, no cookies. --- ### Who is it for? - **E-commerce sellers & resellers** who need live competitor prices and want to know what an item *actually* sells for before they list. - **Price-monitoring & repricing teams** building automated pricing models from real market data. - **Retail & market analysts** studying demand, sell-through rates and price distributions across categories. - **Dropshippers & arbitrage hunters** sourcing profitable products and validating margins with sold data. - **Developers & data scientists** who want an eBay product data API without applying for eBay's official Developer Program keys. --- ### Use cases - **Sold-listings price research** — pull completed/SOLD results for a product to see the true selling price range, median and velocity before you buy or list. - **Competitor price tracking** — schedule daily runs on a keyword or category and watch how competitors' prices, shipping and stock move over time. - **Product catalog enrichment** — scrape item specifics (brand, MPN, UPC, model, color) to fill gaps in your own catalog. - **Seller / store intelligence** — export every active listing from a competitor's store to analyze their assortment, price points and conditions. - **Deal & arbitrage sourcing** — filter by condition, price range and Buy-It-Now to surface underpriced inventory you can flip. --- ### Why use this eBay Scraper? - **No API key, no login** — nothing to register, no rate-limited developer token; just run it. - **25+ rich fields per item** — price, shipping, condition, buying format, bids, time left, sold count, ratings, item location and more, all cleanly typed — plus seller, brand, specifics, returns & quantity via one-flag `enrichDetails`. - **SOLD/completed listings** — the single most valuable eBay data for pricing, and hard to get from the official API. - **Bulk & paginated** — up to 240 items/page, thousands of rows per run via real pagination. - **Powerful dropdown filters** — condition, buying format, sort, free shipping, price range and marketplace, all as friendly menus. - **Export anywhere** — JSON, CSV, Excel, or straight into Google Sheets, a webhook, Zapier, Make or your database. Pay only for the results you keep. --- ### What data can you extract? For every listing card (search / category / sold / sellerItems modes) the scraper returns: | Field | Type | Description | |---|---|---| | `itemId` | string | eBay item id (from the `/itm/` URL) | | `title` | string | Listing title | | `price` | number | Price as a real number (lower bound if a range) | | `priceMin` / `priceMax` | number | Range bounds when the listing shows a price range | | `currency` | string | ISO currency code (USD, GBP, EUR, …) | | `priceText` | string | Original price text as shown on eBay | | `shippingCost` | number | Shipping cost as a number (`0` = free shipping) | | `shippingText` | string | Original shipping text | | `condition` | string | Item condition (New, Used, Refurbished, …) | | `listingType` | string | `Buy It Now` or `Auction` | | `buyingFormat` | string | Human-readable format — `Buy It Now`, `Buy It Now or Best Offer` or `Auction` (always populated) | | `bidsCount` | number | Number of bids (auctions only) | | `timeLeft` | string | Time remaining for auctions | | `bestOffer` | boolean | Whether the listing accepts Best Offer | | `location` / `itemLocation` | string | Item location / country of origin (populated on the majority of cards) | | `productRating` | number | Star rating (when shown) | | `reviewsCount` | number | Number of product reviews | | `soldCount` | number | Units sold (when shown) | | `watchers` | number | Watcher count (when shown) | | `topRated` | boolean | Top Rated Seller badge | | `imageUrl` | string | Primary thumbnail image URL | | `itemUrl` | string | Clean item URL (tracking params stripped) | | `_mode` | string | Which mode produced the row | | `scrapedAt` | string | ISO timestamp of the scrape | **Seller & deep fields on list results** — eBay's search cards do **not** carry the seller or full item specifics, so `sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`, `brand`, `itemSpecifics`, `returnsAccepted`, `quantityAvailable` and `quantitySold` are filled on list-mode rows only when you enable **`enrichDetails`** (see below). Without it, those columns are `null` on search/category/sold/sellerItems rows (the fast path). They are always present in `productDetail` mode. The **productDetail** mode (and `enrichDetails`) adds from the item page: `sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`, precise `itemLocation`, `brand`, `mpn`, `upc`, `model`, `color`, `type`, `itemSpecifics` (full spec table), `quantityAvailable`, `quantitySold`, `availability`, `returnsAccepted`, `returnsText`, and a `descriptionSnippet`. #### Enrich each result with seller & full item details Set **`enrichDetails: true`** to turn every list result into a full record. For each row the actor also opens its eBay item page (with a bounded concurrent worker pool, inside the same time budget) and merges in the **seller** (`sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`), the precise **`itemLocation`**, **`itemSpecifics`**, **`brand`**, **`returnsAccepted`**, **`quantityAvailable`** and **`quantitySold`**. It is **off by default** so high-volume runs stay fast — turn it on with a smaller `maxResults` (e.g. 40–200) when you need seller-level data. ```json { "mode": "search", "query": "laptop", "maxResults": 100, "enrichDetails": true } ```` #### Example output (search / sold card) ```json { "_mode": "search", "itemId": "364567890123", "title": "Dell Latitude 7420 14\" Laptop i7-1185G7 16GB 512GB SSD Win11", "price": 329.99, "priceMin": null, "priceMax": null, "currency": "USD", "priceText": "$329.99", "shippingCost": 0, "shippingText": "Free shipping", "condition": "Used", "listingType": "Buy It Now", "buyingFormat": "Buy It Now or Best Offer", "bidsCount": null, "timeLeft": null, "bestOffer": true, "location": "United States", "itemLocation": "United States", "productRating": 4.5, "reviewsCount": 37, "soldCount": 142, "watchers": 18, "topRated": true, "imageUrl": "https://i.ebayimg.com/images/g/abcAAOSw.../s-l500.jpg", "itemUrl": "https://www.ebay.com/itm/364567890123", "scrapedAt": "2026-07-23T12:00:00.000Z" } ``` > Add `"enrichDetails": true` and each of these rows also gains `sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`, a precise `itemLocation`, `brand`, `itemSpecifics`, `returnsAccepted`, `quantityAvailable` and `quantitySold`. *** ### How to use #### Option A — Search by keyword (most common) 1. Set **Mode** to *Search by keyword*. 2. Type a **Search keyword** (e.g. `nike air max`). 3. Optionally pick a **Condition**, **Buying format**, **Sort**, **price range** or **eBay site**. 4. Set **Max results** (e.g. `600`) and click **Start**. ```json { "mode": "search", "query": "nike air max", "condition": "3000", "buyingFormat": "BIN", "sort": "15", "domain": "ebay.com", "maxResults": 600 } ``` #### Option B — Sold / completed listings (price research) Set **Mode** to *Sold / completed listings* and give a keyword — the actor pulls the completed, sold results so you can analyze the real selling price. ```json { "mode": "sold", "query": "iphone 13 pro 256gb", "domain": "ebay.com", "maxResults": 500 } ``` #### Option C — Category, seller or item detail - **Category:** paste a numeric `categoryId` (e.g. `177`) or a full `categoryUrl`. - **Seller items:** set `seller` to an eBay username. - **Item detail:** set `mode` to `productDetail` and give an `itemUrl`, a list of `itemUrls`, or a list of `itemIds`. ```json { "mode": "productDetail", "itemUrls": ["https://www.ebay.com/itm/364567890123"] } ``` > **Empty input works too.** Run the actor with `{}` and it browses the broad default query (`laptop`) so you always get data back. *** ### Input parameters | Parameter | Type | Default | Description | |---|---|---|---| | `mode` | select | `search` | `search`, `category`, `sold`, `sellerItems`, or `productDetail` | | `query` | string | `laptop` | Keyword for search/sold (also filters category/seller) | | `categoryId` | string | – | Numeric eBay category id (category mode) | | `categoryUrl` | string | – | Paste an eBay category/search URL (overrides categoryId) | | `seller` | string | – | eBay seller username (sellerItems mode) | | `itemUrl` / `itemUrls` | string / array | – | Item URL(s) for productDetail | | `itemIds` | array | – | Item id(s) for productDetail | | `condition` | select | Any | New, Used, Refurbished, For parts, … | | `buyingFormat` | select | Any | Buy It Now, Auction, Best Offer | | `sort` | select | Best Match | Ending soonest, newly listed, price + shipping, … | | `freeShipping` | boolean | `false` | Only free-shipping listings | | `priceMin` / `priceMax` | string | – | Price range bounds | | `domain` | select | `ebay.com` | eBay marketplace (16 sites) | | `maxResults` | integer | `200` | Row cap (drives pagination) | | `enrichDetails` | boolean | `false` | Also open each result's item page to add seller, precise location, item specifics, brand, returns & quantity (slower) | | `proxy` | object | Apify Proxy | Proxy configuration (residential, pinned to the site's country) | Full input example: ```json { "mode": "search", "query": "mechanical keyboard", "condition": "1000", "buyingFormat": "BIN", "sort": "15", "freeShipping": true, "priceMin": "30", "priceMax": "200", "domain": "ebay.com", "maxResults": 800, "proxy": { "useApifyProxy": true } } ``` *** ### Output example (productDetail) ```json { "_mode": "productDetail", "itemId": "364567890123", "title": "Sony WH-1000XM5 Wireless Noise Cancelling Headphones - Black", "price": 279.99, "currency": "USD", "condition": "New", "brand": "Sony", "mpn": "WH1000XM5/B", "upc": "027242923058", "model": "WH-1000XM5", "color": "Black", "itemSpecifics": { "Brand": "Sony", "Model": "WH-1000XM5", "Connectivity": "Bluetooth", "Type": "Over-Ear" }, "quantityAvailable": 12, "quantitySold": 431, "availability": "InStock", "productRating": 4.8, "reviewsCount": 1268, "sellerName": "electronics_hub", "sellerFeedbackCount": 152340, "sellerPositivePercent": 99.6, "shippingText": "Free shipping", "shippingCost": 0, "returnsText": "30 days returns. Buyer pays return shipping.", "itemLocation": "United States", "descriptionSnippet": "Industry-leading noise cancellation with two processors...", "imageUrl": "https://i.ebayimg.com/images/g/xyzAAOSw.../s-l1600.jpg", "itemUrl": "https://www.ebay.com/itm/364567890123", "scrapedAt": "2026-07-23T12:00:00.000Z" } ``` *** ### Tips for best results - **Use `sold` mode for pricing.** Active listings show asking prices; sold listings show what buyers actually paid — far more useful for valuation. - **Narrow with a keyword.** Even in category or seller modes, adding a `query` sharpens the result set and speeds up runs. - **Combine filters** (condition + price range + buying format) to cut noise and stay under `maxResults` with only relevant items. - **Pick the right `domain`.** Scrape `ebay.co.uk` for GBP pricing, `ebay.de` for the German market, etc. Prices are localized per site. - **Raise `maxResults` for volume.** 240 items land per page; set 500–2000 to sweep a whole niche. - **Sort by `Price + shipping: lowest`** to find deals, or `Newly listed` to catch fresh inventory first. - **Paste a browser URL** into `categoryUrl` if you already filtered on eBay — the actor paginates it verbatim. - **Keep Apify Proxy on.** eBay blocks datacenter/origin IPs; the actor uses residential IPs pinned to the marketplace's own country (so the site loads in its native language/currency and location parses cleanly) and rotates a fresh IP per request. - **Turn on `enrichDetails` for seller data.** Search cards omit the seller; enable enrichment (with a smaller `maxResults`) to fill `sellerName`, feedback %, precise location and item specifics on every row. - **Schedule it.** For price tracking, run daily and diff the datasets to build a price history. - **De-dupe is built in.** The scraper drops repeated promoted items across pages by `itemId`, so your dataset stays clean. *** ### Integrations Send eBay data wherever you work: - **Google Sheets** — push results to a sheet for live price dashboards. - **Slack / email** — get notified when new matching listings appear. - **Zapier & Make** — trigger downstream workflows on every run. - **Webhooks** — POST the dataset to your own endpoint the moment a run finishes. - **Schedules** — run hourly/daily for automated price monitoring. - **Apify API & SDK** — pull the dataset from any app in JSON, CSV or Excel. *** ### API usage Run the actor and fetch results programmatically. Get your token from the Apify console. **cURL** ```bash curl -X POST "https://api.apify.com/v2/acts/logiover~ebay-scraper/runs?token=YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"mode":"sold","query":"iphone 13 pro","maxResults":500}' ``` **Node.js** ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_TOKEN' }); const run = await client.actor('logiover/ebay-scraper').call({ mode: 'search', query: 'nike air max', maxResults: 600, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` **Python** ```python from apify_client import ApifyClient client = ApifyClient("YOUR_TOKEN") run = client.actor("logiover/ebay-scraper").call(run_input={ "mode": "sold", "query": "iphone 13 pro 256gb", "maxResults": 500, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["title"], item["price"], item["currency"]) ``` *** ### Use with AI agents (MCP) This actor works as a tool for LLM agents via the Apify MCP server, so an AI assistant can fetch live eBay data on demand. Point your MCP-enabled client (Claude, or any agent framework) at `logiover/ebay-scraper` and prompt it naturally: > "Find the average sold price of a used PlayStation 5 on eBay this week." The agent calls the actor in `sold` mode, reads the numeric `price` fields, and computes the answer from real market data — no manual scraping. *** ### FAQ #### Do I need an eBay API key or developer account? No. The actor uses eBay's public web pages, so there is nothing to register — no API key, no OAuth token, no login, no cookies. #### Can I scrape SOLD / completed listings? Yes. Set `mode` to `sold` and provide a keyword; the actor pulls completed, sold results — ideal for pricing, valuation and sell-through analysis. This is the data most people actually want and it is hard to get from the official eBay API. #### How many results can I get per run? Each results page holds up to 240 listings and the actor paginates until it reaches your `maxResults` or an internal time budget. Runs of hundreds to a few thousand rows are normal; set `maxResults` accordingly. #### Which eBay marketplaces are supported? 16 sites, including ebay.com (US), ebay.co.uk, ebay.de, ebay.com.au, ebay.fr, ebay.it, ebay.es, ebay.ca, ebay.nl, ebay.ie, ebay.ch, ebay.at, ebay.be, ebay.pl, ebay.com.hk and ebay.com.sg. Pick one with the `domain` dropdown. #### Are prices returned as numbers? Yes. `price`, `shippingCost`, `bidsCount`, `sellerFeedbackCount`, `sellerPositivePercent`, `soldCount`, `productRating` and `reviewsCount` are all real numbers, so you can sort, filter and aggregate without cleaning strings. The original text is kept in `priceText`/`shippingText` too. #### Why do some fields come back empty? Not every listing exposes every field — auctions have `bidsCount` and `timeLeft` while Buy-It-Now items do not; `soldCount`, `watchers` and `productRating` only appear on some cards. Crucially, eBay's **search cards do not include the seller or the full item specifics**, so `sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`, `brand`, `itemSpecifics`, `returnsAccepted` and quantity are `null` on list-mode rows unless you set **`enrichDetails: true`** (which fetches each item page to fill them) or use `productDetail` mode. `buyingFormat` and item `location` are populated on the majority of cards out of the box. Empty fields are `null`, never fabricated. #### How do I also get the seller for search / category / sold results? Set **`enrichDetails: true`**. The actor then opens each result's item page and adds `sellerName`, `sellerPositivePercent`, `sellerFeedbackCount`, a precise `itemLocation`, `itemSpecifics`, `brand`, `returnsAccepted`, `quantityAvailable` and `quantitySold`. Keep `maxResults` modest (40–200) when you enable it, since it fetches one extra page per item. #### Can I filter by condition or price? Yes — `condition` (New, Used, Refurbished, For parts…), `buyingFormat`, `priceMin`/`priceMax`, `freeShipping` and `sort` are all available as dropdowns and combine freely. #### Does empty input return anything? Yes. Run it with `{}` and it browses the broad default query so you always get a useful dataset to inspect. #### What export formats are available? JSON, CSV, Excel, XML, RSS and JSONL — download from the run's dataset or pull via the Apify API. It also plugs into Google Sheets, webhooks, Zapier and Make. #### Does eBay block the scraper? eBay blocks bare datacenter and origin IPs, which is why the actor runs behind Apify Proxy on residential IPs pinned to the marketplace's own country, and rotates a fresh IP per request. Keep the proxy enabled for reliable results. #### How fresh is the data? Every run scrapes eBay live, so results reflect the marketplace at the moment you run it. For tracking, schedule the actor and compare datasets over time. #### How do I get details for one specific product? Use `productDetail` mode with the item's URL or id. It returns item specifics (brand, MPN, UPC, model), quantity available/sold, returns policy, seller detail and a description snippet. *** ### Is it legal to scrape eBay? This actor collects only **publicly available** information that eBay serves to any visitor — the same listings, prices and seller data you can see in a browser. It does not log in, bypass authentication, or access private or personal data. You are responsible for using the output in line with eBay's Terms of Service, applicable laws (including data-protection rules such as GDPR/CCPA where relevant) and any contractual obligations you may have. Use scraped data responsibly, respect intellectual-property rights, and do not use it to spam or harm sellers or buyers. If you are unsure about a specific use case, seek legal advice. *** ### Related scrapers - **Amazon Product Scraper** — prices, reviews and Buy Box data from Amazon. - **Google Shopping Scraper** — cross-merchant product prices from Google Shopping. - **AliExpress Scraper** — product and seller data from AliExpress. - **Etsy Scraper** — handmade & vintage product listings and shop data. Looking for another marketplace? Browse the full **logiover** collection of keyless e-commerce and data scrapers on the Apify Store. # Actor input Schema ## `mode` (type: `string`): What to scrape. • **search** — search live listings by keyword (main, highest volume) • **category** — browse a category id or a pasted eBay category/search URL • **sold** — completed / SOLD listings (best for price & market research) • **sellerItems** — every active listing from one seller • **productDetail** — deep item-page details (item specifics, brand/MPN/UPC, quantity, returns) for one or many item URLs / ids ## `query` (type: `string`): Free-text search term used by **search** and **sold** (and optionally to filter **category** / **sellerItems**). Leave blank to use the broad default query so empty input still returns data. ## `categoryId` (type: `string`): Numeric eBay category id for **category** mode (the number in `_sacat=` of a category URL). Examples: 177 = PC Laptops & Netbooks, 9355 = Cell Phones & Smartphones, 139973 = Video Games, 11450 = Clothing. ## `categoryUrl` (type: `string`): Paste any eBay category or search results URL (from your browser) and the actor will paginate it directly. Overrides categoryId when set. ## `seller` (type: `string`): eBay seller username for **sellerItems** mode (e.g. `bestbuy`). You can also paste a `.../usr/` store URL. ## `itemUrl` (type: `string`): A single eBay item URL (`https://www.ebay.com/itm/...`) for **productDetail** mode. ## `itemUrls` (type: `array`): A list of eBay item URLs for batch **productDetail** lookups. ## `itemIds` (type: `array`): A list of numeric eBay item ids for batch **productDetail** (alternative to full URLs). ## `condition` (type: `string`): Filter listings by item condition (search / category / sold / sellerItems). ## `buyingFormat` (type: `string`): Restrict to a buying format. ## `sort` (type: `string`): Ordering of the results page. ## `freeShipping` (type: `boolean`): If enabled, only return listings offering free shipping. ## `priceMin` (type: `string`): Only listings priced at or above this amount (in the site's currency). ## `priceMax` (type: `string`): Only listings priced at or below this amount (in the site's currency). ## `domain` (type: `string`): Which eBay marketplace to scrape. Prices and availability are localized to the site. ## `maxResults` (type: `integer`): Upper bound on rows returned. For search / category / sold / sellerItems this drives pagination (up to 240 items per page). Default 200. ## `enrichDetails` (type: `boolean`): OFF by default (keeps big search / category / sold / sellerItems runs fast). When ON, the actor opens every result's item page and adds fields the search card can't show: **sellerName**, **sellerPositivePercent**, **sellerFeedbackCount**, precise **itemLocation**, **itemSpecifics**, **brand**, **returnsAccepted**, **quantityAvailable** and **quantitySold**. This roughly doubles the work per item, so use a smaller **maxResults** (e.g. 40–200) when you turn it on. Has no effect on productDetail mode (which already fetches item pages). ## `proxy` (type: `object`): eBay blocks datacenter/origin IPs, so Apify Proxy is used by default (AUTO, escalating to RESIDENTIAL on a challenge). Leave the default unless you know what you're doing. ## Actor input object example ```json { "mode": "search", "query": "laptop", "categoryId": "177", "categoryUrl": "https://www.ebay.com/b/Laptops-Netbooks/175672/bn_1648276", "seller": "bestbuy", "itemUrl": "https://www.ebay.com/itm/364567890123", "itemUrls": [], "itemIds": [], "condition": "", "buyingFormat": "", "sort": "", "freeShipping": false, "priceMin": "50", "priceMax": "500", "domain": "ebay.com", "maxResults": 200, "enrichDetails": false, "proxy": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): Full results dataset. Use the Listings view for search/category/sellerItems, the Sold view for completed listings, and the Product detail view for item-page lookups. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "mode": "search", "query": "laptop", "maxResults": 200, "proxy": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("logiover/ebay-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "mode": "search", "query": "laptop", "maxResults": 200, "proxy": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("logiover/ebay-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "mode": "search", "query": "laptop", "maxResults": 200, "proxy": { "useApifyProxy": true } }' | apify call logiover/ebay-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=logiover/ebay-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "eBay Scraper — Listings, Prices & Sold Items API", "description": "Scrape eBay listings by keyword, category, seller or item URL. Extract title, price, shipping, condition, seller, bids, sold count, ratings and more — including SOLD/completed listings for price research. No API key, no login.", "version": "1.1", "x-build-id": "7XSrw1TGvSy6MmP6H" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/logiover~ebay-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-logiover-ebay-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/logiover~ebay-scraper/runs": { "post": { "operationId": "runs-sync-logiover-ebay-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/logiover~ebay-scraper/run-sync": { "post": { "operationId": "run-sync-logiover-ebay-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "mode": { "title": "Mode", "enum": [ "search", "category", "sold", "sellerItems", "productDetail" ], "type": "string", "description": "What to scrape.\n\n• **search** — search live listings by keyword (main, highest volume)\n• **category** — browse a category id or a pasted eBay category/search URL\n• **sold** — completed / SOLD listings (best for price & market research)\n• **sellerItems** — every active listing from one seller\n• **productDetail** — deep item-page details (item specifics, brand/MPN/UPC, quantity, returns) for one or many item URLs / ids", "default": "search" }, "query": { "title": "Search keyword", "type": "string", "description": "Free-text search term used by **search** and **sold** (and optionally to filter **category** / **sellerItems**). Leave blank to use the broad default query so empty input still returns data." }, "categoryId": { "title": "Category id", "type": "string", "description": "Numeric eBay category id for **category** mode (the number in `_sacat=` of a category URL). Examples: 177 = PC Laptops & Netbooks, 9355 = Cell Phones & Smartphones, 139973 = Video Games, 11450 = Clothing." }, "categoryUrl": { "title": "Category / search URL", "type": "string", "description": "Paste any eBay category or search results URL (from your browser) and the actor will paginate it directly. Overrides categoryId when set." }, "seller": { "title": "Seller username", "type": "string", "description": "eBay seller username for **sellerItems** mode (e.g. `bestbuy`). You can also paste a `.../usr/` store URL." }, "itemUrl": { "title": "Item URL", "type": "string", "description": "A single eBay item URL (`https://www.ebay.com/itm/...`) for **productDetail** mode." }, "itemUrls": { "title": "Item URLs (batch)", "type": "array", "description": "A list of eBay item URLs for batch **productDetail** lookups.", "items": { "type": "string" }, "default": [] }, "itemIds": { "title": "Item ids (batch)", "type": "array", "description": "A list of numeric eBay item ids for batch **productDetail** (alternative to full URLs).", "items": { "type": "string" }, "default": [] }, "condition": { "title": "Condition", "enum": [ "", "1000", "1500", "2000", "2010", "2020", "2030", "2500", "3000", "4000", "5000", "6000", "7000" ], "type": "string", "description": "Filter listings by item condition (search / category / sold / sellerItems).", "default": "" }, "buyingFormat": { "title": "Buying format", "enum": [ "", "BIN", "AUCTION", "BO" ], "type": "string", "description": "Restrict to a buying format.", "default": "" }, "sort": { "title": "Sort by", "enum": [ "", "12", "10", "1", "15", "16", "2", "3" ], "type": "string", "description": "Ordering of the results page.", "default": "" }, "freeShipping": { "title": "Free shipping only", "type": "boolean", "description": "If enabled, only return listings offering free shipping.", "default": false }, "priceMin": { "title": "Minimum price", "type": "string", "description": "Only listings priced at or above this amount (in the site's currency)." }, "priceMax": { "title": "Maximum price", "type": "string", "description": "Only listings priced at or below this amount (in the site's currency)." }, "domain": { "title": "eBay site", "enum": [ "ebay.com", "ebay.co.uk", "ebay.de", "ebay.com.au", "ebay.fr", "ebay.it", "ebay.es", "ebay.ca", "ebay.nl", "ebay.ie", "ebay.at", "ebay.ch", "ebay.be", "ebay.pl", "ebay.com.hk", "ebay.com.sg" ], "type": "string", "description": "Which eBay marketplace to scrape. Prices and availability are localized to the site.", "default": "ebay.com" }, "maxResults": { "title": "Max results", "minimum": 1, "maximum": 100000, "type": "integer", "description": "Upper bound on rows returned. For search / category / sold / sellerItems this drives pagination (up to 240 items per page). Default 200.", "default": 200 }, "enrichDetails": { "title": "Enrich each result with seller & full item details (slower)", "type": "boolean", "description": "OFF by default (keeps big search / category / sold / sellerItems runs fast). When ON, the actor opens every result's item page and adds fields the search card can't show: **sellerName**, **sellerPositivePercent**, **sellerFeedbackCount**, precise **itemLocation**, **itemSpecifics**, **brand**, **returnsAccepted**, **quantityAvailable** and **quantitySold**. This roughly doubles the work per item, so use a smaller **maxResults** (e.g. 40–200) when you turn it on. Has no effect on productDetail mode (which already fetches item pages).", "default": false }, "proxy": { "title": "Proxy configuration", "type": "object", "description": "eBay blocks datacenter/origin IPs, so Apify Proxy is used by default (AUTO, escalating to RESIDENTIAL on a challenge). Leave the default unless you know what you're doing.", "default": { "useApifyProxy": true } } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```