Get Jaipur Gold 18k (JAIP-18k) Historical Prices with JSON Format API

Building a Jaipur gold jewelry pricing tool or research dashboard? This guide shows how to get Jaipur Gold 18k historical prices in JSON via Metals-API—starting from the canonical Gold (XAU) historical series, converting to Indian Rupees (INR), applying 18k purity (75%), and producing a clean daily time series suitable for analytics, product pricing, hedging, or backtesting. You will learn how to query Metals-API for Gold historical data, transform that data into 18k equivalents, and integrate it into services that need reliable, timestamped, per troy ounce pricing. We will also cover practical issues like units (troy ounces vs grams), base currency defaults, weekends and market closures, caching, and performance optimization. For complete reference materials, visit the Metals-API Website and documentation: Metals-API Website and Metals-API Documentation. If you need to confirm symbol availability, always check the official list at Metals-API Supported Symbols.

Why “Jaipur Gold 18k” matters and how to compute it from XAU

“Jaipur Gold 18k” (sometimes written informally as JAIP-18k) refers to a localized retail-relevant price notion: the market price of 18 karat gold in Jaipur, India. Metals-API exposes institutional-grade metals data such as Gold (XAU) in a consistent JSON format. When a region-specific 18k symbol is not explicitly listed among the supported symbols, you can derive a robust Jaipur 18k time series from first principles:

• Step 1: Query historical Gold (XAU) in terms of USD per troy ounce.
• Step 2: Convert to INR using currency rates exposed by Metals-API.
• Step 3: Apply the 18k purity factor: 18k is 75% pure (18/24), so multiply the pure gold price by 0.75 for the 18k equivalent.
• Step 4: Convert ounces to grams if your product costing uses grams. A troy ounce is approximately 31.1034768 grams.
• Optional: Add regional making, GST, or margin adjustments outside the API if your pricing workflow requires them.

If Metals-API provides a gold-by-carat rate via the Carat endpoint or a region-specific symbol (verify on the Supported Symbols page), you can request it directly. Otherwise, the above transformation gives a transparent and auditable pipeline from raw XAU data to a Jaipur 18k time series.

Use case: Backfilling a Jaipur 18k historical chart for a pricing app

Suppose you are building a jewelry e-commerce backend for Jaipur where catalog prices should reflect the latest 18k gold cost, yet your analysts also need a historical chart back to 2019 for trend analysis and hedging. Metals-API’s Historical Rates and Time-series endpoints give you daily XAU prices in USD per troy ounce. Combine them with currency rates to INR and apply 18k purity logic to generate a precise, daily Jaipur 18k curve. You can then store this curve in your database, power dashboards, compute rolling averages, trigger alerts on percentage moves, and feed your pricing rules engine.

Key concepts you must get right before coding

• Units matter: Metals-API metals rates are commonly “per troy ounce.” A troy ounce is ~31.1034768 grams. If your pricing uses grams, always convert.
• Base currency: By default, Metals-API returns rates relative to USD unless you specify otherwise. Validate base fields in every response before calculations.
• Timestamps: Responses include a UNIX timestamp and a date string. Align your analytics to a consistent timezone (typically UTC) and date-cutover rules.
• Market closures: Metals markets and FX can be illiquid or closed on weekends/holidays. If you need a seven-day curve, forward-fill or interpolate thoughtfully.
• Caching: Cache responses (e.g., daily series) to reduce API calls and latency. Update only when necessary.
• Validation: Always check the “success” flag, response shape, and “unit” field before using data in pricing or analytics.

What you can do with Metals-API for Jaipur 18k

• Historical backfill since 2019 for XAU; derive 18k in INR for Jaipur product pricing and dashboards.
• Compute day-to-day fluctuation metrics with the Fluctuation endpoint for volatility, alerting, and PnL stress tests.
• Use OHLC for charting and technical studies; fetch Bid/Ask to analyze spreads and liquidity regimes.
• Perform conversions between USD, INR, and XAU using the Convert endpoint to price orders, hedge positions, or settle invoices.

