# eBay Resale Research — Seller Feedback Prices (`agency-shift/ebay-resale-research`) Actor

Collect prices displayed with verified purchases on selected public eBay seller feedback pages. Filter item titles and get source links plus separate price summaries for each eBay listing and currency. Feedback samples are not complete sales history.

- **URL**: https://apify.com/agency-shift/ebay-resale-research.md
- **Developed by:** [Valdeir Lima](https://apify.com/agency-shift) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.48 / 1,000 feedback price observations

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

### What does eBay Resale Research do?

**Collect item prices displayed alongside verified-purchase feedback for selected eBay sellers.** Enter seller usernames, optionally filter item titles, and receive structured observations with source links. Free summaries describe the displayed-price sample for each individual eBay listing and currency.

The source is public seller feedback on [eBay.com](https://www.ebay.com/). These observations cover purchases that received accessible feedback. They do not establish a complete sales history, market-wide sold-search coverage, or the exact final amount a buyer paid. Exact sale dates, shipping, item condition and accepted-offer status remain unavailable.

Use the Actor through Apify Console or API, schedule repeat scans, and connect its dataset to your existing research workflow. No eBay login, account cookies or paid proxy configuration is required.

### Why use eBay seller feedback price research?

This Actor helps researchers inspect a seller's reviewed-purchase price sample, compare displayed prices within one listing, and export observations for their own product-matching process. Each record retains the listing ID, feedback ID, original price text and source page so you can inspect its provenance.

Separate purchases of the same listing remain separate observations. Analytics stay within one eBay listing ID and currency, which prevents a seller's unrelated headphones, vacuum cleaners and accessories from becoming one misleading average. Different listings are not automatically treated as identical models or conditions.

### How to use eBay Resale Research

1. Enter one to ten public eBay seller usernames in the **Input** tab.
2. Optionally enter words required in the item title and phrases to exclude.
3. Choose a result limit and a run spending cap, then start the Actor.
4. Open **Displayed price observations** for the dataset.
5. Check **Scan coverage and errors** for seller outcomes and limits. Open **Free listing-level price summaries** for the sample statistics.

Start with a small run to check that the chosen sellers expose usable feedback for the products you need. A successful empty result can mean there were no matching accessible observations; it does not prove the seller had no sales.

### Input

The Input tab contains the complete form. For example:

```json
{
  "sellerUsernames": ["secondipity"],
  "query": "sony",
  "excludeKeywords": ["case", "charger"],
  "maxResults": 100,
  "maxPagesPerSeller": 3,
  "minSampleSize": 5
}
```

| Field | Default | Meaning |
| --- | --- | --- |
| `sellerUsernames` | Required | 1–10 public usernames, without URLs or credentials. |
| `query` | Empty | Optional feedback item-title search. Local matching requires every normalized word as a complete title word, regardless of order. |
| `excludeKeywords` | `[]` | Up to 30 title words or phrases to exclude; matching ignores case and punctuation. |
| `maxResults` | `100` | Maximum delivered observations across the run, from 1 to 1,000. Your spending cap can stop output sooner. |
| `maxPagesPerSeller` | `3` | Maximum accessible feedback pages for each seller, from 1 to 10. Availability and matching feedback determine the actual result count. |
| `minSampleSize` | `5` | Flag summaries with fewer usable observations as `lowSample`; accepts 1–100. This does not remove small groups. |

The query filters feedback associated with your chosen sellers. It does not discover additional sellers or perform a market-wide eBay sold search. Sellers are processed in input order, so a run-wide limit can leave later sellers unprocessed.

### Output

Each paid dataset row is one verified-purchase feedback price observation. The following abbreviated example is illustrative:

```json
{
  "recordType": "price-observation",
  "saleEvidence": "seller-feedback",
  "feedbackId": "1234567890123",
  "itemId": "123456789012",
  "title": "Example wireless speaker",
  "sellerUsername": "example-seller",
  "marketplace": "ebay.com",
  "displayedPurchasePrice": 49.99,
  "currency": "USD",
  "priceText": "US $49.99",
  "feedbackPeriod": "Past month",
  "verifiedPurchase": true,
  "soldPrice": null,
  "soldDate": null,
  "condition": null,
  "shippingPrice": null,
  "isBestOfferAccepted": null,
  "sourceUrl": "https://www.ebay.com/fdbk/feedback_profile/example-seller",
  "itemUrl": "https://www.ebay.com/itm/123456789012"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

The free **ANALYTICS** key-value record contains listing-level groups with `priceBasis: "displayed-feedback-item-price"`, median, 25th and 75th percentiles, mean, minimum, maximum, sample size, exclusions and `lowSample`. Currency groups remain separate. Shipping is excluded, and exact sale-date spans remain null. These statistics describe the returned feedback sample; they are not a suggested resale price, profit estimate or measure of sales velocity.

The free **SUMMARY** record reports delivered observations, fetched pages, seller outcomes, title-filter exclusions, duplicates, limits, unprocessed sellers and errors. Review it even when a dataset contains results: some sellers may have failed while others succeeded. **ERROR** is present only after a fatal run error.

### Data table

| Field | Meaning |
| --- | --- |
| `observationId` | Stable identifier for downstream deduplication of repeat-run exports. |
| `feedbackId` | Public feedback identifier; no buyer identity is returned. |
| `itemId`, `title` | Listing associated with the feedback and its displayed title. |
| `sellerUsername`, `marketplace` | Selected seller and source marketplace. |
| `displayedPurchasePrice`, `currency` | Parsed displayed item amount and explicitly identified currency. |
| `priceText` | Source text supporting the amount. |
| `feedbackPeriod` | Coarse feedback-age label; it is not a sale date. |
| `verifiedPurchase` | Indicates that the source displayed its verified-purchase label. |
| `sourceUrl`, `itemUrl` | Feedback page and associated listing links. A listing may have ended. |
| `observedAt` | Time the Actor read the page, not when the purchase happened. |
| `soldPrice`, `soldDate`, `condition`, shipping fields, `isBestOfferAccepted` | Null because this source does not verify them. |

Buyer usernames and feedback comments are not included. Masked, ranged, unverified or unparseable price rows do not become paid observations.

### Pricing and cost estimation

The launch rate is **$2.48 per 1,000 delivered observations** (`$0.00248` each), plus Apify's standard **$0.00005 Actor start event**. Run compute is included. Listing-level analytics and the coverage summary have no additional observation charge.

At this rate, 100 delivered observations cost **$0.24805** including one start event; 1,000 cost **$2.48005**. The minimum configurable run budget is **$0.01**. That is a spending cap setting, not a minimum charge. The Actor respects both your result limit and the available event budget. A start event may still apply to a run that returns no observations or encounters a source error.

Duplicates within one run are removed. Repeat runs can return and charge for the same feedback again; there is no persistent “new observations only” mode. Use `observationId` to deduplicate your combined exports.

The launch pricing benchmark came from eBay sold-listing tools. Their coverage differs from this seller-feedback product, so compare source scope as well as price. Check the Actor's live Pricing tab for the currently configured rate.

### Tips for useful price samples

Use specific product-title words and exclusions to narrow the observations, then inspect the source listings. Title matches alone do not prove identical models, condition, bundles or variants. A shared listing ID provides a grouping boundary, not independent verification of those details.

Increase page limits only when you need more available feedback. No page setting can recover private, removed or inaccessible records. A small sample flag calls attention to limited observations; clearing that flag does not make the sample representative of all purchases.

Scheduled runs can help collect observations over time, but review duplicates and coverage before combining them. The Actor supplies no automated cross-listing matching, currency conversion, accepted-offer reconstruction or shipping estimation.

### FAQ and support

**Is this an eBay sold-listings search?**

The Actor reads selected sellers' public feedback. Its output is explicitly labelled `seller-feedback`, and the amount lives in `displayedPurchasePrice`. It does not claim an exact net paid amount or full market coverage.

**Why can the run return fewer rows than requested?**

Only accessible verified-purchase feedback with a usable price and matching title qualifies. Feedback availability, pagination, filters, source changes and the run budget can all reduce output. SUMMARY explains the observed scan outcome.

**Does it bypass login or access challenges?**

No. A sign-in requirement, access block or unsupported response is reported as a source error. The Actor uses public access and does not substitute active listings for missing feedback observations.

**Can I use it outside the United States?**

The supported source is the public `ebay.com` seller feedback interface. Explicitly displayed currencies are preserved; other marketplace interfaces are not exposed as input options.

This Actor is independently developed and is not affiliated with eBay. Review source terms and the requirements for your intended use. Report reproducible problems through the [Issues tab](https://apify.com/agency-shift/ebay-resale-research/issues), including your input and run URL. You can also use that channel to discuss a custom research workflow.

# Actor input Schema

## `sellerUsernames` (type: `array`):

Enter 1–10 public seller usernames, one per line. Use usernames only, not URLs or account credentials. Sellers are processed in this order; a run-wide result or spending limit can leave later sellers unprocessed.

## `query` (type: `string`):

Optional title filter, up to 150 characters. Every word must occur as a complete word in the normalized title; matching ignores case and punctuation. Leave empty to include all usable observations from the selected sellers. This does not search eBay for additional sellers or listings.

## `excludeKeywords` (type: `array`):

Optional list of up to 30 words or phrases, each at most 80 characters. A title containing any complete normalized phrase is excluded. Use terms such as case, charger or parts only when those items are unwanted in your research.

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

Run-wide maximum of 1–1,000 delivered observations, also limited by your spending cap. Separate verified feedback purchases for the same item can each produce a record. Available matching feedback can be much smaller than this limit.

## `maxPagesPerSeller` (type: `integer`):

Read up to 1–10 accessible public feedback pages for each selected seller. This is a ceiling, not a promised page or observation count. The scan stops when no further supported feedback is available or a result/spending limit is reached.

## `minSampleSize` (type: `integer`):

Mark a listing-level analytics group lowSample when fewer than this number of usable observations are present. Does not filter observations or suppress small groups. A larger sample is not a guarantee of price accuracy or representative market coverage.

## Actor input object example

```json
{
  "sellerUsernames": [
    "secondipity"
  ],
  "query": "",
  "excludeKeywords": [],
  "maxResults": 100,
  "maxPagesPerSeller": 3,
  "minSampleSize": 5
}
```

# Actor output Schema

## `observations` (type: `string`):

One verified-purchase feedback price observation per row. These amounts are displayed item prices, not guaranteed final paid totals. Deduplicate repeat-run exports using observationId.

## `analytics` (type: `string`):

ANALYTICS contains median, quartiles, mean, range, sample size and exclusions grouped by eBay listing ID and currency. Feedback summaries use displayed-feedback-item-price and have no exact sale dates or shipping totals.

## `summary` (type: `string`):

SUMMARY reports seller outcomes, pages fetched, delivered/filtered/duplicate counts, limits, unprocessed sellers, warnings and errors. Check this record before treating a run as complete.

## `error` (type: `string`):

ERROR is written after a fatal run error and contains a message and timestamp. A missing record on a successful run is expected.

# 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 = {
    "sellerUsernames": [
        "secondipity"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agency-shift/ebay-resale-research").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 = { "sellerUsernames": ["secondipity"] }

# Run the Actor and wait for it to finish
run = client.actor("agency-shift/ebay-resale-research").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 '{
  "sellerUsernames": [
    "secondipity"
  ]
}' |
apify call agency-shift/ebay-resale-research --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agency-shift/ebay-resale-research"
        }
    }
}
```

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/P5bmyI5E8XMqQobxe/builds/OfGMdMmU1AM0uLyGT/openapi.json