How to Get Real-Time Indore Gold 24k (INDO-24k) Prices Using Python and Metals-API

If you price jewelry or hedge inventory in central India, you probably want real-time Indore Gold 24k (INDO-24k) prices to power dashboards, alerts, and ERP updates. The fastest way to get there in Python is to use Metals-API’s real-time Gold (XAU) market data and transform it into a local 24k workflow: convert per–troy-ounce quotes to per–gram, overlay your regional fees/taxes, and cache the results for high-throughput apps. This guide shows how to fetch and process XAU pricing with Metals-API in Python, discuss bid/ask and OHLC for execution and analytics, and build a robust, production-grade pipeline. It also covers practical details that save time in the real world: base currency behavior, timestamps and timezones, weekends and closures, and caching strategies. To follow along, you will need an API key from the Metals-API Website.

Why real-time Gold (XAU) powers accurate Indore 24k (INDO-24k) workflows

Metals markets are global and dynamic; even if your final display is “Indore 24k,” your data engineering and trading stack should start with reliable source-of-truth benchmarks. Metals-API’s core feed for Gold (XAU) is quoted per troy ounce and delivered via a simple JSON REST API. With it, you can:

Price 24k gold products per gram or per kilogram in near real-time.
Build time-series charts for sales enablement and internal analytics.
Generate alerts on intraday moves using OHLC or bid/ask spreads.
Backfill historical models to fine-tune hedging policies and inventory buffers.

Because the INDO-24k label reflects a local market context rather than an exchange symbol, the practical approach is to use XAU as your primary input, convert to grams, and then apply local adjustments (e.g., premium/discount, logistics, taxes). This keeps your pipeline auditable, portable, and fast to iterate.

Metals-API overview: real-time and historical XAU data for developers

Metals-API provides a developer-friendly JSON REST API exposing:

Real-time prices and snapshots via the Latest Rates and Bid/Ask endpoints.
Historical and time-series data for charting and research.
OHLC data for candlesticks and intraday analytics.
Conversion tools to transform amounts between units and symbols.
Fluctuation summaries to quantify period-over-period changes.
Specialized features like carat-based rates and LME historical data.

Start by reviewing the official Metals-API Documentation and confirm symbol availability on the Metals-API Supported Symbols page. For this article, we focus on XAU and the endpoints you can chain to deliver an Indore 24k workflow in production.

Data model and units: from XAU per troy ounce to INDO-24k per gram

Metals-API returns metals rates relative to a base currency and unit. In examples shown below:

Base currency is USD by default.
Units are “per troy ounce” for metals like XAU.

To present 24k Indore pricing in grams:

Fetch XAU rate (per troy ounce).
Convert troy ounces to grams: 1 troy ounce = 31.1034768 grams.
Optionally convert to your local currency using your internal FX or downstream logic if needed.
Apply regional adjustments (premiums/discounts, GST, making charges) in your business logic.

This separation of concerns keeps the API usage straightforward and your regional customization explicit and testable.

Quick reference: unit conversions you will use daily

Measure	Value	Notes
1 troy ounce	31.1034768 grams	Standard gold weight unit in wholesale markets
1 kilogram	32.1507466 troy ounces	For bullion bar pricing
24k gold	99.9%+ purity	Equivalent to “pure gold” basis for XAU quotes

Authentication and base request pattern

Every Metals-API request includes your API key via the access_key parameter. If you haven’t created one, get started at the Metals-API Website. After you have a key, the simplest pattern to fetch XAU is calling the Latest Rates endpoint and selecting XAU in the response.

Example: Latest Rates (curl)

Below is a representative curl call to request the latest XAU price. Replace YOUR_API_KEY with your actual key.

curl -s "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=XAU"

Representative JSON response (fields and structure as delivered by Metals-API):

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

Key fields you will use

success: Indicates the request completed successfully.
timestamp: UNIX epoch seconds for the quote snapshot; use this for caching and data lineage.
base: The reference currency (USD by default in these examples).
date: Human-readable date of the snapshot.
rates.XAU: The amount of XAU (troy ounces) per one USD or, depending on the interpretation of “relative to USD,” the ratio indicating how much XAU corresponds per base unit. Use this consistently in your conversions.
unit: “per troy ounce” clarifies the weight basis of the metal rates.

From XAU per troy ounce to INDO-24k per gram: Python example

This Python snippet fetches the latest XAU price, converts it to per gram, and then applies an example local premium and tax model you can replace with your own logic. It also shows error handling, timestamp normalization, and a caching hint.

# Python 3 example: Convert XAU per troy ounce to 24k per gram and apply local adjustments