For a deeper exploration of endpoints, refer to the official Metals-API Documentation. To check if a dedicated carat or regional symbol is available, consult Metals-API Supported Symbols. If you are new to the service, you can get a free API key at the Metals-API Website to start prototyping.

From XAU to Jaipur 18k: end-to-end workflow overview

1. Pull historical daily XAU rates (USD base, per troy ounce) for your date range.
2. Pull corresponding FX rates for INR over the same dates (if not returned in the same call).
3. Compute USD per troy ounce to INR per troy ounce by applying USD→INR rate.
4. Multiply INR per troy ounce by 0.75 for 18k purity.
5. Optionally convert to per gram by dividing by 31.1034768.
6. Store the final Jaipur 18k series in your database for charting and pricing engines.

A quick look at real JSON response structures you will use

The following examples show Metals-API JSON payloads (values shown are realistic-format examples). Each includes a base currency, a timestamp, a date, and a rates object. You will extract XAU and FX symbols (e.g., INR) from these structures to generate a Jaipur 18k series.

Latest rates: real-time XAU snapshot

{
"success": true,
"timestamp": 1789432806,
"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"
}

Fields to use:

• base: "USD" indicates rates are quoted relative to USD.
• rates.XAU: value represents troy ounces of gold per 1 USD (i.e., XAU per USD). Equivalently, 1 / XAU yields USD per ounce.
• unit: "per troy ounce" confirms the metal unit.
• timestamp/date: for alignment and caching.

Historical rates: daily close for a single day

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

Use historical rates to backtest or fill charts. Combine with FX to localize to INR.

Time-series: batch daily rates over a period

{
"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"
}

The time-series response lets you iterate dates deterministically and join with INR FX for conversion, then apply 18k purity logic.

Convert endpoint: get direct conversions

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

This is useful to compute ounces from dollars or vice versa. To localize to INR, you’ll combine conversions appropriately and then apply 18k purity.

Fluctuation endpoint: day-over-day changes

{
"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"
}

Use this to build alerts when Jaipur 18k equivalents move beyond thresholds, after you transform XAU to 18k INR.

OHLC endpoint: daily open/high/low/close

{
"success": true,
"timestamp": 1789432806,
"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"
}

OHLC supports richer charting and volatility analysis for Jaipur 18k once you convert OHLC values into INR and apply purity factors consistently.

Bid/Ask endpoint: spread-aware pricing

{
"success": true,
"timestamp": 1789432806,
"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"
}

Use bid/ask to compute conservative procurement prices or risk buffers. For Jaipur 18k, transform both bid and ask to INR and 18k to get a spread-aware band for pricing engines.

Concrete HTTP requests you can run

Below is an example curl request to retrieve historical daily rates for a given date using the Historical Rates endpoint. Replace YOUR_ACCESS_KEY with your key from the Metals-API Website.

curl "https://metals-api.com/api/2026-09-14?access_key=YOUR_ACCESS_KEY&base=USD&symbols=XAU,INR"

Notes:

• Appending base and symbols helps control payload size and aligns data precisely with your conversion logic.
• If INR is supported as a currency rate, including INR ensures you have both XAU and USD→INR for the same timestamp.
• If INR is not returned in the same response, query it separately or use a time-series call that includes both XAU and INR for all dates.

Python example: build a Jaipur 18k daily series

The following code shows how to pull a time series of XAU and INR and compute an 18k INR price per gram. This follows the common 18k purity factor (0.75). Adjust rounding, holidays, and fallback logic as needed for your environment.

import os
import requests
from datetime import date

ACCESS_KEY = os.getenv("METALS_API_KEY", "YOUR_ACCESS_KEY")
START = "2026-09-08"
END = "2026-09-15"

# Step 1: Fetch XAU and INR series together. If your plan supports it, include both.
url = (
f"https://metals-api.com/api/timeseries"
f"?access_key={ACCESS_KEY}"
f"&start_date={START}&end_date={END}"
f"&base=USD&symbols=XAU,INR"
)
resp = requests.get(url, timeout=30)
data = resp.json()

