Access Neodymium (ND) Daily Historical Prices using this API

Building a reliable daily history for neodymium (ND) prices is a practical requirement for several workflows: backfilling quant models, refreshing dashboards in manufacturing ERPs, normalizing supplier quotes, and benchmarking long-term contracts in EV motors, wind turbines, and advanced alloys. This article shows how to access neodymium daily historical prices using the same techniques Metals-API users apply across precious and industrial metals—focusing on the Time-Series and Historical endpoints—so you can integrate ND data into your pricing engines, analytics notebooks, and product pipelines with confidence.

Why daily ND history matters for your stack

Neodymium powers modern electrification—from high-strength NdFeB permanent magnets in EV drivetrains and wind turbines to lightweight audio transducers. For developers and product teams, daily historical neodymium price data supports:

Automated pricing: peg SKU prices to indexed ND values and refresh nightly.
Risk and sensitivity analysis: quantify cost exposure across BOMs and hedging strategies.
Backtesting: evaluate sourcing and inventory policies against multi-year price regimes.
Portfolio analytics: correlate ND with other industrial metals and macro factors.
Procurement governance: benchmark supplier quotes versus reference rates.

With Metals-API, you can fetch real-time rates (for supported symbols), query single-day historical prices, and retrieve multi-day series for charting and statistics—all via a simple JSON REST API. Before implementing, confirm symbol support for ND in the Metals-API Supported Symbols list. If your plan supports ND, the same endpoints used for precious and base metals will apply to neodymium as well. If you’re just getting started, create your free key on the Metals-API Website.

Core implementation pattern for neodymium historical prices

This section outlines the practical path most teams take to stand up ND history:

Confirm symbol and unit conventions in the symbols directory.
Request daily historical data using the Time-Series endpoint for your desired date range (or the single-day Historical endpoint when backfilling specific dates).
Normalize units and store canonical values (e.g., USD per metric ton vs USD per troy ounce) according to your analytics standards.
Cache responses and schedule updates to reduce network load and ensure consistency across services.
Use the Fluctuation or OHLC endpoints for digest summaries or candle charts when needed.

Authentication, base currency, symbols, and units—what to check first

API key: Include your key with the access_key parameter in each request. If you don’t have one yet, you can sign up for a free Metals-API key here.
Base currency: By default, responses are relative to USD, as shown in the examples below.
Units: Examples indicate “per troy ounce.” For industrial metals and your business logic, you may wish to convert to grams, kilograms, or metric tons. 1 troy ounce = 31.1034768 grams. Always store the unit with your values.
Symbol support: Validate ND appears on the supported symbols list. If ND is not available on your plan or region, consider mapping to alternative reference series or contact support for symbol availability.

Fetch daily neodymium history with a single call

If ND is supported in your plan, you can fetch a date range with the Time-Series endpoint and filter the symbol you need for each day.

Example: cURL request for a daily historical window

The following request demonstrates the Time-Series endpoint. Replace YOUR_KEY with your access key, pick start_date and end_date, and select the base currency as needed. If ND is supported, include it among the symbols you process in your application layer.

curl -G https://metals-api.com/api/timeseries \
--data-urlencode "access_key=YOUR_KEY" \
--data-urlencode "base=USD" \
--data-urlencode "start_date=2026-09-09" \
--data-urlencode "end_date=2026-09-16"

A typical JSON response structure for the Time-Series endpoint (example metals shown):

{
"success": true,
"timeseries": true,
"start_date": "2026-09-09",
"end_date": "2026-09-16",
"base": "USD",
"rates": {
"2026-09-09": {
"XAU": 0.000485,
"XAG": 0.03825,
"XPT": 0.000915
},
"2026-09-11": {
"XAU": 0.000483,
"XAG": 0.0382,
"XPT": 0.000913
},
"2026-09-16": {
"XAU": 0.000482,
"XAG": 0.03815,
"XPT": 0.000912
}
},
"unit": "per troy ounce"
}

Interpretation for ND use case:

success: Indicates whether the query executed correctly.
timeseries: Confirms this is a multi-day response.
start_date, end_date: Echo your query bounds; useful for auditing and caching keys.
base: USD by default. If you require pricing in EUR, GBP, or JPY, adjust the base accordingly where supported.
rates: A map of ISO dates to a per-day object of symbol-to-rate fields. Each rate is “base per unit” of metal, expressed as unit (here per troy ounce).
unit: The metal quantity unit. Convert before aggregations if your analytics assume kg, lb, or metric ton.