import os
import time
import json
import math
import urllib.parse
import urllib.request

API_KEY = os.getenv("METALS_API_KEY", "YOUR_API_KEY")
BASE_URL = "https://metals-api.com/api/latest"
TROY_OUNCE_TO_GRAMS = 31.1034768

def fetch_latest_xau():
params = {
"access_key": API_KEY,
"symbols": "XAU"
}
url = BASE_URL + "?" + urllib.parse.urlencode(params)
with urllib.request.urlopen(url, timeout=10) as resp:
data = json.loads(resp.read().decode("utf-8"))
if not data.get("success", False):
raise RuntimeError(f"API error: {data}")
return data

def xau_to_per_gram_usd(xau_rate):
# xau_rate is expressed relative to the base USD and per troy ounce unit
# Convert "per troy ounce" to "per gram" keeping the same base
# When interpreting rates, maintain consistency with the API's "unit" field.
# If rates.XAU represents amount per base currency unit, scale accordingly.
# Here we compute a per-gram multiplier from the per–troy-ounce basis.
per_gram_factor = 1.0 / TROY_OUNCE_TO_GRAMS
return xau_rate * per_gram_factor

def apply_local_adjustments(per_gram_base, premium_pct=0.75, tax_pct=3.0, making_charge_per_gram=0.0):
# Example: add a local market premium percentage, then tax, then fixed making charge per gram.
# Adjust these values to your internal pricing model.
price_with_premium = per_gram_base * (1 + premium_pct / 100.0)
price_with_tax = price_with_premium * (1 + tax_pct / 100.0)
final_price = price_with_tax + making_charge_per_gram
return final_price

def main():
data = fetch_latest_xau()
ts = data["timestamp"]
iso_date = data["date"]
unit = data.get("unit", "per troy ounce")
base = data.get("base", "USD")
xau_rate = data["rates"]["XAU"]

per_gram_base = xau_to_per_gram_usd(xau_rate)
# Replace these example parameters with your Indore-specific adjustments
indo_24k_per_gram = apply_local_adjustments(per_gram_base, premium_pct=0.75, tax_pct=3.0, making_charge_per_gram=0.0)

# In production, cache this result keyed by timestamp/base/symbol/unit for the API's update interval
print(json.dumps({
"timestamp": ts,
"date": iso_date,
"base": base,
"unit_incoming": unit,
"xau_rate_raw": xau_rate,
"xau_per_gram_base": per_gram_base,
"indo_24k_per_gram": indo_24k_per_gram
}, indent=2))

if __name__ == "__main__":
main()

Notes for production:

Cache the response for the duration of the update interval permitted by your plan (e.g., every 60 minutes or every 10 minutes) to avoid unnecessary calls and stabilize your UIs.
If you also manage FX conversion (e.g., to a local currency), maintain a clear step order and document your rate sources for audit.
Test your premium/tax pipeline thoroughly against historical data to ensure sensible behavior during volatile periods.

Intraday execution context: Bid/Ask for trading and quotes

For quoting and execution-sensitive workflows, you’ll want to reference bid/ask rather than midpoint or last price. Metals-API provides a Bid and Ask endpoint that returns bid and ask quotes with spreads. This is valuable when you post quotes or compute slippage buffers for internal execution policies.

Representative JSON response:

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

How to use:

Use XAU.ask to compute customer-facing quotes if you are a buyer (you pay ask) or XAU.bid if you are a seller (you receive bid), depending on your role.
Transform to per-gram by dividing by 31.1034768, then apply your premium/tax rules.
Store the timestamp alongside your quote to ensure consistency in invoicing and auditing.

Pitfall to avoid: mixing bid/ask for different symbols or timestamps in the same quote pipeline. Keep a single snapshot per transaction path.

Candlesticks, analytics, and alerts: OHLC and Fluctuation

Technical teams often want to compute intraday signals or daily risk summaries. Metals-API’s OHLC endpoint returns open, high, low, and close data per symbol for a given period. Combine it with Fluctuation to express percentage changes.

OHLC response example

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

Use cases:

Compute intraday volatility bands for automated re-pricing thresholds in an e-commerce flow.
Plot candlesticks where your y-axis can be per-gram after conversion for a 24k retail audience.
Trigger alerts when close deviates from open beyond a tolerance to schedule hedging actions.

Fluctuation response example

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

Use cases:

Daily market summary email: “XAU moved -0.62% week-over-week.”
Dynamic rebalancing: adjust premiums when change_pct exceeds a threshold.
Risk dashboards: label direction (up/down) and magnitude for operations.

