# 130point Sold Comps Scraper (`phantom_coder/130point-sold-comps-scraper`) Actor

Get sports and Pokémon card sold comps from 130point in one search: eBay plus Fanatics, Goldin, Heritage, Pristine, MySlabs, and CardHobby. Includes Best Offer accepted prices, sale type, sold date, and clean item links. No 130point account or API key required.

- **URL**: https://apify.com/phantom_coder/130point-sold-comps-scraper.md
- **Developed by:** [Phantom Coder](https://apify.com/phantom_coder) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 sold comps

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 130point Sold Comps Scraper

Search 130point.com's sold trading-card comps and get back clean, structured data: eBay sold prices plus Fanatics, Goldin, Heritage, Pristine, MySlabs, and CardHobby, all from one search. No 130point account or API key required.

### Who this is for

Card sellers, price researchers, and collectibles tools that need recent sold comps to price a card: "what did this exact card (grade and all) actually sell for recently, across every major marketplace?"

### Why this Actor is different

- **Best Offer accepted prices are included.** Most eBay sold-price tools only show the final list price. This Actor returns both the accepted offer price and the original asking price, so you see the real negotiated number.
- **Seven marketplaces in one search.** eBay, Fanatics (including legacy PWCC lots), Goldin, Heritage, Pristine, MySlabs, and CardHobby are searched together, so you don't have to run seven separate tools and merge the results yourself.
- **Fresh data.** Sold comps typically show up within the hour of the sale.

### What you get

For each query, a flat list of sold comps with the sold price, currency, sale type (auction, fixed price, or best offer accepted), bid count where available, sold date, a clean item URL, and an image. See [Output](#output) below for the full field list.

### How to use

1. Add one or more search queries (for example `"charizard psa 10"` or `"mike trout 2011 topps update"`). Each query needs at least 4 characters.
2. Optionally narrow the search: pick specific marketplaces, a sold-date range, a price range, a sale type, or a country.
3. Set **Max results per query** if you want more or fewer than the default 200.
4. Run the Actor. Results stream into the dataset as they're found.
5. Export the dataset as JSON, CSV, Excel, or connect it to your own pipeline via the API.

### Input

| Field | Type | Description |
|---|---|---|
| `queries` | array of strings | Required. Search terms, one per sold-comps search. |
| `marketplaces` | array | Which marketplaces to search. Leave empty for all 7. |
| `sortBy` | string | `recent` (default), `priceHighest`, or `priceLowest`. |
| `maxResultsPerQuery` | integer | Max comps per query. Default 200, max 1,500. |
| `soldDateFrom` / `soldDateTo` | string (`YYYY-MM-DD`) | Restrict to a sold-date range. |
| `minPrice` / `maxPrice` | number | Restrict to a sold-price range, in USD. Non-USD listings aren't excluded by this filter (see [Limitations](#limitations)). |
| `saleType` | string | `auction`, `fixedPrice`, or `bestOfferAccepted`. |
| `country` | string | Restrict eBay results to one country's eBay site (best-effort; see [Limitations](#limitations)). |
| `proxyConfiguration` | object | A US residential proxy is required for reliable access. Defaults to Apify Proxy, residential, US. |
| `searchesPerSession` | integer | How many searches to run per browser session before rotating. Default 25, max 28. |

Example input:

```json
{
    "queries": ["charizard psa 10", "mike trout 2011 topps update"],
    "marketplaces": ["ebay", "fanatics"],
    "sortBy": "recent",
    "maxResultsPerQuery": 200,
    "minPrice": 50
}
```

### Output

Each dataset item is one sold comp:

```json
{
    "query": "charizard psa 10",
    "marketplace": "ebay",
    "itemId": "178529961617",
    "title": "Pokemon Charizard V 079/073 Champion's Path Secret Rare Holo PSA 10 English",
    "soldPrice": 700,
    "currency": "AUD",
    "soldPriceText": "$700.00",
    "originalPrice": 738.7,
    "originalPriceCurrency": "AUD",
    "saleType": "bestOfferAccepted",
    "bestOfferAccepted": true,
    "bids": null,
    "soldAt": "2026-10-25T11:20:46.000Z",
    "url": "https://www.ebay.com.au/itm/178529961617",
    "imageUrl": "https://i.ebayimg.com/images/g/J8gAAeSwy1Fqt7BH/s-l500.jpg",
    "sourceId": "EBAY-v1|178529961617|0",
    "scrapedAt": "2026-10-25T18:00:00.000Z"
}
```

A query with no matching sales returns no items for that query - the run still completes normally:

```json
[]
```

### Understanding the data

- `soldPrice` and `currency` reflect the listing's own currency. eBay results include its international sites, so a `"charizard psa 10"` search can mix USD, GBP, AUD, CAD, and EUR results - see [Limitations](#limitations).
- `originalPrice` is only populated for `bestOfferAccepted` sales; it's the original asking price before the offer was accepted.
- `bids` is populated for auctions where a bid count is available (mainly eBay and Goldin) and is `null` otherwise.
- `itemId` is the marketplace's own item or lot id; `sourceId` is 130point's raw internal id, kept for traceability.
- `url` is a cleaned link to the original listing with eBay Partner Network and other affiliate tracking parameters removed.

### Use cases

- **Pricing a card to sell.** Run `"2011 topps update mike trout psa 10"` to see the last 200 sold prices across marketplaces before setting your own list price.
- **Tracking a set's market.** Run one query per card in a set on a schedule and chart sold prices over time.
- **Building a pricing database.** Run a large batch of card names with `maxResultsPerQuery` set high, and `minPrice` set to filter out low-value noise.

### FAQ

**Do I need a 130point account?** No. This Actor runs anonymously.

**Why do some results show a different currency?** 130point surfaces eBay's international sites directly. A USD query can return GBP, AUD, CAD, or EUR sales from eBay UK, Australia, Canada, and Europe.

**Can I get more than 1,500 results for one query?** Not in a single run. Split a high-volume search into narrower queries (by year, grade, or set) instead.

### Limitations

- **200 results per call, no pagination.** 130point's search returns at most 200 results per call (100 when searching a single marketplace), with no further pages. For `maxResultsPerQuery` above 200, the Actor automatically splits the search by marketplace and sort order to collect more, but very high values on a narrow query may still return fewer than requested if the underlying inventory runs out.
- **Only one filter set is reliably applied per query.** 130point's search backend only honors date/price/sale-type/country filters on the first filtered search in a browser session; the Actor always re-applies every filter to each result on its own side as a safety net, so filtered output is always correct even when the underlying API call wasn't.
- **Freshness.** New sales typically appear within about an hour.
- **International eBay prices are in local currency**, not converted to USD. Check the `currency` field. `minPrice`/`maxPrice` are USD amounts and are only applied (on the Actor's side) to USD-denominated comps; non-USD comps rely on the site's own filtering instead of a currency conversion that could be wrong.
- **Duplicates across searches within a query are resolved, but not perfectly.** The same sale can appear in more than one of the searches run for a single query (for example when results are split by marketplace or sort to collect more than 200). The Actor keeps the first copy it collects, even if a later copy turns out to be the preferred eBay US listing.

### Pricing

This Actor uses the Pay-Per-Event model. You only pay for the events below - platform usage (compute and proxy) is covered by the event price, not billed separately.

| Event | Price | When it's charged |
|---|---|---|
| Actor start | $0.00005 per GB of run memory (so about $0.0002 per run at the default 4 GB) | Once per run. |
| Sold comp | $3.00 / 1,000 (Free), $2.70 / 1,000 (Starter), $2.40 / 1,000 (Scale), $2.00 / 1,000 (Business and Enterprise) | Once per sold comp saved to the dataset. Duplicates, filtered-out items, and blocked or empty searches are never charged. |

#### Typical costs

- Pricing a single card (200 sold comps): about $0.60 on the Free plan, about $0.40 on the Business plan.
- Monitoring 20 cards weekly at 200 comps each: about $52/month on the Free plan, about $35/month on the Business plan.

### Output field reference

| Field | Type | Description |
|---|---|---|
| `query` | string | The search query that returned this comp. |
| `marketplace` | string | `ebay`, `fanatics`, `goldin`, `heritage`, `pristine`, `myslabs`, or `cardhobby`. |
| `itemId` | string | The marketplace's own item or lot id. |
| `title` | string | Listing title. |
| `soldPrice` | number | Sold price, in `currency`. |
| `currency` | string | ISO currency code. |
| `soldPriceText` | string | The sold price as originally formatted (e.g. `"$700.00"`). |
| `originalPrice` | number | null | Original asking price, for best-offer sales only. |
| `originalPriceCurrency` | string | null | Currency of `originalPrice`. |
| `saleType` | string | `auction`, `fixedPrice`, or `bestOfferAccepted`. |
| `bestOfferAccepted` | boolean | True if this was a best-offer sale. |
| `bids` | number | null | Bid count, where available. |
| `soldAt` | string | ISO 8601 timestamp of the sale. |
| `url` | string | Clean link to the original listing. |
| `imageUrl` | string | null | Listing image URL. |
| `sourceId` | string | 130point's raw internal id for this comp. |
| `scrapedAt` | string | ISO 8601 timestamp of when this Actor collected the comp. |

### Related Actors

Pair sold comps with live listings and other marketplaces:

- [Cardmarket Listings Scraper](https://apify.com/phantom_coder/cardmarket-listings-scraper) - every seller listing on a Cardmarket card page, with condition, language, quantity, and price in EUR or USD.
- [TCGplayer Listings Scraper](https://apify.com/phantom_coder/tcgplayer-listings-scraper) - every seller listing for a TCGplayer card, with price, shipping, condition, and seller, compared with market price.
- [Whatnot Scraper](https://apify.com/phantom_coder/whatnot-scraper) - Whatnot listings, live shows, and sellers, with viewer and show stats over time.
- [Catawiki Sold Prices Scraper](https://apify.com/phantom_coder/catawiki-sold-prices-scraper) - Catawiki sold prices and past auction results, with history back to 2020.

### Support

Found a bug or have a feature request? Open an issue on this Actor's Apify Store page, or contact the developer directly through Apify.

# Actor input Schema

## `queries` (type: `array`):

Card search terms, one per sold-comps search (for example "charizard psa 10"). Each must be at least 4 characters - shorter ones are skipped with a warning.

## `marketplaces` (type: `array`):

Which marketplaces to search. Leave empty to search all of them: eBay, Fanatics, Goldin, Heritage, Pristine, MySlabs, and CardHobby.

## `sortBy` (type: `string`):

How to order each query's results (and which results are returned first when a query has more matches than fit in a single search call).

## `maxResultsPerQuery` (type: `integer`):

The maximum number of sold comps to return for each query.

## `soldDateFrom` (type: `string`):

Only include comps sold on or after this date (YYYY-MM-DD).

## `soldDateTo` (type: `string`):

Only include comps sold on or before this date (YYYY-MM-DD).

## `minPrice` (type: `number`):

Only include comps that sold for at least this amount, in USD. Non-USD listings (eBay's international sites) aren't excluded by this filter - see the README.

## `maxPrice` (type: `number`):

Only include comps that sold for at most this amount, in USD. Non-USD listings (eBay's international sites) aren't excluded by this filter - see the README.

## `saleType` (type: `string`):

Only include comps of this sale type. Leave unset to include auctions, fixed-price (Buy It Now) sales, and offers accepted.

## `country` (type: `string`):

Only include eBay comps sold on this country's eBay site. Best-effort: comps from marketplaces other than eBay are never excluded by this filter, since their country can't be determined.

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

A US residential proxy is required for reliable access.

## `searchesPerSession` (type: `integer`):

How many searches to run before rotating to a fresh browser session and IP. Lower this if you see more sessions failing than usual.

## `debugMode` (type: `boolean`):

Saves extra diagnostics for troubleshooting. Leave off.

## Actor input object example

```json
{
  "queries": [
    "charizard psa 10",
    "mike trout 2011 topps update"
  ],
  "marketplaces": [],
  "sortBy": "recent",
  "maxResultsPerQuery": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "searchesPerSession": 25,
  "debugMode": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "queries": [
        "charizard psa 10",
        "mike trout 2011 topps update"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("phantom_coder/130point-sold-comps-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 = { "queries": [
        "charizard psa 10",
        "mike trout 2011 topps update",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("phantom_coder/130point-sold-comps-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 '{
  "queries": [
    "charizard psa 10",
    "mike trout 2011 topps update"
  ]
}' |
apify call phantom_coder/130point-sold-comps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,phantom_coder/130point-sold-comps-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/TKTRklfmWqyYQVa9n/builds/8E9iUD56ZcxOh0cS7/openapi.json