# Graded Card Census Scraper - PSA Population Data (`lulzasaur/graded-card-census-scraper`) Actor

Get graded trading card population data for entire sets or single cards. Bulk set lookup by URL or name search. Full grade breakdown (Auth through Gem Mint 10) with half grades and qualifiers. Supports Pokemon, baseball, basketball, football, hockey, and soccer cards.

- **URL**: https://apify.com/lulzasaur/graded-card-census-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** Other
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Graded Card Census Scraper

Look up graded trading card population data — **single cards or entire sets**. Get the full grade breakdown (Auth through Gem Mint 10) for every card in a set with a single request.

> **Disclaimer**: This tool is not affiliated with, endorsed by, or sponsored by PSA or Collectors Universe. "PSA" is a registered trademark of Collectors Universe, Inc. and is used here solely for identification purposes.

### Features

- **Bulk set lookup**: Get population data for ALL cards in a set at once (e.g., all 397 cards in Surging Sparks)
- **Set search**: Find sets by name — just enter "Surging Sparks" and get full population data
- **Cert lookup**: Enter a certification number to get card details and population report
- **Spec ID lookup**: Direct population lookup by spec ID
- **Full grade breakdown**: Auth, grades 1-10, half grades (1.5, 2.5, etc.), and qualifier counts

### Input

| Field | Type | Description |
|-------|------|-------------|
| `setUrl` | string | Set population page URL for bulk lookup |
| `setName` | string | Search for a set by name (e.g., "Surging Sparks", "2023 Topps Chrome") |
| `certNumber` | string | Certification number for single card lookup |
| `specID` | integer | Spec ID for direct population lookup |
| `apiToken` | string | Optional API token (only needed for cert/specID lookups) |

Provide **one of**: `setUrl`, `setName`, `certNumber`, or `specID`.

### Examples

#### Bulk Set Lookup (recommended)