Backfilling and research: Historical and Time-series

To calibrate premiums and tax logic, you need clean historical baselines. Metals-API provides one-shot historical snapshots and multi-day time-series blocks.

Historical snapshot response

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

With this, you can compute day-over-day moves or create a daily cache for reporting. For full-range charts, the Time-series endpoint returns date-keyed blocks:

Time-series response

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

Implementation notes:

Always key your local cache by start_date, end_date, base, and symbol to avoid overlap bugs.
Weekends and holidays: some dates may be missing or unchanged; treat missing days explicitly when building charts.
Use the unit field to keep conversions correct across different metal types.

Conversion logic: turning amounts into metal quantities

The Convert endpoint is useful when showing how much gold a certain budget buys or when interoperating with other currency systems. The API returns the amount in the target symbol given a source amount.

Convert response example

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

How to use for retail flows:

Convert budget to troy ounces, then to grams (multiply by 31.1034768) and show approximate grams purchasable at spot.
Overlay your local fees to produce the final number for checkout or invoicing.
Log the timestamp for customer communication clarity and dispute resolution.

Real-time alerting with the Intraday endpoint

When your team needs to react quickly to price changes, the Intraday endpoint streams intraday exchange rate data for a single symbol. You can sample it at the frequency permitted by your plan and keep a rolling buffer for dashboard spark lines and alert triggers.

Best practices:

Set an update cadence aligned with your plan’s refresh interval (e.g., every 60 minutes or 10 minutes).
Debounce alerts to avoid flapping during choppy markets.
Persist the last few intraday points so users can see context, not just point-in-time values.

Carat-based rates and 24k workflows

For workflows that explicitly use carat notations, Metals-API’s Carat endpoint returns gold rates by carat. For 24k (pure gold), you can compare outputs with your XAU-based conversion pipeline and confirm consistency. While Indore retail often quotes 24k, many operations still compute from XAU for consistency and then map to carat displays. The Carat endpoint is a convenient validation or display shortcut for carat-specific user experiences.

Combining endpoints to deliver a complete INDO-24k experience

A robust end-to-end pipeline typically looks like this:

Fetch latest XAU with Latest Rates for the spot snapshot.
Optionally grab Bid/Ask to compute executable quotes and protect against spread risk.
Convert per–troy-ounce to per–gram, then apply your local adjustments (premiums, taxes, charges).
Use OHLC for intraday analytics and to define safe re-pricing thresholds.
Backfill historical and time-series for charts and to backtest your premium/tax logic.
Provide a Convert flow so users can translate budgets to grams or ounces directly.
Use Intraday for responsive dashboards and alerting.
Cache iteratively to keep your UI snappy and your API calls economical.

Interpreting timestamps, dates, and timezones

timestamp is UNIX epoch seconds. Store as an integer and convert to your business timezone when rendering.
date is a human-readable snapshot date; use it for daily reporting labels.
When reconciling across systems, always use the epoch timestamp as the primary key.

Caching and performance optimization

Exploit the update interval of your plan: Metals-API “Latest” updates every 60 minutes, 10 minutes, or faster depending on subscription. Cache accordingly.
Deduplicate requests: batch symbols where possible rather than calling multiple times per page.
Localize unit conversions: do unit math in your app; don’t force repeated API calls just to switch between ounces and grams.
Immutable caching for historical/time-series: those values won’t retroactively change; store and reuse aggressively.
Add E2E caching keys: include base, symbols, unit, and timestamp to prevent cross-contamination.

Error handling and resilience

Check success before reading rates.
On network timeouts, retry with exponential backoff. Respect the API’s rate limits.
Guard against missing symbols or empty arrays; fail closed by hiding stale prices or marking them clearly as delayed.
Normalize numeric types: parse floats carefully and avoid binary rounding surprises in financial displays; round explicitly for UI.

Security and compliance

Never embed your access_key in client-side code; proxy through your backend.
Encrypt secrets at rest and rotate keys responsibly.
Log access by request ID and timestamp for audit trails.
Validate and sanitize any user-supplied parameters if you forward them to the API (e.g., symbol whitelisting).

Handling weekends, market closures, and sparse days

Expect fewer updates during weekends/holidays. Your time-series may have gaps or unchanged values.
UI tip: render non-trading days as gaps or dimmed points to avoid misleading flat lines.
Alerting: suspend or soften thresholds on known closures to avoid false positives.

Designing for scale: architecture and throughput

