Utilize Gold Oct 2026 (GCV26) Historical Prices through this API

Need to analyze Gold Oct 2026 (GCV26) historical prices for backtesting, hedging, or product pricing? Metals-API makes it straightforward to retrieve high-quality Gold (XAU) historical prices and analytics you can use as a robust proxy for the COMEX GCV26 futures contract. In this guide, we’ll show you how to build a historical dataset for GCV26-aligned analysis using Metals-API’s Historical, Time-Series, OHLC, Bid/Ask, Fluctuation and Convert features; how to interpret units and base currency; and how to make your integration resilient, cache-efficient, and production-ready.

What you’ll build: a reproducible Gold (XAU) historical series aligned to GCV26 analysis

GCV26 (Gold October 2026 COMEX futures) is a contract-specific symbol that typically isn’t quoted directly by spot price APIs. Metals-API provides high-fidelity spot XAU data, historical time series, intraday snapshots (depending on plan), and OHLC aggregates you can use to:

Backfill a daily historical series over the expected life of the GCV26 contract.
Calculate USD/oz prices, basis estimates, and compare spot vs. futures curves using external futures data if available.
Power dashboards, pricing engines, alerts, and research notebooks that need consistent, well-documented gold data.

In short, you’ll treat XAU spot from Metals-API as a stable, liquid proxy for GCV26 analytics: calibrate or combine it with your futures feed if you have one, or use it standalone for research, product pricing, and model development where spot suffices.

Before we start: what you need

A free or paid API key from the Metals-API Website. If you don’t have one yet, sign up now to get a free API key and follow along.
Familiarity with JSON-based REST APIs and basic data wrangling.
Awareness that Metals-API primarily serves spot and aggregated data for symbols like XAU, not individual futures contract tickers. You’ll use XAU data in USD terms (or convert as needed) to analyze or proxy GCV26.

Understanding the data model: base currency, units, timestamps

Metals-API responses are grounded in three core concepts:

Base currency: By default, “base”: "USD". Rates express how much of a metal unit you get per 1 base currency unit. For example, a response might show "XAU": 0.000482 with "unit": "per troy ounce" and "base": "USD", meaning 1 USD buys 0.000482 troy ounces of gold. To get USD/oz, invert: USD_per_oz = 1 / 0.000482.
Units: Precious metals are quoted per troy ounce. If you need grams, kilograms, or other weight bases, convert accordingly (1 troy ounce = 31.1034768 grams).
Timestamps and dates: Responses include a Unix epoch "timestamp" and ISO "date". Treat timestamps as UTC. If you aggregate by local exchange session, normalize to your preferred timezone and calendar.

Why this matters for GCV26 analysis

The GCV26 futures price is typically quoted in USD per troy ounce. Since Metals-API returns XAU as ounces per USD by default, always invert to align with common USD/oz quoting used in futures analytics, valuation, and risk calculations. For comparing spot to futures (basis), you’ll normalize both series to USD/oz and align on a consistent calendar (close-to-close or end-of-day UTC).

Quick start: pull daily Gold (XAU) history for the GCV26 window

To build a historical reference series for the period leading up to and including October 2026, use the Time-Series and Historical features. You can then layer on OHLC aggregates for daily bars, Bid/Ask snapshots for spreads, and Fluctuation analytics for daily changes.

One-shot backfill with Time-Series

Ideal to fetch a continuous run of daily data for an initial backfill, e.g., from the start of 2025 up to today. You’ll pivot this into USD/oz and store it in your database or data lake.

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

How to read it:

rates[date].XAU: ounces per USD on that date. Compute USD/oz as 1 / XAU.
Missing days: markets may be closed on weekends/holidays; you might not see data for those dates.
Unit is explicitly “per troy ounce”—store this metadata alongside your data so conversions are traceable.

Daily-specific retrieval with Historical

If you need a specific day (e.g., the last trading day of each month), use the date-based Historical feature.

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

Key fields for developers:

