# eBay Scraper (`parseforge/ebay-scraper`) Actor

Scrape eBay listings and SOLD prices without a login: search or paste URLs, get sold price and date, bids, condition, shipping, location and more. Active, sold and completed modes, 8 marketplaces, filters and pagination. Pay per result.

- **URL**: https://apify.com/parseforge/ebay-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 455 total users, 44 monthly users, 97.4% runs succeeded, 3 bookmarks
- **User rating**: 1.85 out of 5 stars

## Pricing

from $4.50 / 1,000 ebay listings

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### eBay Scraper

**Scrape eBay product listings, prices, seller details, and sold data from any search, category, or direct URL.** Each result returns the title, price, condition, shipping cost, and seller info in a flat, structured row. Export to CSV, JSON, Excel, or XML.

eBay's official APIs require developer accounts, complex authentication, and strict rate limits that throttle large-scale data collection. This Actor reads the public web pages directly, letting you scrape active listings or confirmed sold prices by search query, category, or direct URL. It handles pagination, proxy rotation, and structured data extraction so you get clean, analysis-ready datasets without writing any code.

| Who uses it | What they scrape eBay for |
|---|---|
| E-commerce sellers | Monitor competitor pricing and inventory levels for specific products. |
| Market researchers | Analyze market supply, demand trends, and average selling prices by category. |
| Resellers and flippers | Find underpriced items and research confirmed sold prices to set profitable resale values. |
| Data analysts | Build price history databases and track product availability over time. |

### What it does

This Actor collects eBay product listings or sold items by search query, category, or direct URL and returns each result as a flat row with title, price, condition, shipping, and seller information.

- 🔍 **Search-based scraping:** Enter a search query, category, and filters like condition, price range, or location to target specific listings.
- 🔗 **Direct URL input:** Paste one or more eBay listing, search, or category page URLs to scrape exactly the pages you need.
- 📊 **Sold and completed listings:** set Mode to sold to get the sold price, sold date, bids and shipping of items that actually sold, or completed to include ended listings that did not sell. No login or cookie needed, see "Sold and completed listings" below.
- 🌐 **Eight marketplaces:** ebay.com, ebay.co.uk, ebay.de, ebay.fr, ebay.it, ebay.es, ebay.ca and ebay.com.au. Pick one in the Input tab or paste a URL from that site; the proxy country follows the site.
- ⚙️ **Filters:** category ID, condition (New, Open box, Refurbished, Used, For parts), price range, buying format (auction, Buy It Now, Best Offer), item location, free shipping, sort order (including ended recently) and, for sold data, a sold-within-N-days window.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with eBay data

**💰 Price competitor products.**

An e-commerce seller runs the Actor daily on a search for their top 50 products to track competitor prices and adjust their own listings.

**📈 Research sold prices for resale.**

A vintage clothing reseller searches for sold listings of a specific brand and condition to determine the market value before sourcing inventory.

**📊 Build a market trend dataset.**

A data analyst scrapes a category weekly, collecting prices and seller counts to model supply and demand shifts over time.

**🛒 Find arbitrage opportunities.**

A flipper searches for underpriced Buy It Now listings in a niche category, filtering by condition and price to identify profitable flips.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API keys required** | Scrapes public eBay pages directly with no developer account or token management. |
| **Residential proxies built in** | Uses Apify's residential proxies to avoid blocking and access geo-specific marketplaces. |
| **Structured output** | Returns every listing as a clean, flat row with consistent fields for title, price, shipping, and seller. |
| **Flexible input methods** | Start from a search term, a category ID, or a list of direct URLs. |

### How it compares

This Actor combines active listing and sold data scraping with flexible search filters and direct URL input, while the competitors below each focus on a narrower slice of eBay data.

