# Metal Prices Scraper (`parseforge/metalprices-com-scraper`) Actor

Scrape daily metal commodity prices from 23 metals including gold, silver, copper, aluminum, and platinum. Get current prices or historical data back to 2000 in 65+ currencies. Supports 6 measurement units. Export weekly price trends for market analysis.

- **URL**: https://apify.com/parseforge/metalprices-com-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## Metal Prices Scraper

Collect current and historical metal commodity prices from DailyMetalPrice.com without coding. This scraper extracts prices for 23 metals including gold, silver, copper, platinum, palladium, and more in 65+ currencies, making it perfect for commodity traders tracking price movements, analysts building pricing models, or researchers studying metal market trends.

> **The Metal Prices Scraper collects commodity prices with up to 7 data fields per record, including historical data back to 2000, multi-currency support, and flexible unit conversion.**

### What Does It Do

- **Gold & Silver** - Track precious metal spot prices across multiple currencies and units
- **Copper & Aluminum** - Monitor base metal prices for manufacturing cost analysis
- **Platinum Group** - Collect palladium, platinum, rhodium, ruthenium, and iridium prices
- **Rare Metals** - Get pricing data for lithium, cobalt, gallium, indium, and neodymium
- **Historical Data** - Access price history going back to 2000 for trend analysis
- **65+ Currencies** - Convert prices to USD, EUR, GBP, JPY, CNY, and many more
- **Multiple Units** - Choose from pounds, troy ounces, grams, kilograms, or metric tons
- **All Metals Today** - Fetch current prices for all 23 metals in a single run

### Input

- **Mode** - Choose "history" for single metal time series or "currentAll" for all metals today
- **Metal** - Select from 23 metals (gold, silver, copper, platinum, etc.)
- **Currency** - Currency code for prices (USD, EUR, GBP, JPY, etc.)
- **Unit** - Price unit (lb, troy ounce, oz, gram, kg, metric ton)
- **Period** - Days of historical data (5 to 2400 days, or all history)
- **Max Items** - How many price records to collect per run