if not data.get("success"):
raise RuntimeError(f"API error: {data}")

# Step 2: Build Jaipur 18k series:
# - XAU is quoted as XAU per USD (ounces per 1 USD). Invert to get USD per ounce.
# - Multiply by USD->INR to get INR per ounce.
# - Multiply by 0.75 (18k purity) to get 18k INR per ounce.
# - Divide by 31.1034768 to get per gram if desired.
OZ_TO_G = 31.1034768
jaipur_18k_per_gram = {}

for dt, rates in data.get("rates", {}).items():
xau = rates.get("XAU")
inr = rates.get("INR")
if xau is None or inr is None:
# skip or handle with interpolation/forward-fill
continue

usd_per_oz = 1.0 / xau
inr_per_oz = usd_per_oz * inr
inr_18k_per_oz = inr_per_oz * 0.75
inr_18k_per_gram = inr_18k_per_oz / OZ_TO_G

jaipur_18k_per_gram[dt] = round(inr_18k_per_gram, 2)

print(jaipur_18k_per_gram)

What matters in the JSON response:

• success: Validate it before using data.
• base: Ensure it is “USD” for the inversion logic shown; if not, adjust accordingly.
• rates[date].XAU: Metals per USD; invert to get USD per troy ounce.
• rates[date].INR: USD→INR exchange rate; multiply to convert USD/oz to INR/oz.
• unit: Confirm “per troy ounce” for XAU rates.

End-to-end: turning JSON into Jaipur 18k analytics

With a clean time series of INR 18k per gram, you can implement:

• Dynamic product pricing: Update daily or intraday for carts and quotes.
• Charts and indicators: Compute SMA/EMA, Bollinger Bands on 18k INR/gram.
• Alerts: Notify when Jaipur 18k changes by +/− X% in a day (via Fluctuation endpoint data or your derivative series).
• Hedging: Translate procurement schedules into XAU and INR exposures and simulate PnL under scenario analysis using OHLC and Fluctuation.

Exploring Gold (XAU): digital transformation, analytics, and innovation

Gold (XAU) has evolved from a physical store of value to a data-driven asset integrated into modern fintech systems. Metals-API abstracts away data sourcing complexity and exposes consistent JSON endpoints, enabling:

• Digital transformation in precious metals: Seamless integration into ERPs, e-commerce pricing, and inventory valuation.
• Data analytics and market insights: Backtesting strategies against synchronized XAU and FX time series; computing rolling betas against INR and other currencies.
• Technology integration in trading: Connect XAU streams into order-routing or hedging logic, enhanced by bid/ask spreads and OHLC structures.
• Innovation in price discovery: Combine Metals-API with your internal demand data to price jewelry dynamically and reduce stock risk.
• Digital asset solutions: Tokenize 18k inventory exposure by pricing underlying 24k XAU and adjusting purity and costs in real time.

Detailed guidance for each Metals-API feature you will likely use

Historical Rates: daily close snapshots you can trust

Purpose: Retrieve the daily rate for a specific date since 2019. Essential for backfilling Jaipur 18k series.

• Key parameters:
  • access_key: your API key
  • date path segment: YYYY-MM-DD
  • base: typically USD for metals; verify in responses
  • symbols: XAU plus currencies you need (e.g., INR) if available
• Usage: Call per day (or prefer Time-series for batch).

Example success response (see earlier “Historical rates” example). Extract rates.XAU and rates.INR if present. If INR isn’t included, fetch INR separately or use Convert endpoint as a cross-check.

Common pitfalls:

• Confusing XAU per USD with USD per XAU. Always verify whether you must invert.
• Not checking unit “per troy ounce.” Do not mix with grams without conversion.
• Timezone misalignment between your application and “date” fields. Normalize to UTC.

Performance tips:

• Batch with Time-series calls to reduce HTTP overhead.
• Cache daily responses; they don’t change retroactively once finalized.

Security tips:

• Do not log full URLs with access_key in plaintext logs.
• Use environment variables or secret managers for your API key.

Time-series: efficiently retrieve continuous windows

Purpose: Get daily rates between start_date and end_date. Ideal for Jaipur 18k backfills and rolling analytics windows.

• Key parameters:
  • access_key
  • start_date, end_date (YYYY-MM-DD)
  • base=USD (typical)
  • symbols=XAU, and add INR if needed and supported

Response: See the earlier “Time-series” example. Iterate over rates[date] to compute INR 18k per gram.

Common pitfalls:

• Skipping dates where INR is missing; decide on interpolation or forward-fill policy.
• Assuming every calendar date has data; weekends/holidays might be absent or have repeated values.

Performance tips:

• Use incremental windows (e.g., last 7 days) for daily updates; avoid re-pulling your entire history.
• Persist rolled-up aggregates (e.g., monthly averages) to reduce recomputation.

Latest: intra-day updates for near-real-time pricing

Purpose: Retrieve the latest rates for metals. Useful for pricing carts and quotes in near real time.

• Update cadence: Depending on plan, updated every 60 minutes, 10 minutes, or more frequently. Check your subscription level.
• Combine with a currency rate (e.g., INR) to update your Jaipur 18k price point.

Common pitfalls:

• Using latest data for historical analysis; keep historical and latest workflows separate to maintain data lineage.

Performance tips:

• Respect caching headers and set a minimum refresh interval aligned to your plan.

Convert: precise conversions across metals and currencies

Purpose: Convert any amount from one symbol to another, such as USD→XAU or USD→INR. For Jaipur 18k, you may use Convert to cross-check intermediate calculations.

• Key usage patterns:
  • USD→XAU to find ounces for a dollar amount.
  • USD→INR to localize pricing.

Common pitfalls:

• Not recording the info.timestamp and info.rate used for auditability.

Security tips:

• Server-to-server calls only; do not expose your key in client-side code.

Fluctuation: change metrics for alerting and risk

Purpose: Retrieve start_rate, end_rate, absolute change, and change_pct between two dates. Combined with your 18k transformation, it powers alerts and risk dashboards specific to Jaipur.

Tips:

• Use Fluctuation for XAU and INR; then propagate the changes into your derived series for 18k INR/gram.
• Define alert thresholds conservatively to avoid noise on quiet days.

OHLC: better charting and technicals

Purpose: Open/High/Low/Close for stronger analysis and charting. To maintain internal consistency, convert each OHLC point from XAU to INR and apply 18k factor individually rather than converting only close.

Tips:

• Use OHLC to compute ATR, volatility bands, and price momentum on the derived 18k INR/gram series.

Bid/Ask: spread-aware procurement and pricing

Purpose: Access bid and ask to assess spreads and incorporate execution slippage into pricing rules.

Implementation ideas:

• Compute Jaipur 18k bid and ask bands by transforming both bid and ask to INR and 18k purity; then price retail SKUs off mid, bid, or a premium-adjusted mid, depending on your strategy.

Carat Endpoint: gold-by-carat retrieval

Purpose: Retrieve gold rates by carat when available on your plan. If an explicit regional 18k symbol (e.g., a Jaipur-specific code) appears on the Supported Symbols page or if the Carat endpoint provides 18k directly, you can request it to simplify your pipeline. Otherwise, compute from XAU using the 0.75 purity factor as described.

Tips:

• Always validate the base currency and unit returned by Carat endpoint responses.
• If only carat-adjusted USD values are returned, you’ll still need USD→INR conversion to localize for Jaipur.

Lowest/Highest and OHLC by date: range analysis and daily envelopes

Purpose: Retrieve the lowest-highest price and open-high-low-close for specific dates to do envelope checks, detect outliers, or construct range-bound strategies before transforming to 18k INR.

Tips:

• Store low/high bands daily for sanity checks against retail pricing anomalies.

Historical LME: industrial metals context

