# NGC Coin Census Population Report Scraper (`crawlerbros/ngc-coin-census-scraper`) Actor

Scrape the NGC (Numismatic Guaranty Corporation) Coin Census Population Report - the numismatic industry's most comprehensive graded coin database. Search coin series by name or browse by category to retrieve population data showing how many coins have been graded at each grade level (MS-60 throu...

- **URL**: https://apify.com/crawlerbros/ngc-coin-census-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 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/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

## NGC Coin Census Population Report Scraper

Extract graded coin population data from the **NGC (Numismatic Guaranty Corporation) Coin Census Population Report** — the numismatic industry's most comprehensive and authoritative graded coin database, tracking 50M+ graded coins across all countries and eras.

### What It Does

This actor queries the public NGC coin census API to retrieve structured population report data including:

- Coin series name, year, date, denomination, and mint mark
- Designation (MS = Mint State, PF = Proof, SP = Specimen)
- Total NGC population (number of coins graded)
- Full grade breakdown (MS-60 through MS-70, Proof grades, Details grades)
- Star designations and Plus grades
- Variety and strike information

### Modes

| Mode | Description |
|---|---|
| `searchCoinSeries` | Search by coin series keyword (e.g. "Morgan Dollar", "Liberty Eagle") |
| `byCategoryId` | Get all population data for a specific country/category ID |
| `listCategories` | List all 290+ coin categories in the NGC database |

### Input Parameters

| Field | Type | Description |
|---|---|---|
| `mode` | select | `searchCoinSeries`, `byCategoryId`, or `listCategories` |
| `keywords` | string | Coin series to search (e.g. "Morgan Dollar", "Lincoln Cent") |
| `categoryId` | integer | NGC category ID for mode=byCategoryId (use listCategories to find IDs) |
| `yearFrom` | integer | Filter coins with year >= this value |
| `yearTo` | integer | Filter coins with year <= this value |
| `designation` | select | Filter by MS, PF (Proof), or SP (Specimen) |
| `minPopulation` | integer | Only include coins with total population >= this value |
| `includeGradeBreakdown` | boolean | Include population count per grade level (default true) |
| `maxItems` | integer | Maximum records to return (default 100, max 2000) |

### Output Fields