| Feature | ParseForge | eBay Product Listing Scraper | eBay Sold Listings Search |
|---|---|---|---|
| Scrapes active listings | Yes | Yes | Not listed |
| Scrapes sold listings | Yes | Not listed | Yes |
| Search by keyword | Yes | Yes | Yes |
| Direct URL input | Yes | Yes | Not listed |
| Condition filter | Yes | Not listed | Not listed |
| Price range filter | Yes | Not listed | Not listed |
| Multi-marketplace proxy targeting | Yes | Not listed | Yes |

### Sold and completed listings

Sold and completed listings need no login and no cookie. eBay sends anonymous web browsers to its sign-in page for these searches, so the Actor requests them the way eBay's own Android app does, which returns the full result list (checked on ebay.com, ebay.co.uk and ebay.de).

- **Mode = active** (the default) returns current listings.
- **Mode = sold** returns items that sold; **completed** also returns ended listings that did not sell.
- If eBay ever redirects a sold search to sign-in anyway, the run stops with a clear message instead of returning wrong data. Turn on "Fall back to active listings" to get current asking prices instead (rows say `listingStatus: ACTIVE`), or paste an "eBay session cookie" (optional) from a browser where you are signed in.

Sold rows fill `soldPrice`, `soldDate` and `listingStatus` (SOLD, or UNSOLD for ended listings that did not sell), next to `bids`, `shippingCost`, `totalPrice` and `bestOfferAccepted` where eBay prints them.

### Configure the run

Drive the Actor from search queries, categories, and direct URLs, alone or together, and filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10,
  "searchQuery": "laptop",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

A larger pull:

```json
{
  "maxItems": 200,
  "searchQuery": "laptop",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected ($5.00 per 1,000; volume plans pay less, down to $4.50 per 1,000 on Gold). You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [eBay Scraper](https://apify.com/parseforge/ebay-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to eBay through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/ebay-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your search query or URLs are valid and that your filters are not too restrictive. Try removing optional filters like price range or condition to see if results appear. Also confirm you are using residential proxies, as datacenter IPs are often blocked by eBay. A run that finds nothing ends as failed with the reason, never as an empty success.

**Why is the Actor returning fewer items than my maxItems setting?**

The Actor stops when it reaches the end of available listings for your query. eBay may cap search results at a certain number of pages. Try narrowing your search with more specific keywords or filters to ensure you capture all relevant items.

**I'm getting blocked or seeing CAPTCHAs.**

Make sure you are using residential proxies in the proxy configuration. If you are already using them, try increasing the run's delay or reducing concurrency to mimic human browsing behavior.

**The data fields are empty or missing for some listings.**

eBay's page structure can vary slightly by listing type or region. If specific fields are missing, the listing may not have that data available. Check the raw HTML output option to debug, or try targeting a different regional site.

**Can I use both Start URLs and a search query at the same time?**

If both are sent, the Start URLs win and the search query is ignored (the Input tab pre-fills a demo query, so pasting a URL never fails). A URL that already has the sold filter (LH_Sold=1) runs in sold mode.

**Why are seller fields empty on some runs?**

eBay prints the seller line on search cards only for some result layouts. When it is not on the page the fields are null; they are never guessed.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape sold listings with this Actor? | Yes. Set Mode to sold (or completed); no login or cookie is needed. See "Sold and completed listings". |
| Do I need an eBay API key or developer account? | No. This Actor scrapes the public eBay website directly. You do not need to register an app, get an API key, or manage OAuth tokens. |
| How many listings can I scrape in one run? | Free users can scrape up to 10 items as a preview. Paid Apify users can set a maximum up to 1,000,000 items per run. |
| Can I scrape eBay sites in other countries? | Yes: ebay.com, ebay.co.uk, ebay.de, ebay.fr, ebay.it, ebay.es, ebay.ca and ebay.com.au. Choose the marketplace in the Input tab or paste a URL from that site. |
| What data fields does the Actor return? | 50 fields per row, e.g. title, price, priceDisplay, currency, condition, shipping, shippingCost, totalPrice, listingStatus, soldPrice, soldDate, bids, timeLeft, seller (name, feedback score and percent), location, watchers, quantitySold, freeReturns, productId and marketplace. Item-page fields such as specifications, description and identifiers exist in the schema and are filled only when eBay shows them on the search card. |
| Can I filter by item condition? | Yes: New, Open box, Refurbished, Certified refurbished, Seller refurbished, Used, or For parts or not working. |
| How do I scrape only Buy It Now listings? | Check the 'Buy It Now Only' box in the input settings to exclude auction-style listings and return only fixed-price items. |
| Can I provide a list of specific eBay URLs to scrape? | Yes. Use Start URLs for eBay search, category or store pages. If a search query is also set, the URLs win. |
| Does this Actor handle pagination automatically? | Yes. The Actor follows pagination links through search results and category pages until it reaches your max items limit or the end of the listings. |
| What export formats are supported? | You can export your scraped data to CSV, JSON, Excel, or XML directly from the Apify dataset. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by eBay Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `startUrls` (type: `array`):

Direct URLs to eBay search, category, store or listing pages. Wins over Search Query when both are given (the Console pre-fills Search Query, so pasting a URL never fails). A URL that already carries LH_Sold=1 runs in sold mode.

## `searchQuery` (type: `string`):

Keywords to search, e.g. laptop or iphone 15 pro 256gb. Ignored when Start URLs are given.

## `mode` (type: `string`):

Empty = active. active = current listings (default, works without login). sold = items that actually sold, with sold price and date. completed = sold and unsold ended listings. Sold and completed work without any login.

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

Which eBay site to search when using Search Query (empty = ebay.com). Start URLs choose their own site.

## `category` (type: `string`):

eBay category ID or name (e.g., '58058' for Computers/Tablets & Networking)

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

Filter by condition.

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

Restrict to auctions, Buy It Now or Best Offer listings.

## `minPrice` (type: `number`):

Minimum price in the marketplace currency (USD on ebay.com, GBP on ebay.co.uk).

## `maxPrice` (type: `number`):

Maximum price in the marketplace currency.

## `location` (type: `string`):

Item location: US (domestic), North America or Worldwide. Leave empty for the eBay default.

## `sortOrder` (type: `string`):

How to sort. endedRecently is the useful one for sold and completed listings.

## `buyItNowOnly` (type: `boolean`):

Legacy switch, same as Buying format = Buy It Now.

## `freeShippingOnly` (type: `boolean`):

Show only items with free shipping

## `soldWithinDays` (type: `integer`):

Sold and completed modes only: keep sales from the last N days. Works best with Sort = endedRecently.

## `ebayCookie` (type: `string`):

Cookie header copied from a browser where you are signed in to eBay. Optional: sold and completed modes work without it. Only useful if eBay ever starts refusing anonymous sold searches. Used only for this run.

## `fallbackToActiveListings` (type: `boolean`):

If eBay refuses sold results (eBay redirected the search to sign-in), return active listings instead of failing. Rows are marked listingStatus = ACTIVE so they are never mistaken for sales.

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

Select proxy configuration for scraping. Residential proxies are recommended for eBay. Use the Country option to target eBay regional sites (e.g. GB for ebay.co.uk).

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "laptop",
  "buyingFormat": "all",
  "buyItNowOnly": false,
  "freeShippingOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `items` (type: `string`):

Complete item dataset with all fields including title, price, seller, shipping, and specifications

## `overview` (type: `string`):

Overview view of items with key fields displayed in a table format

# 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 = {
    "maxItems": 10,
    "searchQuery": "laptop",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "searchQuery": "laptop",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/ebay-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 '{
  "maxItems": 10,
  "searchQuery": "laptop",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/ebay-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/ebay-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/xeEotFjdrGXtFqYIT/builds/hNoYLvP5LWEyyn4L3/openapi.json