Get Iridium (IRD) - Per Ounce Historical Prices using this API for 2026 time series analysis

Need Iridium (IRD) per‑ounce historical prices to run a 2026 time‑series analysis? This guide shows exactly how to pull daily Iridium data from the Metals-API Time-series and Historical endpoints, transform it into analytics‑ready series, and feed it into dashboards, risk engines, and pricing models. We will keep the focus tightly on Iridium and the specific workflow of backfilling 2026 candles and computing performance metrics—in other words, what you need for real product pricing, portfolio analytics, and research pipelines. Along the way, we’ll address subtle but critical implementation details like base currency normalization, troy ounce vs gram conversions, timestamp handling in UTC, caching to reduce request volume, and resilient error handling.

Why 2026 Iridium (IRD) time series? Practical use cases you can ship today

Iridium is a niche yet strategically important PGM metal used in high‑performance alloys, catalysts, electronics, and advanced manufacturing. If you’re building fintech or industrial applications, getting Iridium (IRD) price history right unlocks:

• 2026 backtesting and signal research: compute daily returns, rolling volatility, drawdowns, and correlation with other industrial commodities or portfolio factors.
• Smart procurement dashboards: track Iridium’s daily close to inform purchase timing and budget forecasts for critical components.
• Cost‑plus and dynamic pricing: reprice IRD‑linked SKUs daily using per‑ounce benchmarks or OHLC candles for volatility‑aware markups.
• Risk and exposure analytics: quantify sensitivity of product margins to Iridium fluctuations and set hedging triggers.

Below, we’ll implement an end‑to‑end flow with the Metals-API Time-series, Historical, and OHLC endpoints—focusing on IRD only—so you can ship a robust 2026 analysis stack.

About Iridium (IRD): data, digital transformation, and analytics‑ready context

Iridium is one of the densest and most corrosion‑resistant metals, prized for extreme‑environment applications—from spark plugs to crucibles for crystal growth in semiconductors. Historically illiquid spot markets and specialized supply chains meant less‑transparent pricing compared to gold or copper. That landscape is changing: APIs like Metals-API provide machine‑readable, per‑ounce pricing with consistent timestamps and standardized symbols, making it feasible to integrate IRD into the same pipelines you use for FX or precious metals.

For developers, that means you can:

• Instrument production systems with live Iridium prices using the same stack you use for other assets.
• Run systematic research and forecasting across 2026 and prior periods with reliable daily granularity.
• Apply smart technology integration—alerts, anomaly detection, ML signals—on top of normalized IRD time series.

For the latest symbol definitions and availability (including IRD), consult the Symbols page: Metals-API Supported Symbols. Always confirm symbol support in your plan and environment before deploying to production.

What we’ll build: a clean 2026 Iridium price history, ready for analysis

We will:

1. Fetch IRD daily per‑ounce prices across a 2026 date window with the Time-series endpoint.
2. Backfill any individual missing dates using the Historical endpoint.
3. Optionally retrieve OHLC candles for selected days to enrich trading metrics.
4. Normalize base currency, handle units (troy ounces), and compute common analytics.
5. Implement caching and robust error handling.

Before you begin, sign up for an API key at the Metals-API Website. Then keep the Metals-API Documentation open alongside this guide for reference on optional parameters and plan‑specific features.

Data conventions that matter (read this before you code)

• Base currency: By default, Metals-API returns rates relative to USD. The rate represents how many troy ounces of the metal one USD buys (i.e., “per USD” in troy ounces). Always confirm your base and interpret rates correctly when converting to price per ounce.
• Units: All metal rates are expressed per troy ounce by default. 1 troy ounce ≈ 31.1034768 grams. If you price per gram or kilogram, convert explicitly.
• Timestamps and timezones: The API date fields are calendar dates in UTC. Daily series are best treated as end‑of‑day UTC values.
• Weekends/closures: Some dates may be absent or unchanged due to non‑trading days or weekend schedules. Your pipeline should forward‑fill or skip gracefully.
• Symbols: Use IRD for Iridium. Validate symbol availability with the official symbols list prior to requesting data.

