# USGS Mineral Resources (MRDS) Data Scraper (`compute-edge/usgs-mrds-mineral-resources-scraper`) Actor

Extract 300,000+ U.S. mine and mineral deposit records from USGS MRDS. Filter by state, commodity (gold, copper, uranium), and development status. Ideal for mining exploration and industrial research.

- **URL**: https://apify.com/compute-edge/usgs-mrds-mineral-resources-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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 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

## USGS Mineral Resources (MRDS) Data Scraper

Extract **300,000+ mine and mineral deposit records** from the United States Geological Survey (USGS) **Mineral Resources Data System (MRDS)** — the authoritative federal database of mines, mineral prospects, and mineral occurrences across North America and globally.

Whether you're in mining exploration, industrial supply chain research, geological analysis, or building a critical-minerals pipeline for AI, this Actor gives you structured, filtered access to the complete MRDS dataset in seconds.

### What data does this scraper extract?

| Field | Description |
|-------|-------------|
| `depId` | Unique MRDS deposit ID |
| `siteName` | Name of the mine, prospect, or occurrence |
| `latitude` / `longitude` | Geographic coordinates |
| `state` / `county` / `country` | Location |
| `commodity1` / `commodity2` / `commodity3` | Primary and secondary commodities (gold, copper, lithium, uranium, etc.) |
| `devStatus` | Development status: Producer, Past Producer, Occurrence, Prospect |
| `depositType` | Deposit classification (e.g., placer, lode, vein) |
| `productionSize` | Size classification (L=Large, M=Medium, S=Small, N=None) |
| `ore` / `gangue` | Ore and gangue mineral descriptions |
| `discoveryYear` | Year discovered |
| `firstProductionYear` / `lastProductionYear` | Historical production timeframe |
| `mrdsId` | Legacy MRDS identifier |
| `url` | Direct link to the full MRDS record |

#### Who uses this data?

- **Mining companies and exploration firms** identifying known deposits in target areas before field campaigns
- **Investment analysts and due-diligence teams** building comprehensive mineral resource databases
- **Critical minerals researchers** tracking supply-chain exposure to lithium, cobalt, rare earths, and strategic materials
- **Geologists and academics** studying regional mineralization patterns
- **Government agencies and NGOs** monitoring domestic mineral production capacity

### How to scrape USGS MRDS mineral data

1. Open the Actor on Apify Store and click **Try for free**.
2. Configure your filters in the input form:
   - **State**: Enter a 2-letter US state code (e.g., `NV` for Nevada, `AK` for Alaska). Leave blank for all states.
   - **Commodity**: Enter a partial name like `gold`, `copper`, `lithium`, or `uranium`. Matches any of the three commodity columns.
   - **Development Status**: Filter by mine status — `Producer`, `Past Producer`, `Occurrence`, or `Prospect`.
   - **Max Results**: Default is 3,000 for a fast preview. Set to `0` to export the full 300,000+ record dataset.
3. Click **Save & Run** — the Actor downloads the MRDS zip, parses the CSV, and writes results to your dataset.
4. Download your data as JSON, CSV, or Excel from the **Dataset** tab.

### Input example