Purpose: Access historical LME symbols (dating back to 2008) for broader macro context in pricing frameworks that include gold alongside copper, aluminum, nickel, zinc, etc. While Jaipur 18k focuses on gold, jewelry manufacturers using base-metals components or multi-commodity hedging may leverage this endpoint for cross-asset analysis.

Field-by-field: how to correctly interpret Metals-API responses

• success: Boolean. Must be true before using the payload. If false, inspect error fields (code/message) if present.
• timestamp: UNIX epoch (seconds). Use for sorting, alignment, and idempotent caching.
• date: ISO date string (YYYY-MM-DD). Prefer “date” for human display; use “timestamp” for machine ordering.
• base: The quoted base. For metals, it is commonly “USD”. If base changes, your inversion and conversion logic must adapt.
• rates: Dictionary mapping symbol→value. For metals like XAU, the value commonly means metal units per USD, per troy ounce.
• unit: Typically “per troy ounce” for metals. Convert to grams where needed.

Handling weekends, holidays, and missing data

• Expect sparse or unchanged data on weekends and certain holidays. Do not assume seven days of unique values.
• Define a clear filling rule:
  • Forward-fill: Common for pricing charts; mark filled values distinctly for audit transparency.
  • No fill: For strict backtests, skip dates without settled data.
• Keep audit logs of original timestamps, base, and units. For compliance or financial reporting, maintain immutable raw-data snapshots and separate transformation logs.

Caching, performance, and scaling strategies

• Cache hierarchy:
  • Level 1 (in-memory): Recent latest/historical responses for fast reuse.
  • Level 2 (persistent): Store daily time series results to avoid repeated queries.
• Batching: Prefer Time-series for multi-day windows rather than looping single-date calls.
• Incremental updates: After initial backfill, only fetch new data since last stored date.
• Idempotence: Use timestamp in cache keys; do not overwrite historical values once finalized.
• Data volumes: If powering many endpoints, stage a precomputed Jaipur 18k series table in your database to serve UI and APIs efficiently.

Error handling and recovery

• Check success flag on all responses.
• Handle HTTP errors with retries and exponential backoff; avoid hot loops on transient failures.
• Validate response shape: ensure base, unit, and required symbols exist before computing downstream values.
• Fallback logic: If INR is unavailable for a date, choose to skip, forward-fill, or use an alternate FX source consistent with your governance policy.

Security: keeping your key and data safe

• API key hygiene:
  • Store keys in environment variables or a secret manager; never hardcode in source control.
  • Do not expose keys to client-side browsers or mobile apps; proxy via your backend.
  • Rotate keys periodically and when staff roles change.
• Transport security: Always use HTTPS. Validate TLS in your HTTP client.
• Logging: Scrub URLs and headers of access keys. Log only high-level events and hashes.

Data validation and sanitization

• Check that rates.XAU and currency rates are numeric and within plausible bounds.
• Ensure unit is “per troy ounce” before applying ounce→gram conversion.
• Use high-precision floats (decimal types) for financial calculations; round only at presentation layers.

Architectural patterns for integrating Metals-API

• ETL service:
  • Scheduled job fetches XAU and INR via Time-series for the last N days.
  • Transforms to Jaipur 18k INR/gram.
  • Writes to a normalized time-series table with audit metadata.
• Pricing microservice:
  • Reads the latest Jaipur 18k price from the time-series store.
  • Applies SKU-level weights and making costs to derive list price.
• Analytics API:
  • Serves OHLC-derived indicators on Jaipur 18k for dashboards.
  • Implements alerts using Fluctuation-derived thresholds.

Compliance, auditability, and reproducibility

• Retain raw JSON snapshots and store transformation parameters: base currency, purity factor, ounce→gram factor, FX source, and timestamp.
• Version your transformation pipeline. A change to purity assumptions or fees must be traceable in outputs.
• Use immutable storage for historical series to avoid accidental rewrites.

Practical checks for Jaipur 18k pricing sanity