Endpoints used in this guide

We’ll use exactly these three endpoints for the 2026 analysis workflow:

• Time-series: Daily IRD rates between two dates in 2026.
• Historical: One specific date’s IRD rate (for backfill and spot checks).
• OHLC: Open/High/Low/Close for IRD on selected dates (for candlestick analytics).

For additional endpoints (Latest, Fluctuation, Bid/Ask, Convert, and more), see the Metals-API Documentation. Do not assume availability across all subscription tiers—always check the docs and your plan.

Authentication and request basics

• Access key: Supply your API key with the access_key parameter on every request.
• HTTPS: Use HTTPS endpoints for transport security.
• Query parameters: Keep them URL‑encoded and validated. Strings for dates should be YYYY-MM-DD in UTC.

If you haven’t yet, get your key now: Create a free Metals-API account and obtain your API key.

Time-series endpoint for 2026 IRD backfill

The Time-series endpoint returns daily historical rates between a start_date and end_date. For 2026 analysis, you might pull the entire year or partial windows for rolling computations.

Purpose and functionality

Use Time-series to retrieve a contiguous daily series of IRD per‑ounce rates between two 2026 dates. This is the backbone for analytics such as:

• Daily returns and log returns.
• Rolling volatility (e.g., 20‑day, 60‑day).
• Max drawdown in 2026.
• Feature engineering for forecasting models.

Key parameters

• access_key: Your API key.
• start_date: Inclusive start date (YYYY-MM-DD), e.g., 2026-01-01.
• end_date: Inclusive end date (YYYY-MM-DD), e.g., 2026-12-31.
• base: Optional, base currency (default USD). If omitted, interpret rates as “per USD” in troy ounces.
• symbols: Set to IRD to isolate Iridium.

Example: curl request to fetch daily IRD for January 2026

curl -s "https://metals-api.com/api/timeseries?access_key=YOUR_API_KEY&start_date=2026-01-01&end_date=2026-01-31&symbols=IRD"

Sample JSON response (illustrative values)

Note: Example payload below is for demonstration only and not actual market data.

{
"success": true,
"timeseries": true,
"start_date": "2026-01-01",
"end_date": "2026-01-31",
"base": "USD",
"rates": {
"2026-01-01": { "IRD": 0.0000123 },
"2026-01-02": { "IRD": 0.0000122 },
"2026-01-03": { "IRD": 0.0000122 },
"2026-01-04": { "IRD": 0.00001225 },
"2026-01-05": { "IRD": 0.00001228 }
/* ... more days through 2026-01-31 ... */
},
"unit": "per troy ounce"
}

Response fields you’ll actually use

• success: Boolean—check this before parsing.
• timeseries: Boolean—verifies this is a time-series response.
• start_date / end_date: Echo of your request; confirms the bounds used.
• base: Currency base. If “USD”, then IRD value is troy ounces per USD. To compute USD per troy ounce, invert it: price_per_ounce_usd = 1 / IRD.
• rates: Map of date strings to an object keyed by symbol (IRD). Each value is per‑ounce in relation to the base.
• unit: Typically “per troy ounce”. Use this to verify units before converting.

Compute USD per ounce from the API’s default base

Because the base is USD by default, rates are “troy ounces per USD.” Most dashboards require “USD per troy ounce.” Convert via reciprocal:

• USD_per_ounce = 1.0 / rate_per_usd
• USD_per_gram = USD_per_ounce / 31.1034768

JavaScript example: fetch 2026 Q1 IRD, convert to USD/oz, and calculate daily returns