Central price service: build a microservice that fetches Metals-API data, normalizes units, applies your Indore adjustments, and exposes a low-latency internal API.
Read-optimized store: keep a memory cache (e.g., Redis) keyed by symbol/base/unit/timestamp for your frontends.
Batch jobs: run nightly historical backfills and store them in an analytics warehouse for BI and ML.
Observability: instrument request counts, error rates, and cache hit ratios. Alert on anomalies.

Detailed endpoint walkthroughs with field usage and pitfalls

Latest Rates for operational spot

Purpose: Fastest path to a fresh XAU snapshot for your Indore 24k pipeline.

Representative response:

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

Fields to rely on:

rates.XAU and unit: compute per-gram pricing.
timestamp: drive caching and SLA metadata in your UI.

Common pitfalls:

Mixing base currencies unintentionally; confirm base is what you expect.
Forgetting the per–troy-ounce unit when translating to grams or kg.

Bid and Ask for executable quoting

Purpose: Accurate transactional quotes using bid/ask.

Representative response:

{
"success": true,
"timestamp": 1789606756,
"base": "USD",
"date": "2026-09-17",
"rates": {
"XAU": {
"bid": 0.000481,
"ask": 0.000483,
"spread": 2.0e-6
}
},
"unit": "per troy ounce"
}

Tips:

Use ask for buy-side and bid for sell-side pricing to customers.
Record spread to understand liquidity conditions.

OHLC for analytics and thresholds

Purpose: Build candlesticks, compute volatility, and set re-price triggers.

Representative response excerpt:

{
"rates": {
"XAU": {
"open": 0.000485,
"high": 0.000487,
"low": 0.000481,
"close": 0.000482
}
},
"unit": "per troy ounce"
}

Use high-low range for intraday banding; compare close to your last quoted price for mark-to-market adjustments.

Historical and Time-series for backtesting

Purpose: Daily archives for research, charting, and policy tuning.

Representative responses shown earlier provide day-keyed maps. Behavior:

Historical: single date snapshot; cache immutably.
Time-series: multi-day range; handle gaps gracefully.

Fluctuation for business reporting

Purpose: Percentage change summaries for stakeholders.

Representative fields:

change and change_pct: feed KPI tiles.
start_rate and end_rate: store for evidence and back-audits.

Convert for budgeting and unit UX

Purpose: Translate budgets to metal amounts or vice versa.

Representative response shown earlier includes:

query: from/to/amount for traceability.
info.timestamp and info.rate: record your conversion provenance.
result: amount in target unit; convert to grams if needed.

Carat for purity-specific displays

Purpose: Display or validate carat-based prices (e.g., 24k) to align with retail labeling. Integrate with your main XAU pipeline to keep parity across experiences.

Data validation and sanitization best practices

Whitelist symbols you support (e.g., “XAU”) to prevent injection via query parameters.
Validate numeric responses: ensure fields exist and are numeric before arithmetic.
Guard against negative or zero rates; fallback to the previous valid snapshot if necessary.
Unit testing: snapshot test a few known responses to lock parsing logic.

Integration patterns for trading, fintech, and ERP

Trading desk tools: Use Bid/Ask and Intraday for immediate decisioning; archive OHLC and Fluctuation for EOD reconciliation.
Fintech apps: Expose a low-latency internal endpoint serving per-gram 24k prices; back by Redis and refresh with Latest at plan cadence.
E-commerce: Precompute per-gram 24k and per-item prices server-side; invalidate caches on material moves or on a timed schedule.
ERP: Sync daily Time-series close to maintain period-end valuations and cost-of-goods assumptions.

Digital transformation and market insight with Gold (XAU)

Digitizing precious metals pricing unlocks predictive analytics and innovation in price discovery. With a consistent XAU feed:

Data analytics: Fit volatility-aware markups, detect anomalies, and quantify pass-through effects of fees and taxes.
Technology integration: Standardize a single source of truth for frontends, ERP, and BI so operations stay aligned.
Innovation: Build digital asset products referencing XAU, dynamic pricing engines, and customer-facing budget-to-grams calculators.

Request examples for common tasks

Fetch latest XAU only (curl)

curl -s "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=XAU"

Backfill a chart with time-series (concept)

Request Time-series for a date window and compute per-gram values for each day. Then, store results with date keys for plotting in dashboards or reports.

Understanding the response schema in depth

success: Boolean gate. If false, inspect the error object (ensure you log it).
timestamp: Align all downstream computations to this time; do not mix different timestamps in a single quote.
base: Keep base explicit in cache keys; never assume it’s always USD in multi-currency apps.
rates: A symbol-to-value map. In examples shown, XAU is the primary item for gold.
unit: “per troy ounce” anchors your weight conversions.