```json
{
  "state": "NV",
  "commodity": "gold",
  "devStatus": "Producer",
  "maxResults": 500
}
````

### Output example

```json
{
  "depId": "10009306",
  "siteName": "Horse Mountain",
  "latitude": 39.69999,
  "longitude": -106.20061,
  "country": "United States",
  "state": "Colorado",
  "county": "Eagle",
  "commodityType": "M",
  "commodity1": "Uranium",
  "commodity2": "",
  "commodity3": "",
  "devStatus": "Occurrence",
  "operationType": "Unknown",
  "depositType": "",
  "productionSize": "N",
  "ore": "",
  "gangue": "",
  "discoveryYear": "",
  "firstProductionYear": "",
  "lastProductionYear": "",
  "mrdsId": "D002208",
  "url": "https://mrdata.usgs.gov/mrds/show-mrds.php?dep_id=10009306"
}
```

### Pricing

This Actor downloads the full ~25 MB MRDS dataset and filters it locally — a single run costs approximately **$0.003–$0.005** depending on the number of results.

| Run type | Estimated cost |
|----------|---------------|
| Filtered run (state + commodity, ~500 results) | ~$0.003 |
| Full 300k+ export | ~$0.005 |

### FAQ

**Is the MRDS database kept up to date?**
USGS updates the MRDS periodically. Each run fetches the latest official download directly from USGS servers, so your data always reflects the current state of the database.

**Can I filter by multiple commodities?**
The `commodity` filter does a partial-text match against all three commodity columns simultaneously. Enter `gold` to match any deposit where gold appears in any commodity field. For multiple commodities, run the Actor twice and merge the datasets.

**Does this work outside the United States?**
Yes. MRDS contains global deposits. Leave the `state` filter blank to include all countries. Set `maxResults: 0` to export the complete international dataset.

**Why does an empty run return 3,000 records by default?**
With 300,000+ records, an unlimited run can take several minutes. The 3,000-record default delivers a fast, representative preview. Set `maxResults: 0` to retrieve the full dataset when you're ready.

**What does `commodityType` M or N mean?**
`M` = Metallic deposit (gold, silver, copper, etc.), `N` = Non-metallic deposit (phosphate, silica, potash, etc.).

### Other scrapers by SeatSignal

- [USGS Earthquake Hazards Scraper](https://apify.com/seatsignal) — seismic event data from USGS feeds
- [EPA ECHO Compliance Scraper](https://apify.com/seatsignal) — Clean Air Act and Clean Water Act violations
- [USASpending Federal Awards Scraper](https://apify.com/seatsignal) — federal grants and contracts data

### Legal disclaimer

This Actor accesses only publicly available, non-personal data from the USGS Mineral Resources Data System — a US federal government open-data resource in the public domain. No authentication is bypassed. Use responsibly and in accordance with all applicable laws. The Actor operator is not affiliated with USGS or the Department of the Interior. For support, contact the developer via the Apify Store listing.

# Actor input Schema

## `state` (type: `string`):

Filter by US state using the 2-letter postal code (e.g. NV, AK, AZ). Leave blank to include all states and countries.

## `commodity` (type: `string`):

Partial match on the primary or secondary commodity field (e.g. 'gold', 'copper', 'lithium', 'uranium'). Case-insensitive. Leave blank to include all commodities.

## `devStatus` (type: `string`):

Partial match on development status (e.g. 'Producer', 'Past Producer', 'Occurrence', 'Prospect'). Leave blank to include all statuses.

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

Maximum number of records to return. Default is 3000. Set to 0 to return all matching records (may be 300,000+, takes longer).

## Actor input object example

```json
{
  "state": "",
  "commodity": "",
  "devStatus": "",
  "maxResults": 3000
}
```

# 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("compute-edge/usgs-mrds-mineral-resources-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("compute-edge/usgs-mrds-mineral-resources-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 compute-edge/usgs-mrds-mineral-resources-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/usgs-mrds-mineral-resources-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Mineral Resources (MRDS) Data Scraper",
        "description": "Extract 300,000+ U.S. mine and mineral deposit records from USGS MRDS. Filter by state, commodity (gold, copper, uranium), and development status. Ideal for mining exploration and industrial research.",
        "version": "0.1",
        "x-build-id": "6UgviAXZgi32pmSVT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~usgs-mrds-mineral-resources-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-usgs-mrds-mineral-resources-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/compute-edge~usgs-mrds-mineral-resources-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-usgs-mrds-mineral-resources-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/compute-edge~usgs-mrds-mineral-resources-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-usgs-mrds-mineral-resources-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",
                "properties": {
                    "state": {
                        "title": "State (2-letter code)",
                        "type": "string",
                        "description": "Filter by US state using the 2-letter postal code (e.g. NV, AK, AZ). Leave blank to include all states and countries.",
                        "default": ""
                    },
                    "commodity": {
                        "title": "Commodity",
                        "type": "string",
                        "description": "Partial match on the primary or secondary commodity field (e.g. 'gold', 'copper', 'lithium', 'uranium'). Case-insensitive. Leave blank to include all commodities.",
                        "default": ""
                    },
                    "devStatus": {
                        "title": "Development Status",
                        "type": "string",
                        "description": "Partial match on development status (e.g. 'Producer', 'Past Producer', 'Occurrence', 'Prospect'). Leave blank to include all statuses.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of records to return. Default is 3000. Set to 0 to return all matching records (may be 300,000+, takes longer).",
                        "default": 3000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
