# MySlabs Graded Card Scraper: Sold Comps & Listings (`getascraper/myslabs-graded-cards-scraper`) Actor

Scrapes MySlabs.com graded card listings and sold comps: PSA, BGS, CGC, SGC, HGA, and TAG slabs across sports cards, Pokemon, and TCG. Structured JSON with price, availability, condition, images, and parsed grade. Built-in diffMode tracks new listings for scheduled price monitoring.

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

## Pricing

from $1.16 / 1,000 card listings

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?

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

## MySlabs Graded Card Scraper: Sold Comps & Listings

**Pull structured PSA, BGS, CGC, SGC, HGA, and TAG slab data from MySlabs.com in minutes, not manual eBay searches.** This Actor scrapes graded trading card listings, active auctions, Buy-It-Now items, and private deals from [MySlabs](https://myslabs.com), the peer-to-peer graded-slab marketplace for sports cards, Pokemon, and TCG. Card arbitrage traders use it to spot underpriced slabs against sold comps, and builders wire it into price-monitoring tools and spreadsheets via the Apify API, scheduling, and integrations (Google Sheets, Make, Zapier). Every field ships as clean JSON, no manual copy-pasting from listing pages.

### Why use this MySlabs scraper?

- **Built for reliability, not just coverage.** The main alternative on the Apify Store failed or timed out on roughly 1 in 5 runs over its last 30 days. This Actor ships with generous retry defaults and timeout tuning specifically to avoid that failure pattern.
- **All six grading companies in one run.** PSA, BGS, CGC, SGC, HGA, and TAG grades are parsed out of each listing title into a clean, filterable field, no regex work on your end.
- **Built for recurring monitoring, not one-off pulls.** A `diffMode` input tracks previously seen listing IDs so a scheduled run only returns what's new since the last one, instead of re-scraping the whole marketplace every time.
- **No login wall, no CAPTCHA workaround needed.** MySlabs ships full product data in the page's own structured data, so this Actor stays fast and cheap to run.

### How to use the MySlabs scraper

1. Click **Try for free** and open the Input tab.
2. Pick a **Search mode**: `all`, `auction`, `bin` (Buy-It-Now), or `private-deals` for a live listing grid, or `sitemap` to crawl the full inventory of `/slab/view/` pages. Use `urls` to scrape specific listing links.
3. Set **Max listing pages** and **Max items** to bound the run.
4. For scheduled price monitoring, turn on **diffMode** and set a **State key**. Each scheduled run then returns only listings not seen in a prior run.
5. Click **Start** and download results from the Dataset tab as JSON, CSV, Excel, or via the API.

### Input

| Field | What it does |
|---|---|
| `searchMode` | Which MySlabs surface to crawl: all listings, auctions, Buy-It-Now, private deals, full-inventory sitemap, or specific URLs |
| `startUrls` | Specific `/slab/view/<id>/` URLs, used only with `searchMode: "urls"` |
| `maxPages` | Cap on paginated listing-grid pages fetched per run |
| `maxItems` | Cap on card records returned per run |
| `diffMode` | Skip listing IDs already captured under the same `stateKey`, for incremental scheduled runs |
| `stateKey` | Namespace for the diff-mode baseline, so you can run multiple watch configurations from one Actor |
| `resetBaseline` | Clear the stored seen-ID baseline before this run |
| `maxRequestRetries` / `requestTimeoutSecs` | Retry and timeout tuning |
| `proxyConfiguration` | Apify Proxy settings (datacenter is the default and is sufficient for MySlabs) |

See the Input tab for the full schema with defaults.

### Output

Each dataset item is one card listing:

```json
{
  "listingId": "1784776",
  "listingUrl": "https://myslabs.com/slab/view/1784776/",
  "listingType": "bin",
  "title": "1997 Finest Embossed #297 Michael Jordan PSA 10",
  "grader": "PSA",
  "grade": "10",
  "gradeLabel": "PSA 10",
  "price": 10.09,
  "currency": "USD",
  "availability": "InStock",
  "itemCondition": "New",
  "images": ["https://cdn.myslabs.com/..."],
  "shippingCountry": "US",
  "scrapedAt": "2026-08-24T00:00:00.000Z"
}
```

Download results as JSON, CSV, Excel, HTML, or XML from the Dataset tab, or pull them via the Apify API into Sheets, Make, Zapier, or your own pipeline.

#### Data fields

| Field | Description |
|---|---|
| `title`, `description` | Listing title and description text |
| `grader`, `grade`, `gradeLabel` | Grading company, numeric grade, and combined label (e.g. "PSA 10"), parsed from the title |
| `price`, `currency` | Listing price and currency |
| `availability` | `InStock` (active) or `OutOfStock` (sold or removed) |
| `itemCondition` | Item condition as listed |
| `images` | CDN image URLs |
| `shippingCountry`, `shippingHandlingDaysMin/Max`, `shippingTransitDaysMin/Max` | Shipping details |
| `sellerUsername` | Not returned. MySlabs hides the seller's username behind a login wall on anonymous requests, so this field is always `null` rather than a guessed or fabricated value |
| `certNumber` | Not returned. MySlabs does not expose a populated cert number in the public listing HTML, so this field is always `null` |
| `listingType` | Which search surface the listing came from: all, auction, bin, or private-deals |

### Pricing

This Actor runs on Apify's Pay-Per-Event pricing. Check the Pricing tab on this Store page for current per-result rates, and use `maxItems` to keep run cost predictable. Apify gives every new account free platform credits to try the Actor before you commit to a paid plan.

### Tips

- Use `sitemap` search mode for a one-time full-inventory pull, and one of `all`/`auction`/`bin`/`private-deals` with `diffMode` on for ongoing monitoring.
- Keep `stateKey` unique per watch configuration if you run several schedules (for example, one per grading company or listing type) so their diff baselines don't collide.
- `maxRequestRetries` defaults high specifically to ride out transient errors instead of dropping listings.

### FAQ

**Does this need a MySlabs account or API key?** No. All scraped fields come from publicly accessible listing pages.

**Can I track only new listings since my last run?** Yes, turn on `diffMode`. MySlabs does not expose a machine-readable listing date, so incremental tracking works by remembering previously seen listing IDs rather than filtering by date.

**Which grading companies are supported?** PSA, BGS, CGC, SGC, HGA, and TAG, parsed directly from each listing's title.

**Is this legal?** This Actor only collects publicly visible marketplace data and does not access account-only pages. You're responsible for how you use the scraped data under MySlabs' terms and applicable law.

**Something look off?** Open an issue on the Actor's Issues tab, or reach out for a custom scraping solution.

# Actor input Schema

## `searchMode` (type: `string`):

Which MySlabs listing surface to crawl. "all"/"auction"/"bin"/"private-deals" crawl the matching search grid directly (fastest: full Product/Offer data is already embedded there). "sitemap" walks /sitemap-slabs-\*.xml for full-inventory discovery, visiting every /slab/view/<id>/ page. "urls" scrapes only the URLs you provide below.

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

MySlabs listing URLs to scrape directly (e.g. https://myslabs.com/slab/view/1784776/). Only used when Search mode is "Specific URLs".

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

Upper bound on how many paginated listing-grid pages (~75 listings/page) are fetched before stopping. Only applies to all/auction/bin/private-deals search modes.

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

Maximum number of card records to output in this run.

## `diffMode` (type: `boolean`):

Track previously seen listing IDs (namespaced by State key) and skip anything already captured. Listing-grid pages are newest-first, so the crawl stops early once it reaches a previously-seen ID, pair with a schedule to build an incremental new-listings feed instead of re-scraping the whole surface every run.

## `since` (type: `string`):

Optional ISO date to record in the run summary for your own bookkeeping (e.g. "2026-08-01"). MySlabs' JSON-LD does not expose a listing-date field, so this does NOT filter results server-side: use "diffMode" above for actual incremental behavior.

## `stateKey` (type: `string`):

Namespace for the diff-mode seen-ID baseline, useful when running multiple watch configurations (e.g. per search mode) from the same Actor.

## `resetBaseline` (type: `boolean`):

Clear the stored seen-ID baseline for this State key before this run, so the next run's diffMode comparison starts fresh.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for a failed page fetch before giving up on that request. Kept generous by default to avoid the timeout/abort failures seen on the competing MySlabs actor.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout before a fetch is considered failed and retried.

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

MySlabs is Tier 0 (confirmed 2026-08-24): plain requests get clean 200s, Cloudflare is present but passive with no JS challenge observed. Datacenter proxy is the default and should be sufficient; switch to RESIDENTIAL only if you see rate-based blocking at high volume.

## Actor input object example

```json
{
  "searchMode": "all",
  "startUrls": [],
  "maxPages": 20,
  "maxItems": 100,
  "diffMode": false,
  "stateKey": "myslabs-default",
  "resetBaseline": false,
  "maxRequestRetries": 5,
  "requestTimeoutSecs": 45,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `runSummary` (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 = {
    "startUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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