async function fetchIridiumTimeseries() {
const url = "https://metals-api.com/api/timeseries" +
"?access_key=" + encodeURIComponent(process.env.METALS_API_KEY) +
"&start_date=2026-01-01&end_date=2026-03-31&symbols=IRD";
const res = await fetch(url, { method: "GET" });
if (!res.ok) throw new Error("HTTP " + res.status);
const data = await res.json();
if (!data.success) throw new Error("API error or invalid response");
const series = [];
const dates = Object.keys(data.rates).sort();
for (const d of dates) {
const perUsd = data.rates[d].IRD; // troy ounces per USD
if (typeof perUsd !== "number" || perUsd <= 0) continue;
const usdPerOunce = 1 / perUsd;
series.push({ date: d, usdPerOunce });
}
// compute simple daily returns
const enriched = series.map((pt, i) => {
if (i === 0) return { ...pt, ret: null };
const prev = series[i - 1].usdPerOunce;
const ret = (pt.usdPerOunce - prev) / prev;
return { ...pt, ret };
});
return enriched;
}

fetchIridiumTimeseries()
.then(s => console.log(s.slice(0, 5)))
.catch(err => console.error(err));

Performance and scaling

• Minimize window size: Request only the date range needed (e.g., 2026‑01‑01 to 2026‑12‑31) rather than multi‑year spans.
• Cache responses: Store raw JSON by (start_date, end_date, symbols, base) as cache key. Persist normalized arrays (USD/oz) in your DB to avoid re‑computations.
• Retry with backoff: Use exponential backoff for transient network issues. Avoid tight retry loops that risk exceeding quotas.
• Batching: For monthly or quarterly updates, fetch smaller chunks instead of a massive one‑shot if your environment or plan has per‑request constraints.

Common pitfalls and troubleshooting (Time-series)

• Misinterpreting base: If you see surprisingly small numbers, you’re likely reading “troy ounces per USD.” Invert to get USD/oz.
• Sparse weekends: Don’t expect a datapoint for every calendar date, depending on the market. Forward‑fill for charts if needed, but document your method.
• Missing IRD: If IRD isn’t returned, verify symbol support for your key at Supported Symbols and ensure symbols=IRD was specified.
• Data validation: Reject negative or zero rates.

Historical endpoint for single‑day IRD backfills in 2026

The Historical endpoint is ideal when you need one specific day—for example, to patch a missing record, validate a signal, or compute a point‑in‑time conversion.

Purpose and functionality

Request the IRD rate for a particular date (e.g., 2026‑06‑15). The API returns the per‑ounce rate using your base (USD by default) for that date only.

Key parameters

• access_key: Your API key.
• date: The specific day, YYYY-MM-DD (UTC).
• base: Optional base currency (default USD).
• symbols: IRD.

Example: curl request for a single 2026 date

curl -s "https://metals-api.com/api/2026-06-15?access_key=YOUR_API_KEY&symbols=IRD"

Sample JSON response (illustrative values)

Note: Example payload below is for demonstration only and not actual market data.

{
"success": true,
"timestamp": 1792214400,
"base": "USD",
"date": "2026-06-15",
"rates": {
"IRD": 0.0000118
},
"unit": "per troy ounce"
}

Response fields you’ll actually use

• date: Confirms the requested day in UTC.
• rates.IRD: Troy ounces per USD for IRD that day. Invert to get USD/oz.
• timestamp: Unix time (UTC) for when the rate was last updated or computed by the service.
• unit: Typically per troy ounce—verify before conversions.

Real‑world scenarios

• Point fixes: After a partial outage, patch “2026‑08‑03” only, then re‑compute derived metrics.
• Trade reconciliation: Validate that a given day’s price used in a pricing decision matches the historical API output.
• Compliance snapshots: Store the JSON alongside an execution record to comply with audit requirements.

Troubleshooting (Historical)

• 404 or success=false: Verify the date format, IRD symbol support, and that the date is within available history.
• Zero or missing rate: Sanity check and alert; consider retry or manual verification.

OHLC endpoint for IRD: Candles to enrich your 2026 research

