# PCGS Coin Population Scraper - Census / Grade Data (`lulzasaur/pcgs-coin-pop-scraper`) Actor

Scrape the PCGS Population Report: how many coins are graded at each PCGS grade. Look up any U.S., world, or pattern series and get per-coin grade breakdowns (PO1 to MS/PR70 with + grades) plus total population, PCGS #, year, denomination, and designation.

- **URL**: https://apify.com/lulzasaur/pcgs-coin-pop-scraper.md
- **Developed by:** [lulz bot](https://apify.com/lulzasaur) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.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 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

## PCGS Coin Population Scraper — Census / Grade Data

Get **PCGS Population Report data** — how many coins are graded at each PCGS grade — for any U.S., world, or pattern series. This is the numismatic equivalent of a card population report: for every coin (date, mint mark, variety, designation) it returns the full grade breakdown, from low circulated grades up through **MS/PR 70** (including **+** grades), plus the total graded population and the coin's PCGS number.

Great for coin dealers, collectors, registry-set builders, price-guide makers, and anyone analyzing rarity and grade distribution. (PCGS is the other major coin grader alongside NGC.)

### What you get

For each coin in a series:

| Field | Description |
|-------|-------------|
| `pcgsNumber` | PCGS catalog number for this coin + designation, e.g. `2431` |
| `description` | Human-readable coin label, e.g. `1909 1C Lincoln, RD` |
| `series` | Series / group (e.g. Lincoln Cent (Wheat Reverse)) |
| `region` | PCGS region index (uscoins, chinesecoins, ...) |
| `year`, `denomination`, `designation` | Coin attributes (designation = MS, MSBN, MSRB, MSRD, PR, PRDC, etc.) |
| `populationByGrade` | Object mapping grade label → count, e.g. `{ "MSRD65": 794, "MSRD65+": 8, "MSRD66": 1290, ... }` — only non-zero grades are included |
| `totalPop` | Total coins graded for this coin |
| `listingUrl` | Link to the PCGS coin detail (ValueView) page |
| `seriesUrl` | Link to the PCGS Population Report page for the series |

### Input

Navigate the Pop Report the same way the PCGS website does: pick a **Region**, then optionally filter to a **Series** by name.

```json
{
  "region": "United States",
  "series": "Lincoln",
  "maxResults": 1000
}
```

| Field | Description |
|-------|-------------|
| `region` | Region / category. Examples: United States, China, Great Britain, World, Canada, Mexico, Patterns. Default: United States |
| `series` | Series name filter (substring). Blank = all series in the region |
| `seriesSlug` + `seriesId` | Advanced: scrape one series directly (from `pcgs.com/pop/detail/<slug>/<id>`) |
| `maxResults` | Max coin rows (0 = unlimited). Default 1000 |
| `maxSeries` | Max number of series to scrape (0 = unlimited) |
| `proxyConfiguration` | RESIDENTIAL proxy is used by default (PCGS blocks datacenter IPs) |

#### Examples

Scrape one specific series directly:

```json
{ "seriesSlug": "lincoln-cent-wheat-reverse-1909-1958", "seriesId": 46 }
```

All Morgan dollars:

```json
{ "region": "United States", "series": "Morgan" }
```

China coins, capped:

```json
{ "region": "China", "maxSeries": 5, "maxResults": 500 }
```

### Notes

- Data comes from the public PCGS Population Report (HTML, server-rendered). **Use the residential proxy** (default) — PCGS blocks datacenter IPs.
- Grades come from the **Comprehensive** view, so each coin row includes its full grade spread in one record. Grade labels combine the designation with the numeric grade (e.g. `MS65`, `PR69`, `MSRD66+`).
- `populationByGrade` only lists grades with a non-zero count, keeping output compact.
- PCGS splits each series into Mint State (MS) and Proof (PR) tables; this scraper merges both into the per-coin output.

# Actor input Schema

## `region` (type: `string`):

Which PCGS Population Report index to scrape. Examples: 'United States', 'China', 'Great Britain', 'World', 'Canada', 'Mexico', 'Patterns'. You can also pass a raw slug like 'uscoins' or 'greatbritaincoins'. Defaults to United States.

## `series` (type: `string`):

Optional series-name filter (substring match). Examples: 'Lincoln', 'Morgan', 'Buffalo', 'Walking Liberty', 'Saint-Gaudens'. Leave blank to scrape ALL series in the region (use Max Series / Max Results to cap volume).

## `seriesSlug` (type: `string`):

Advanced: scrape one specific series directly by its PCGS slug. Find it in a series URL: pcgs.com/pop/detail/<SLUG>/<ID>. Example: 'lincoln-cent-wheat-reverse-1909-1958'. Requires Series ID too.

## `seriesId` (type: `integer`):

Advanced: the numeric series ID from a PCGS series URL: pcgs.com/pop/detail/<slug>/\<SERIES\_ID>. Example: 46 for Lincoln Cent (Wheat Reverse). Used together with Series Slug.

## `maxResults` (type: `integer`):

Maximum number of coin rows to output (0 = unlimited). Each row is one coin (date/variety/designation) with its full grade breakdown.

## `maxSeries` (type: `integer`):

Maximum number of series to scrape (0 = unlimited). Useful to cap broad scrapes that span an entire region.

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

PCGS blocks datacenter IPs, so RESIDENTIAL proxy is strongly recommended (and used by default). Leave as-is unless you have a reason to change it.

## Actor input object example

```json
{
  "region": "United States",
  "maxResults": 200,
  "maxSeries": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/pcgs-coin-pop-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 = {
    "region": "United States",
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DUhWigPMhpscwcrdR/builds/HuEJYPdOL1jnc223E/openapi.json