# MySlabs Scraper — Graded Cards & Sold Prices (`crawloop/myslabs-scraper`) Actor

Scrape MySlabs graded-card listings and the sold archive. Each row is one slab: title, grade, asking or sold price, date, and image. Keyword search for active listings, Buy It Now, auctions, or sold comps. No login.

- **URL**: https://apify.com/crawloop/myslabs-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 slab results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## MySlabs Scraper — Graded Cards & Sold Prices

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by MySlabs or its affiliates. Data is read from publicly accessible search and sold-archive pages only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

**MySlabs scraper** for graded sports cards and Pokémon slabs. Each dataset row is one public card: title, grader, grade, asking price or sold price, sale date on archive rows, and image. Use it as a **MySlabs API alternative** from **Python**, **Node.js**, **cURL**, or **Apify MCP**, and export the dataset as JSON.

### Collectibles suite

| Actor | Role |
| --- | --- |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | High-end auction live lots and sold comps |
| [Fanatics Collect Scraper](https://apify.com/crawloop/fanatics-collect-scraper) | Weekly and Premier auctions, Buy Now, sold comps |
| [Heritage Auctions Scraper](https://apify.com/crawloop/heritage-auctions-scraper) | Heritage live bids and archive cards |
| MySlabs Scraper — Graded Cards & Sold Prices ◄── you are here | Peer-to-peer slab listings and sold archive |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | Set-level PSA pop census and gem rate |
| [PriceCharting Scraper](https://apify.com/crawloop/pricecharting-scraper) | Guide prices for games, TCG, and comics |
| [Whatnot Listings Scraper](https://apify.com/crawloop/whatnot-listings-scraper) | Live-commerce listings and shops |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Marketplace completed sales |
| [eBay Active Listings Scraper](https://apify.com/crawloop/ebay-active-listings-scraper) | Live asking prices |

**Suite next step:** after a MySlabs sold row, run [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) for the same title, then [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) for the gem rate.

### When to use

- Pull **MySlabs asking prices** for a player, set, or PSA / BGS / CGC grade
- Read the **sold archive** for a keyword and keep the sale date on the card
- Limit a search to **Buy It Now**, **auctions**, or **slabbed cards**
- Export a short JSON list for a pricing sheet or an AI assistant

**When not to use:** eBay completed sales — use [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper). Elite auction hammers — use [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper). Offers, buyer identity, and checkout stay behind login and are not collected.

### Key features

- **Active listings and sold archive** — archive search is a different card set, with a sale date
- **Channels** — all, auctions, Buy It Now, private deals
- **Slabbed-card filter** — optional category limit
- **Grade from the title** — PSA, BGS, SGC, CGC, HGA, TAG, CSG
- **Cert number** when the public description prints one
- **Browser** — Camoufox, 2048 MB, US residential. Datacenter HTTP gets a Cloudflare challenge

### Input

| Field | Description |
| --- | --- |
| `mode` | `listings` or `archive` |
| `listingChannel` | `all`, `auction`, `bin`, or `private` (listings only) |
| `category` | `all` or `slabs` |
| `searchQueries` | Keywords. Empty keywords and no URLs save 0 rows |
| `startUrls` | Optional search URLs or slab pages |
| `sort` | Newest, oldest, price, views, tracked |
| `startPage` / `maxPages` | Page window per keyword |
| `maxItems` | Row cap (default 25) |
| `proxyConfiguration` | US residential. Required for search pages |

#### Example — active PSA 10 listings

```json
{
  "mode": "listings",
  "searchQueries": ["charizard psa 10"],
  "category": "slabs",
  "maxItems": 25,
  "maxPages": 1
}
```

#### Example — sold archive

```json
{
  "mode": "archive",
  "searchQueries": ["michael jordan psa 10"],
  "maxItems": 20,
  "maxPages": 1
}
```

### Output

| Field | Description |
| --- | --- |
| `slabId` | Numeric id |
| `title` | Card title |
| `price` | Asking price, or sold price on archive rows |
| `currency` | Usually USD |
| `listingStatus` | `active` or `sold` |
| `soldDate` | Archive date as printed on the card |
| `grader` / `grade` | Parsed from the title |
| `year` | Parsed from the title |
| `certNumber` | Present when the description includes a certification number |
| `saleType` | `offer`, `fixed_price`, or `auction` when the badge says so |
| `imageUrl` | Primary image |
| `url` | Public slab page |
| `query` | Keyword that produced the row |

```json
{
  "slabId": "1919227",
  "title": "1994 Upper Deck Michael Jordan PSA 10",
  "price": 26.46,
  "currency": "USD",
  "listingStatus": "active",
  "grader": "PSA",
  "grade": "10",
  "year": "1994",
  "saleType": "offer",
  "url": "https://www.myslabs.com/slab/view/1919227/"
}
```

### Use cases

- Compare a PSA 10 ask on MySlabs with a sold-archive row for the same title
- Build a short Buy It Now list for one player before a show
- Feed an assistant a JSON sample of graded Pokémon slabs

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/myslabs-scraper').call({
  mode: 'archive',
  searchQueries: ['charizard psa 10'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("crawloop/myslabs-scraper").call(run_input={
    "mode": "listings",
    "searchQueries": ["michael jordan psa 10"],
    "maxItems": 25,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item.get("price"), item.get("grade"))
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~myslabs-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"listings","searchQueries":["charizard psa 10"],"maxItems":10}'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp).
Connect your Apify account, then call this Actor by its Store name.

Example prompts:

- "Run MySlabs Scraper in archive mode for 'charizard psa 10' and return title, price, and sold date as JSON"
- "Scrape active MySlabs Buy It Now listings for 'michael jordan psa 10' and list the ten lowest asks"
- "After MySlabs sold rows, run eBay Sold Listings Scraper for the same titles"

### FAQ

**Is this a MySlabs API alternative?**
Yes for public search cards and the sold archive. No developer key and no login.

**Does sold mode use the same cards as active search?**
No. `mode: archive` reads the sold archive. Those rows include a sale date. Active search is a separate list.

**Does the scraper open every slab page?**
Search rows come from the search card. A slab URL in `startUrls` is fetched as its own page. Offers and buyer names stay behind login.

**Why is grade sometimes empty?**
Grade is parsed from the title. A raw card or a title without PSA / BGS / CGC / SGC stays ungraded.

**Do I need a proxy?**
Yes. Search pages return a Cloudflare challenge on datacenter IPs. The input uses US residential. Platform usage for that proxy is paid on the run.

### Related Actors

| Actor | Role |
| --- | --- |
| MySlabs Scraper — Graded Cards & Sold Prices ◄── you are here | Slab listings and sold archive |
| [eBay Sold Listings Scraper](https://apify.com/crawloop/ebay-sold-listings-scraper) | Marketplace completed sales |
| [Goldin Auctions Scraper](https://apify.com/crawloop/goldin-scraper) | Elite auction comps |
| [PSA Population Report Scraper](https://apify.com/crawloop/psa-pop-report-scraper) | PSA pop and gem rate |

# Actor input Schema

## `mode` (type: `string`):

listings reads active search results. archive reads the sold archive (a different set of cards, with a sale date).

## `listingChannel` (type: `string`):

Active listings only. all, live auctions, Buy It Now, or private deals.

## `category` (type: `string`):

all keeps every category. slabs limits the search to slabbed cards.

## `searchQueries` (type: `array`):

Player, set, or grade, such as charizard psa 10. A run with no keywords and no slab URLs saves 0 rows.

## `startUrls` (type: `array`):

Optional public search URLs or /slab/view/ links. Slab pages are one row each.

## `sort` (type: `string`):

Sort order on search pages.

## `startPage` (type: `integer`):

First search page. Use this to resume a deep pull.

## `maxPages` (type: `integer`):

Pages to read per keyword, starting at Start page.

## `maxItems` (type: `integer`):

Maximum dataset rows for the run.

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

US residential. Datacenter IPs receive a Cloudflare challenge.

## Actor input object example

```json
{
  "mode": "listings",
  "listingChannel": "all",
  "category": "all",
  "searchQueries": [],
  "startUrls": [],
  "sort": "created_desc",
  "startPage": 1,
  "maxPages": 2,
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Default dataset items.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/myslabs-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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    } }

# Run the Actor and wait for it to finish
run = client.actor("crawloop/myslabs-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call crawloop/myslabs-scraper --silent --output-dataset

```

## MCP server setup

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