# NGC Census Scraper — Coin Populations, Grades & Totals (`scrapersdelight/ngc-census-scraper`) Actor

Look up the NGC coin census (population report) by series URL or search term — one row per coin with year, mint mark, variety, designation, every grade count 1–70 (incl. Plus/Star) and totals. US + world coins, all grading scales. No login or API key. $4 per 1,000 coins.

- **URL**: https://apify.com/scrapersdelight/ngc-census-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Automation, E-commerce, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 per coin rows

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

## 🪙 NGC Census Scraper — Coin Populations, Grades & Totals

**Pull the [NGC coin census](https://www.ngccoin.com/population-report/) (population report) into clean rows — one row per coin line with the year, mint mark, variety, strike, MS/PF designation, the FULL grade-count distribution (1 through 70, including ⭐ Star and ➕ Plus grades and Details grades) and the total graded. Point it at any census URL — a whole country, a denomination, or a single series like Morgan Dollars — or just type a search term.**

No login, no API key, no browser automation — every number comes from NGC's public census service, the same data the population-report pages display. Works for **US and world coins** and all four grading scales (standard, Details, Sheldon, NGCX).

***

### What does NGC Census Scraper do?

It turns NGC's population report into structured data you can export to **JSON, CSV, Excel, or pull via API**. The census is the canonical answer to "how many examples of this coin has NGC graded, and in which grades?" — the number that drives rarity, registry sets, and pricing.

- 🔗 **Scrape by census URL** — paste any `ngccoin.com/population-report/…` URL: a category (United States, China…), a denomination (Dollars, Cents…), or a single series (Morgan Dollars 1878-1921).
- 🔎 **Or search by series name** — "morgan dollars", "saint-gaudens", "panda" — every matching series (US + world) is scraped.
- 🪙 **One row per coin line** — `1881-S $1 MS`, `1793 CHAIN "AMERI." S-1 BN 1C MS`, … exactly the rows the census table shows.
- 📊 **Full grade distribution** — a `grades` object with every grade count: `60…70`, `64Plus`, `65Star`, `68PlusStar`, plus `POOR_Details` … `UNC_Details`.
- ➕ **Totals** — `total_graded` per coin line, ready to sort by rarity.
- 🎚️ **Grading scales** — standard, Details-graded, Sheldon, or the NGCX 1–10 scale.
- 🏷️ **MS / PF filter** — restrict to Mint State or Proof designations.
- 🌍 **US + world** — all 296 census categories, from Colonial-era US to modern Chinese Pandas.

***

### What data does it extract?

For every coin line:

- 🆔 `population_id`, `coin_id`, `universal_coin_type_id`, `collectible_master_id`
- 🏷️ `description` (e.g. `1881-S $1 MS`), 📅 `year`, `year_label`, `mint_mark`
- 💵 `denomination`, 🔠 `variety` (VAM/Sheldon refs), `strike` (BN/RB/RD…), `designation` (MS/PF)
- 📊 `grades` — object of every grade count, e.g. `{ "70": 0, "67": 12, "65Plus": 3, "65Star": 1, … }`
- ➕ `total_graded`
- 🗂️ `category` (country), `subcategory` (denomination/era), `series`, `series_id`
- 🔗 `census_url` (the canonical population-report page), `grading_scale`
- 🕒 `date_modified`, `scraped_at`

***

### Who is it for?

- 💰 **Coin dealers & auction houses** pricing inventory by certified rarity (pop reports drive premiums).
- 📈 **Numismatic researchers & data builders** tracking population growth and conditional rarity across series.
- 🏆 **Registry-set collectors** finding the grades where a coin is genuinely scarce.
- 🤖 **Marketplace / ML developers** enriching coin listings with census counts (the same play as PCGS pop data).

***

### How to use it (step by step)

1. Click **Try for free**.
2. Paste a **census URL** (the prefilled Morgan Dollars series works out of the box) — or type a **search term**.
3. *(Optional)* pick a **grading scale** or restrict to **MS / PF**.
4. *(Optional)* set a **coin filter** (e.g. `1881-S`) or raise **Max records**.
5. Click **Start**, then open the **Dataset** tab to view/export.

#### Quick start

```json
{
  "censusUrls": ["https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"],
  "maxRecords": 100
}
```

#### Search example — every Saint-Gaudens series

```json
{ "searchTerm": "saint-gaudens", "maxRecords": 500 }
```

#### Whole-denomination example — all US dollar series, proofs only

```json
{
  "censusUrls": ["https://www.ngccoin.com/population-report/united-states/3/dollars/13/"],
  "designation": "PF",
  "maxRecords": 0
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `censusUrls` | `ngccoin.com/population-report/…` URLs at category, denomination, or series depth (a scale or MS/PF segment in the URL is honored) |
| `searchTerm` | global series search across the whole census (US + world) |
| `gradingScale` | `all` (standard) · `details` · `sheldon` · `ngcx` |
| `designation` | `any` · `MS` · `PF` |
| `coinFilter` | server-side keyword filter inside each series (e.g. `1881-S`, `cameo`) |
| `maxRecords` | hard cap per run (0 = unlimited; prefilled to 100) |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism |

***

### Output

Each coin line is one dataset record. Example (trimmed):

```json
{
  "population_id": 104783261,
  "description": "1881-S $1 MS",
  "year": 1881,
  "mint_mark": "S",
  "denomination": "$1",
  "designation": "MS",
  "total_graded": 234567,
  "grades": { "70": 0, "69": 2, "68PlusStar": 1, "67": 1450, "65": 52000, "60": 1200, "UNC_Details": 310 },
  "series": "Morgan Dollars (1878-1921)",
  "category": "United States",
  "subcategory": "Dollars",
  "census_url": "https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"
}
```

Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. In CSV the `grades` object flattens to one column per grade — the census table, as a spreadsheet.

***

### How much does it cost?

Pay-per-event — you pay for what you pull, no subscription. **$4 per 1,000 coin records.**

| Event | What it covers | Price |
|-------|----------------|-------|
| `lot-scraped` | each coin census row returned | $0.004 / row |

The entire Morgan Dollars series (~400 rows) costs about **$1.60**. A 100-row sample run: **$0.40**.

***

### Tracking census changes over time

NGC refreshes the census daily. To build a population time series (e.g. watch a key date's pop in MS65), run this actor on an **Apify Schedule** (weekly is plenty), keep `maxRecords` scoped to your series, and diff `total_graded` / `grades` between runs — `date_modified` tells you when NGC last touched each line.

***

### Is it legal to scrape the NGC census?

This actor reads **public, login-free aggregate statistics** (counts of coins graded, per grade) — no personal data, no user accounts. Scraping publicly available data is generally legal, but you are responsible for your use: **review NGC's Terms of Use before commercial use or redistribution of the data.**

***

### FAQ

**What is the NGC census / population report?**
Numismatic Guaranty Company (NGC) publishes counts of every coin it has ever certified, broken down by grade — the "pop report" collectors and dealers use to judge rarity.

**Do I need an NGC account or API key?**
No. The census is public; the actor reads it directly. No login or API key.

**Does it cover world coins or only US?**
Both — all 296 census categories: United States plus every world country NGC grades (China, Great Britain, Mexico…).

**What are Plus and Star grades?**
NGC appends ➕ (Plus) for high-end coins within a grade and ⭐ (Star) for exceptional eye appeal. Each combination is a separate census column, and each gets its own key in `grades` (e.g. `65Plus`, `66Star`, `64PlusStar`).

**What is the `details` grading scale?**
Coins with surface problems get a "Details" grade (e.g. `XF Details`). Set `gradingScale: "details"` to pull those tables.

**What is NGCX?**
NGC's 1–10 grading scale used for modern crossover collectibles. Set `gradingScale: "ngcx"`.

**Can I scrape one specific coin?**
Yes — use `coinFilter` (e.g. `1893-S`) inside a series, or paste a census URL that carries `?populationID=…`.

**Can I get PCGS populations too?**
This actor covers NGC only; pair it with a PCGS population scraper for both services' counts.

**How fresh is the data?**
NGC updates the census daily; every run pulls live numbers. `date_modified` shows NGC's own last-change stamp per coin line.

**Why is a row's `total_graded` bigger than the sum of `grades`?**
Totals can include older-format or label-only submissions NGC counts in the total. Treat `total_graded` as authoritative.

**How do I export the data?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

***

### Feedback

Found a missing field or want a new feature (variety drill-down, PCGS cross-reference, change alerts)? Open an issue on the actor — fast fixes and feature requests welcome.

# Actor input Schema

## `censusUrls` (type: `array`):

ngccoin.com/population-report/ URLs at any depth — a whole category (e.g. …/united-states/3/), a denomination (…/united-states/3/dollars/13/), or a single series (…/morgan-dollars-1878-1921/72/all/). A grading scale (all/details/sheldon/ngcx) or MS/PF segment in the URL is honored. Combine with, or use instead of, a search term.

## `searchTerm` (type: `string`):

Global search across every NGC census series (US + world), e.g. 'morgan dollars', 'saint-gaudens', 'panda'. Every matching series is scraped (subject to Max records).

## `gradingScale` (type: `string`):

Which census table to pull: 'all' = the standard NGC numeric scale (default), 'details' = details-graded coins (POOR…UNC Details), 'sheldon' = Sheldon-scale view, 'ngcx' = the NGCX 1–10 scale. URLs containing a scale segment override this.

## `designation` (type: `string`):

Optionally restrict to Mint State (MS) or Proof (PF) coins. 'Any' returns both.

## `coinFilter` (type: `string`):

Optional server-side keyword filter applied inside each series, e.g. '1881-S', 'CC', 'cameo' — keeps only coin lines matching the keyword.

## `maxRecords` (type: `integer`):

Hard cap on coin rows scraped this run (cost/safety guard). 0 = unlimited. Prefilled to 100 for a fast first run.

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

Proxy settings. Datacenter rotation is plenty — the census API has no anti-bot.

## `requestConcurrency` (type: `integer`):

Max series fetched in parallel. Keep modest to respect the site.

## `diagnose` (type: `boolean`):

Dev only. Parses the first census URL, dumps a raw population JSON page to the key-value store, logs the first parsed record, then exits.

## Actor input object example

```json
{
  "censusUrls": [
    "https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"
  ],
  "gradingScale": "all",
  "designation": "any",
  "maxRecords": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 3,
  "diagnose": false
}
```

# Actor output Schema

## `coins` (type: `string`):

The dataset of census rows (one item per coin line, with the full grade-count distribution and totals).

# 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 = {
    "censusUrls": [
        "https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"
    ],
    "maxRecords": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/ngc-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 = {
    "censusUrls": ["https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"],
    "maxRecords": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/ngc-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 '{
  "censusUrls": [
    "https://www.ngccoin.com/population-report/united-states/3/dollars/13/morgan-dollars-1878-1921/72/all/"
  ],
  "maxRecords": 100
}' |
apify call scrapersdelight/ngc-census-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5ma0UeePjes78TFsE/builds/NNE5iciJDfQKd4oUw/openapi.json