timestamp: Use for idempotent caching and de-duplication. Treat as the authoritative time the price was valid.
rates.XAU: Invert to USD/oz, convert to grams if needed, then persist with date as your partition key.
base and unit: Store these fields to ensure downstream transformations don’t assume defaults.

From spot to a GCV26-grade analytics foundation

While Metals-API focuses on spot and aggregated data (not specific futures contracts like GCV26), you can approximate contract-related analytics by:

Using spot XAU USD/oz as the primary curve.
Adding time decay, storage cost, convenience yield, and financing adjustments to build a fair-value futures curve if your model needs it.
Combining with your own (or third-party) futures settlement feed to compute basis (Futures – Spot) or implied carry. When you do, ensure both series share a common timestamp convention and price unit.

For reference on futures contract codes and calendars, consult the exchange; for example, the CME Group site provides contract specifications and calendars for gold futures. Always align your trading session definitions across spot and futures when computing basis.

Producing USD/oz prices correctly

Because rates are returned as ounces per USD, compute the commonly used USD per ounce as below. This is crucial when you compare to GCV26 prices or show quotes to end-users:

USD_per_oz = 1 / rates.XAU
Grams_per_USD = (rates.XAU * 31.1034768)
USD_per_gram = 1 / (rates.XAU * 31.1034768)

Example: Latest spot for real-time dashboards

{
"success": true,
"timestamp": 1789433442,
"base": "USD",
"date": "2026-09-15",
"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"
}

Convert to USD/oz for display; cache by timestamp to minimize API calls and jitter. Depending on your plan, “Latest” updates as frequently as every 10 minutes or longer. See the Metals-API Documentation for update intervals and plan details.

OHLC, Bid/Ask, and Fluctuation: analytics your models will use

For backtesting signals ahead of GCV26 expiration, daily bars and changes provide more nuance than raw mid-prices.

Daily bars with OHLC

Use OHLC to obtain open/high/low/close for XAU on a given date. This is often the canonical input for factor models, volatility estimations, and backtests.

{
"success": true,
"timestamp": 1789433442,
"base": "USD",
"date": "2026-09-15",
"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"
}

Common developer steps:

Invert all four fields to get USD/oz OHLC.
Compute ranges (high-low), close-to-close returns, ATR, and realized volatility.
Resample to your model’s frequency. If your model uses EOD UTC, map “date” to that convention for joins with futures data.

Bid/Ask for spreads and execution modeling

Bid/Ask snapshots let you infer spreads and build theoretical execution cost models for strategies that rebalance based on spot prices close to futures expiry.

{
"success": true,
"timestamp": 1789433442,
"base": "USD",
"date": "2026-09-15",
"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"
}

What you’ll use:

rates.XAU.bid and rates.XAU.ask: Convert each to USD/oz separately to get a sense of the spread in USD terms.
rates.XAU.spread: Already provided in ounces-per-USD terms; invert carefully if you need a USD-per-oz spread approximation. For small spreads, linear approximations often suffice.

Fluctuation for day-over-day change analytics

Quickly compute period changes (absolute and percent) without pulling and differencing two snapshots yourself.

{
"success": true,
"fluctuation": true,
"start_date": "2026-09-08",
"end_date": "2026-09-15",
"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"
}

Note: change_pct is computed in ounces-per-USD space. If your research standardizes on USD/oz returns, recompute percent change after inverting both start_rate and end_rate.

Symbols, alloys, and related instruments you might combine with XAU

For portfolio context, you may also track silver (XAG), platinum (XPT), palladium (XPD) or base metals (XCU, XAL, XNI, XZN). Confirm exact symbol availability and definitions on the Metals-API Supported Symbols page. If your products involve jewelry-grade alloys, the Carat feature is helpful to translate spot gold into carat-based quoting for consumer-facing SKUs.

Carat-based quoting for retail and ERP integration

If you price items in 24k, 22k, 18k, etc., use Carat data to transform spot XAU into jewelry-grade rates by carat with a specified currency base. While GCV26 analytics emphasize pure XAU, retail and manufacturing workflows often need both.

Example response structure (retrieve gold rates by carat, base as needed):