While daily close is often enough, OHLC (Open/High/Low/Close) enhances analytics: intraday range, true range, breakout signals, and gap detection (across daily bars). We’ll fetch IRD OHLC for an example 2026 date.

Purpose and functionality

Retrieve open, high, low, and close values for IRD for a given date. Like other endpoints, units are per troy ounce relative to the base (USD by default), so interpret carefully and convert if needed.

Example: curl request for OHLC on a 2026 date

curl -s "https://metals-api.com/api/open-high-low-close/2026-09-17?access_key=YOUR_API_KEY&symbols=IRD"

Sample JSON response (illustrative values)

Note: Example payload below is for demonstration only and not actual market data.

{
"success": true,
"timestamp": 1790000000,
"base": "USD",
"date": "2026-09-17",
"rates": {
"IRD": {
"open": 0.0000119,
"high": 0.0000121,
"low": 0.0000117,
"close": 0.0000118
}
},
"unit": "per troy ounce"
}

Using OHLC in practice

• Convert each field to USD/oz by inversion, then compute daily range (high‑low), average true range, and gap analysis (compare today’s open vs. prior close).
• Risk sizing: Use ATR‑based position sizing or procurement thresholding if your strategy relies on range estimates.
• Visualization: Build candlestick charts for internal dashboards.

Common pitfalls and checks (OHLC)

• Per‑USD vs USD‑per‑ounce: Consistently invert all four fields before computing derived analytics in USD/oz.
• Edge cases: If high=low or open=close, ensure no downstream divisions by zero; verify with a retry if unusual patterns persist.
• Missing days: If OHLC for a given date isn’t available, fall back to the daily close from Time-series.

Field‑level breakdown: What to store and how to query it efficiently

• Primary key: date (UTC) + symbol (IRD) + base (USD) + source (endpoint). Keeping the endpoint tag helps with lineage (e.g., “TS” for Time-series, “HIST” for Historical, “OHLC” for candles).
• Raw values: Persist the original per‑USD troy ounce rates (as returned) and a normalized USD/oz field. Keep both for auditability.
• Metadata: Save timestamp and unit exactly as returned. Units protect you against accidental schema drift.
• Quality flags: Add columns like is_weekend, is_holiday (if you load a holiday calendar), is_backfilled, obtained_at (ingestion time), source_status.

Currency and unit normalization for IRD

Most product teams need USD per troy ounce; some need grams or local currency. Here’s a canonical normalization flow:

1. Read base (default USD). If base=USD and rate=r (troy ounces per USD), compute USD_per_oz = 1 / r.
2. If you need grams: USD_per_g = USD_per_oz / 31.1034768.
3. If you need a different currency (e.g., EUR), combine with a currency rate (e.g., USD→EUR) to convert USD_per_oz to EUR_per_oz. Use Metals-API conversion features if included in your plan; otherwise use a separate FX feed and document the source.

Document this pipeline prominently in your codebase. Unit confusion is the most common source of mispricing in commodity integrations.

Caching, versioning, and idempotency

• Cache raw JSON for each unique parameter set. For Time-series, cache monthly chunks (e.g., 2026‑01‑01..2026‑01‑31) to accelerate re‑runs.
• Immutable history: Historical daily values are stable. Cache aggressively and use long TTLs; invalidate only when you rotate keys or change normalization code.
• Idempotent loaders: Ensure your backfill job can be re‑run safely by replacing the canonical record for a given (date, symbol) key.
• Digest columns: Store a checksum of raw JSON; skip processing if unchanged.

Error handling and resilience

• Check success flag and HTTP status. If success=false or non‑2xx, log, alert if needed, and retry with backoff.
• Graceful degradation: If OHLC is unavailable for a day, fall back to Time-series daily close. If Time-series misses a day, try Historical for that specific date.
• Input validation: Date strings must be YYYY-MM-DD. Reject or sanitize bad inputs early.
• Zero/negative guardrails: Immediately quarantine records with non‑positive rates.

