# eBay Scraper By Buyer Interest & Seller Feedback (`simpleapi/ebay-scraper`) Actor

🛒 ebay scraper extracts eBay product data at scale—listings, titles, prices, images, item specifics, seller ratings, shipping & reviews—from search, categories, or stores. ⚡ Fast & reliable. 📊 Export CSV/JSON/API. 🚀 Perfect for price tracking, market research, SEO & dropshipping.

- **URL**: https://apify.com/simpleapi/ebay-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/actors/running/actors-in-store.md#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 Scraper — Listings, Buyer Interest and Seller Feedback

Extract eBay listings from any search page or direct item link and get them back as structured JSON — title, price, was-price, brand, and category data alongside live watchers count, a derived demand score, and seller feedback count/percentage. Resellers, dropshippers, pricing analysts, and market researchers use this data to rank listings by real buyer interest instead of price alone, and to screen out low-trust sellers before sourcing. Paste your URLs and every field lands in one flat row per listing.

### What is eBay Scraper By Buyer Interest & Seller Feedback?

eBay Scraper By Buyer Interest & Seller Feedback is an Apify Actor that turns eBay search-result pages and individual listing pages into structured data rows, adding buyer-demand and seller-trust signals pulled from the same page load. No eBay account, login, or API key is required — the Actor reads public search and listing pages exactly as a visitor's browser would.

- **Discovery by URL** — paste eBay search/category URLs to cast a wide net, or direct `/itm/` listing URLs for a laser-focused pull; mix both freely in one run.
- **Full listing identity and pricing** — title, subtitle, price, was-price, availability, sold count, brand, EAN/MPN/UPC, and category breadcrumb, in the same pass.
- **Live buyer-interest signals** — real watchers count plus a derived `demandScore` that combines watchers and sold count.
- **Seller-trust signals** — seller feedback count, positive-feedback percentage, and return-policy terms (day window and who pays return shipping).
- **Built-in quality filters** — `minWatchers` and `minSellerFeedbackPercent` drop low-interest or low-trust listings before they ever reach your dataset.
- **Structured export** — one consistent JSON schema per listing, downloadable as JSON, CSV, or Excel through Apify's standard dataset export.

### What data can I extract with eBay Scraper By Buyer Interest & Seller Feedback?

Every run returns one flat row per listing covering identity, pricing, stock, seller, buyer-interest, and trust data:

| Field | Example Value | Use Case |
| --- | --- | --- |
| `url` | `https://www.ebay.com/itm/195678901234` | Canonical link back to the live listing |
| `itemNumber` | `195678901234` | Unique eBay item ID for deduping/joins |
| `title` | `"Electric Massage Recliner Chair with Heat"` | Product identification |
| `subTitle` | `"Zero Gravity, Bluetooth Speaker, Remote Control"` | Extra positioning copy sellers add |
| `whyToBuy` | `["Free shipping", "Top Rated Plus"]` | Seller-highlighted selling points |
| `price` | `499.99` | Numeric price for sorting/filtering |
| `priceWithCurrency` | `"US $499.99"` | Display-ready price |
| `wasPrice` | `599.99` | Pre-discount price for markdown tracking |
| `wasPriceWithCurrency` | `"US $599.99"` | Display-ready was-price |
| `available` | `12` | Remaining stock count |
| `availableText` | `"More than 10 available"` | Raw stock phrasing as shown on eBay |
| `sold` | `184` | Cumulative units sold |
| `image` | `https://i.ebayimg.com/images/g/abc/s-l1600.jpg` | Primary listing photo |
| `seller` | `"cozyhome-outlet"` | Seller username/store handle |
| `itemLocation` | `"Ontario, CA, United States"` | Ships-from location |
| `brand` | `"Homall"` | Structured brand for filtering |
| `type` | `"Massage Chair"` | Product-type item specific |
| `categories` | `["Home & Garden", "Furniture", "Massage Chairs"]` | Breadcrumb category path |
| `ean` | `"0192837465019"` | Barcode identifier, when disclosed |
| `mpn` | `"MC-2200BLK"` | Manufacturer part number, when disclosed |
| `upc` | `"Does not apply"` | UPC, or eBay's own "not applicable" text |
| `watchersCount` | `47` | Live buyer-interest count |
| `watchersText` | `"47 watchers"` | Raw text as rendered on the page |
| `demandScore` | `225.0` | Derived interest index (see below) |
| `sellerFeedbackCount` | `3512` | Total feedback ratings for the seller |
| `sellerFeedbackPositiveText` | `"99.2% positive"` | Raw feedback text |
| `sellerFeedbackPositivePercent` | `99.2` | Clean float for trust-threshold filtering |
| `returnPolicyText` | `"30 days returns. Buyer pays for return shipping."` | Full policy sentence |
| `returnPolicyDays` | `30` | Explicit return window, when stated |
| `returnShippingPaidBy` | `"Buyer"` | Who covers return shipping, when stated |
| `scrapedAt` | `"2026-07-25T14:02:11.123456+00:00"` | Timestamp of extraction |