• Cross-verify: Occasionally compute 18k INR via two routes (e.g., USD→XAU and USD→INR separately vs. a single Convert chain) to ensure path independence.
• Compare trends with reputable market commentary (e.g., LBMA, Reserve Bank of India) for macro sanity.
• Detect outliers by comparing daily close to intraday OHLC bands before publishing prices.

Concrete workflow: multi-day Jaipur 18k backfill using curl

For a production pipeline, you’ll typically script requests. The following shows the pattern using Time-series to batch XAU and INR:

curl "https://metals-api.com/api/timeseries?access_key=YOUR_ACCESS_KEY&start_date=2026-09-08&end_date=2026-09-15&base=USD&symbols=XAU,INR"

Then, for each date:

1. usd_per_oz = 1 / rates[date].XAU
2. inr_per_oz = usd_per_oz * rates[date].INR
3. jaipur_18k_inr_per_oz = inr_per_oz * 0.75
4. jaipur_18k_inr_per_gram = jaipur_18k_inr_per_oz / 31.1034768

Store each computed value along with the original timestamp, base=USD, and unit metadata.

Advanced analytics: trend, volatility, and hedging from 18k series

• Trend detection: Compute 20-day and 50-day EMAs on Jaipur 18k INR/gram; use crossovers for procurement cadence decisions.
• Volatility: Derive historical volatility from OHLC-transformed series to scale safety buffers in pricing.
• Scenario analysis: Shock XAU and USD→INR separately to see composite impact on Jaipur 18k, informing hedging allocations between gold and FX instruments.

Troubleshooting common issues

• “Numbers look inverted.” Remember: XAU often arrives as ounces per USD; invert to get USD per ounce.
• “Weekend gaps.” Handle missing dates by forward-fill or skip; document the policy for stakeholders.
• “Mismatch between charts and pricing.” Ensure both charting and pricing use the same base, unit, and purity conversion path.
• “API key errors.” Verify the key, the account status, and that the request parameters match your plan capabilities.

Putting it all together: from API to Jaipur 18k product pricing

• Data ingestion: Scheduled Time-series calls for XAU and INR with base=USD.
• Transformation: Invert XAU to USD/oz, multiply by INR, apply 0.75, convert to grams.
• Persistence: Store date, timestamp, 18k INR/gram, and audit metadata.
• Application layer: Use the latest 18k INR/gram to price SKUs by net weight and making charges; expose an internal API for your storefront and ERP.
• Analytics: Build dashboards with OHLC-derived volatility and Fluctuation-derived alerts to time procurement.

Where to go next

• Get your free API key and start testing: Metals-API Website
• Read endpoint specifics, parameters, and examples: Metals-API Documentation
• Verify symbols and carat availability: Metals-API Supported Symbols

FAQ

• Does Metals-API provide a direct “Jaipur 18k” symbol?
  Always check the Supported Symbols. If not listed, derive Jaipur 18k by converting XAU to INR and applying the 0.75 purity factor.
• What unit are metal prices in?
  Per troy ounce by default. Convert to grams if your pricing uses grams (1 troy ounce ≈ 31.1034768 g).
• How do I handle weekends and holidays?
  Expect missing or unchanged data; forward-fill or skip based on your business rules. Document the policy for reporting consistency.
• Which base currency should I use?
  USD is standard for metals. Confirm the “base” field in responses before computing.
• How do I avoid overusing my quota?
  Use Time-series for batch retrieval, cache daily responses, and run incremental updates. Respect your plan’s update frequency.
• Can I retrieve OHLC and Bid/Ask for XAU?
  Yes. Use the OHLC endpoint for open/high/low/close and Bid/Ask for spreads, then transform each value to INR and 18k for precise analytics.
• Is there a carat endpoint?
  Yes, a Carat endpoint exists. If it returns 18k directly, you can simplify the pipeline; otherwise, compute 18k from XAU with a 0.75 factor.
• How do I secure my API key?
  Store it in environment variables or a secret manager; do not expose it in client-side code; rotate periodically and scrub from logs.
• Where can I learn more?
  Visit the Metals-API Documentation and sign up at the Metals-API Website.