# PCGS Coin Price Guide Scraper (`lulzasaur/pcgs-coin-prices-scraper`) Actor

Scrape PCGS coin prices across all grades (G-4 through MS-70/PR-70). Search by coin type or browse categories. Returns prices, PCGS numbers, year, mintmark, and denomination.

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

## Pricing

from $10.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 Price Guide Scraper

Extract coin prices from the **Professional Coin Grading Service (PCGS)** price guide at [pcgs.com/prices](https://www.pcgs.com/prices) — the industry standard for rare US coin valuations.

### What This Scraper Does

- Fetches **dealer asking prices** for PCGS-graded coins across key Sheldon grades (G-4 through MS-70/PR-70)
- Covers all **144 US coin series**: cents, nickels, dimes, quarters, half dollars, dollars, and gold
- Extracts **coin identification**: PCGS number, year, mint mark, denomination, variety, designation (MS/PL/DMPL/PR)
- Returns both **low and high price** for each grade (some grades show a bid/ask range)
- Supports pagination — Morgan Dollars alone have 341 rows across 4 pages

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `category` | `category`, `categories`, or `search` |
| `categorySlug` | string | `morgan-dollar` | URL slug for the coin series |
| `categoryId` | integer | `744` | PCGS numeric category ID |
| `searchQuery` | string | `""` | Coin name/date filter (search mode) |
| `gradeRange` | string | `most-active` | `most-active`, `grades-1-20`, `grades-25-60`, `grades-61-70`, or `all` |
| `includeProofs` | boolean | `false` | Also fetch Proof (PR) strike prices |
| `includeSpecimens` | boolean | `false` | Also fetch Specimen (SP) strike prices |
| `maxResults` | integer | `5` | Max rows to return (0 = unlimited) |
| `proxyConfiguration` | object | RESIDENTIAL | Residential proxy settings |

### Modes

#### `category` — Browse a Coin Series

Scrapes all price rows for a specific coin type. Use `categorySlug` and `categoryId` together.

**Popular categories:**

| Series | Slug | ID |
|--------|------|----|
| Morgan Dollar | `morgan-dollar` | 744 |
| Peace Dollar | `peace-dollar` | 26 |
| Walking Liberty Half Dollar | `walking-liberty-half-dollar` | 733 |
| Franklin Half Dollar | `franklin-half-dollar` | 734 |
| Kennedy Half Dollar | `kennedy-half-dollar` | 125 |
| Mercury Dime | `mercury-dime` | 16 |
| Roosevelt Dime | `roosevelt-dime` | 17 |
| Buffalo Nickel | `buffalo-nickel` | 83 |
| Jefferson Nickel | `jefferson-nickel` | 84 |
| Lincoln Cent (Wheat) | `lincoln-cent-wheat` | 46 |
| Lincoln Cent (Modern) | `lincoln-cent-modern` | 47 |
| Indian Cent | `indian-cent` | 44 |
| Saint-Gaudens Double Eagle | `saint-gaudens-double-eagle` | 159 |
| Liberty Double Eagle | `liberty-head-double-eagle` | 157 |
| American Silver Eagle | `american-silver-eagle` | 100 |
| American Gold Eagle | `american-gold-eagle` | 164 |

Use `categories` mode to discover all 144 slugs and IDs.

```json
{
  "mode": "category",
  "categorySlug": "morgan-dollar",
  "categoryId": 744,
  "gradeRange": "most-active",
  "maxResults": 50
}
```

#### `categories` — List All Series

Returns all 144 coin series available in the PCGS price guide.

```json
{
  "mode": "categories",
  "maxResults": 0
}
```

#### `search` — Search by Date or Name

Filters rows within a category by coin name, date, or mint mark.

```json
{
  "mode": "search",
  "categorySlug": "morgan-dollar",
  "categoryId": 744,
  "searchQuery": "1881-S",
  "maxResults": 10
}
```

### Output Fields

Each result record includes:

```json
{
  "pcgsNumber": "7130",
  "coinName": "1881-S",
  "year": "1881",
  "mintMark": "S",
  "variety": null,
  "designation": "MS",
  "series": "morgan-dollar",
  "categorySlug": "morgan-dollar",
  "categoryId": 744,
  "priceG4": 92,
  "priceF12": 92,
  "priceEF40": 92,
  "priceAU55": 94,
  "priceAU55High": 94,
  "priceMS63": 100,
  "priceMS63High": 110,
  "priceMS64": 125,
  "priceMS64High": 150,
  "priceMS65": 185,
  "priceMS65High": 225,
  "priceMS66": 400,
  "priceMS66High": 500,
  "priceMS67": 1100,
  "priceMS67High": 1750,
  "priceMS68": 5500,
  "priceMS68High": 18000,
  "gradeRange": "most-active",
  "sourceUrl": "https://www.pcgs.com/prices/detail/morgan-dollar/744/most-active",
  "scrapedAt": "2026-04-23T00:00:00.000Z"
}
```

### Designations

PCGS tracks prices separately for each strike type:

- **MS** — Mint State (regular business strikes)
- **PL** — Prooflike (mirror-like surfaces but business struck)
- **DMPL** — Deep Mirror Prooflike (strong mirror surfaces)
- **PR** — Proof (specially struck for collectors, use `includeProofs: true`)
- **SP** — Specimen (use `includeSpecimens: true`)

### Grade Ranges

PCGS splits coin prices across four grade tabs:

- **most-active** — 8-10 key circulated/mint state grades (fastest, default)
- **grades-1-20** — AG-3 through F-20 (heavy wear)
- **grades-25-60** — VF-25 through AU-58
- **grades-61-70** — MS-61 through MS-70 (pristine)

Use `gradeRange: "all"` to fetch all 4 tabs and get every available grade.

### Use Cases

- **Coin dealer pricing** — Benchmark inventory against PCGS official values
- **Collection valuation** — Value graded coins by PCGS number and grade
- **Price tracking** — Monitor weekly price changes across the series
- **Market research** — Analyze grade premiums and population relationships
- **Numismatic research** — Study pricing across all US coinage series

### About PCGS Prices

PCGS price guide values represent average **dealer asking prices** compiled weekly from:

- Dealer price lists and website offerings
- Fixed-price list advertisements
- Significant auction results
- Activity at major coin shows

Prices are typically shown as a range (low/high) representing the minimum ask and a typical ask for attractive/original examples within the grade.

***

Built by [lulzasaur](https://apify.com/lulzasaur) · [PCGS Price Guide](https://www.pcgs.com/prices)

# Actor input Schema

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

Scraping mode. 'category' fetches all coin prices for a series. 'categories' lists all 144 available series with slugs and IDs. 'search' filters rows by coin name.

## `categorySlug` (type: `string`):

URL slug for the coin series (e.g. 'morgan-dollar', 'lincoln-cent-wheat', 'walking-liberty-half-dollar'). Use 'categories' mode to discover all slugs.

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

PCGS numeric category ID paired with categorySlug (e.g. 744 for Morgan Dollars). Use 'categories' mode to discover IDs.

## `searchQuery` (type: `string`):

Coin name filter for 'search' mode (e.g. '1881-S', '1909-S VDB'). Filters rows within the selected category.

## `gradeRange` (type: `string`):

Which grade tab to scrape. 'most-active' returns the 8-10 most-traded grades. Other ranges add lower or higher grades. 'all' fetches all 4 tabs.

## `includeProofs` (type: `boolean`):

Also fetch proof-strike (PR) prices in addition to Mint State (MS) prices.

## `includeSpecimens` (type: `boolean`):

Also fetch specimen-strike (SP) prices where available.

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

Maximum number of coin rows to return. Set to 0 for unlimited.

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

Proxy settings. Residential proxies improve reliability against PCGS rate limiting.

## Actor input object example

```json
{
  "mode": "category",
  "categorySlug": "morgan-dollar",
  "categoryId": 744,
  "searchQuery": "",
  "gradeRange": "most-active",
  "includeProofs": false,
  "includeSpecimens": false,
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("lulzasaur/pcgs-coin-prices-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("lulzasaur/pcgs-coin-prices-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 '{}' |
apify call lulzasaur/pcgs-coin-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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