# eBay Seller Scraper - Full Store Inventory & Price Stats (`henrycrawl/ebay-seller-scraper`) Actor

Monitor a competitor's entire eBay store. Give it seller usernames or store URLs and get every live listing plus a per-seller summary: listing count, price min, max, median and average, condition mix, and how many units the catalogue has recorded as sold. No eBay API key needed.

- **URL**: https://apify.com/henrycrawl/ebay-seller-scraper.md
- **Developed by:** [Henry Crawl](https://apify.com/henrycrawl) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Seller Scraper - Full Store Inventory & Price Stats

**Monitor a competitor's entire eBay store.** Give it seller usernames or store URLs and
get **their whole live catalogue**, plus a per-seller summary that answers the questions a
keyword scrape cannot: how big is this seller, where do they price, and what actually moves.

No eBay API key, no developer account. Common uses: sizing up a competitor before entering a
category, tracking a supplier's range and price band, and building a seller shortlist.

### Two outputs

**1. Dataset — one row per listing**

| Field | Example |
|---|---|
| `sellerScope` | `overflowoutlet` |
| `title` | `YETI Rambler 20 oz Tumbler` |
| `priceValue` / `currency` | `24.99` / `USD` |
| `condition` | `Brand New` |
| `sellerName`, `sellerFeedbackPercent`, `sellerFeedbackCount` | `overflowoutlet`, `99.1`, `4500` |
| `soldCount`, `watchers` | `461`, `12` |
| `shippingValue`, `freeShipping`, `itemLocation` | `4.99`, `false`, `United States` |
| `itemId`, `itemUrl`, `imageUrl` | |
| `scrapedAt`, `ebaySite`, `proxyCountry` | |

**2. `SELLER_SUMMARY` record — one entry per seller**

```json
[{
  "seller": "overflowoutlet",
  "listingsScraped": 200,
  "priceMin": 6.99, "priceMax": 189.0,
  "priceMedian": 24.5, "priceAverage": 31.18,
  "conditionMix": { "Brand New": 173, "Pre-Owned": 27 },
  "listingsWithRecordedSales": 38,
  "unitsSoldAcrossListings": 1462
}]
```

That summary is the point of this actor. A keyword scrape tells you what is for sale; this
tells you what a specific competitor's business looks like.

### Input

```json
{
  "sellers": ["overflowoutlet", "https://www.ebay.com/str/somestore"],
  "maxListingsPerSeller": 500,
  "sortBy": "newly_listed",
  "condition": "new",
  "proxyCountry": "US"
}
```

Accepts plain usernames, `ebay.com/str/...` or `/usr/...` store URLs, or any eBay URL
containing `_ssn` — so you can paste whatever you already have.

Filters: eBay site, sort order (use **Newly listed** to see what a competitor just added),
condition, buying format and price range.

### Currency depends on where you ask from

eBay prices by geography. Asking about a US seller from another country returns a
different currency entirely, which silently breaks any comparison. Set `proxyCountry` to
match the marketplace; it defaults to the United States.

### The cap is real

`maxListingsPerSeller` stops at exactly that number for each seller, and a seller is
abandoned early if three consecutive pages return nothing usable — so a layout change
cannot quietly turn into a long, expensive run.

### Runs fail loudly, not silently

Every run writes a `DIAGNOSTICS` record with block rate, bytes per item and the fill rate
of every output field. If nothing was extracted, or more than half the pages were blocked,
the run is marked **failed** with the reason — because half a catalogue presented as a
whole one is worse than an error.

### Typical uses

- Competitor teardown: catalogue size, price band, condition mix, what sells
- Finding unauthorised or grey-market resellers of a brand and how they price
- Sourcing: watching a specific liquidation or wholesale seller for new inventory
- Valuing a store before buying it, or benchmarking your own against a rival

### Notes and limits

- `soldCount` and `watchers` appear only on listings where eBay displays them, and are
  `null` elsewhere rather than guessed. `unitsSoldAcrossListings` therefore counts only
  what eBay publicly shows.
- Very large stores are capped by design; raise `maxListingsPerSeller` deliberately.
- Keep `maxConcurrency` low: eBay authorises by session.

### Support

If a field stops filling or you need a filter that is not exposed, open an issue on the
actor page with the input you used.

### FAQ

**Do I need an eBay API key?**
No. This reads public store pages. You only need an Apify account.

**Does it include sold prices?**
It returns `soldCount` from live listings — how many units each listing has moved — and rolls
that into `unitsSoldAcrossListings` per seller. It does not read eBay's separate Sold-items
filter, which answers HTTP 403 on every attempt.

**What is in the per-seller summary?**
Listing count, price min, max, median and average, condition mix, how many listings have
recorded sales, and total units moved. It is written to the key-value store as `SELLER_SUMMARY`.

**Why does the currency look wrong?**
eBay prices by IP country. Set `proxyCountry` to match the marketplace you actually want.

**How do I get all listings from a specific eBay seller programmatically?**
Give this actor the seller's username and it walks their store pages for you, returning one row
per listing with the price parsed into a number and a currency code, the condition, the
shipping cost and the public "X sold" counter where eBay shows one, plus a per-seller summary.
No API key, no OAuth application, no developer account: it reads the same public store pages a
shopper sees. The two things worth knowing before you build on it are that eBay prices by the
country of the requesting IP — so set `proxyCountry` to the market you actually mean, and check
the `currency` field rather than assuming dollars — and that sold history is not part of a
seller's public store page, only the counters on their live listings.

# Actor input Schema

## `sellers` (type: `array`):

eBay usernames, store URLs (ebay.com/str/... or /usr/...), or any eBay URL containing \_ssn. One entry per seller.

## `maxListingsPerSeller` (type: `integer`):

Stops at exactly this many listings for each seller. Enforced, so you cannot be billed for more rows than you asked for.

## `ebaySite` (type: `string`):

Which regional eBay to read the seller's inventory from.

## `proxyCountry` (type: `string`):

eBay prices by geography. Asking about a US seller from elsewhere returns a different currency, so match this to the marketplace.

## `sortBy` (type: `string`):

Order the seller's inventory. Newly listed is useful for tracking what a competitor just added.

## `condition` (type: `string`):

Only include items in this condition.

## `buyingFormat` (type: `string`):

Restrict to Buy It Now or auction listings.

## `minPrice` (type: `integer`):

Lower price bound, in the marketplace currency.

## `maxPrice` (type: `integer`):

Upper price bound, in the marketplace currency.

## `itemsPerPage` (type: `integer`):

eBay supports 60, 120 or 240. Keep 240 to minimise requests per thousand rows.

## `maxConcurrency` (type: `integer`):

Keep low. eBay authorises by session, so parallelism burns sessions faster than it saves time.

## `proxyConfiguration` (type: `object`):

Defaults to Apify residential proxy in the selected country. eBay refuses datacenter IP ranges.

## Actor input object example

```json
{
  "sellers": [
    "overflowoutlet"
  ],
  "maxListingsPerSeller": 200,
  "ebaySite": "www.ebay.com",
  "proxyCountry": "US",
  "sortBy": "best_match",
  "condition": "any",
  "buyingFormat": "any",
  "itemsPerPage": 240,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

One row per listing in the seller's catalogue: title, parsed price and currency, condition, seller feedback, sold count, shipping, location and listing URL.

## `sellerSummary` (type: `string`):

Per seller: listing count, price min, max, median and average, condition mix, listings with recorded sales, and total units sold across the catalogue.

## `diagnostics` (type: `string`):

Block rate, pages processed and the fill rate of every output field for this run.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sellers": [
        "overflowoutlet"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("henrycrawl/ebay-seller-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "sellers": ["overflowoutlet"] }

# Run the Actor and wait for it to finish
run = client.actor("henrycrawl/ebay-seller-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "sellers": [
    "overflowoutlet"
  ]
}' |
apify call henrycrawl/ebay-seller-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,henrycrawl/ebay-seller-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PwzXk1HnYp8iDU0G2/builds/Wv6Wh7Hgf9xfw9IhD/openapi.json