Security best practices

• Store access_key as a secret in your vault or environment variables; never commit keys to source control.
• Restrict egress: Allowlist the Metals-API host in outbound firewall rules if your infrastructure supports it.
• TLS only: Use HTTPS exclusively. Validate certificates via your platform’s defaults.
• Least privilege: If you proxy requests, ensure internal roles have minimum network access.

Data completeness and weekend behavior for IRD

Depending on Iridium’s market calendar, you may see unchanged or absent daily values on weekends or holidays. When building charts:

• Forward‑fill for visualization only (don’t mix forward‑filled values into performance calculations without flags).
• Compute returns over trading days only, or handle multi‑day gaps by compounding over the elapsed gap.
• Mark non‑trading days in your dataset to maintain transparency.

Upgrading analytics: derived metrics on IRD for 2026

• Daily return: r_t = (P_t / P_{t-1}) − 1.
• Log return: ln(P_t) − ln(P_{t-1}) for more stable aggregation.
• Rolling volatility: stdev of daily returns over N days, annualized if required.
• Drawdown: Track running peak and compute P_t / peak − 1.
• Range metrics (with OHLC): true range = max(high−low, |high−prev_close|, |low−prev_close|).

Integration architecture: from API call to dashboard

1. Ingest layer: A scheduled job calls Time-series monthly for IRD in 2026, caches JSON, and persists normalized USD/oz to a time‑series database.
2. Backfill service: On detection of a gap, it calls Historical for the missing date.
3. Analytics worker: Computes derived metrics nightly (returns, vol, drawdown).
4. OHLC enrich: For selected dates (e.g., month‑ends), fetch OHLC and update candle views.
5. API gateway: Your internal API serves normalized data to front‑end charts and pricing engines.
6. Monitoring: Track request counts, error rates, and data validation flags.

Validation and QA checklist for 2026 IRD

• Spot‑check random days with the Historical endpoint to validate Time-series results.
• Unit sanity: Confirm USD/oz magnitudes align with known reference periods (ballpark checks).
• No negative or zero rates post‑normalization.
• Consistent timezone: All dates stored as YYYY-MM-DD UTC.
• Schema tests: If unit field changes in the API response, alert and halt processing.

Cost control and performance tuning

• Cache monthly Time-series windows and refresh only at month close, unless you require rolling daily updates.
• Reuse responses across services by writing them to an object store keyed by the exact query string.
• Avoid redundant Historical calls by checking if the date is already in your normalized store.
• Prefer smaller, predictable requests over very large ranges to reduce timeout risk.

Data lineage, auditability, and reproducibility

• Persist raw JSON and normalization code version (git SHA) with each batch.
• Write event logs for each fetch: endpoint, query, response size, success flag, timestamp.
• Use immutable object storage for raw payloads; only your normalized store is mutable.

Smart technology integration: alerts, signals, and strategy hooks

• Alerts: Trigger Slack/Email/Webhooks on x% daily move or when price crosses budget thresholds.
• Signals: Build breakout and mean‑reversion features using OHLC range and rolling volatility.
• Hedging triggers: When 20‑day vol exceeds a threshold, notify procurement to evaluate hedges or substitute materials.
• ML: Feed normalized 2026 IRD into models with macro/fx factors; log feature provenance carefully.

Operational tips for beginners

• Start narrow: First load a single month (e.g., 2026‑01), validate, then scale.
• Graph checks: Visual charting quickly reveals anomalies (spikes, flats). Pair code with visuals.
• Document assumptions: Units, base currency, weekend policy, and gap handling should be in your README.
• Monitor your key: Track response errors that indicate auth issues or plan limits.

Where to find more details

• Endpoint usage, parameters, and feature availability: Metals-API Documentation
• Symbol availability, codes, and units: Metals-API Supported Symbols
• Main landing page and account creation: Metals-API Website
• General finance reference on troy ounces and conversions: LBMA educational resources