When ND is supported in your plan and symbol set, you should see an “ND” (or the relevant symbol from the symbols directory) rate per day. Store the date, symbol, rate, base, and unit to keep lineage and ensure reproducibility.

JavaScript example: Transform and store neodymium series

This minimal client demonstrates fetching a series and normalizing the daily ND observation into metric grams for analytics. Adapt the transformation only after verifying the unit returned by your plan.

<script>
// Fetch time-series data and extract ND into grams
async function fetchNeodymiumSeries(startDate, endDate) {
const url = new URL('https://metals-api.com/api/timeseries');
url.searchParams.set('access_key', 'YOUR_KEY');
url.searchParams.set('base', 'USD');
url.searchParams.set('start_date', startDate);
url.searchParams.set('end_date', endDate);

const res = await fetch(url.toString(), { method: 'GET' });
if (!res.ok) throw new Error('Network error: ' + res.status);
const data = await res.json();

// Example response shape reference:
// {
// "success": true,
// "timeseries": true,
// "start_date": "...",
// "end_date": "...",
// "base": "USD",
// "rates": { "YYYY-MM-DD": { "ND": <rate>, ... }, ... },
// "unit": "per troy ounce"
// }

if (!data.success) throw new Error('API indicated failure');

const troyOunceToGram = 31.1034768;
const base = data.base || 'USD';
const unit = data.unit || 'per troy ounce';

// Validate unit before converting; if not "per troy ounce", adjust the factor accordingly.
if (unit !== 'per troy ounce') {
console.warn('Unexpected unit:', unit);
}

const out = [];
for (const [date, symbols] of Object.entries(data.rates || {})) {
if (!symbols) continue;
const nd = symbols['ND']; // Requires ND support in your plan/symbols list
if (typeof nd === 'number') {
// nd is USD per troy ounce; convert to USD per gram for analytics
const usdPerGram = nd / troyOunceToGram;
out.push({ date, base, symbol: 'ND', usdPerOunce: nd, usdPerGram });
}
}
return out;
}

fetchNeodymiumSeries('2026-09-09', '2026-09-16')
.then(series => console.log('ND series:', series))
.catch(err => console.error(err));
</script>

Fields you will use:

rates[date][ND]: The ND rate for that date in base currency per unit.
unit: Apply unit-aware transformations before joining with BOMs or feeding ML models.
base: Keep the base to avoid cross-currency confusion in multi-region pricing.

For endpoint parameters and behavior, refer to the Metals-API Documentation. Always confirm ND symbol availability in the Metals-API Supported Symbols directory.

Single-day backfill for neodymium

When you need a specific day—e.g., to reconcile an invoice or correct a missing point in your DB—use the Historical endpoint by appending a date (YYYY-MM-DD). The response shape mirrors other endpoints, making ETL straightforward.

{
"success": true,
"timestamp": 1789433246,
"base": "USD",
"date": "2026-09-15",
"rates": {
"XAU": 0.000485,
"XAG": 0.03825,
"XPT": 0.000915
},
"unit": "per troy ounce"
}

Replace the example metals with ND when supported. Mapping guidelines:

date: The effective market date for the rate.
timestamp: Useful for time-based caching keys and ordering; treat as a Unix epoch in seconds.
rates.ND: The price expressed as base per unit.
unit: Convert before join operations if your analytics assume non-troy units.

Tracking short-term neodymium changes

Operations and procurement care about movers and volatility. Metals-API provides two patterns that translate well to ND workflows: Fluctuation and OHLC. These are especially helpful for alerting, dashboards, and position-sizing logic.

Day-over-day deltas for alerting using Fluctuation

{
"success": true,
"fluctuation": true,
"start_date": "2026-09-09",
"end_date": "2026-09-16",
"base": "USD",
"rates": {
"XAU": {
"start_rate": 0.000485,
"end_rate": 0.000482,
"change": -3.0e-6,
"change_pct": -0.62
},
"XAG": {
"start_rate": 0.03825,
"end_rate": 0.03815,
"change": -0.0001,
"change_pct": -0.26
},
"XPT": {
"start_rate": 0.000915,
"end_rate": 0.000912,
"change": -3.0e-6,
"change_pct": -0.33
}
},
"unit": "per troy ounce"
}

Interpretation for ND:

rates.ND.start_rate and end_rate: Bookend rates for the chosen window.
change and change_pct: Use these for threshold-based alerts (“Notify me if ND moves more than ±2%”).
unit: Same unit conventions apply; store along with change_pct for transparency.

OHLC for candle charts and execution logic