{
"success": true,
"base": "USD",
"date": "2026-09-15",
"rates": {
"XAU_24K": 0.000482,
"XAU_22K": 0.000442,
"XAU_18K": 0.000361
},
"unit": "per troy ounce"
}

Use cases:

E-commerce: dynamically price rings and chains based on live or intraday spot plus margin.
ERP: standardize BOM costs and revaluation processes each day using a reproducible close rate.

From API to analytics: complete request and application example

cURL: pull a daily OHLC bar for XAU on a given date

Use this to backfill a daily bar that you can compare against futures data for the same session.

curl -G "https://metals-api.com/api/ohlc/2026-09-15" \
--data-urlencode "access_key=YOUR_API_KEY" \
--data-urlencode "base=USD" \
--data-urlencode "symbols=XAU"

Representative JSON (see OHLC example above):

{
"success": true,
"timestamp": 1789433442,
"base": "USD",
"date": "2026-09-15",
"rates": {
"XAU": {
"open": 0.000485,
"high": 0.000487,
"low": 0.000481,
"close": 0.000482
}
},
"unit": "per troy ounce"
}

Store this as a bar in your time-series DB, but convert to USD/oz first to align with futures prices for GCV26 comparisons.

JavaScript (Node.js or browser) example: backfill and invert to USD/oz

async function fetchGoldBackfill(start, end, apiKey) {
const url = new URL("https://metals-api.com/api/timeseries");
url.searchParams.set("access_key", apiKey);
url.searchParams.set("base", "USD");
url.searchParams.set("start_date", start);
url.searchParams.set("end_date", end);
url.searchParams.set("symbols", "XAU");

const res = await fetch(url);
if (!res.ok) throw new Error("HTTP " + res.status);
const data = await res.json();
if (!data.success) throw new Error("API error: " + JSON.stringify(data));

const out = [];
for (const [date, payload] of Object.entries(data.rates)) {
const ozPerUSD = payload.XAU;
if (ozPerUSD && ozPerUSD > 0) {
const usdPerOz = 1 / ozPerUSD;
out.push({ date, usdPerOz, source: "metals-api", unit: "USD_per_troy_ounce" });
}
}
// Sort by date to ensure deterministic order
out.sort((a, b) => a.date.localeCompare(b.date));
return out;
}

// Example usage:
// fetchGoldBackfill("2026-08-01", "2026-10-31", process.env.METALS_API_KEY)
// .then(series => console.log(series))
// .catch(err => console.error(err));

What to do next:

Join this USD/oz series with your futures settlement or last-trade prices for GCV26 to compute basis.
Run rolling regressions or carry models to estimate fair-value futures adjustments.
Cache responses by start/end date windows to avoid re-fetching the same periods.

Convert and normalize: harmonize metals and currencies

If your portfolio or product prices in EUR, GBP, or JPY, use Convert to get amounts directly without manual inversion and FX crosswork.

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

Usage tips:

Use Convert for quick answers such as “What’s 1,000 USD in troy ounces of gold today?”
For large workloads, consider pulling Latest or Time-Series once and doing batch math locally, to minimize requests.

Intraday snapshots for finer granularity

Depending on your plan, Intraday provides time-sliced rates for a single symbol like XAU. Use it to enrich GCV26-adjacent analysis on volatile days near expiry when timing matters. Always cache intraday slices and respect your plan’s refresh interval constraints described in the Metals-API Documentation.

Historical LME and cross-metal context

While LME-specific symbols focus on base metals and date back further for some instruments, they can be relevant for cross-commodity strategies and industrial hedging logic. If your research extends beyond gold, explore the historical-lme feature alongside XAU to understand broader metals market regimes. Refer to the Metals-API Supported Symbols to confirm availability.

Practical implementation notes developers often miss

1) Weekend and holiday behavior

Expect gaps for weekends and market holidays. Your time-series code should handle missing “business days.”
For EOD models, pick a consistent daily snapshot—e.g., close from the OHLC feature—to avoid mid-session noise.

2) Caching strategy to save requests and improve stability