Get all cards in a set by URL:
```json
{
  "setUrl": "https://www.psacard.com/pop/tcg-cards/2024/pokemon-ssp-en-surging-sparks/285178"
}
````

Search by set name:

```json
{
  "setName": "Surging Sparks"
}
```

#### Single Card Lookup

```json
{
  "certNumber": "12345678"
}
```

### Output

#### Bulk Set Results

Each card in the set is returned as a separate item:

```json
{
  "specID": 12168745,
  "cardNumber": "240",
  "subject": "Hydreigon EX",
  "variety": "Special Illustration Rare",
  "setName": "2024 Pokemon Ssp EN-Surging Sparks",
  "year": "2024",
  "psaPop": {
    "total": 8849,
    "auth": 1,
    "grade1": 0,
    "grade2": 0,
    "grade3": 1,
    "grade4": 5,
    "grade5": 23,
    "grade6": 29,
    "grade7": 61,
    "grade8": 785,
    "grade8_5": 20,
    "grade9": 4610,
    "grade10": 3334
  },
  "halfGradeTotal": 20,
  "qualifiedGradeTotal": 0
}
```

#### Single Card Results

Includes additional cert-specific fields: grade, brand, category, label type, and population-higher counts.

### Use Cases

- **Card investors**: Analyze the full population of a set to find scarce cards
- **eBay sellers**: Add census data to listings in bulk
- **Price guide sites**: Build population databases for entire card sets
- **Collection tracking**: Compare your collection against full set population data
- **Market research**: Track grading volume trends across sets

### Related Scrapers

More marketplace scrapers and data tools by [lulzasaur](https://apify.com/lulzasaur):

- [TCGPlayer Scraper](https://apify.com/lulzasaur/tcgplayer-scraper) — Trading card prices
- [Reverb Scraper](https://apify.com/lulzasaur/reverb-scraper) — Music gear marketplace
- [OfferUp Scraper](https://apify.com/lulzasaur/offerup-scraper) — Local marketplace listings
- [Craigslist Scraper](https://apify.com/lulzasaur/craigslist-scraper) — Classifieds and for-sale posts
- [Goodreads Scraper](https://apify.com/lulzasaur/goodreads-scraper) — Book ratings and reviews
- [Grailed Scraper](https://apify.com/lulzasaur/grailed-scraper) — Luxury fashion resale
- [StubHub Scraper](https://apify.com/lulzasaur/stubhub-scraper) — Event ticket prices
- [Redfin Scraper](https://apify.com/lulzasaur/redfin-scraper) — Real estate listings and prices

# Actor input Schema

## `setName` (type: `string`):

Search for a set by name and get ALL cards with grade breakdowns. Examples: 'Surging Sparks', '2023 Topps Chrome', 'Prizm Basketball'.

## `setUrl` (type: `string`):

Direct PSA Pop set page URL. Use this if set name search doesn't find your set. Example: https://www.psacard.com/pop/tcg-cards/2024/pokemon-ssp-en-surging-sparks/285178

## `certNumbers` (type: `array`):

Array of PSA cert numbers for batch lookup. Uses caching so repeat lookups are free. Example: \["10000001", "10000002"]

## `certNumber` (type: `string`):

Single PSA cert number (e.g. '10000001'). For multiple certs, use 'Cert Numbers (Batch)' above.

## `specID` (type: `integer`):

Spec ID for direct population lookup (advanced). You can get this from a cert lookup result.

## `apiToken` (type: `string`):

Your own PSA API bearer token for higher rate limits. Without this, cert lookups share a 100 calls/day free quota. Not needed for set lookups.

## `cacheDurationHours` (type: `integer`):

How long to cache results (default: 168 hours / 7 days). Cached results don't count against API quota. PSA grades are permanent so caching is safe. Set to 0 to disable.

## Actor input object example

```json
{
  "setName": "Surging Sparks",
  "cacheDurationHours": 168
}
```

# Actor output Schema

## `results` (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 = {
    "setName": "Surging Sparks"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/graded-card-census-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 = { "setName": "Surging Sparks" }

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/graded-card-census-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "setName": "Surging Sparks"
}' |
apify call lulzasaur/graded-card-census-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lulzasaur/graded-card-census-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Graded Card Census Scraper - PSA Population Data",
        "description": "Get graded trading card population data for entire sets or single cards. Bulk set lookup by URL or name search. Full grade breakdown (Auth through Gem Mint 10) with half grades and qualifiers. Supports Pokemon, baseball, basketball, football, hockey, and soccer cards.",
        "version": "1.5",
        "x-build-id": "Z4CPu5xGTBXyC9A5I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lulzasaur~graded-card-census-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lulzasaur-graded-card-census-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lulzasaur~graded-card-census-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lulzasaur-graded-card-census-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lulzasaur~graded-card-census-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lulzasaur-graded-card-census-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "setName": {
                        "title": "Set Name (Search)",
                        "type": "string",
                        "description": "Search for a set by name and get ALL cards with grade breakdowns. Examples: 'Surging Sparks', '2023 Topps Chrome', 'Prizm Basketball'."
                    },
                    "setUrl": {
                        "title": "Set URL (Direct)",
                        "type": "string",
                        "description": "Direct PSA Pop set page URL. Use this if set name search doesn't find your set. Example: https://www.psacard.com/pop/tcg-cards/2024/pokemon-ssp-en-surging-sparks/285178"
                    },
                    "certNumbers": {
                        "title": "Cert Numbers (Batch)",
                        "type": "array",
                        "description": "Array of PSA cert numbers for batch lookup. Uses caching so repeat lookups are free. Example: [\"10000001\", \"10000002\"]"
                    },
                    "certNumber": {
                        "title": "Cert Number (Single)",
                        "type": "string",
                        "description": "Single PSA cert number (e.g. '10000001'). For multiple certs, use 'Cert Numbers (Batch)' above."
                    },
                    "specID": {
                        "title": "Spec ID",
                        "type": "integer",
                        "description": "Spec ID for direct population lookup (advanced). You can get this from a cert lookup result."
                    },
                    "apiToken": {
                        "title": "PSA API Token",
                        "type": "string",
                        "description": "Your own PSA API bearer token for higher rate limits. Without this, cert lookups share a 100 calls/day free quota. Not needed for set lookups."
                    },
                    "cacheDurationHours": {
                        "title": "Cache Duration (hours)",
                        "minimum": 0,
                        "maximum": 720,
                        "type": "integer",
                        "description": "How long to cache results (default: 168 hours / 7 days). Cached results don't count against API quota. PSA grades are permanent so caching is safe. Set to 0 to disable.",
                        "default": 168
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```