{
"success": true,
"timestamp": 1789519646,
"base": "USD",
"date": "2026-09-16",
"rates": {
"XAU": {
"open": 0.000485,
"high": 0.000487,
"low": 0.000481,
"close": 0.000482
},
"XAG": {
"open": 0.03825,
"high": 0.0383,
"low": 0.0381,
"close": 0.03815
},
"XPT": {
"open": 0.000915,
"high": 0.000918,
"low": 0.00091,
"close": 0.000912
}
},
"unit": "per troy ounce"
}

For ND, these fields plug directly into candlestick components and simple rule-based signals. Keep in mind the timestamp and date are important for alignment with market sessions and your internal calendars.

Real-time and intraday considerations for ND

Depending on your plan, the Latest, Intraday, and Bid/Ask endpoints provide up-to-date snapshots for supported symbols. These are helpful when combining live views with daily history.

Latest example

{
"success": true,
"timestamp": 1789519646,
"base": "USD",
"date": "2026-09-16",
"rates": {
"XAU": 0.000482,
"XAG": 0.03815,
"XPT": 0.000912,
"XPD": 0.000744,
"XCU": 0.294118,
"XAL": 0.434783,
"XNI": 0.142857,
"XZN": 0.344828
},
"unit": "per troy ounce"
}

For ND users, this endpoint is appropriate for live dashboards or for seeding today’s provisional price before end-of-day close. Respect the update interval of your plan (e.g., every 60 or 10 minutes) and cache coherently across services.

Intraday snapshots

The Intraday endpoint allows you to query intraday exchange rate data for a single symbol where supported. For ND, validate the symbol’s eligibility in your plan. Use intraday data to compute micro-trends or to provide tighter SLAs for e-commerce repricing.

Bid/Ask spreads for execution-aware analytics

{
"success": true,
"timestamp": 1789519646,
"base": "USD",
"date": "2026-09-16",
"rates": {
"XAU": {
"bid": 0.000481,
"ask": 0.000483,
"spread": 2.0e-6
},
"XAG": {
"bid": 0.0381,
"ask": 0.0382,
"spread": 0.0001
},
"XPT": {
"bid": 0.000911,
"ask": 0.000913,
"spread": 2.0e-6
}
},
"unit": "per troy ounce"
}

In ND workflows, bid/ask can frame real-world executable ranges for procurement quotes, helping teams distinguish between indicative mid and plausible transaction bounds.

Currency conversion and multi-currency neodymium pricing

If your BOMs, ledgers, or supply contracts live in EUR, GBP, or JPY, the Convert endpoint helps translate ND notional amounts between currencies (and, where applicable, between metal and currency). Validate symbol support and confirm your plan’s conversion capabilities.

{
"success": true,
"query": {
"from": "USD",
"to": "XAU",
"amount": 1000
},
"info": {
"timestamp": 1789519646,
"rate": 0.000482
},
"result": 0.482,
"unit": "troy ounces"
}

For ND-specific conversions, you’ll follow a similar pattern. Store the rate, base, and unit so downstream systems can reconcile amounts precisely. If you maintain multi-entity accounting, apply a single source of truth for FX to avoid FX drift across services.

Lowest/highest and volatility-aware ND reporting

Use the Lowest/Highest Price endpoint to quickly summarize a period’s extremes. For procurement scorecards and monthly operations reviews, this provides context at a glance without precomputing min/max in your DB. Combine with Fluctuation to quantify amplitude and directional bias.

How to design a robust ND historical price pipeline

Recommended architecture

Scheduler: Nightly job triggers Time-Series for [T-7, T] rolling window and persists to your data store.
Storage: Normalize to a canonical table keyed by (date, symbol, base, unit) with numeric rate fields. Keep an index on date and symbol.
Validation: Compare new data against prior day’s close with tolerance thresholds (e.g., ±10% for anomaly flags depending on your risk model).
Transformation: Convert “per troy ounce” to grams or metric tons as needed; record the conversion factor version to ensure auditability.
Cache: Maintain a short TTL cache for live views using the Latest or Intraday data to reduce request volume.

Data hygiene and unit safety

Always read and store the unit field (“per troy ounce”) alongside each rate.
Convert once, consistently, and annotate your conversions with the factor used (e.g., 31.1034768 g/oz t).
For long-term storage, consider preserving the original rate plus your normalized value to future-proof reprocessing.

Timezone and calendars

date fields in responses are ISO dates; align them to your reporting timezone (UTC recommended) and to your market calendar.
Weekends/holidays: Expect flat or missing updates depending on market conditions and the endpoint. Your ETL should handle no-change days gracefully.
When computing returns or volatility, match business-day calendars to avoid distortions.

