# Marketplace Sold Comps Analyzer (`theendfear/factory-marketplace-sold-comps-analyzer-3100819b`) Actor

Analyze user-provided completed marketplace sale records into sold-comps pricing guidance without scraping.

- **URL**: https://apify.com/theendfear/factory-marketplace-sold-comps-analyzer-3100819b.md
- **Developed by:** [Marco S.](https://apify.com/theendfear) (community)
- **Categories:** E-commerce, Business
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 analysis record emitteds

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?

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

## Marketplace Sold Comps Analyzer

Analyze user-provided completed marketplace sale records into sold-comps pricing guidance. The Actor does not autonomously discover listings, scrape marketplaces, use proxies, require logins, or call paid external APIs.

### What It Does

This Actor groups completed sale records by item and turns them into comparable-sales metrics: comp count, recent sales count, sold-price percentiles, spread, outliers, marketplace and condition distribution, confidence score, sample quality, and a recommended listing price range.

### Who It Is For

Resellers, marketplace operators, pricing analysts, liquidation teams, and ecommerce teams that already have completed sale exports and need a repeatable way to convert raw sold records into listing-price decisions.

### Input

Provide `records` with completed sales. Each valid record needs an item or title, a sold price, and a sale date. Recommended fields are `item`, `soldPrice`, `soldAt`, `marketplace`, `condition`, `saleType`, `currency`, and `url`. `groupKey`, `priceField`, `dateField`, and `dedupeKey` let you map your own export columns.

### Output

Each dataset row is one item group with completed-sale metrics: `compCount`, `recentSalesCount`, `medianSoldPrice`, `p25SoldPrice`, `p75SoldPrice`, `recommendedListPriceLow`, `recommendedListPriceHigh`, `confidenceScore`, `sampleQuality`, marketplace and condition distributions, recommended action, score explanation, and source record indexes.

### How It Works

The Actor validates that each record describes a completed sale by requiring an item key, numeric sold price, and parseable sold date. It normalizes item names, prices, dates, currency, marketplace, condition, and sale type, then deduplicates by marketplace, item, currency, sold price, sold date, and source key.

For each item group it calculates min, 25th percentile, median, 75th percentile, mean, max, spread percentage, and IQR-based outlier count. `recentSalesCount` counts sales within 90 days of the latest sale date in that item group. `soldVelocityProxy` is recent sales per 30 days inside the observed window; it is only a proxy from the supplied records, not a marketplace-wide demand estimate.

`confidenceScore` ranges from 0 to 100. More comps add coverage confidence, more recent sales add recency confidence, a tight spread improves confidence, very wide spread lowers it, and outliers lower it. `sampleQuality` is `strong` at 75+, `usable` at 55+, and `thin` below 55. Recommended action follows sample quality: list within the recommended range, review conditions before listing, or collect more sold comps.

### Example

```json
{
  "records": [
    {
      "item": "Vintage Camera X",
      "soldPrice": "$100.00",
      "soldAt": "2026-05-01",
      "marketplace": "eBay",
      "condition": "used",
      "saleType": "auction",
      "url": "https://m.example/1"
    },
    {
      "item": "Vintage Camera X",
      "soldPrice": 140,
      "soldAt": "2026-07-01",
      "marketplace": "Mercari",
      "condition": "excellent",
      "saleType": "buy_it_now",
      "url": "https://m.example/2"
    }
  ],
  "groupKey": "item",
  "priceField": "soldPrice",
  "dateField": "soldAt",
  "dedupeKey": "url"
}
```

Example output row:

```json
{
  "itemKey": "vintage camera x",
  "compCount": 2,
  "recentSalesCount": 2,
  "medianSoldPrice": 120,
  "recommendedListPriceLow": 110,
  "recommendedListPriceHigh": 130,
  "confidenceScore": 53,
  "sampleQuality": "thin",
  "recommendedAction": "collect_more_sold_comps"
}
```

### Pricing

PAY\_PER\_EVENT event `analysis_record_emitted` is charged once per emitted sold-comps analysis row. Invalid records, duplicates, skipped rows, and charge-limited rows are not billable.

### Limitations

This Actor only analyzes completed sale records supplied by the user. It does not scrape eBay, Amazon, Facebook Marketplace, or other marketplaces; it does not verify whether a sale is real; it does not perform FX conversion; it does not forecast future demand; and it does not use live marketplace data unless you provide it as input.

### Integration

Run it directly with JSON input, from an Apify task, or downstream from another Actor/export that produces completed sale records in a default dataset. Results are written to the default dataset and the run summary is written to the `OUTPUT` key-value store record.

### Differentiation

Use Marketplace Sold Comps Analyzer when you have completed sale records with dates and need sold-comps pricing guidance. Use Ecommerce Price List Analyzer when you have active offer or catalog records and need current price-list spread and outlier analysis.

# Actor input Schema

## `records` (type: `array`):

Array of user-provided completed marketplace sale records. Each valid record should include item/title, sold price, sale date, marketplace, and optional condition.

## `groupKey` (type: `string`):

Field used to group comparable sold items. Fallbacks include item, title, product, and name.

## `priceField` (type: `string`):

Field containing the completed sale price. Fallbacks include soldPrice, salePrice, price, amount, and finalPrice.

## `dateField` (type: `string`):

Field containing the sale date. Fallbacks include soldAt, soldDate, saleDate, date, and completedAt.

## `dedupeKey` (type: `string`):

Optional field used with item, marketplace, price, and sold date to remove duplicate completed sales.

## `maxRecords` (type: `integer`):

Maximum number of input records to process in one run.

## Actor input object example

```json
{
  "groupKey": "item",
  "priceField": "soldPrice",
  "dateField": "soldAt",
  "dedupeKey": "url",
  "maxRecords": 5000
}
```

# Actor output Schema

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

Grouped sold-comps analysis rows in the 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("theendfear/factory-marketplace-sold-comps-analyzer-3100819b").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("theendfear/factory-marketplace-sold-comps-analyzer-3100819b").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 '{}' |
apify call theendfear/factory-marketplace-sold-comps-analyzer-3100819b --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,theendfear/factory-marketplace-sold-comps-analyzer-3100819b"
        }
    }
}

```

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/0gDiThtH8x2L4ZRLF/builds/fQilHnUqUXEnzw4ku/openapi.json