Cache by request signature (URL + params) and response timestamp.
For Latest and Bid/Ask, cache for at least the provider’s update interval; avoid over-polling.
For Historical and OHLC on past dates, cache effectively forever (content is immutable).

3) Timezones and clocks

Treat API timestamps as UTC. Convert once at ingestion time to your canonical timezone.
For futures comparisons, align on a single “close” definition—EOD UTC vs exchange close can differ.

4) Units and conversions

Always record unit metadata (“per troy ounce”) and base currency.
Centralize conversion helpers (invert for USD/oz, ounces-to-grams) in a single utility module.

5) Data validation and outlier handling

Clamp or flag values where inversion yields implausible USD/oz; check for zeros or missing fields before inverting.
Version control schema changes so downstream consumers aren’t surprised by new fields.

Endpoint-by-endpoint: behavior, fields, pitfalls, and performance

Latest

Purpose: get current snapshot rates across many metals. Depending on plan, updates every 60 minutes, every 10 minutes, or per plan limits.

Representative response:

{
"success": true,
"timestamp": 1789433442,
"base": "USD",
"date": "2026-09-15",
"rates": {
"XAU": 0.000482,
"XAG": 0.03815,
"XPT": 0.000912,
"XPD": 0.000744
},
"unit": "per troy ounce"
}

Use cases: dashboards, quick conversions, real-time alerts.
Pitfalls: Do not treat Latest as tick-by-tick. Respect update frequency; cache appropriately.
Performance: Pull only the symbols you need (if supported) and share a single snapshot across services via your cache or message bus.
Security: Never expose your access_key in client-side code without mitigations (e.g., proxy requests through your backend).

Historical (date-based)

Purpose: get rates for a specific past date. Historical coverage depends on instrument and plan; verify availability in documentation.

Response recap:

{
"success": true,
"timestamp": 1789347042,
"base": "USD",
"date": "2026-09-14",
"rates": {
"XAU": 0.000485
},
"unit": "per troy ounce"
}

Use cases: end-of-month valuation, re-pricing archives, NAV calculations.
Pitfalls: Ensure you request business dates; if a date has no data, handle errors or empty payloads gracefully.
Performance: Cache indefinitely; deduplicate by date+symbol.

Time-Series

Purpose: retrieve a contiguous interval of daily rates. Ideal for backfills and batch analytics.

Response recap (see above). Notes:

Use cases: historical modeling, chart backfills, research notebooks.
Pitfalls: Intervals with holidays/weekends will have fewer entries than calendar days. Align with your expected trading calendar.
Performance: Prefer a few larger time-series calls over many single-day requests to reduce overhead.

Fluctuation

Purpose: get change and percent change between two dates.

Use cases: simple performance summaries, period-over-period metrics.
Pitfalls: Percent changes are in ounces-per-USD space. If your app displays USD/oz returns, recompute after inverting.
Performance: Useful for summaries; avoids extra client-side differencing.

OHLC

Purpose: open/high/low/close on a given date.

Use cases: charting, backtests, signal computation.
Pitfalls: Always invert each field; do not invert once at the end using close only if your features use full bars.
Performance: Cache daily bars and derive technical indicators server-side to avoid recomputation.

Bid/Ask

Purpose: current bid and ask for metals.

Use cases: execution cost modeling, spread-aware alerts.
Pitfalls: Spreads are tiny in ounces-per-USD; inversion approximations are acceptable for small spreads, but verify for accuracy-sensitive workflows.
Security: Treat frequent polling as sensitive; protect your key and respect plan limits.

Convert

Purpose: convert any amount from one currency/metal to another.

Use cases: instant “how many ounces for $X?”, checkout price calculators, quote panels.
Pitfalls: For repeated conversions, prefer pulling a base snapshot then doing local math to save calls.

Carat

Purpose: gold rates by carat.

Use cases: jewelry pricing, retail catalogs, consumer apps.
Pitfalls: Carat multipliers and purity assumptions vary by locale—document your approach for auditability.

Historical LME