Caching strategies to cut requests by 70–90%

Use EOD caching: Fetch at a fixed nightly time; seed provisional intraday values for dashboards and reconcile at close.
Key caches by endpoint + normalized query string (including base, start_date, end_date).
Persist daily snapshots in your DB so repeated dashboard loads don’t trigger network calls.

Performance and scaling tips for ND workloads

Batch ranges: Prefer Time-Series over multiple single-day calls when backfilling weekly/monthly windows.
Sparse symbol extraction: Even if you receive multiple metals in one response, extract and store only ND plus any benchmarks you need.
Numeric precision: Use decimal or 64-bit floating point consistently; store rates and converted values with fixed precision in your DB schema.
Parallelism: If running multiple symbols or date windows, respect your plan’s request limits and backoff guidelines; fan-out with bounded concurrency.

Security and governance

Key management: Keep the access_key in secret stores or environment variables; never commit to source control.
Transport: Use HTTPS for all calls.
Service isolation: Proxy outbound requests through a controlled service with request signing or IP allowlists if needed.
Audit trails: Log the date, request parameters, response timestamp, and checksums of the payload for reproducibility.

Error handling and resilience

Network failures: Implement retries with exponential backoff and jitter. Cache the last known good value for read-only dashboards.
Empty/missing symbols: If ND is not present for a date, fill forward only if your governance allows; otherwise flag for review.
Schema checks: Validate presence of success, base, unit, and expected date keys before processing.
Alerting: Notify when daily ND updates fail, or when change_pct exceeds configured thresholds.

Advanced analytics patterns with ND history

Cross-metal correlations: Compute rolling correlations between ND and copper/aluminum to inform substitution and hedging.
Regime detection: Identify volatility regimes using Fluctuation or OHLC-derived features.
Cost-to-serve: Tie ND price history to BOM consumption to derive margin sensitivity analytics for each SKU.
Forecast calibration: Use historical data as training targets for ML models that incorporate macro factors.

Operational walkthrough: From supplier quote to posted price

Receive supplier quote for ND-based component.
Pull last 30 days via Time-Series; compute median and 5th/95th percentile to contextualize the quote.
Convert USD per troy ounce to USD per kilogram for BOM comparability.
Apply company markup and logistics costs; generate a recommended sales price range.
Publish to ERP; record the versioned data references (date, unit, source).

Endpoints in practice: what you’ll actually use day to day

Time-Series (primary for daily ND history)

Why you’ll use it: It returns per-day rates for a date window, perfect for backfills and rolling updates.

Typical usage pattern: Nightly job for [T-7, T] window, store ND in your data warehouse.

Example response shape (reference):

{
"success": true,
"timeseries": true,
"start_date": "2026-09-09",
"end_date": "2026-09-16",
"base": "USD",
"rates": {
"2026-09-09": { "XAU": 0.000485, "XAG": 0.03825, "XPT": 0.000915 },
"2026-09-11": { "XAU": 0.000483, "XAG": 0.0382, "XPT": 0.000913 },
"2026-09-16": { "XAU": 0.000482, "XAG": 0.03815, "XPT": 0.000912 }
},
"unit": "per troy ounce"
}

Pro tips:

Respect date limits per plan.
Don’t assume continuous market days; gaps can occur on weekends/holidays.
Persist raw and normalized values.

Historical (single date drill-down)

Use for corrections, audits, or spot checks. Response shape mirrors Latest with a single date. See the single-day JSON above.

Latest (front-end visualizations)

For dashboards needing a current snapshot. Cache aggressively; the update cadence depends on plan tier.

Fluctuation (alerting and scorecards)

Perfect for “what moved” summaries across a basket of metals, including ND when supported.

OHLC (charting and model features)

Drive candlesticks, compute true ranges, and derive volatility features for tactical decisions.

Bid/Ask (execution realism)

Use to simulate buy/sell ranges and evaluate supplier quotes versus executable spreads.

Convert (multi-currency portfolios)

Unify pricing in your accounting currency and ensure consistent FX handling across microservices.

Practical considerations developers often miss

Units are everything: Don’t mix troy ounces with grams. Normalize immediately.
Base confusion: Label the base in your table schema; never assume USD downstream.
Weekend logic: Charts that auto-resample to business days look cleaner and avoid false gaps.
Caching discipline: Set well-defined TTLs; coordinate across services to avoid thundering herds at market close.

Digital transformation in the ND market stack