```json
{
  "coinId": 17311,
  "populationId": 101098537,
  "displayName": "1878 8TF $1 PF",
  "year": "1878 8TF",
  "numericYear": 1878,
  "denomination": "$1",
  "mintMark": "",
  "designation": "PF",
  "coinSeriesName": "Morgan Dollars (1878-1921)",
  "populationTotal": 112,
  "hasMSPopulation": false,
  "hasPFPopulation": true,
  "gradeBreakdown": {
    "MS-67": 3,
    "MS-66": 8,
    "MS-65": 21,
    "MS-64": 37,
    "UNC Details": 2,
    "AU Details": 1
  },
  "sourceUrl": "https://www.ngccoin.com/population-report/united-states/morgan-dollars-1878-2009-pscid-133/",
  "recordType": "coinCensus",
  "scrapedAt": "2026-06-02T12:00:00+00:00"
}
````

### Common Category IDs

| ID | Category |
|---|---|
| 3 | United States |
| 10 | China |
| 8 | Canada |
| 13 | Great Britain |
| 4 | Australia |

Use `mode=listCategories` to get the complete list of 290+ categories.

### Example Use Cases

- **Coin valuation research** — Determine rarity by checking how many MS-65+ examples exist
- **Population tracking** — Monitor NGC census data for specific coin series over time
- **Numismatic research** — Analyze grade distribution for US or world coins
- **Coin dealer tools** — Export population data for pricing and inventory analysis

### Data Source

Data comes from the **NGC Coin Census API** (`production.api.aws.ccg-ops.com`) — the official backend API powering NGC's public Population Report at ngccoin.com. No authentication, API key, or proxy required.

### Frequently Asked Questions

**What is the NGC Population Report?**
The NGC Population Report tracks every coin submitted to NGC for grading, showing how many examples have been certified at each grade level. It is widely used by collectors and dealers to assess coin rarity and value.

**Are all countries covered?**
Yes — NGC grades coins from over 100 countries. Use `mode=listCategories` to see the full list or `mode=byCategoryId` with the appropriate country category ID.

**What do the grade levels mean?**
NGC uses the Sheldon scale (1-70) for numeric grades. MS (Mint State) = uncirculated, PF (Proof) = specially struck for collectors, SP (Specimen) = early collector issues. "Details" grades indicate cleaned or damaged coins.

**What does population mean?**
Population is the total number of coins certified by NGC at or for that particular grade. Higher populations indicate more common coins; lower populations indicate rarer examples.

# Actor input Schema

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

How to search the NGC coin census database.

## `keywords` (type: `string`):

Coin series name to search (e.g. 'Morgan Dollar', 'Liberty Eagle', 'Lincoln Cent', 'Buffalo Nickel').

## `categoryId` (type: `integer`):

NGC research category ID. Use mode=listCategories to discover IDs. Example: 3 = United States.

## `yearFrom` (type: `integer`):

Only include coins with numericYear >= this value.

## `yearTo` (type: `integer`):

Only include coins with numericYear <= this value.

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

Filter by coin designation type.

## `minPopulation` (type: `integer`):

Only include coins where total NGC population is at least this number.

## `includeGradeBreakdown` (type: `boolean`):

Include the population count for each individual grade level (MS-60 through MS-70, Details grades, etc.).

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

Maximum number of coin records to return.

## Actor input object example

```json
{
  "mode": "searchCoinSeries",
  "keywords": "Morgan Dollar",
  "designation": "",
  "includeGradeBreakdown": true,
  "maxItems": 100
}
```

# Actor output Schema

## `coinCensus` (type: `string`):

Dataset containing all scraped NGC coin census population records.

# 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 = {
    "mode": "searchCoinSeries",
    "keywords": "Morgan Dollar",
    "includeGradeBreakdown": true,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ngc-coin-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 = {
    "mode": "searchCoinSeries",
    "keywords": "Morgan Dollar",
    "includeGradeBreakdown": True,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ngc-coin-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 '{
  "mode": "searchCoinSeries",
  "keywords": "Morgan Dollar",
  "includeGradeBreakdown": true,
  "maxItems": 100
}' |
apify call crawlerbros/ngc-coin-census-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NGC Coin Census Population Report Scraper",
        "description": "Scrape the NGC (Numismatic Guaranty Corporation) Coin Census Population Report - the numismatic industry's most comprehensive graded coin database. Search coin series by name or browse by category to retrieve population data showing how many coins have been graded at each grade level (MS-60 throu...",
        "version": "1.0",
        "x-build-id": "gBwFkCcctYLMrwdKO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ngc-coin-census-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ngc-coin-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/crawlerbros~ngc-coin-census-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ngc-coin-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/crawlerbros~ngc-coin-census-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ngc-coin-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchCoinSeries",
                            "byCategoryId",
                            "listCategories"
                        ],
                        "type": "string",
                        "description": "How to search the NGC coin census database.",
                        "default": "searchCoinSeries"
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "string",
                        "description": "Coin series name to search (e.g. 'Morgan Dollar', 'Liberty Eagle', 'Lincoln Cent', 'Buffalo Nickel').",
                        "default": "Morgan Dollar"
                    },
                    "categoryId": {
                        "title": "Category ID (mode=byCategoryId)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "NGC research category ID. Use mode=listCategories to discover IDs. Example: 3 = United States."
                    },
                    "yearFrom": {
                        "title": "Year from filter",
                        "minimum": 1600,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include coins with numericYear >= this value."
                    },
                    "yearTo": {
                        "title": "Year to filter",
                        "minimum": 1600,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Only include coins with numericYear <= this value."
                    },
                    "designation": {
                        "title": "Designation filter",
                        "enum": [
                            "",
                            "MS",
                            "PF",
                            "SP"
                        ],
                        "type": "string",
                        "description": "Filter by coin designation type.",
                        "default": ""
                    },
                    "minPopulation": {
                        "title": "Minimum total population",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include coins where total NGC population is at least this number."
                    },
                    "includeGradeBreakdown": {
                        "title": "Include full grade breakdown",
                        "type": "boolean",
                        "description": "Include the population count for each individual grade level (MS-60 through MS-70, Details grades, etc.).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of coin records to return.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