Example input:
```json
{
  "mode": "history",
  "metalCode": "au",
  "currency": "USD",
  "unit": "oz",
  "period": 30,
  "maxItems": 10
}
````

### Output

Each price record includes up to 7 data fields. Download as JSON, CSV, or Excel.

| Metal Name | Metal Code | Price |
|---|---|---|
| Unit | Date | Currency |
| Scraped At | Error (if any) | |

### Why Choose the Metal Prices Scraper?

| Feature | Our Actor |
|---|---|
| Fast API-based extraction (no browser needed) | Yes |
| 23 metals including precious, base, and rare metals | Yes |
| Historical data back to 2000 | Yes |
| 65+ currency conversions (USD, EUR, GBP, JPY, etc.) | Yes |
| Multiple unit options (oz, lb, g, kg, ton) | Yes |
| Two modes: all metals today or single metal history | Yes |
| CSV, Excel, and JSON export | Yes |
| Automatic retry logic with exponential backoff | Yes |
| Support for large-scale collection (1 million+ items) | Yes |

### How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up** - [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool** - Search for "Metal Prices Scraper" in the Apify Store and select your metal and options
3. **Run It** - Click "Start" and watch your results appear

That's it. No coding, no setup needed. Export your data in CSV, Excel, or JSON format.

### Business Use Cases

- **Commodity Trader** - Track daily gold, silver, and platinum prices across currencies to identify arbitrage opportunities and time market entries
- **Supply Chain Manager** - Monitor copper, aluminum, and steel prices weekly to forecast raw material costs and adjust procurement strategies
- **Financial Analyst** - Collect historical price data for precious and base metals to build regression models and publish market outlook reports

### FAQ

**How does this scraper work?**
The scraper fetches price data from DailyMetalPrice.com using HTTP requests with browser-grade headers. No browser or proxy needed. Pure API access for fast and reliable results.

**What metals are supported?**
All 23 metals: Aluminum, Cobalt, Copper, Gallium, Gold, Indium, Iridium, Iron Ore, Lead, Lithium, Molybdenum, Neodymium, Nickel, Palladium, Platinum, Rhodium, Ruthenium, Silver, Steel, Tellurium, Tin, Uranium, and Zinc.

**How far back does historical data go?**
Historical data goes back to approximately 2000 for most metals. Set the period to 0 (All history) to get all available data points.

**Can I get prices in my local currency?**
Yes. The scraper supports 65+ currencies including USD, EUR, GBP, JPY, CNY, AUD, CAD, CHF, INR, BRL, and many more. Just enter your currency code.

**Can I schedule this to run automatically?**
Yes. Use the Apify scheduler to run this actor on a daily, weekly, or monthly basis. You can also integrate it with Make, Zapier, or GitHub Actions for automated price feed updates.

**Is scraping DailyMetalPrice.com allowed?**
DailyMetalPrice.com is a public website with freely accessible price data. You are collecting publicly visible data. Always review the site terms of service and ensure your use case complies with local laws and regulations.

**How long does a run take?**
A run collecting 30 days of gold prices takes a few seconds. Fetching all metals for today is similarly fast.

**Are there any limits?**
Free users get up to 10 items. Paid users can collect up to 1,000,000 results.

### Integrate Metal Prices Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### More ParseForge Actors

- [FRED Economic Data Scraper](https://apify.com/parseforge/fred-economic-data-scraper) - Collect Federal Reserve economic data series and indicators
- [YATCO Yacht Listing Scraper](https://apify.com/parseforge/yatco-scraper) - Extract yacht listings with prices and specifications
- [Copart Public Search Scraper](https://apify.com/parseforge/copart-public-search-scraper) - Search and collect vehicle auction listings
- [GSA eLibrary Scraper](https://apify.com/parseforge/gsa-elibrary-scraper) - Extract government contract data from GSA
- [PR Newswire Scraper](https://apify.com/parseforge/pr-newswire-scraper) - Collect press releases and corporate news

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by DailyMetalPrice.com or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

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

Choose scraping mode. 'history' fetches historical prices for a single metal. 'currentAll' fetches today's prices for all 23 metals.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `metalCode` (type: `string`):

Select the metal to scrape prices for (used in history mode).

## `currency` (type: `string`):

Currency code for prices (e.g. USD, EUR, GBP, JPY). Supports 65+ currencies.

## `unit` (type: `string`):

Price unit. Default depends on the metal (oz for precious metals, lb for base metals).

## `period` (type: `integer`):

Number of days of historical data (e.g. 30, 120, 480). Use 0 for all available history (back to ~2000). Only used in history mode.

## Actor input object example

```json
{
  "mode": "history",
  "maxItems": 10,
  "metalCode": "au",
  "currency": "USD",
  "unit": "oz",
  "period": 30
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset with all scraped items

# 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": "history",
    "maxItems": 10,
    "metalCode": "au",
    "currency": "USD",
    "unit": "oz",
    "period": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/metalprices-com-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": "history",
    "maxItems": 10,
    "metalCode": "au",
    "currency": "USD",
    "unit": "oz",
    "period": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/metalprices-com-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": "history",
  "maxItems": 10,
  "metalCode": "au",
  "currency": "USD",
  "unit": "oz",
  "period": 30
}' |
apify call parseforge/metalprices-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Metal Prices Scraper",
        "description": "Scrape daily metal commodity prices from 23 metals including gold, silver, copper, aluminum, and platinum. Get current prices or historical data back to 2000 in 65+ currencies. Supports 6 measurement units. Export weekly price trends for market analysis.",
        "version": "1.0",
        "x-build-id": "mMhLeknTYSjl9A7lX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~metalprices-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-metalprices-com-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/parseforge~metalprices-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-metalprices-com-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/parseforge~metalprices-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-metalprices-com-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "history",
                            "currentAll"
                        ],
                        "type": "string",
                        "description": "Choose scraping mode. 'history' fetches historical prices for a single metal. 'currentAll' fetches today's prices for all 23 metals."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "metalCode": {
                        "title": "Metal",
                        "enum": [
                            "al",
                            "co",
                            "cu",
                            "ga",
                            "au",
                            "in",
                            "ir",
                            "fe",
                            "pb",
                            "li",
                            "mo",
                            "nd",
                            "ni",
                            "pd",
                            "pt",
                            "rh",
                            "ru",
                            "ag",
                            "st",
                            "te",
                            "sn",
                            "u",
                            "zn"
                        ],
                        "type": "string",
                        "description": "Select the metal to scrape prices for (used in history mode)."
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code for prices (e.g. USD, EUR, GBP, JPY). Supports 65+ currencies."
                    },
                    "unit": {
                        "title": "Unit",
                        "enum": [
                            "lb",
                            "t",
                            "oz",
                            "g",
                            "kg",
                            "ton"
                        ],
                        "type": "string",
                        "description": "Price unit. Default depends on the metal (oz for precious metals, lb for base metals)."
                    },
                    "period": {
                        "title": "Period (days)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Number of days of historical data (e.g. 30, 120, 480). Use 0 for all available history (back to ~2000). Only used in history mode."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