As neodymium demand scales with electrification and smart technology, developers are modernizing commodity pipelines. Metals-API’s REST design, consistent schemas, and integration-ready endpoints simplify API-first architectures: streaming dashboards, serverless ETL, notebook-driven research, and ML pipelines. The result is faster iteration, reproducible analytics, and tighter feedback loops between procurement, engineering, and finance.

To start building, review the Metals-API Documentation and verify ND in the symbols directory. For broader market context, explore the London Metal Exchange resources and the USGS Minerals Information Center for supply/demand insights.

Data quality, validation, and reconciliation playbook

Cross-check: Periodically compare your ND time series against alternative references or supplier indexes to detect anomalies.
Trend sanity: Use Fluctuation to ensure consecutive days behave within reasonable bounds; flag outliers for review.
Reconciliation runs: Weekly jobs can recompute 7-day aggregates (min, max, average) and compare to primary stores for drift detection.
Versioning: Tag stored observations with API timestamp and retrieval time to reconstruct historical states.

End-to-end example: building a daily ND index for a manufacturing ERP

Symbol check: Confirm ND is available via the Supported Symbols page.
ETL: Nightly Time-Series for [T-7, T]. Extract ND, convert to USD/kg, write to ERP’s pricing table.
Reporting: A scheduled report computes 30D moving averages and volatility; a panel shows Lowest/Highest for the month.
Alerts: Fluctuation job posts Slack alerts for >2% daily changes in ND.
Audit: Store raw JSON payload checksums and units to satisfy internal audit and vendor compliance.

Troubleshooting ND historical integrations

ND not appearing in rates: Re-verify symbol support; check plan entitlements; ensure you’re using the correct symbol case.
Unexpected unit: Confirm the unit in the response; adjust your conversion logic accordingly.
Missing days: Confirm market calendars; for charts, resample to business days and mark gaps explicitly.
Rate drift in dashboards: Ensure all services share the same cache layer and TTL; pin to EOD updates for consistency.
FX mismatches: If joining with external FX sources, prefer Metals-API’s base handling or centralize FX conversions in one service.

Governance checklist for production rollout

Secrets: access_key loaded from env/secret store; rotation policy documented.
Observability: metrics for request count, latency, error rate, and cache hit ratio.
SLOs: define freshness (e.g., rates available by 00:30 UTC) and uptime targets.
Backfills: pre-load at least 12–24 months of ND history for analytics baselines where available.

Conclusion: from idea to production-grade ND data flows

Accessing neodymium daily historical prices is straightforward with Metals-API’s consistent JSON schema and production-ready endpoints. The essential loop is simple: confirm ND symbol support, fetch historical windows via Time-Series (or single dates via Historical), normalize units, cache aggressively, and wire alerts/visualizations with Fluctuation and OHLC fields. With clean ND history in your stack, you can power accurate pricing, resilient procurement, and data-driven product decisions beyond spreadsheets and manual updates. Get your key on the Metals-API Website and start integrating today; the full parameter and field details are in the Metals-API Documentation.

FAQ

How do I confirm that neodymium (ND) is supported?

Check the Metals-API Supported Symbols page. If ND is listed and included in your plan, you can query it just like other metals shown in the examples.

What unit are ND prices returned in?

Responses include a unit field (e.g., “per troy ounce”). Convert to grams, kilograms, or metric tons if your analytics require it. 1 troy ounce = 31.1034768 grams.

Which endpoint should I use for daily ND history?

Use the Time-Series endpoint for windows (e.g., last 30 days) and the Historical endpoint for single-day backfills. For dashboards, you can seed with Latest and reconcile at end of day.

How do I handle weekends and holidays?

Expect fewer or no updates on non-trading days. Use business-day calendars for charts and analytics, and avoid interpreting lack of change over weekends as a signal.

How can I reduce request volume?

Cache nightly snapshots in your DB; use shared caches with TTLs for live views; batch ranges via Time-Series instead of multiple single-day requests.

Can I get OHLC or Bid/Ask for ND?

Where supported for your plan and symbol set, you can request OHLC and Bid/Ask. Always verify availability in the documentation and symbols list.

Is it possible to price my BOMs in EUR while storing USD history?

Yes. Store canonical USD history and convert to EUR for presentation using the Convert endpoint or by setting the base appropriately. Keep base and unit in your schemas.

Where can I learn more?

Start with the Metals-API Documentation and verify symbols on the symbols list. For market context, see the LME and the USGS Minerals Information Center. To get started right away, request your key on the Metals-API Website.

Ready to use Metals-API?

Try it now!