Purpose: access historical LME symbols (from earlier years for certain instruments).

Use cases: macro research, industrial hedging strategies.
Pitfalls: Confirm exact symbol coverage on the symbols page before designing schemas.

Intraday

Purpose: intraday snapshots for a single symbol.

Use cases: near-real-time monitoring, pre-close hedging decisions.
Pitfalls: Respect refresh intervals; don’t assume tick-level granularity.
Performance: Batch requests where possible; throttle and backoff under load.

Authentication, authorization, and key hygiene

API Key: pass your key via the access_key query parameter.
Do not expose keys directly in browser apps. Route calls through your backend or use a serverless function that injects the key server-side.
Rotate keys periodically and on suspicion of leakage.
Use environment variables and a secret manager; never commit keys.

Error handling and recovery strategies

Check "success": false: The API may include error details in the JSON. Log and map to your app’s error taxonomy.
HTTP failures: Implement exponential backoff with jitter. Differentiate between client errors (4xx) and transient server/network issues (5xx, timeouts).
Empty or partial data: When a date has no data, treat it as a normal gap (e.g., weekend). Decide whether to forward-fill for UI or leave gaps for strict quant workflows.

Rate limiting and quotas

Update intervals and quotas depend on your plan. Avoid speculative assumptions about exact limits; consult the Metals-API Documentation. Best practices include:

Batch fetches with Time-Series or multi-symbol requests when supported.
Cache immutable data aggressively.
Stagger jobs to avoid thundering herd effects at top-of-hour refreshes.

Performance optimization and scaling patterns

Data lake first: Ingest historicals (Time-Series, OHLC) into a lake/warehouse; serve models from there to reduce API hits.
Materialized views: Precompute USD/oz, grams, and core indicators at ingestion. Store alongside raw to avoid recomputation.
Service boundaries: A dedicated “pricing-service” can mediate Metals-API calls for all internal consumers, with shared caches.
CDN and edge caches: For public pages, front your backend with a CDN and short TTLs aligned with update intervals.

Security, auditability, and compliance

Log every request’s parameters, timestamp, and hash the response payload to reproduce valuations later.
Store the “base” and “unit” fields with each record. Auditors love explicit metadata trails.
Protect keys in transit (HTTPS) and at rest (KMS/secret manager). Use IAM roles for server-to-server workflows.

Common pitfalls and how to avoid them

Forgetting to invert: If your charts look inverted, you probably displayed ounces-per-USD instead of USD-per-ounce.
Mixing timezones: Futures settlements vs. spot EOD UTC—normalize to one convention.
Assuming data on closed days: Always code for gaps; don’t assume every calendar date has values.
Over-polling Latest: Respect update intervals; cache and share snapshots.

Designing a GCV26-aligned research workflow with Metals-API

Pull a Time-Series of XAU from your backtest start to your backtest end. Invert to USD/oz and persist.
Augment with OHLC for daily bars, and Bid/Ask for spread-aware cost estimates near roll dates.
If you have a futures feed, ingest GCV26 settlements and compute basis vs your USD/oz spot close.
Estimate a fair-value curve (carry, storage, financing) if you need a model-driven GCV26 proxy without direct futures data.
Build alerts on Fluctuation outputs for large moves approaching October 2026 expiry.

Quality checks and sanity tests

Cross-compare inverted USD/oz to a reputable reference (e.g., institutional terminals or well-known financial data portals) for a spot-check.
Ensure unit conversions (grams, kilograms) match precise constants and rounding rules you publish internally.
Reconcile your EOD price with OHLC.close on the same date for consistency.

Innovation themes: using XAU data to go beyond price lookups

Digital transformation in precious metals: Embed spot and OHLC in e-commerce, treasury, and procurement systems to digitize revaluations and quotes.
Data analytics and market insights: Build factor models, volatility surfaces, and carry analytics that feed into your GCV26 hedging playbook.
Technology integration in trading: Stream Metals-API snapshots into low-latency caches, trigger roll decisions and hedges automatically.
Innovation in price discovery: Combine Bid/Ask with OHLC to assess liquidity and slippage, unlocking better execution strategies.
Digital asset solutions: Tokenize gold-linked products with transparent, auditable pricing sourced from Metals-API endpoints.