Performance considerations and scaling tips

Edge caching: If you serve web clients across regions, place your price microservice behind a CDN configured to respect short TTLs aligned to your update interval.
Asynchronous refresh: Refresh Metals-API data on a schedule and publish to subscribers (WebSocket or SSE) to avoid request bursts.
Batch analytics: For OHLC and Fluctuation, compute secondary metrics (ATR, rolling averages) offline and store as cached artifacts for fast rendering.

Troubleshooting guide

No or empty rates: Verify symbol is supported via the Metals-API Supported Symbols page and confirm your plan includes the endpoint.
Unexpected unit math: Always read unit from the response; convert only once per pipeline stage.
Stale UI values: Ensure your cache TTL matches the update cadence for your plan; add a “last updated at” label sourced from timestamp.
Inconsistent quotes during fast moves: Anchor all steps of a single quote to the same timestamp; avoid re-fetching mid-transaction.

Compliance and audit trails

Persist raw responses for critical events (e.g., order placement) with timestamp and hash for later audit.
Log applied adjustments (premium, tax) and configuration version.
Document your rounding policy (e.g., round half-up to two decimals for display).

Linking documentation and symbol references

API reference and endpoint behavior: Metals-API Documentation.
Check symbol availability and metadata: Metals-API Supported Symbols.
Sign up for your key and start testing: Metals-API Website.

For broader market context and standards, review resources such as the London Bullion Market Association (LBMA) good delivery guidelines and reference market commentary from reputable financial sources to align your pricing with market practice.

Putting it all together: a minimal end-to-end flow

Acquire API key from the Metals-API Website and store securely.
Call Latest Rates for XAU; record timestamp, base, and unit.
Convert troy ounces to grams and apply Indore-specific adjustments in your business logic.
Cache results and display “last updated” using timestamp.
Use Bid/Ask for executable quotes; log the spread.
Backfill with Time-series for charts and analytics; compute Fluctuation for KPI summaries.
Add OHLC-driven alerts when volatility breaches your thresholds.

Example responses at a glance

Latest Rates (snapshot)

{
"success": true,
"timestamp": 1789606756,
"base": "USD",
"date": "2026-09-17",
"rates": {
"XAU": 0.000482
},
"unit": "per troy ounce"
}

OHLC (for analytics)

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

Fluctuation (period change)

{
"success": true,
"fluctuation": true,
"start_date": "2026-09-10",
"end_date": "2026-09-17",
"base": "USD",
"rates": {
"XAU": {
"start_rate": 0.000485,
"end_rate": 0.000482,
"change": -3.0e-6,
"change_pct": -0.62
}
},
"unit": "per troy ounce"
}

Convert (budget to ounces)

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

Call to action

Ready to build real-time Indore 24k (INDO-24k) pricing and analytics in Python? Get your free API key at the Metals-API Website and explore the full set of options in the Metals-API Documentation. Confirm symbol coverage and plan your integration using the Metals-API Supported Symbols reference.

Conclusion

Delivering accurate Indore Gold 24k (INDO-24k) pricing starts with a disciplined XAU pipeline: fetch a reliable spot snapshot via Metals-API, convert from troy ounces to grams, then apply your local adjustments. For trading and execution, prefer Bid/Ask; for analytics, use OHLC and Fluctuation; for research and backfilling, lean on Historical and Time-series. Protect your key, build resilient error handling and caching, and keep careful records of timestamps and units. This approach scales cleanly across trading tools, fintech apps, e-commerce storefronts, ERP integrations, and research workflows—while staying transparent and auditable for your team.

FAQ

How do I get started? Sign up for an API key on the Metals-API Website, then follow the examples here and the Metals-API Documentation.
What symbol should I use for gold? Use XAU. If you specifically display 24k retail prices, convert to per gram and apply your local adjustments for the INDO-24k context.
What unit are metal prices in? Metals-API returns metals per troy ounce by default for symbols like XAU. Convert to grams by dividing by 31.1034768.
How often are prices updated? Depending on your subscription plan, Latest may update every 60 minutes, 10 minutes, or faster. Cache results accordingly.
How do I handle weekends and holidays? Expect sparse or unchanged data; make your charts and alerts tolerant of missing days.
Can I convert currencies? Use the Convert endpoint to translate between USD and XAU amounts; integrate your FX logic as needed for local currency displays.
Is there intraday data? Yes, use Intraday for higher-frequency snapshots of a single symbol.
How should I secure my key? Keep it server-side, rotate periodically, and never expose it in client code.

Ready to use Metals-API?

Try it now!