# USGS MRDS Mineral Resource Records (`automation-lab/usgs-mrds-mineral-resource-records`) Actor

Search or resolve public USGS MRDS mineral deposit records and export stable IDs, coordinates, commodities, geology, development context, analytical data, and references.

- **URL**: https://apify.com/automation-lab/usgs-mrds-mineral-resource-records.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 92.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.41 / 1,000 item extracteds

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?

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

## USGS MRDS Mineral Resource Records

Search or resolve public **mrdata USGS** Mineral Resources Data System (MRDS) records and export stable deposit IDs, names, coordinates, commodities, development context, geology, analytical data, comments, and bibliographic references.

Use the Actor for repeatable mineral exploration screening, regional resource research, and GIS enrichment without manually navigating one MRDS page at a time.

### What does this USGS MRDS Actor do?

The Actor supports three complementary routes:

1. resolve exact MRDS deposit IDs or public record URLs;
2. search by site name, location, commodity, material, or operation type;
3. discover records inside WGS84 bounding boxes for spatial analysis.

Every accepted candidate is enriched from the official structured USGS record endpoint. Results use a consistent schema even though old MRDS sections vary between records.

The Actor does not manufacture missing geology or production values. Unavailable values are returned as `null`, empty arrays, or omitted keys inside rich source sections.

### Who is it for?

#### Mineral exploration teams

Build regional prospect lists, compare published commodity associations, and review historical development context before deeper due diligence.

#### GIS analysts

Turn a longitude/latitude bounding box into tabular, GeoJSON-friendly point attributes for joining with geology, land, infrastructure, or environmental layers.

#### Researchers and consultants

Resolve citations and stable MRDS identities for reports covering mines, prospects, occurrences, districts, and mineral-resource history.

#### Data engineers

Schedule repeatable Apify runs and send normalized records to spreadsheets, warehouses, notebooks, or geospatial pipelines.

### Why use this Actor?

- Uses public USGS MRDS structured data rather than scraping visual map pixels.
- Keeps the stable `depositId` and canonical source links on every row.
- Normalizes source fields that may appear as either one object or an array.
- Combines exact lookup, attribute search, and bounding-box discovery.
- Applies user filters to discovered and explicit records before saving.
- Charges only for records that pass filters and are written to the dataset.
- Uses a lightweight HTTP workflow with no browser or residential proxy requirement.

### What data can you extract?

| Field group | Examples |
| --- | --- |
| Identity | `depositId`, `mrdsId`, `recordType`, `siteName`, alternate names, record grade |
| Coordinates | latitude, longitude, datum |
| Jurisdiction | country, state or province, county |
| Commodities | names, codes, groups, type, reported importance |
| Development | status, operation type, production years and size, significance |
| Geology | materials, deposit models, rocks, structures, tectonics, alteration, ore control, orebody |
| Economic context | ownership, land status, holdings, workings, production, resources, reserves |
| Evidence | analytical data, categorized comments, bibliographic references |
| Provenance | canonical detail URL, JSON URL, source update value, fetch timestamp |

MRDS is a historical database. Record depth varies substantially: some entries are simple commodity occurrences, while others include extensive geological and economic sections.

### Input options

#### `recordIds`

A list of stable MRDS deposit IDs.

```json
{
  "recordIds": ["10016307", "10215357"],
  "maxItems": 2
}
```

#### `recordUrls`

Public MRDS detail, record, or JSON URLs. The Actor extracts the deposit ID and resolves the same official JSON record.

#### `searches`

An array of search objects. Supported fields are:

- `siteName`;
- `nameMatch`: `beginsWith` or `contains`;
- `state`;
- `county`;
- `country`;
- `commodity`;
- `material`;
- `operationType`;
- `developmentStatus`.

Location and commodity filters can be combined to make screening queries more precise.

#### `boundingBoxes`

Each box requires:

- `west` and `east` from -180 to 180;
- `south` and `north` from -90 to 90;
- `west < east` and `south < north`.

A box can also include the same record filters used by searches.

#### Limits

`maxItems` limits unique saved records across every route. `maxConcurrency` controls simultaneous detail requests and defaults to a source-friendly value of 5.

### Getting started

1. Open the Actor in Apify Console.
2. Choose one input route: exact records, searches, or bounding boxes.
3. Keep `maxItems` small for the first run.
4. Click **Start**.
5. Open **Dataset** to inspect normalized records.
6. Export JSON, CSV, Excel, XML, or another supported Apify dataset format.
7. Save the configuration as a Task when you want repeatable runs.

### Example: search Colorado gold records

```json
{
  "searches": [
    {
      "siteName": "Keystone",
      "nameMatch": "contains",
      "state": "Colorado",
      "country": "United States",
      "commodity": "Gold"
    }
  ],
  "maxItems": 3
}
```

This real input returns full MRDS records rather than only search-result cards.

### Example: GIS enrichment by bounding box

