# eBay Seller & Market Monitor (`highbrow_qualification_z7w/ebay-seller-market-monitor`) Actor

Monitor eBay seller inventory and detect listing changes between runs. Track new and removed listings, price updates, availability, shipping, and content changes. Build a baseline, schedule recurring runs, and export structured results via dataset or API.

- **URL**: https://apify.com/highbrow\_qualification\_z7w/ebay-seller-market-monitor.md
- **Developed by:** [Roman Bublyk](https://apify.com/highbrow_qualification_z7w) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 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/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

## eBay Seller & Market Monitor

Monitor public eBay seller inventory over time and distinguish real catalog changes from listing churn.

The Actor keeps a stateful snapshot for every seller and marketplace, compares each successful run with the previous one, and returns structured seller summaries, listing snapshots, and lifecycle events.

### Why this Actor

Most eBay monitoring tools treat every listing ID as a separate product. Sellers can end and recreate listings, which makes simple ID-based monitoring report misleading additions and removals.

This Actor follows a more conservative principle:

> Track the product, not only the listing.

It uses exact listing IDs and normalized product signals to identify changes while exposing the matching method, evidence, and confidence. A disappeared listing is never presented as a confirmed sale because public eBay pages do not provide enough evidence for that conclusion.

### What it detects

- new listings;
- ended listings;
- price changes;
- content changes;
- probable relists when the available evidence is strong enough;
- unknown outcomes when a listing disappears without proof of a sale.

### Supported marketplaces

- `EBAY_US` — United States;
- `EBAY_GB` — United Kingdom;
- `EBAY_DE` — Germany.

### Input

```json
{
  "sellers": [
    {
      "username": "musicmagpie",
      "marketplace": "EBAY_GB"
    }
  ],
  "maxListingsPerSeller": 100,
  "emitUnchangedListings": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### Input fields

| Field | Required | Description |
| --- | --- | --- |
| `sellers` | Yes | One to 20 public seller usernames and their marketplaces. |
| `maxListingsPerSeller` | No | Maximum listings collected per seller, from 1 to 1,000. Default: 100. If the limit is reached, boundary events are suppressed to prevent false changes caused by window rotation. |
| `emitUnchangedListings` | No | When enabled, writes all current listing snapshots to the dataset. Default: `false`. |
| `proxyConfiguration` | No | Apify proxy configuration. When omitted, the Actor uses Apify Residential Proxy because eBay commonly blocks datacenter traffic. |

Keep `maxListingsPerSeller` unchanged between scheduled runs. Changing it creates a new baseline because two differently sized snapshots cannot be compared reliably.

### Output

The default dataset can contain four record types:

| `recordType` | Meaning |
| --- | --- |
| `seller-summary` | Run-level result for one seller, including baseline state and event counts. |
| `lifecycle-event` | A detected change with matching method, evidence, and confidence. |
| `listing-snapshot` | Current normalized listing data. Emitted on the first run or when explicitly requested. |
| `error` | Structured seller-level failure that does not hide successful results for other sellers. |

Example lifecycle event:

```json
{
  "recordType": "lifecycle-event",
  "schemaVersion": "1.0",
  "status": "ok",
  "eventType": "PRICE_CHANGED",
  "sellerUsername": "example-seller",
  "marketplace": "EBAY_GB",
  "previousListingId": "123456789012",
  "currentListingId": "123456789012",
  "confidence": 1,
  "confidenceLevel": "confirmed",
  "matchingMethod": "LISTING_ID_EXACT",
  "evidence": ["same_listing_id", "price_changed"],
  "observedAt": "2026-09-22T20:46:27.580Z"
}
```

### Stateful monitoring

The first successful run for a seller is a baseline and does not report historical changes that the Actor could not observe. Later runs compare the current inventory with the stored snapshot.

Each seller summary reports snapshot coverage:

- `snapshotTruncated: false` and `lifecycleCoverage: complete-snapshot` mean the collected snapshot is below the configured limit, so additions, endings, relists, price changes, and content changes can be evaluated;
- `snapshotTruncated: true` and `lifecycleCoverage: overlap-only` mean the configured limit was reached. The Actor then reports price and content changes only for listing IDs visible in both snapshots. It suppresses additions, endings, and relists because leaving a capped result window does not prove that a listing ended.

`baselineReason` can be:

- `no-previous-snapshot` — the seller has no stored snapshot yet;
- `monitoring-scope-changed` — `maxListingsPerSeller` changed;
- `null` — the current run was compared with the preceding compatible snapshot.

For useful monitoring, save the input as an Apify Task and schedule it at a consistent interval.

### API

Apify automatically exposes the Actor through its REST API. Replace `<ACTOR_ID>` with the Actor ID shown in the Console and `<APIFY_TOKEN>` with your token.

#### Start a run

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<ACTOR_ID>/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "sellers": [{"username": "musicmagpie", "marketplace": "EBAY_GB"}],
    "maxListingsPerSeller": 100,
    "emitUnchangedListings": false,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

#### Run synchronously and return dataset items

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/<ACTOR_ID>/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "sellers": [{"username": "musicmagpie", "marketplace": "EBAY_GB"}],
    "maxListingsPerSeller": 100
  }'
```

#### Read results from a completed run

Use the `defaultDatasetId` returned by the run:

```bash
curl \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json&clean=true"
```

The Input, API, and Integration tabs in Apify Console generate equivalent examples for JavaScript, Python, cURL, and supported integrations from the Actor's schemas.

### Accuracy and limitations

- The Actor monitors publicly visible active inventory; it does not access private seller analytics, orders, or buyer data.
- A missing listing means that it ended or disappeared from the monitored inventory. It does not prove that the item sold.
- For sellers whose inventory reaches `maxListingsPerSeller`, the Actor intentionally suppresses new, ended, unknown-outcome, and relisted events. Increase the limit to obtain complete-snapshot lifecycle coverage when the seller's inventory fits within the supported maximum.
- Prices are the values displayed in the seller search results for the selected marketplace and proxy context. A detail or checkout page can show a different value because of location, tax, shipping, promotions, or session state.
- eBay can change markup or restrict automated traffic. Residential proxies reduce blocking but cannot guarantee uninterrupted access.
- The Actor does not use an LLM. Lifecycle classification is deterministic and evidence-based.

### Proxy and cost considerations

eBay commonly rejects datacenter traffic. Both the input form and the runtime fallback therefore use Apify Residential Proxy. Platform compute and proxy usage are included in the Actor's Store event pricing rather than charged to the user as a separate usage line.

### Privacy

The Actor processes public seller and listing information only. It does not require eBay credentials and does not intentionally collect buyer information.

# Actor input Schema

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

Public eBay seller usernames and marketplaces to monitor.

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

Maximum number of listings collected for each seller. If the seller has at least this many listings, lifecycle detection is limited to exact IDs visible in consecutive snapshots. Keep the value unchanged between runs.

## `emitUnchangedListings` (type: `boolean`):

Emit every current listing snapshot in addition to seller summaries and detected lifecycle events. Enabling this increases dataset item count.

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

Apify proxy settings. Residential proxies are recommended because eBay commonly blocks datacenter traffic.

## Actor input object example

```json
{
  "sellers": [
    {
      "username": "musicmagpie",
      "marketplace": "EBAY_GB"
    }
  ],
  "maxListingsPerSeller": 100,
  "emitUnchangedListings": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Structured monitoring results from this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "sellers": [
        {
            "username": "musicmagpie",
            "marketplace": "EBAY_GB"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_qualification_z7w/ebay-seller-market-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "sellers": [{
            "username": "musicmagpie",
            "marketplace": "EBAY_GB",
        }] }

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

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

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

```

## CLI example

```bash
echo '{
  "sellers": [
    {
      "username": "musicmagpie",
      "marketplace": "EBAY_GB"
    }
  ]
}' |
apify call highbrow_qualification_z7w/ebay-seller-market-monitor --silent --output-dataset

```

## MCP server setup

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

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/teTcAMfq7tC9yeefD/builds/PXMGyC256ASV3VP6Y/openapi.json