#### Buyer-interest and seller-trust signals

`watchersCount` and `sellerFeedbackCount`/`sellerFeedbackPositivePercent` are read from the same item-page HTML as everything else — no extra request per listing. **Watchers are genuinely conditional data**: eBay only renders the watchers widget once a listing crosses its own internal interest threshold, so `watchersCount`/`watchersText` come back `null` on lower-interest listings rather than a faked `0`. `demandScore` is not an eBay metric — it's a value this Actor derives (`3 × watchersCount + 1 × sold`, weighting live watcher intent above cumulative sales) so listings can be ranked on one number. Use `sellerFeedbackPositivePercent` together with `returnPolicyDays`/`returnShippingPaidBy` to screen out sellers before you commit to sourcing from them.

#### Targeting and identity data

`categories`, `brand`, `type`, and `itemLocation` are the fields to segment on: filter a dataset down to one category branch, one brand, or one shipping region after the run, or use them to spot-check that a search URL actually returned the product line you meant. `ean`/`mpn`/`upc` support exact cross-listing/cross-marketplace matching when a seller discloses them, and `itemNumber` is the stable join key across repeated runs.

### How does eBay Scraper By Buyer Interest & Seller Feedback differ from the official eBay API?

eBay's own Browse API can return a `watchCount` field and seller feedback data via `getItem`, but the default rate limit is 5,000 calls/day per app, and a higher tier needs eBay's Application Growth Check — a real ceiling on bulk demand-screening for a new app ([eBay Developers Program, API Call Limits](https://developer.ebay.com/develop/get-started/api-call-limits)).

| Feature | eBay Browse API | This eBay Scraper |
| --- | --- | --- |
| Access requirement | Registered developer app, OAuth token | None — no eBay account or API key |
| Default call volume | 5,000 calls/day per app | `maxListings` up to 100,000 per run |
| Watchers + feedback | Separate `getItem` call per listing | One page fetch per listing, all fields included |
| Search-page discovery | `search` returns light summaries; detail needs one call per item | Paste a search URL, every listing is discovered and fetched |
| Setup | Register app, manage OAuth tokens | Paste URLs and run |
| Output shape | Raw API JSON, varies by fieldgroup | One flat, consistent JSON row per listing |

#### What's the eBay Browse API's default rate limit?

5,000 calls per day per application, covering `getItem` — the method carrying `watchCount` and seller feedback ([eBay Developers Program, API Call Limits](https://developer.ebay.com/develop/get-started/api-call-limits)). Since `getItem` returns one listing at a time, screening a few thousand listings a day for buyer interest already uses most of that quota, before counting the calls needed to discover those listings. This Actor covers the gap by reading the same public page a buyer would load, one fetch per listing, with no per-day API quota beyond your own Apify usage.

Reach for the official API for a production eBay integration on eBay's own infrastructure. Reach for this Actor for buyer-interest and seller-trust data from a list of URLs, with no developer app to register.

### How to use data extracted from eBay?

#### Resellers and dropshippers

Paste a category or search URL, set `minWatchers` and `minSellerFeedbackPercent` to your bar, and the dataset that lands is already screened to "hot and trustworthy" candidates. Sort the result on `demandScore` and `wasPrice` vs `price` to find listings with both live buyer interest and room for a markdown, then cross-check `ean`/`mpn`/`upc` against your own catalog before sourcing. The output drops straight into a spreadsheet or a sourcing pipeline without opening a single listing manually.

#### Pricing and monitoring agencies

Agencies tracking eBay pricing for clients can rerun the same set of listing or search URLs on a schedule and diff `price`, `sold`, and `watchersCount` between runs to show a client whether a competitor's listings are gaining interest or getting discounted. `itemNumber` is the stable key for joining rows across runs, so a week-over-week or month-over-month watcher/price trend report doesn't need any manual reconciliation.

#### Market research and intelligence

Point the Actor at a category's search results and analyze the returned `categories`, `brand`, and `price` fields in bulk to map which sub-categories and brands dominate a search term, or aggregate `demandScore` and `sold` by `brand` to see which manufacturers actually convert. Because search and direct-listing inputs return the same schema, category-wide sampling and single-listing deep dives can feed the same analysis pipeline.

#### AI agents and automated pipelines

Because output is one flat JSON schema per listing, an agent can call this Actor as a tool to pull live eBay demand data mid-conversation, ground a recommendation in real `watchersCount`/`sellerFeedbackPositivePercent` figures, or feed a RAG pipeline with current listing and seller-trust context rather than stale training data.

### 🔼 Input sample

None of the five input parameters are required — the Actor runs with `listingUrls` alone.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `listingUrls` | No | array (string list) | eBay search/category URLs or direct `/itm/` listing URLs; mix both. Also accepts the base `urls` field. | `["https://www.ebay.com/sch/i.html?_nkw=massage+recliner+chair"]` |
| `maxListings` | No | integer (0–100,000) | Cap on how many listing pages to process after URL discovery; 0 = no limit. Also accepts the base `maxItems` field. | `20` |
| `minWatchers` | No | integer (0–100,000, default `0`) | Keep only listings with at least this many watchers; `0` = no filter. | `10` |
| `minSellerFeedbackPercent` | No | number (0–100, default `0`) | Keep only listings from sellers at or above this positive-feedback percentage; `0` = no filter. | `98` |
| `networkSettings` | No | object (proxy editor) | Optional Apify Proxy configuration. Also accepts the base `proxyConfiguration` field. | `{"useApifyProxy": true}` |

```json
{
  "listingUrls": [
    "https://www.ebay.com/sch/i.html?_nkw=massage+recliner+chair",
    "https://www.ebay.com/itm/195678901234"
  ],
  "maxListings": 50,
  "minWatchers": 10,
  "minSellerFeedbackPercent": 98,
  "networkSettings": { "useApifyProxy": true }
}
```

**Pitfall to avoid:** setting `minWatchers` or `minSellerFeedbackPercent` above `0` drops any listing where that signal genuinely can't be read — eBay only renders the watchers widget above its own internal interest threshold, so a real but lower-interest listing is excluded the same as one with true zero interest. If your dataset looks thinner than expected, lower the threshold back to `0` and check `watchersCount`/`sellerFeedbackPositivePercent` on the unfiltered rows first.

### 🔽 Output sample

Results are pushed to the Actor's dataset one row per listing as they're scraped, and can be exported as JSON, CSV, or Excel from the Apify run's Storage tab.

```json
{
  "url": "https://www.ebay.com/itm/195678901234",
  "itemNumber": "195678901234",
  "title": "Electric Massage Recliner Chair with Heat and Bluetooth Speaker",
  "subTitle": "Zero Gravity, Full Body, Remote Control",
  "whyToBuy": ["Free shipping", "Top Rated Plus", "30 day returns"],
  "price": 499.99,
  "priceWithCurrency": "US $499.99",
  "wasPrice": 599.99,
  "wasPriceWithCurrency": "US $599.99",
  "available": 12,
  "availableText": "More than 10 available",
  "sold": 184,
  "image": "https://i.ebayimg.com/images/g/abc123/s-l1600.jpg",
  "seller": "cozyhome-outlet",
  "itemLocation": "Ontario, CA, United States",
  "brand": "Homall",
  "type": "Massage Chair",
  "categories": ["Home & Garden", "Furniture", "Massage Chairs"],
  "ean": "0192837465019",
  "mpn": "MC-2200BLK",
  "upc": "Does not apply",
  "watchersCount": 47,
  "watchersText": "47 watchers",
  "demandScore": 325.0,
  "sellerFeedbackCount": 3512,
  "sellerFeedbackPositiveText": "99.2% positive",
  "sellerFeedbackPositivePercent": 99.2,
  "returnPolicyText": "30 days returns. Buyer pays for return shipping.",
  "returnPolicyDays": 30,
  "returnShippingPaidBy": "Buyer",
  "scrapedAt": "2026-07-25T14:02:11.123456+00:00"
}
```

A listing that fails to load (removed, ended, or blocked mid-run) is still added to the dataset, but as a short placeholder row — `{"url", "error": "unavailable", "errorReason", "scrapedAt"}` — instead of a full product record, so you can see which URLs need a retry. These placeholder rows, and any listing filtered out by `minWatchers`/`minSellerFeedbackPercent`, are not charged; only a fully-extracted, filter-passing row is billed under the `row_result` event. To export just the billed rows, filter out any record where the `error` field is present.

### How do you filter and target specific listings?

Precision here starts with the input itself: paste a **search or category URL** to let the Actor discover every listing on the results grid (broad canvas, good for category-wide demand sweeps), or paste **direct `/itm/` listing URLs** when you already know exactly which items to check (laser-focused, no discovery step, faster per listing). The two input types can be mixed in a single `listingUrls` array.

`maxListings` is the volume control: it caps how many discovered/pasted listings actually get fetched, so a category sweep can be sampled cheaply (a low cap for a quick read on demand) or run exhaustively (`0` = no limit) once you know the URL is worth the full pull.

`minWatchers` and `minSellerFeedbackPercent` are the quality thresholds — the two filters that make this Actor a targeting tool rather than a plain page dumper. Set them together to keep only listings that are both in demand and from a trustworthy seller; remember that either filter drops listings where the underlying signal is genuinely absent on the page, not just low.

```json
{ "listingUrls": ["https://www.ebay.com/sch/i.html?_nkw=vintage+camera"], "maxListings": 200 }
```

```json
{ "listingUrls": ["https://www.ebay.com/itm/195678901234", "https://www.ebay.com/itm/198765432109"] }
```

```json
{ "listingUrls": ["https://www.ebay.com/sch/i.html?_nkw=graphics+card"], "minWatchers": 25, "minSellerFeedbackPercent": 99 }
```

### ▶️ Want to try other eBay scrapers?

| Scraper Name | What it extracts |
| --- | --- |
| eBay Seller Scraper With Business Seller Info | Seller profile pages: feedback score, store stats (items sold, positive-feedback %, followers, top-rated badge), and the seller's public business disclosure (VAT number, company registration number, registered business name) |
| Amazon Search Products Scraper: Brand Comparison Details | Amazon search results with brand-level price and listing comparison data |
| Amazon Bestsellers Scraper with Price Drop Report | Amazon bestseller lists with price-drop tracking over time |
| Amazon Seller Data Extractor With Business Contact Enrichment | Amazon seller storefronts enriched with business contact details |
| Alibaba Email Scraper & Trade Assurance Details | Alibaba supplier listings with contact emails and Trade Assurance verification status |

### How to extract eBay data programmatically

This Actor runs like any Apify Actor: one API call with your input JSON, one auth header, structured dataset JSON back.

#### Python example

```python
import requests

TOKEN = "YOUR_APIFY_API_TOKEN"
ACTOR = "SimpleAPI~ebay-scraper-by-buyer-interest-seller-feedback"

run = requests.post(
    f"https://api.apify.com/v2/acts/%7BACTOR%7D/run-sync-get-dataset-items",
    params={"token": TOKEN},
    json={
        "listingUrls": ["https://www.ebay.com/sch/i.html?_nkw=drone"],
        "minWatchers": 10,
        "minSellerFeedbackPercent": 98,
    },
)

for row in run.json():
    print(row["title"], row["watchersCount"], row["sellerFeedbackPositivePercent"])
```

#### MCP for AI agents

Apify Actors, including this one, are reachable through Apify's own Actors MCP Server without any actor-specific code:

```bash
npx -y @apify/actors-mcp-server --actors SimpleAPI/ebay-scraper-by-buyer-interest-seller-feedback
```

Point an MCP-compatible client — Claude Desktop, Claude Code, or Cursor — at this server (with an `APIFY_TOKEN` in the environment) and an agent can call the Actor as a tool to pull live watcher counts and seller feedback for a product line mid-conversation, without a custom integration.

#### Export to spreadsheets or CRM

From the run's Storage tab, export the dataset as CSV and map columns directly: `title` → product name, `price`/`wasPrice` → pricing columns, `watchersCount`/`demandScore` → a lead-scoring or priority column, `seller`/`sellerFeedbackPositivePercent` → a supplier-vetting column in your CRM or sourcing sheet.

### Is it legal to scrape eBay listings?

Yes — scraping publicly listed eBay pages for business and product data (prices, stock, categories, seller store handles) is generally permitted, since these records exist precisely to be found by shoppers and search engines. This Actor does not collect private buyer information; `seller` is a public store/username, not a private individual's personal details, so this falls under standard ToS and database-rights considerations rather than GDPR/CCPA personal-data rules. Always review eBay's own Terms of Service before large-scale or commercial use, and consult legal counsel for commercial applications involving bulk storage of any personal data you do encounter.

### ❓ FAQ

#### Are removed or ended eBay listings flagged in the output?

Yes — if a listing page can't be fully read (ended, removed, or blocked by eBay's bot defenses), the Actor still adds a row for that URL, but as a short placeholder: `{"error": "unavailable", "errorReason": ...}` instead of the full product record, so you can see exactly which URLs to retry or drop.

#### Can I get watchers and seller feedback along with the main listing data?

Yes, in the same row — `watchersCount`, `sellerFeedbackCount`, and `sellerFeedbackPositivePercent` are parsed from the same page fetch used for title/price/stock, with no extra request per listing and no pagination caveat beyond `maxListings`.

#### How accurate is the watcher and seller feedback data?

It's exactly what eBay renders on the page at request time. `watchersCount` is `null` (never a faked `0`) on listings below eBay's own display threshold, and feedback percentage reflects the seller's current public score — both change as buyers interact with the listing, so treat each run as a point-in-time snapshot.

#### How many listings can I get per run?

`maxListings` accepts 0–100,000, where `0` means no cap and the Actor processes every listing discovered from your input URLs; the schema's prefill is 20 for quick test runs.

#### How does the minWatchers / minSellerFeedbackPercent filter work?

Both are threshold filters applied after each listing is scraped: a listing is only saved to the dataset if its `watchersCount` and `sellerFeedbackPositivePercent` both meet or exceed the values you set (default `0` = no filtering). Listings where the underlying signal can't be read are treated as failing the bar, not passing it.

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

Yes — it's callable as an HTTP endpoint by any agent framework via the Apify API, and it's also reachable through Apify's Actors MCP Server (`npx -y @apify/actors-mcp-server --actors SimpleAPI/ebay-scraper-by-buyer-interest-seller-feedback`) for MCP-compatible clients like Claude Desktop and Claude Code.

#### Can I use this scraper without an eBay API key or developer account?

Yes — you need an Apify account to run the Actor, but no eBay account, login, or developer API key at all. Just paste eBay search or listing URLs.

#### How is buyer interest actually measured?

Through two real signals read straight from the listing page — `watchersCount` (live watch-list count, only shown by eBay once a listing crosses its own interest threshold) and `sold` (cumulative units sold) — combined into a derived `demandScore` (`3 × watchersCount + 1 × sold`). `demandScore` is this Actor's own weighting, not a metric eBay publishes itself, built so listings can be ranked on one number instead of eyeballing both fields separately.

### Conclusion

eBay Scraper By Buyer Interest & Seller Feedback turns eBay search results and listing pages into structured JSON that already answers the two questions price alone can't: is anyone actually interested, and can this seller be trusted. Resellers, pricing agencies, and market researchers get watchers, demand score, and seller feedback in the same row as price and stock, with quality filters to keep only the listings worth a closer look. Paste your search or listing URLs into the Actor on Apify and run it to get your first structured dataset back in minutes.

# Actor input Schema

## `listingUrls` (type: `array`):

🗺️ Add one or many eBay links — mix & match as you like!

🔎 Search / category pages → we'll discover listings from the results grid.

🏷️ Single listing pages → we'll grab that item's full details + demand signals.

✅ Paste full URLs from your browser; that's all you need.

(Also accepts the base `urls` field for backward compatibility.)

## `maxListings` (type: `integer`):

📊 Set a ceiling on how many listing pages to process after URL discovery — great for quick samples or budget-friendly runs.

0️⃣ Use 0 for no limit (go as far as your inputs allow).

⚡ Lower = faster & lighter; higher = broader coverage.

(Also accepts the base `maxItems` field.)

## `minWatchers` (type: `integer`):

🔥 Only keep listings with AT LEAST this many watchers.

⚠️ eBay only shows the watchers widget above an internal interest threshold — listings where it's genuinely absent are treated as not meeting the bar (never assumed to pass).

0️⃣ Default 0 = no filter (keep every listing, watchers shown when available).

## `minSellerFeedbackPercent` (type: `number`):

🛡️ Only keep listings from sellers with AT LEAST this positive-feedback percentage (e.g. 99.5 = 99.5% positive or higher).

0️⃣ Default 0 = no filter.

Listings where the percentage can't be read are treated as not meeting the bar (never assumed to pass).

## `networkSettings` (type: `object`):

🛡️ Optional Apify Proxy settings for smoother runs when the target site is picky about traffic.

✨ Tune country or groups in the proxy editor if your use case needs it — especially for international or large-scale jobs.

💚 Leave defaults if you're unsure; you can always rerun with adjustments.

(Also accepts the base `proxyConfiguration` field.)

## Actor input object example

```json
{
  "listingUrls": [
    "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "maxListings": 20,
  "minWatchers": 0,
  "minSellerFeedbackPercent": 0,
  "networkSettings": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped items in the Actor's default dataset.

# 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 = {
    "listingUrls": [
        "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
    ],
    "maxListings": 20,
    "networkSettings": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/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 = {
    "listingUrls": ["https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"],
    "maxListings": 20,
    "networkSettings": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/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 '{
  "listingUrls": [
    "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2499334.m570.l1313&_nkw=massage%2Brecliner%2Bchair&_sacat=6024"
  ],
  "maxListings": 20,
  "networkSettings": {
    "useApifyProxy": true
  }
}' |
apify call simpleapi/ebay-scraper --silent --output-dataset

```

## MCP server setup

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