# eBay Store and Product Lead Finder (`esrok/ebay-store-product-lead-finder`) Actor

Extract public eBay product listings, seller/store information, prices, product URLs, images, ratings, sold counts, item locations, and listing metadata from eBay keywords or search URLs.

- **URL**: https://apify.com/esrok/ebay-store-product-lead-finder.md
- **Developed by:** [Esrok](https://apify.com/esrok) (community)
- **Categories:** E-commerce, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 ebay product results

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 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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Store and Product Lead Finder

Extract public eBay product listings, seller/store information, prices, product URLs, images, ratings, sold counts, item locations, and listing metadata from eBay keywords or search/category URLs.

Best for ecommerce sellers, product researchers, agencies, dropshipping researchers, price monitoring teams, and automation builders who need clean public eBay data without manual copying.

### What this Actor does

eBay Store and Product Lead Finder collects public product and seller/store data from eBay search result pages. Users can enter keywords or direct eBay search/category URLs and receive structured rows that are ready for spreadsheets, dashboards, APIs, and competitor research workflows.

The Actor is focused on public ecommerce research. It does not log in, scrape private buyer data, access private messages, collect payment data, or bypass restricted areas.

### Why use it

Manual eBay research is slow and inconsistent. This Actor turns product searches into clean datasets with product, price, seller, sold count, image, and ranking fields so you can compare listings and sellers faster.

### Who it is for

- Ecommerce sellers
- Market researchers
- Competitor tracking teams
- Dropshipping researchers
- eBay seller researchers
- Price monitoring teams
- Product research teams
- Agencies
- Automation builders using Apify, Make, Zapier, n8n, Google Sheets, or APIs

### Use cases

- Research products by keyword
- Track competitor product listings
- Discover public seller/store leads
- Compare prices and shipping costs
- Monitor visible sold counts
- Build ecommerce research datasets
- Export public eBay listings to CSV, JSON, Excel, or API workflows

### Input

- `keywords` - eBay product search keywords
- `searchUrls` - direct public eBay search/category URLs
- `maxResults` - maximum product results to return
- `includeSellerInfo` - include seller/store fields when visible
- `includeImages` - include product image URLs
- `includeShipping` - include visible shipping prices/details
- `includeSoldCount` - include sold count when visible
- `minPrice` - optional minimum price
- `maxPrice` - optional maximum price
- `condition` - optional condition hint such as new or used
- `location` - optional location hint
- `deduplicateResults` - remove duplicate items
- `proxyConfiguration` - optional Apify proxy support
- `debugMode` - save extra debugging data

### Output

Each dataset item can include:

- `productTitle`
- `productUrl`
- `itemId`
- `price`
- `currency`
- `shippingPrice`
- `condition`
- `imageUrl`
- `sellerName`
- `sellerUrl`
- `sellerRating`
- `sellerFeedbackPercent`
- `storeName`
- `storeUrl`
- `soldCount`
- `itemLocation`
- `listingType`
- `sourceKeyword`
- `rankingPosition`
- `scrapedAt`

### Example input

```json
{
  "keywords": ["vintage camera", "wireless headphones"],
  "maxResults": 50,
  "includeSellerInfo": true,
  "includeImages": true,
  "includeShipping": true,
  "includeSoldCount": true,
  "minPrice": 20,
  "maxPrice": 500,
  "condition": "used",
  "deduplicateResults": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### Example output

```json
{
  "productTitle": "Vintage 35mm Film Camera with Lens",
  "productUrl": "https://www.ebay.com/itm/123456789012",
  "itemId": "123456789012",
  "price": 89.99,
  "currency": "USD",
  "shippingPrice": 8.95,
  "condition": "Used",
  "imageUrl": "https://i.ebayimg.com/images/example.jpg",
  "sellerName": "example-camera-store",
  "sellerUrl": "https://www.ebay.com/usr/example-camera-store",
  "sellerRating": 12450,
  "sellerFeedbackPercent": 99.7,
  "storeName": "Example Camera Store",
  "storeUrl": "https://www.ebay.com/str/examplecamerastore",
  "soldCount": 42,
  "itemLocation": "United States",
  "listingType": "Buy It Now",
  "sourceKeyword": "vintage camera",
  "rankingPosition": 1,
  "scrapedAt": "2026-05-30T12:00:00.000Z"
}
```

### How to run

1. Open the Actor on Apify.
2. Enter eBay product keywords or direct public search/category URLs.
3. Set result limits and optional filters.
4. Run the Actor.
5. Export the dataset from Apify.

### Export and integrations

Export results as CSV, JSON, JSONL, XML, RSS, or Excel. Use Apify integrations to connect the output to Make, Zapier, n8n, Google Sheets, webhooks, or a custom API pipeline.

### API usage

Start a run with the Apify API:

```bash
curl "https://api.apify.com/v2/acts/esrok~ebay-store-product-lead-finder/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["vintage camera"],"maxResults":25,"includeSellerInfo":true}'
```

Fetch dataset items:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=true&token=YOUR_APIFY_TOKEN"
```

### Responsible use

Use this Actor only for lawful public ecommerce research. Do not use it to collect private buyer data, scrape private messages, collect payment data, bypass logins, or violate eBay terms.

### Limitations

- eBay page structure and visible fields can vary by region, query, and listing type.
- Sold counts and seller/store data are returned only when publicly visible.
- The Actor does not access login-only data.
- Public pages that block automated traffic may require proxy settings or may not return results.

### FAQ

#### Does this scrape private buyer information?

No. It only extracts publicly visible product and seller/store information.

#### Can it collect sold counts?

Yes, when the sold count is publicly visible on the page.

#### Can I use direct eBay category URLs?

Yes. Add public eBay search or category URLs in `searchUrls`.

#### Does it support price filters?

Yes. You can provide `minPrice` and `maxPrice`; keyword searches also pass those filters to eBay search URLs.

# Actor input Schema

## `keywords` (type: `array`):

eBay product search keywords.

## `searchUrls` (type: `array`):

Optional direct public eBay search/category URLs.

## `maxResults` (type: `integer`):

Maximum product results to return.

## `includeSellerInfo` (type: `boolean`):

Extract public seller/store data when visible.

## `includeImages` (type: `boolean`):

Include product image URLs when visible.

## `includeShipping` (type: `boolean`):

Include visible shipping price/details.

## `includeSoldCount` (type: `boolean`):

Include sold count when publicly visible.

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

Optional minimum price filter.

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

Optional maximum price filter.

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

Optional condition hint. Examples: new, used, open box, refurbished.

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

Optional item location hint.

## `deduplicateResults` (type: `boolean`):

Remove duplicate product URLs/item IDs.

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

Optional Apify proxy configuration. Useful for reliable public eBay requests.

## `debugMode` (type: `boolean`):

Save extra request/debug information to the key-value store.

## Actor input object example

```json
{
  "keywords": [
    "vintage camera",
    "wireless headphones"
  ],
  "searchUrls": [],
  "maxResults": 50,
  "includeSellerInfo": true,
  "includeImages": true,
  "includeShipping": true,
  "includeSoldCount": true,
  "deduplicateResults": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debugMode": false
}
```

# Actor output Schema

## `ebayProductSellerLeads` (type: `string`):

Clean public eBay product listing and seller/store records for ecommerce research and competitor monitoring.

# 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 = {
    "keywords": [
        "vintage camera",
        "wireless headphones"
    ],
    "searchUrls": [],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("esrok/ebay-store-product-lead-finder").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 = {
    "keywords": [
        "vintage camera",
        "wireless headphones",
    ],
    "searchUrls": [],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("esrok/ebay-store-product-lead-finder").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 '{
  "keywords": [
    "vintage camera",
    "wireless headphones"
  ],
  "searchUrls": [],
  "maxResults": 50
}' |
apify call esrok/ebay-store-product-lead-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=esrok/ebay-store-product-lead-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Store and Product Lead Finder",
        "description": "Extract public eBay product listings, seller/store information, prices, product URLs, images, ratings, sold counts, item locations, and listing metadata from eBay keywords or search URLs.",
        "version": "1.0",
        "x-build-id": "2LQwCoTpJ9Hd2ByvT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/esrok~ebay-store-product-lead-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-esrok-ebay-store-product-lead-finder",
                "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/esrok~ebay-store-product-lead-finder/runs": {
            "post": {
                "operationId": "runs-sync-esrok-ebay-store-product-lead-finder",
                "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/esrok~ebay-store-product-lead-finder/run-sync": {
            "post": {
                "operationId": "run-sync-esrok-ebay-store-product-lead-finder",
                "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": {
                    "keywords": {
                        "title": "Product keywords",
                        "type": "array",
                        "description": "eBay product search keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "eBay search or category URLs",
                        "type": "array",
                        "description": "Optional direct public eBay search/category URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum product results to return.",
                        "default": 100
                    },
                    "includeSellerInfo": {
                        "title": "Include seller info",
                        "type": "boolean",
                        "description": "Extract public seller/store data when visible.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Include images",
                        "type": "boolean",
                        "description": "Include product image URLs when visible.",
                        "default": true
                    },
                    "includeShipping": {
                        "title": "Include shipping",
                        "type": "boolean",
                        "description": "Include visible shipping price/details.",
                        "default": true
                    },
                    "includeSoldCount": {
                        "title": "Include sold count",
                        "type": "boolean",
                        "description": "Include sold count when publicly visible.",
                        "default": true
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "type": "number",
                        "description": "Optional minimum price filter."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "type": "number",
                        "description": "Optional maximum price filter."
                    },
                    "condition": {
                        "title": "Condition",
                        "type": "string",
                        "description": "Optional condition hint. Examples: new, used, open box, refurbished."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional item location hint."
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate results",
                        "type": "boolean",
                        "description": "Remove duplicate product URLs/item IDs.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Useful for reliable public eBay requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Save extra request/debug information to the key-value store.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```