```json
{
  "boundingBoxes": [
    {
      "west": -107.06,
      "south": 38.87,
      "east": -107.03,
      "north": 38.89,
      "commodity": "Lead"
    }
  ],
  "maxItems": 3
}
```

The output includes coordinates and source links suitable for conversion to point features in a GIS workflow.

### Output example

A current record has this normalized shape (long source sections shortened here):

```json
{
  "depositId": "10016307",
  "mrdsId": "DC00917",
  "recordType": "Site",
  "siteName": "Keystone",
  "recordGrade": "D",
  "latitude": 38.88138,
  "longitude": -107.04662,
  "country": "United States",
  "state": "Colorado",
  "county": "Gunnison",
  "commodityNames": ["Lead", "Zinc", "Silver", "Gold", "Copper"],
  "developmentStatus": "Producer",
  "productionYears": "1957",
  "districts": ["Ruby"],
  "bibliographicReferences": [
    { "category": "Deposit", "reference": "DMEA RECORDS", "recordId": null }
  ],
  "sourceUrl": "https://mrdata.usgs.gov/mrds/show-mrds.php?dep_id=10016307",
  "sourceJsonUrl": "https://mrdata.usgs.gov/mrds/json/10016307"
}
```

### How much does it cost to extract USGS MRDS records?

This Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each accepted dataset record.

The current start fee is **$0.005**. The BRONZE item price is **$0.00067905 per record**, with lower unit prices on higher Apify pricing tiers.

At the BRONZE rate, example charge calculations are:

| Saved records | Charge calculation |
| ---: | --- |
| 1 | one $0.005 start event + 1 × $0.00067905 item event |
| 10 | one $0.005 start event + 10 × $0.00067905 item events |
| 100 | one $0.005 start event + 100 × $0.00067905 item events |
| 1,000 | one $0.005 start event + 1,000 × $0.00067905 item events |

Platform compute is handled through the active Apify pricing configuration. Failed candidates, duplicates, and records rejected by filters do not produce an item charge.

### Build mineral exploration screening workflows

#### Spreadsheet research

Run a commodity and region search, export CSV or Excel, and add analyst scoring columns for follow-up.

#### GIS joins

Use `longitude` and `latitude` to create point geometry, then join records with geological, ownership, access, or infrastructure layers.

#### Record enrichment

Keep `depositId` in an internal table and periodically resolve important records to obtain their currently exposed source sections and references.

#### Reproducible research

Store Actor input alongside a report or notebook so another analyst can rerun the same public-source extraction.

MRDS ceased systematic updates in 2011. Scheduled runs are useful for reproducibility and detecting occasional source corrections, not as a promise of real-time mine monitoring.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~usgs-mrds-mineral-resource-records/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"recordIds":["10016307"],"maxItems":1}'
```

To wait for a result and receive dataset items directly:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~usgs-mrds-mineral-resource-records/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"recordIds":["10016307"],"maxItems":1}'
```

### Use the Apify API with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/usgs-mrds-mineral-resource-records').call({
  searches: [{ state: 'Colorado', commodity: 'Gold' }],
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/usgs-mrds-mineral-resource-records').call(
    run_input={
        'boundingBoxes': [{
            'west': -107.06,
            'south': 38.87,
            'east': -107.03,
            'north': 38.89,
            'commodity': 'Lead',
        }],
        'maxItems': 25,
    }
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use USGS MRDS through MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/usgs-mrds-mineral-resource-records"
```

#### Claude Desktop, Cursor, and VS Code setup

Use this MCP JSON configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/usgs-mrds-mineral-resource-records"
    }
  }
}
```

Example prompts:

- “Resolve MRDS deposit 10016307 and summarize its commodities and development status.”
- “Find lead-bearing MRDS records in this WGS84 bounding box and return a GIS-ready table.”
- “Search Colorado MRDS sites containing Keystone and include bibliographic references.”

### Data quality and limitations

- USGS states that systematic MRDS updates ceased in 2011.
- Some coordinates were derived from historical descriptions and may have limited precision.
- Source records vary from sparse occurrences to detailed deposits.
- Historical abbreviations and free-text fields are preserved where interpretation would be unsafe.
- A source search may return at most 10,000 candidates.
- The Actor does not geocode place names; use explicit jurisdictions or bounding boxes.
- Bounding boxes crossing the antimeridian are not accepted as one box.
- Upstream maintenance, timeouts, or schema changes can temporarily prevent retrieval.
- The Alaska Resource Data File is the more actively maintained USGS source for many Alaska-specific research jobs; this Actor returns MRDS records only.

### Legality and responsible use

MRDS is a public USGS scientific information source. Use exported records in accordance with applicable USGS terms and attribution guidance.

Historical records are screening evidence, not legal, investment, safety, engineering, reserve-certification, or land-access advice. Verify important locations, ownership, resource estimates, and operational status with authoritative current sources before making decisions.

Do not present an MRDS occurrence as proof of an economically recoverable deposit.

