# NGC US Coin Price Guide (`automation-lab/ngc-coin-price-guide`) Actor

Export NGC US coin price guide rows from official series URLs with coin labels, grades, designations, USD reference values, update dates and provenance for recurring catalog refresh.

- **URL**: https://apify.com/automation-lab/ngc-coin-price-guide.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.03 / 1,000 grade-value rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## NGC US Coin Price Guide

Export **NGC coin price guide** reference values from supplied official US series URLs. Each dataset row represents one priced coin-grade-modifier cell, with the source coin label, denomination, designation, source update date and provenance. Use the results to refresh a numismatic reference dataset or compare your own dated snapshots.

This Actor does not estimate the value of a physical coin. Guide values are reference figures, not offers, realized sales or appraisals. It is an independent tool, not affiliated with or endorsed by NGC.

### Who is it for?

- Catalog maintainers refreshing known US coin series.
- Collection-software developers joining official coin IDs to grade-value references.
- Researchers building reproducible, dated reference snapshots.

### Why use it?

Receive tidy grade-level rows instead of transcribing a wide table. Source coin labels are retained verbatim rather than splitting uncertain mintmarks or varieties into invented fields. Blank price cells are skipped rather than converted to zero. Stable coin IDs, source links and extraction timestamps make downstream comparisons traceable.

### Getting started

