# eBay Seller Scraper By Keyword & Marketplace Search (`scrapier/ebay-seller-scraper`) Actor

🛒 eBay Seller Scraper extracts seller profiles, store info, active listings, prices, ratings & feedback. 📊 Ideal for competitor analysis, pricing, product research & lead gen. ⚡ Fast, reliable; export CSV/JSON for analytics & automation.

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

## Pricing

from $5.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Keyword Discovery, Feedback and Listings

eBay Seller Scraper By Keyword & Marketplace Search finds eBay sellers by keyword or category search — or scrapes seller profile URLs you already have — across 16 eBay marketplaces. Each result returns the seller's feedback score alongside structured data for their live listings: item link, condition, image, and discount percentage. Every response is clean, structured JSON — ready to pass directly to an LLM, index into a vector store, or feed a monitoring pipeline. Point it at a niche and start mapping who actually sells there.

### What is eBay Seller Scraper By Keyword & Marketplace Search?

It is an Apify Actor that turns an eBay keyword or category search into a list of the real sellers behind the matching listings, or scrapes a list of seller profile URLs you already know, on any of 16 eBay country sites. Each output row is one seller, carrying their feedback score plus a `listings` array of structured commerce fields for what they currently have live. No eBay account or login is used or required — it reads only the public pages any visitor sees.

- **Keyword / category discovery** — type a search term ("vintage camera", "nike sneakers") and the Actor resolves the actual sellers behind matching listings, one item-page hop at a time, without you knowing any usernames up front
- **16-marketplace support** — run the same search or seller list against `ebay.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`, `.com.au`, `.at`, `.ie`, `.nl`, `.pl`, `.ch`, `.com.hk`, `.com.my`, `.com.sg`, or `.ph`
- **Direct seller mode** — paste known seller profile URLs (any locale) or bare usernames and skip discovery entirely
- **Structured per-listing commerce fields** — deep item URL, condition, image, original price, discount percentage, best-offer flag, and shipping/delivery attribute text
- **Combined runs** — mix keyword discovery and direct seller URLs in one job; every row records whether it came from a keyword (`discoveredViaKeyword`, `matchedQuery`) or from a direct URL
- **Built-in fallback fetching** — direct request first, escalating through datacenter and residential proxy tiers only when a page comes back blocked

### What data can you get with eBay Seller Scraper By Keyword & Marketplace Search?

Every run returns one JSON object per seller, with a nested array of that seller's current listings.

| Result Type | Extracted Fields | Primary Use Case |
| --- | --- | --- |
| Seller profile | `url`, `name`, `feedback_score`, `marketplaceDomain`, `discoveredViaKeyword`, `matchedQuery`, `scrapedAt` | Identify and track who sells in a niche or locale |
| Listing (nested in `listings[]`) | `title`, `price`, `productUrl`, `condition`, `imageUrl`, `originalPrice`, `discountPercent`, `cardAttribute`, `hasBestOffer` | Price, condition, and inventory analysis per seller |

#### Listings

Each seller row carries a `listings` array — items currently live on that seller's storefront. Beyond `title` and `price`, every listing includes a direct `productUrl`, the stated `condition`, a full-size `imageUrl`, and — when marked down — `originalPrice` plus a computed `discountPercent`. `cardAttribute` collects shipping/offer text from the card, and `hasBestOffer` flags items open to offers. That's a seller and their live, priced inventory in one row.

### How does eBay Seller Scraper By Keyword & Marketplace Search differ from the official eBay API?

eBay's official Buy APIs (Browse API, and the older Finding and Trading APIs) return item and seller data too, but only to registered, approved developer applications — not to someone who just wants to check who sells in a niche.