### Troubleshooting

#### The run says that no input route was provided

Add at least one non-empty `recordIds`, `recordUrls`, `searches`, or `boundingBoxes` array.

#### A search returns no records

Try fewer filters, check the historical spelling of the site or jurisdiction, or switch `nameMatch` from `beginsWith` to `contains`.

#### An exact record is missing from output

Confirm that the URL contains a numeric MRDS deposit ID. If filters are attached to an explicit route in a future saved configuration, make sure the record satisfies them.

#### A record has empty geology or analytical data

That is normal for sparse MRDS records. The Actor preserves source availability rather than filling fields from unrelated records.

#### A request fails temporarily

The Actor retries timeouts and transient HTTP failures. If USGS maintenance continues, rerun later and inspect the Actor log for the affected deposit ID.

### FAQ

#### Is this a live mine-status database?

No. MRDS is mainly historical and ceased systematic updates in 2011. `developmentStatus` reflects the source record, not necessarily current operations.

#### Can I look up one known record?

Yes. Use `recordIds` or `recordUrls` for the cheapest and most deterministic route.

#### Can I search by commodity and state?

Yes. Put `commodity` and `state` in a search object. Add a site name, county, country, material, or operation type when useful.

#### Does the Actor return full source detail?

It normalizes the most useful identity, location, commodity, development, analytical, comment, and reference fields. Rich geology and development sections preserve the official structured data currently exposed for each record.

#### Does it use a proxy or browser?

No. The current implementation uses public USGS HTTP endpoints and a conservative request concurrency.

#### Can I export GeoJSON?

The primary result is a dataset row with longitude and latitude. Export JSON and construct Point geometries in your GIS or data pipeline; Apify also supports common tabular export formats.

### Related Actors

This is a standalone mineral-resource research workflow in the automation-lab portfolio. It does not currently require a related Actor to deliver the promised MRDS screening and GIS-enrichment job.

Explore other public-data Actors from [automation-lab on Apify](https://apify.com/automation-lab) when your workflow needs a different official source.

# Actor input Schema

## `recordIds` (type: `array`):

Stable USGS MRDS deposit IDs to resolve, such as 10016307.

## `recordUrls` (type: `array`):

Public MRDS detail, JSON, or record URLs. The Actor extracts and resolves each deposit ID.

## `searches` (type: `array`):

Search by site name, location, commodity, material, operation type, or development status. Multiple search objects may be combined.

## `boundingBoxes` (type: `array`):

Geographic areas in WGS84 decimal degrees, optionally narrowed by record filters.

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

Maximum unique full MRDS records saved across all input routes.

## `maxConcurrency` (type: `integer`):

Maximum simultaneous official USGS detail requests. Keep the default for source-friendly recurring runs.

## Actor input object example

```json
{
  "recordIds": [
    "10016307"
  ],
  "searches": [
    {
      "siteName": "Keystone",
      "nameMatch": "contains",
      "state": "Colorado",
      "country": "United States",
      "commodity": "Gold"
    }
  ],
  "boundingBoxes": [
    {
      "west": -107.06,
      "south": 38.87,
      "east": -107.03,
      "north": 38.89,
      "commodity": "Lead"
    }
  ],
  "maxItems": 20,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

Open normalized MRDS records in the dataset overview.

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

Open complete normalized MRDS records through the dataset API.

# 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 = {
    "recordIds": [
        "10016307"
    ],
    "searches": [
        {
            "siteName": "Keystone",
            "nameMatch": "contains",
            "state": "Colorado",
            "country": "United States",
            "commodity": "Gold"
        }
    ],
    "boundingBoxes": [
        {
            "west": -107.06,
            "south": 38.87,
            "east": -107.03,
            "north": 38.89,
            "commodity": "Lead"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/usgs-mrds-mineral-resource-records").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 = {
    "recordIds": ["10016307"],
    "searches": [{
            "siteName": "Keystone",
            "nameMatch": "contains",
            "state": "Colorado",
            "country": "United States",
            "commodity": "Gold",
        }],
    "boundingBoxes": [{
            "west": -107.06,
            "south": 38.87,
            "east": -107.03,
            "north": 38.89,
            "commodity": "Lead",
        }],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/usgs-mrds-mineral-resource-records").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 '{
  "recordIds": [
    "10016307"
  ],
  "searches": [
    {
      "siteName": "Keystone",
      "nameMatch": "contains",
      "state": "Colorado",
      "country": "United States",
      "commodity": "Gold"
    }
  ],
  "boundingBoxes": [
    {
      "west": -107.06,
      "south": 38.87,
      "east": -107.03,
      "north": 38.89,
      "commodity": "Lead"
    }
  ]
}' |
apify call automation-lab/usgs-mrds-mineral-resource-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/usgs-mrds-mineral-resource-records"
        }
    }
}

```

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/0CwFqohB2lLwcSS5W/builds/Vgza6CsfX0KlDk6bW/openapi.json