1. Open the official [NGC US guide](https://www.ngccoin.com/price-guide/united-states/).
2. Select a category and a numeric series, such as Flying Eagle Cents.
3. Copy the series URL ending in a numeric ID.
4. Paste it into `startUrls`, choose a global `maxItems`, and start the Actor.
5. Inspect the dataset and export JSON, CSV or Excel.

```json
{
  "startUrls": [{"url":"https://www.ngccoin.com/price-guide/united-states/cents/16/"}],
  "maxItems": 100
}
```

### Inputs

| Field | Behavior |
|---|---|
| `startUrls` | Required, 1–25 official HTTPS numeric US series URLs. Use objects with a `url` property, as in the example. Duplicate URLs are fetched once. Only `url` is used; editor fields such as method, headers, payload and userData are ignored. Requests always use GET without user-supplied credentials. |
| `maxItems` | Default 100. Global number of priced coin-grade-modifier rows after deduplication; integer 1–100000. Zero/unlimited is not supported. |

Use `https://www.ngccoin.com/price-guide/united-states/<category>/<numeric-series>/`. Query strings, fragments, credentials, alternate domains, world pages and category landing pages are rejected. The bare `ngccoin.com` host is normalized to `www.ngccoin.com`.

The editor prefill uses 20 rows for an inexpensive first test; omitted `maxItems` still defaults to 100. The Actor processes URLs sequentially in input order, then cells in source-table order. It stops fetching additional series when the global row limit is reached. There are no hidden search filters or country modes. A paid-result budget may stop collection earlier.

### Extracted data

| Field | Meaning |
|---|---|
| `series` | Official series title. |
| `coinLabel` | Source year/mint/variety label without speculative splitting. |
| `denomination` | Source denomination, for example `1C`. |
| `designation` | Source designation, including qualifiers when shown. |
| `coinId` | NGC coin identity as a string. |
| `grade` | Exact grade attribute; numeric grades remain strings. |
| `modifier` | `base`, `plus`, `star` or `plus-star` from the priced cell. |
| `guideValue`, `currency` | Numeric displayed reference value and `USD`. |
| `sourceUpdatedAt` | Original US-formatted date printed for the coin, or null. Not a claim of today's valuation. |
| `sourceUrl` | Official series page fetched. |
| `coinUrl` | Official explorer redirect link, not an additional detail fetch. |
| `scrapedAt` | UTC ISO extraction timestamp. |

### Output example

This representative source cell is from the Flying Eagle series:

```json
{
  "series": "Flying Eagle Cents (1856-1858)",
  "coinLabel": "1857 EAGLE",
  "denomination": "1C",
  "designation": "MS",
  "coinId": "12016",
  "grade": "PrAg",
  "modifier": "base",
  "guideValue": 25,
  "currency": "USD",
  "sourceUpdatedAt": "5/10/2021",
  "sourceUrl": "https://www.ngccoin.com/price-guide/united-states/cents/16/",
  "coinUrl": "https://www.ngccoin.com/redirects/coin-explorer/12016/",
  "scrapedAt": "2026-10-24T06:05:07.677Z"
}
```

Deduplication uses `coinId`, `grade` and `modifier` across all supplied URLs. Different grades are different results, even for the same coin. Dates and prices above illustrate a source snapshot, not a promise that values remain unchanged.

### Coverage and limits

Only priced cells in the supplied US series' initial public table are exported. Interactive variety expansion and coin-detail enrichment are not performed. A variety already named in that table remains in `coinLabel`; do not interpret this as exhaustive variety coverage.

World catalogs, India/UK catalog searches, certification lookup, population counts, images, mintage, historical prices, auction transactions and appraisals are outside scope. The Actor does not browse every US series automatically. It does not provide built-in change alerts or merge snapshots across runs.

### How much does it cost to export NGC US coin grade values?

The pricing contract consists of a one-time `start` event for a validated run and an `item` event for each exported priced grade-value row. Duplicate and blank cells are not item events. Different grades of the same coin are separately metered rows. Review the active tier prices and your maximum charge before starting; this documentation does not guarantee a particular invoice.

The start fee is **$0.04 per validated run**. Per-row prices depend on your Apify Store spending tier:

| Tier | Price per grade-value row |
|---|---:|
| FREE | $0.0019726 |
| BRONZE | $0.0017153 |
| SILVER | $0.0013379 |
| GOLD / PLATINUM / DIAMOND | $0.0010292 |

Worked example at BRONZE: 1 row costs $0.0417153, 25 rows cost $0.0828825, and 100 rows cost $0.21153, including the start fee. These are event-charge examples, not an appraisal or payout forecast. If an upstream failure occurs after some results, those rows and their charges may remain; failure does not imply a refund or complete collection.

No user proxy account or separate paid data-service subscription is required. There is no automatic residential or browser fallback. All normal runtime dependencies are operated by the publisher. Store spend tiers follow Apify's aggregate monthly Store-spend rules, not a private volume schedule for this Actor.

### Integrations

Download CSV into a spreadsheet, or load JSON into your catalog pipeline. Schedule the same input using Apify Schedules and perform change detection downstream. Scheduling is a platform feature, not a claim that the source publishes new prices on every run.

### Snapshot comparisons

Join successive exports on coin ID, grade and modifier, retaining extraction timestamps and source update dates separately. Compare only overlapping keys when runs have different row limits. A missing row in a limited export does not establish that a coin was removed or its value became zero. Store each complete export outside the Actor if you need a historical series; the Actor itself retrieves only current displayed references.

### Related Actors

This is a standalone numismatic reference product. No unrelated commerce Actor is needed to use its output.

### API usage

Keep your token in an environment variable, not in shared input files or logs.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ngc-coin-price-guide/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.ngccoin.com/price-guide/united-states/cents/16/"}],"maxItems":25}'
```

JavaScript with `apify-client`:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ngc-coin-price-guide').call({
  startUrls: [{url:'https://www.ngccoin.com/price-guide/united-states/cents/16/'}],
  maxItems: 25,
});
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ngc-coin-price-guide').call(run_input={
    'startUrls': [{'url': 'https://www.ngccoin.com/price-guide/united-states/cents/16/'}],
    'maxItems': 25,
})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(f"Run {run['id']}: {run['status']}")
print(client.dataset(run['defaultDatasetId']).list_items(limit=25).items)
```

### MCP setup

Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/ngc-coin-price-guide"
```

Claude Desktop, Cursor and VS Code: configure the equivalent HTTP server with your client's supported authentication mechanism:

```json
{"mcpServers":{"ngc-guide":{"url":"https://mcp.apify.com?tools=automation-lab/ngc-coin-price-guide"}}}
```

Example prompt: “Export up to 25 grade-value rows from the official Flying Eagle Cents series URL. Show the source update date and explain that guide prices are not appraisals.”

Discover the actual tool names and argument schemas with scoped `tools/list`. Actor selection also includes run/data helpers; it does not expose exactly one tool. Discovery is not authorization to run or abort an Actor.

For an authorized invocation, start once and retain its run ID and storage IDs. If still running, follow that same run with bounded backoff (2, 4, 8 seconds, capped at 10), stopping after a 120-second consumer deadline. On client timeout recover the known run, not a new run. Report pending or failed honestly.

After success, read dataset pages of 20 rows using explicit offset, limit and fields. For model context, use at most 100 source rows or 64 KiB of serialized UTF-8 content, whichever comes first, enforcing the byte bound host-side before injection. If the client cannot enforce bytes, do not claim that guarantee. Report truncation and the next source offset. Full exports stay outside model context. This consumer budget does not reduce Actor collection coverage. No universal token-savings claim is made.

### FAQ and troubleshooting

Transient network errors, HTTP 429 and server errors receive at most three total attempts with bounded backoff. Permanent statuses, redirects and unrecognized tables fail rather than return fabricated results. A failed run can contain partial results from earlier series.

**Why was my URL rejected?** Select a numeric US series, not the category landing page or world catalog. Remove query strings and fragments.

**Why fewer rows than expected?** Blank prices are omitted, duplicates are removed, and the global limit or paid-result budget may stop collection. No interactive variety expansion occurs.

**Why an old update date?** That is the source's printed coin update date, not the time the Actor fetched the page. `scrapedAt` records extraction time separately.

**Does success mean every grade exists?** No. Only explicitly priced cells in recognized source tables are exported. No missing price is inferred.

### Legality and data handling

Use the public reference data responsibly and assess source terms, copyright and your intended reuse. This tool does not confer source rights or provide legal or investment advice. Apify's standard terms apply; there are no custom end-user terms.

The Actor uses no AI model at runtime and sends no scraped records to a model provider. It fetches public coin data, not personal profiles, private accounts or authentication cookies. Requests go directly to NGC; outputs and run logs are stored by Apify under your account's retention settings. The Actor does not create a separate cross-run cache. Delete runs and associated storage through Apify when no longer needed; account-level retention/backups remain governed by Apify.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Do not submit confidential information in URL paths or unsupported fields. No credentials are needed in the public input.

### Support

Report reproducible issues through the Actor's Apify Issues tab with the run link, official series URL and expected missing cell. Do not post tokens or private account information. Source changes can break extraction; a blocked or changed source fails honestly rather than generating a successful empty catalog.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/ngc-coin-price-guide/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Supply 1–25 HTTPS official numeric series URLs, for example /price-guide/united-states/cents/16/. Category landing pages, query strings, fragments and world URLs are rejected. Duplicate URLs are fetched once; results deduplicate globally by coin ID, grade and modifier. Only url is used: method, headers, payload and userData are ignored; requests always use GET without user-supplied credentials.

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

Global maximum exported priced coin-grade-modifier cells across all supplied series, after deduplication. Default 100; range 1–100000. Zero/unlimited is not supported. Input order and source table order determine which rows fit; remaining URLs are not fetched after the limit. A paid-result budget may stop earlier.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ngccoin.com/price-guide/united-states/cents/16/"
    }
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Export results as JSON, CSV or Excel from the default dataset.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.ngccoin.com/price-guide/united-states/cents/16/"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ngc-coin-price-guide").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 = {
    "startUrls": [{ "url": "https://www.ngccoin.com/price-guide/united-states/cents/16/" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ngc-coin-price-guide").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.ngccoin.com/price-guide/united-states/cents/16/"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/ngc-coin-price-guide --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/ngc-coin-price-guide"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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