| Feature | eBay Browse API (official) | eBay Seller Scraper By Keyword & Marketplace Search |
| --- | --- | --- |
| Setup | eBay Developer Program registration, production-key approval, OAuth client-credentials token per request ([developer.ebay.com](https://developer.ebay.com/api-docs/static/oauth-credentials.html)) | No account, key, or approval — enter a search term or URL and run |
| Search sellers by keyword | Not exposed directly — `item_summary/search` returns items; whichever sellers appear are incidental, there is no "search sellers" endpoint | Purpose-built: keyword search resolves distinct sellers, one row each |
| Seller feedback | `feedbackScore` / `feedbackPercentage` on each item's nested `Seller` object ([developer.ebay.com](https://developer.ebay.com/api-docs/buy/browse/types/gct:Seller)) | `feedback_score` returned once per seller row |
| Per-seller listing detail | Separate item-level calls needed to assemble a seller's full current inventory | `listings[]` with condition/image/discount already attached, same row |
| Marketplace scope | One `marketplace_id` per request | One `marketplaceDomain` input field selects any of 16 locales |
| Output shape | Raw API JSON matching eBay's schema — assembly required | One ready-to-use JSON row per seller |

The official API is the right choice if you're building an eBay-integrated app under eBay's own terms and already have developer approval. This Actor is the faster path when you just need a list of sellers and their live inventory for research, without registering an application first.

### How to scrape eBay with eBay Seller Scraper By Keyword & Marketplace Search?

1. Open **eBay Seller Scraper By Keyword & Marketplace Search** on the Apify platform.
2. Add one or more terms to `searchQueries` (e.g. `"vintage camera"`) to discover sellers, and/or paste known profile URLs into `sellerProfileUrls` — no field is strictly required by the schema, but at least one of the two must be filled or the run finds nothing to scrape.
3. Pick `marketplaceDomain` for the locale you want, and set `maxSellersPerQuery` / `maxSearchResultPages` to control how deep the discovery goes.
4. Click **Start** and watch rows land in the Output tab as each seller is scraped.
5. Export the dataset as JSON, CSV, or Excel, or pull it via the Apify API.

Real request body:

```json
{
  "searchQueries": ["vintage camera"],
  "marketplaceDomain": "ebay.com",
  "maxSellersPerQuery": 5,
  "maxSearchResultPages": 1
}
```

#### How to run multiple queries in one job

List every keyword you want on its own line in `searchQueries` — the Actor works through them one at a time in the same run, discovering up to `maxSellersPerQuery` distinct sellers for each term before moving to the next, and skipping any username it has already resolved earlier in the same run. There's no separate batching endpoint to learn: one input array is the batch.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `searchQueries` | No | array | Keyword/category search terms — one per line. Discovers new sellers whose listings match the term. Leave empty to skip discovery. | `["vintage camera"]` |
| `marketplaceDomain` | No | string (enum) | Which of the 16 eBay locales to search/scrape on for discovery and for bare usernames. Full seller URLs keep their own domain. | `"ebay.com"` |
| `maxSellersPerQuery` | No | integer | Cap on unique sellers resolved per search term. Default `5`. | `5` |
| `maxSearchResultPages` | No | integer | Search-result pages scanned per term when discovering sellers. Default `1`. | `1` |
| `sellerProfileUrls` | No | array | Known seller profile URLs (any of the 16 marketplaces) or bare usernames. Also accepts the legacy `urls` key. | `["https://www.ebay.co.uk/usr/chrisjoh7639"]` |
| `proxyConfiguration` | No | object | Optional Apify Proxy configuration. Defaults to no proxy; the Actor escalates direct → datacenter → residential automatically if a request is blocked. | `{"useApifyProxy": false}` |

Example input:

```json
{
  "searchQueries": ["vintage camera", "nike sneakers"],
  "marketplaceDomain": "ebay.com",
  "maxSellersPerQuery": 5,
  "maxSearchResultPages": 1,
  "sellerProfileUrls": ["https://www.ebay.co.uk/usr/chrisjoh7639"],
  "proxyConfiguration": { "useApifyProxy": false }
}
```

**Common pitfall:** every field is optional in the schema, but leaving both `searchQueries` and `sellerProfileUrls` empty gives the Actor nothing to do — it logs a warning and the run ends with zero rows. Fill at least one. Separately, if you open the proxy block, don't pick **Own proxies** and leave the list empty — that fails validation; choose **No proxy** instead.

### ⬆️ Output

Results are typed, normalized JSON, one object per seller, with a consistent schema across runs — pushed live to the dataset as each seller finishes scraping. Export it as JSON, CSV, Excel, or any other format the Apify dataset export supports.

#### Scraped results

```json
[
  {
    "url": "https://www.ebay.com/usr/cameravaultusa",
    "name": "cameravaultusa",
    "feedback_score": "99.2% positive",
    "marketplaceDomain": "ebay.com",
    "discoveredViaKeyword": true,
    "matchedQuery": "vintage camera",
    "listings": [
      {
        "title": "Vintage 35mm Film Camera - Fully Tested",
        "price": "$45.00",
        "productUrl": "https://www.ebay.com/itm/123456789012",
        "condition": "Pre-owned",
        "imageUrl": "https://i.ebayimg.com/images/g/abc/s-l500.jpg",
        "originalPrice": "$60.00",
        "discountPercent": 25,
        "cardAttribute": ["Free shipping"],
        "hasBestOffer": true
      }
    ],
    "scrapedAt": "2026-07-25T12:03:41+00:00"
  },
  {
    "url": "https://www.ebay.com/usr/retrolensco",
    "name": "retrolensco",
    "feedback_score": "100% positive",
    "marketplaceDomain": "ebay.com",
    "discoveredViaKeyword": true,
    "matchedQuery": "vintage camera",
    "listings": [
      {
        "title": "Vintage Twin Lens Reflex Camera",
        "price": "£78.00",
        "productUrl": "https://www.ebay.com/itm/223344556677",
        "condition": "Used",
        "imageUrl": "https://i.ebayimg.com/images/g/def/s-l500.jpg",
        "originalPrice": "",
        "discountPercent": null,
        "cardAttribute": ["Located in United Kingdom"],
        "hasBestOffer": false
      }
    ],
    "scrapedAt": "2026-07-25T12:04:02+00:00"
  },
  {
    "url": "https://www.ebay.co.uk/usr/chrisjoh7639",
    "name": "chrisjoh7639",
    "feedback_score": "100% positive",
    "marketplaceDomain": "ebay.co.uk",
    "discoveredViaKeyword": false,
    "matchedQuery": null,
    "listings": [
      {
        "title": "Nikon FM2 Camera Body",
        "price": "£110.00",
        "productUrl": "https://www.ebay.co.uk/itm/334455667788",
        "condition": "Very Good",
        "imageUrl": "https://i.ebayimg.com/images/g/ghi/s-l500.jpg",
        "originalPrice": "£130.00",
        "discountPercent": 15,
        "cardAttribute": ["Free returns"],
        "hasBestOffer": true
      }
    ],
    "scrapedAt": "2026-07-25T12:05:17+00:00"
  }
]
```

### How can I use the data extracted with eBay Seller Scraper By Keyword & Marketplace Search?

- **Competitive seller research (resellers, dropshippers, sourcing teams):** run your niche keywords, then rank discovered sellers by `feedback_score` and inspect their `listings` to see exactly what's live, at what condition and price, before deciding who to watch or contact.
- **Price and discount monitoring:** re-scrape the same seller list on a schedule and diff `price`, `originalPrice`, and `discountPercent` per `productUrl` to catch markdowns and Best Offer listings (`hasBestOffer`) as they appear.
- **AI engineers and LLM developers:** wire an agent to call this Actor with a category term, receive structured JSON back, and ground answers about "who sells X" or "what's this seller currently listing" without the model hallucinating storefront details.
- **Market researchers:** compare the same keyword across several `marketplaceDomain` values to see how seller counts, feedback scores, and pricing differ between the US, UK, EU, and APAC eBay sites.

### How do you monitor eBay seller feedback and listings over time?

Monitoring here means re-running the same keyword set or seller list on a schedule and comparing each seller's row to its previous version. Because every row carries a `scrapedAt` timestamp, you can always tell which run a given snapshot came from.

The fields worth diffing between runs are `feedback_score` (a seller's reputation moving up or down), the contents of `listings[]` keyed by `productUrl` (new items appearing, old ones disappearing — meaning sold or delisted), and `price` / `discountPercent` on items that persist between runs (a live price cut or a new Best Offer flag).

A practical workflow: keep a fixed list of seller URLs or niche keywords in your input, run the Actor on a recurring schedule, and compare each new dataset export against the previous one — join on `url` (seller) and `productUrl` (listing) — then alert whenever `feedback_score` drops, a tracked seller's listing count changes, or `discountPercent` crosses a threshold you care about.

This Actor has no built-in webhook or diffing feature of its own; the comparison logic lives in whatever you run afterward. What it does provide is the real scheduling hook: Apify's platform-level **Schedule** feature can trigger this Actor with the same input on a recurring cadence, so the snapshots you're diffing arrive automatically.

### Integrate eBay Seller Scraper By Keyword & Marketplace Search and automate your workflow

eBay Seller Scraper By Keyword & Marketplace Search works with any language or tool that can send an HTTP request.

#### REST API with Python

```python
import requests

url = "https://api.apify.com/v2/acts/scrapier~ebay-seller-scraper-by-keyword-and-marketplace-search/run-sync-get-dataset-items"
headers = {"Authorization": "Bearer <YOUR_APIFY_API_TOKEN>"}
payload = {
    "searchQueries": ["vintage camera"],
    "marketplaceDomain": "ebay.com",
    "maxSellersPerQuery": 5,
}

response = requests.post(url, headers=headers, json=payload)
sellers = response.json()

for seller in sellers:
    print(seller["name"], seller["feedback_score"], len(seller["listings"]))
```

#### MCP for query-grounded AI agents

This Actor is reachable through Apify's Actors MCP Server: `npx @apify/actors-mcp-server --tools scrapier/ebay-seller-scraper-by-keyword-and-marketplace-search`, or via the hosted `https://mcp.apify.com` endpoint. An MCP-native client (Claude Desktop, Claude Code, or another MCP agent framework) can call it as a tool — the agent sends a keyword or seller URL, gets back structured seller/listing JSON, and answers grounded in what's actually live on eBay right now.

#### Scheduled monitoring and delivery

Use Apify's **Schedule** feature to trigger runs with the same input on a recurring cadence, then pull each run's dataset via the API or webhook integrations available on the platform. There is no built-in push-notification feature inside the Actor itself — delivery is whatever your schedule or webhook is wired to.

### Is it legal to scrape eBay seller data?

Yes — scraping publicly visible eBay seller and listing pages is generally legal in most jurisdictions, since this Actor only collects what any visitor can already see without logging in. Seller names, feedback scores, and listing details are business data, not personal data about private individuals, so this sits closer to ToS and database-rights considerations than to GDPR/CCPA personal-data rules. eBay's Terms of Service restrict automated access, so compliance is a contractual question between you and eBay, not strictly a legal ban on scraping public pages. Scraping for one-off research or monitoring carries a different risk profile than scraping at scale to train a model or rebuild a competing catalog. Consult your legal team for commercial use cases involving bulk data storage.

### Frequently asked questions

#### Which eBay marketplaces does this Actor support?

All 16: `ebay.com`, `.co.uk`, `.de`, `.fr`, `.it`, `.es`, `.ca`, `.com.au`, `.at`, `.ie`, `.nl`, `.pl`, `.ch`, `.com.hk`, `.com.my`, and `.ph`, selected via the `marketplaceDomain` field. Seller profile URLs pasted directly keep their own domain regardless of this setting.

#### How do I control how many sellers I get back?

`maxSellersPerQuery` caps unique sellers resolved per search term (default `5`), and `maxSearchResultPages` controls how many pages of search results are scanned per term to find them (default `1`). Raise `maxSearchResultPages` for niche keywords that need a deeper scan to surface enough distinct sellers.

#### How does this Actor handle eBay's anti-bot measures?

It fetches with Chrome TLS/HTTP impersonation rather than a plain HTTP client, and if a request comes back blocked it escalates through a direct → datacenter proxy → residential proxy fallback ladder with backoff between residential retries, reusing a working exit IP for the rest of the run once one is found.

#### How many results does this Actor return per query?

Up to `maxSellersPerQuery` distinct sellers per search term (default `5`, no fixed upper bound — you set it), drawn from up to `maxSearchResultPages` pages of search results (default `1`). Both are your own input values, not a platform-imposed cap.

#### How do I use this Actor to monitor a seller or niche over time?

Keep the same seller list or keyword set in your input, run it on a schedule via Apify's Schedule feature, and diff each new dataset against the last one on `url` and `productUrl` — alert on `feedback_score` changes or new/removed/discounted listings.

#### Does it work with Claude, ChatGPT, and AI agent frameworks?

Yes. It's callable as a plain HTTP endpoint by any agent framework, and it's also reachable through Apify's Actors MCP Server (`npx @apify/actors-mcp-server --tools scrapier/ebay-seller-scraper-by-keyword-and-marketplace-search`) for MCP-native clients.

#### How does this Actor compare to other eBay scrapers?

As observed on their public Apify listings on 2026-07-25, some eBay scrapers cover more marketplaces (one lists 20 locales) and richer seller-profile fields like registration date or store description; others cover fewer (one lists 5). This Actor's distinction is combining keyword-based seller discovery with per-listing commerce detail (condition, image, discount percentage) in the same seller row, across 16 marketplaces, without requiring you to already know a seller's username.

#### Can I use it without managing proxies or eBay credentials?

Yes. No eBay account or login is used — everything comes from public pages. Proxy handling is automatic and optional: leave `proxyConfiguration` at its default and the Actor runs direct-first, only reaching for Apify Proxy if a request gets blocked.

#### Does this Actor require knowing a seller's username in advance?

No — that's what `searchQueries` is for. Give it a keyword or category term and it resolves real seller usernames from matching listings itself. `sellerProfileUrls` is there for when you do already know who you want.

### Your feedback

Found a bug, a field that doesn't match this README, or a marketplace that needs different handling? Let us know through the Issues tab on this Actor's Apify Console page. Reports like this directly shape what gets fixed next.

# Actor input Schema

## `searchQueries` (type: `array`):

📋 **Discover NEW sellers by niche** — one search term per line (e.g. "vintage camera", "nike sneakers", "pokemon cards"). For each term, the actor searches the chosen marketplace, hops to each matching item page once to resolve the real seller, then scrapes that seller's storefront. Leave empty to skip discovery and only use the profile URLs below.

## `marketplaceDomain` (type: `string`):

🗺️ **Which eBay locale to search/scrape on.** Applies to keyword discovery and to bare usernames entered below. Full seller profile URLs keep their own domain automatically.

## `maxSellersPerQuery` (type: `integer`):

🚦 Caps how many unique sellers get resolved (and then scraped) per search term, via the one-hop item-page lookup. Keeps discovery runs fast and predictable.

## `maxSearchResultPages` (type: `integer`):

📚 How many pages of search results to scan per search term when looking for sellers to discover. Increase this if a niche keyword needs a deeper scan to find enough distinct sellers.

## `sellerProfileUrls` (type: `array`):

📋 **Already know sellers?** One per line — a full profile URL (e.g. `https://www.ebay.co.uk/usr/your_seller_name`, any of the 16 supported marketplaces) or a bare username (uses the marketplace selected above). Works together with, or instead of, keyword discovery above.

(Backward compatible: the base actor's `urls` input key is still accepted if you're reusing an old input JSON.)

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

🌐 **You can skip this section** — the actor works out of the box.

If you open this block:

- ✅ Choose **No proxy** for normal runs, **or**
- ✅ Turn on **Apify Proxy** and pick a group (Datacenter / Residential), **or**
- ✅ Add your own proxy URLs under **Own proxies**.

⚠️ **Do not** select **Own proxies** and leave it empty — Apify will show a validation error. Pick **No proxy** instead.

## Actor input object example

```json
{
  "searchQueries": [
    "vintage camera"
  ],
  "marketplaceDomain": "ebay.com",
  "maxSellersPerQuery": 5,
  "maxSearchResultPages": 1,
  "sellerProfileUrls": [
    "https://www.ebay.co.uk/usr/chrisjoh7639"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchQueries": [
        "vintage camera"
    ],
    "marketplaceDomain": "ebay.com",
    "maxSellersPerQuery": 5,
    "maxSearchResultPages": 1,
    "sellerProfileUrls": [
        "https://www.ebay.co.uk/usr/chrisjoh7639"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapier/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 = {
    "searchQueries": ["vintage camera"],
    "marketplaceDomain": "ebay.com",
    "maxSellersPerQuery": 5,
    "maxSearchResultPages": 1,
    "sellerProfileUrls": ["https://www.ebay.co.uk/usr/chrisjoh7639"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapier/ebay-seller-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 '{
  "searchQueries": [
    "vintage camera"
  ],
  "marketplaceDomain": "ebay.com",
  "maxSellersPerQuery": 5,
  "maxSearchResultPages": 1,
  "sellerProfileUrls": [
    "https://www.ebay.co.uk/usr/chrisjoh7639"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapier/ebay-seller-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapier/ebay-seller-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/TFPh6LPeYTmvglfTi/builds/wdZ3PzMKdVvqtoijp/openapi.json