Compare common fields and transformations you’ll rely on

Field	Meaning	Typical Transform	Used For
base	Reference currency (default USD)	None; store alongside rates	Audits, conversions
unit	Pricing unit (per troy ounce)	None; store for metadata	Unit conversions
rates.XAU	Ounces per USD	Invert to USD/oz	Charts, basis, EOD prices
timestamp	Epoch seconds	Normalize to UTC ISO	Caching, joins
OHLC (open/high/low/close)	Daily bar fields	Invert each; compute indicators	Backtests, risk
Bid/Ask	Execution sides + spread	Invert each side	Cost modeling
Fluctuation.change_pct	Percent change in oz/USD	Recompute in USD/oz if needed	Performance summaries

Troubleshooting guide

“Numbers look upside down.” You forgot to invert ounces-per-USD into USD-per-ounce. Fix: usdPerOz = 1 / rates.XAU.
“My dates skip randomly.” Weekends/holidays. Fix: Join on business calendars; optionally forward-fill for UIs, but do not fabricate for models.
“I hit rate limits.” Reduce polling; switch to Time-Series; cache immutable results; centralize calls in one backend service.
“User sees different price than report.” Define a canonical price source/time (e.g., OHLC.close at EOD UTC) for all official reporting.
“Security flagged exposed key.” Move requests server-side; rotate key; use secret manager and environment variables.

Where to find symbol and endpoint details

Explore every parameter, response field, and update interval in the official Metals-API Documentation.
Confirm availability and definitions of metals on the Metals-API Supported Symbols page.
Create your key or upgrade your plan via the Metals-API Website to start integrating now.

Additional reading and references

Concepts: Contango, backwardation, carry, and basis discussions can be found on education portals such as Investopedia’s futures primers.
Contract context: Exchange calendars and contract specs provide important session timings for aligning spot vs futures during backtesting.

Conclusion: A production-ready path to GCV26-aligned gold analytics

Even though Metals-API doesn’t publish individual futures contract symbols like GCV26, it provides everything you need to build a rigorous gold (XAU) foundation for GCV26 analysis: robust historical series, daily OHLC bars, intraday snapshots (by plan), bid/ask spreads, and fluctuation metrics. By consistently inverting ounces-per-USD to USD-per-ounce, aligning timestamps to your research calendar, caching aggressively, and applying best practices for error handling and security, you can power backtests, hedges, and pricing workflows that are transparent, performant, and easy to audit.

Ready to implement? Visit the Metals-API Website to get your free API key, then dive into the Metals-API Documentation for endpoint parameters and examples. Check which instruments you can pull today on the Metals-API Supported Symbols page, and start building your GCV26-aligned dataset now.

FAQ

Does Metals-API provide the GCV26 futures ticker directly?

No. Metals-API focuses on spot and aggregated metals data (e.g., XAU). Use XAU as a proxy or combine it with your futures feed to compute basis and carry-related analytics for GCV26.

What unit are gold prices returned in?

Rates are “per troy ounce” and typically in ounces-per-USD with base "USD". To get USD/oz, invert the rate: USD_per_oz = 1 / rates.XAU.

What timezone are timestamps in?

Treat timestamps as UTC. Normalize to your chosen research timezone at ingestion.

How far back does historical data go?

Historical coverage depends on plan and instrument. Review the coverage section in the Metals-API Documentation for precise limits.

How should I handle weekends and holidays?

Expect gaps. Don’t fabricate values for quant models. For UI, consider forward-filling with clear labeling.

Can I get OHLC and Bid/Ask for XAU?

Yes. Use the OHLC and Bid/Ask features as shown above. Always invert fields if you need USD/oz.

How do I avoid exposing my API key?

Never call Metals-API directly from public clients with your raw key. Use a backend proxy, store your key in a secret manager, and rotate it periodically.

Ready to use Metals-API?

Try it now!