End-to-end example: assembling a 2026 IRD dataset

1. Request Time-series for 2026‑01‑01 to 2026‑12‑31 with symbols=IRD.
2. Normalize to USD/oz and store as a daily time series keyed by date.
3. For any gaps, call Historical for the specific date(s) and merge.
4. For month‑end days, request OHLC to enrich candlestick views.
5. Compute returns, vol, and drawdown; publish to your analytics API and BI dashboards.

Additional sample responses: edge cases and variants

Time-series with a weekend span (illustrative)

{
"success": true,
"timeseries": true,
"start_date": "2026-07-03",
"end_date": "2026-07-07",
"base": "USD",
"rates": {
"2026-07-03": { "IRD": 0.0000116 },
"2026-07-06": { "IRD": 0.00001155 },
"2026-07-07": { "IRD": 0.0000117 }
},
"unit": "per troy ounce"
}

Note how 2026‑07‑04 and 2026‑07‑05 are absent. Adjust your pipeline accordingly.

Historical with invalid symbol (illustrative error)

{
"success": false,
"error": {
"code": "symbol_not_supported",
"message": "The requested symbol is not supported in this plan or environment."
}
}

If you encounter an error object, verify that IRD is supported for your key on the symbols page, and confirm the correct symbol code is “IRD”.

Production readiness checklist

• Secrets managed: access_key rotated and stored securely.
• Observability: request logs, error rates, and data validation metrics captured.
• Retry/backoff: transient failures handled without flooding the API.
• Caching: raw JSON and normalized tables cached to minimize calls.
• Unit tests: reciprocal conversion verified against known fixtures.
• Schema guardrails: failing fast if unit or base changes unexpectedly.

Call to action

Ready to load Iridium (IRD) per‑ounce historical prices for 2026 and run your time‑series analysis? Start here:

• Create your key: Sign up on the Metals-API Website
• Skim the docs for Time-series, Historical, and OHLC parameters: Metals-API Documentation
• Confirm IRD availability and symbol details: Metals-API Supported Symbols

Conclusion

Iridium (IRD) may be niche, but your integration doesn’t have to be. With Metals-API’s Time-series, Historical, and OHLC endpoints, you can assemble a clean 2026 per‑ounce dataset in hours, not weeks—complete with robust normalization, caching, and analytics hooks. By standardizing on base currency conventions, respecting UTC dates, and applying a disciplined data engineering approach, your team can backtest strategies, power dynamic pricing, and support procurement decisions with confidence. The same pipeline scales to alerts, volatility models, and advanced ML features. Grab your key, validate the IRD symbol, and start building.

FAQ

• What symbol should I use for Iridium?
  Use IRD. Always verify symbol availability on the official symbols list.
• Are rates returned as USD per ounce or ounces per USD?
  By default the base is USD, so the rate is troy ounces per USD. Invert the value to get USD per troy ounce.
• How do I handle missing days (weekends/holidays)?
  Expect gaps. Forward‑fill for charts only, or compute returns across the gap. Avoid injecting synthetic prices into analytics unless flagged.
• Which endpoints are best for 2026 backfills?
  Use Time-series for ranges and Historical for specific dates. Add OHLC for candle‑based analytics.
• Can I get prices in grams or another currency?
  Convert USD/oz to grams by dividing by 31.1034768. For other currencies, combine with FX conversion (check the documentation for plan features) or apply your own FX feed.
• What timezone are dates in?
  Dates are in UTC. Store and process them as UTC to prevent off‑by‑one errors.
• How should I cache?
  Cache by exact query parameters (start_date, end_date, base, symbols). For 2026, monthly windows work well. Persist raw JSON and normalized tables.
• How do I get started?
  Create a free API key on the Metals-API Website, review the documentation, confirm IRD on the symbols page, and run the Time-series curl example with your key.