Get Accurate Pondicherry Gold 22k (POND-22k) Prices in Indian Rupees and Other Currencies with this API

If you need accurate Pondicherry gold 22k (POND-22k) prices in Indian Rupees (INR) and other currencies for pricing jewelry, powering a bullion checkout, monitoring risk in a trading system, or driving a market dashboard, Metals-API gives you a production-ready foundation. In this guide, we’ll show how to use the API’s real-time gold (XAU) rates, carat-based pricing, conversion, OHLC, and fluctuation features to calculate, display, and analyze 22-karat gold prices in INR and any other currency your application supports—along with implementation patterns, scalability tips, and the operational detail developers rely on.

Why POND-22k pricing is different—and how to calculate it correctly with Metals-API

In Indian retail markets like Pondicherry, customers often ask for “22k gold rate today,” quoted in INR per gram. Metals-API delivers institutional-grade gold (XAU) benchmarks as “per troy ounce” values with USD as the default base currency. To arrive at POND-22k with precision and auditability, your workflow should:

• Start with the latest XAU rate provided by the API.
• Convert to INR using the Convert or Latest Rates endpoint (or set your base appropriately if supported by your plan).
• Translate troy ounces to grams (1 troy ounce = 31.1034768 grams).
• Apply 22k purity adjustment (22k implies 22/24 fineness relative to 24k pure gold).
• Optionally add a local market premium/discount (e.g., for Pondicherry-specific logistics, making charges, or retail spreads) outside the API rate.

Metals-API also exposes richer features—Bid/Ask for spreads, OHLC and Lowest/Highest for analytics, Historical and Time-Series for charting and strategy backtests, Intraday for finer granularity (plan-dependent), and Carat for streamlined karat conversions. Explore supported symbols and features via the Metals-API Supported Symbols and the full Metals-API Documentation.

How developers and product teams use POND-22k data

• E-commerce jewelry: Show live INR per gram for 22k items, auto-repricing carts and quotes.
• Branch/retail dashboards: Standardize branch-level POND-22k displays with local markup overlays.
• Trading and risk: Monitor INR-denominated exposure to gold, run alerts on daily fluctuations, and track bid/ask spreads to manage slippage.
• ERP and accounting: Book bullion inventory and COGS using standardized, timestamped reference rates and historical snapshots.
• Research and analytics: Backtest hedging strategies using time-series and OHLC data; compare INR vs USD performance and drawdowns.

Core concepts: base currency, units, timestamps, and carat math

Before we dive into requests and response handling, a few essentials:

• Base currency: API responses default to USD base. You can transform to INR with the Convert endpoint, or request rates as needed based on plan capabilities.
• Units: Gold is quoted “per troy ounce.” Convert to grams using 31.1034768 grams per troy ounce.
• Karat to fineness: 24k is pure (fineness 1.0). 22k is 22/24 = 0.916666..., 18k is 0.75, etc. Metals-API provides a Carat endpoint to streamline karat price derivation from LME/benchmark-like references.
• Timestamps and timezone: Responses include “timestamp” and “date.” Treat timestamps as seconds since epoch UTC. For local scheduling (e.g., IST for Pondicherry), convert and display consistently.
• Market closures and weekends: Metals markets may have limited updates during weekends/holidays. Your app should handle stale timestamps, fallback to previous close, and visually flag “last updated” times.
• Caching: Cache recent responses to reduce API calls, improve latency, and provide resiliency during brief network disruptions. Consider TTLs aligned with your plan’s update frequency.

Getting started: keys, symbols, and the request model

To call the API, obtain an access_key from the Metals-API Website. You’ll pass this key to endpoints via an access_key parameter. Check symbol availability and exact tickers using the Metals-API Supported Symbols. Gold uses the symbol XAU, and INR is supported as a currency. Carat-based rates for gold are accessible via the Carat feature.

Quick path to POND-22k in INR: request, convert, compute

Below is a practical demonstration of how to go from benchmark gold to 22k INR per gram.

Example curl request: latest rates for XAU

This example fetches the latest rates with USD as base and XAU among the symbols, then you’ll compute 22k INR price after conversion. Replace YOUR_API_KEY with your key.

curl -G 'https://metals-api.com/api/latest' \
--data-urlencode 'access_key=YOUR_API_KEY' \
--data-urlencode 'base=USD' \
--data-urlencode 'symbols=XAU'

Sample JSON response (structure and fields based on Metals-API format):

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

Field usage:

• success: Check before processing.
• timestamp/date: Persist for audit and “last updated” display.
• base: USD here; stay consistent during conversion logic.
• rates.XAU: 0.000482 “per troy ounce” means 1 USD buys 0.000482 troy ounces of gold, or equivalently 1 troy ounce costs 1 / 0.000482 USD.
• unit: per troy ounce (confirm unit assumptions across your pipeline).

Convert USD to INR and compute 22k per gram

Next, convert either the ounce price to INR or the USD amount to INR using the Convert feature. You can convert monetary amounts to XAU or vice versa. After computing INR per troy ounce, translate to per gram and apply 22k factor (22/24).

JavaScript example: end-to-end POND-22k INR per gram

// Assumes you fetched two things:
// 1) Latest XAU rate with base USD: rates.XAU (per troy ounce)
// 2) A USD to INR conversion rate (e.g., via Convert or Latest with currencies), named usdToInr

async function computePondicherry22kInInrPerGram({ usdPerOunce, usdToInr }) {
// 1) Convert USD per troy ounce to INR per troy ounce
const inrPerOunce = usdPerOunce * usdToInr;

// 2) Convert to INR per gram (1 troy ounce = 31.1034768 grams)
const gramsPerTroyOunce = 31.1034768;
const inrPerGram24k = inrPerOunce / gramsPerTroyOunce;

// 3) Apply 22k factor
const karatFactor = 22 / 24; // 0.916666...
const inrPerGram22k = inrPerGram24k * karatFactor;

return {
inrPerOunce24k: inrPerOunce,
inrPerGram24k: inrPerGram24k,
inrPerGram22k
};
}

// Example: using Metals-API JSON shapes provided
// Response: rates.XAU = 0.000482 per troy ounce (base USD)
// USD->INR rate: obtain via Convert or Latest (not shown here)

Notes:

• To get usdPerOunce, invert the quoted 0.000482 “per troy ounce” if you prefer “USD per ounce” arithmetic: usdPerOunce = 1 / 0.000482.
• Alternatively, you can work in “ounces per USD” and keep the inversion at the last step. Consistency matters; pick one and test carefully.
• If your plan grants access to the Carat endpoint, you can directly query 22k equivalent prices to reduce manual fineness math. See “Using the Carat feature” below.

Exploring the Gold (XAU) data model: innovation in price discovery and analytics

Gold (XAU) sits at the intersection of macro hedging, consumer demand (jewelry), and industrial use. Metals-API packages this depth into a clean JSON layer that your stack can ingest for algorithmic trading, dynamic pricing, and analytics dashboards. When you price POND-22k in INR, you are effectively bridging international benchmark data (often anchored in USD references) with local retail economics—an ideal place to apply technology for transparency, automation, and intelligent decision-making.

This is where modern data engineering meets traditional markets: blend real-time XAU inputs with carat fineness, currency conversion, market hours logic, and audit trails. Use time-series and OHLC for BI, alerting, and model training. Metals-API streamlines the data ingestion side so you can focus on the business logic that differentiates your product.

Working with Latest Rates for live POND-22k updates

The Latest Rates capability provides the most recent exchange rates for metals like XAU and, depending on plan, updates at intervals such as every 60 minutes or 10 minutes. Use it to drive “live” pricing on storefronts, internal tools, and trading panes.

Latest Rates: example response

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

Key implementation points:

• Persist timestamp and date for each refresh to support pricing audits.
• Cache the result until your plan’s next expected refresh interval. A short TTL improves resilience and UX.
• If the response arrives with the same timestamp as your cached data, skip re-pricing to cut compute and UI churn.

Common pitfalls with Latest Rates

• Misinterpreting units: Always assume “per troy ounce” for metals.
• Base confusion: If base is USD, transforming to INR is a separate step (Convert or additional rates query).
• Weekend staleness: Detect unchanged timestamps and either show “last updated” copy or fall back to previous close logic with a visual badge.

Security and performance with Latest Rates

• Do not expose your access_key in client-side apps; route through your backend.
• Use server-side caching and ETag-like patterns at your edge to reduce latency.
• Log success=false cases and apply exponential backoff on transient network errors.

Historical rates for charting, backfills, and reconciliation

To analyze POND-22k behavior or reconcile accounting entries for previous days, query the Historical Rates feature. It returns a single day’s snapshot, ideal for backfilling missing data or validating end-of-day positions.

Historical Rates: example response

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

How to use this for POND-22k:

• Store daily XAU snapshots in your data warehouse.
• Convert to INR using historical FX for the same date to maintain pricing integrity.
• Compute 22k per gram historically for charts and reports.

Historical Rates tips

• Always pair gold with the corresponding day’s INR rate to avoid FX drift.
• If markets were closed, ensure you know whether the date maps to last available rate.
• Apply idempotent writes when backfilling to prevent duplicates.

Time-Series for multi-day windows and analytics

For time-bound analytics (e.g., 7-day trends or monthly risk), query Time-Series to fetch continuous windows of daily data. This feeds dashboards and supports backtests without manual day-by-day calls.

Time-Series: example response

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

Using Time-Series for POND-22k:

• For each day, convert XAU to INR and apply 22k factor to compute INR/g series.
• Join to your internal premium/discount model per day to reflect local conditions.
• Feed BI dashboards or quant notebooks for trend analysis.

Time-Series performance considerations

• Query reasonable windows consistent with plan limits.
• Cache windows and delta-update with Latest for near-real-time UIs.
• Normalize timestamps to UTC and derive local day boundaries for India Standard Time where needed (IST is UTC+5:30).

Convert for precise currency transformations

The Convert capability lets you transform an amount from one currency or metal to another, e.g., USD to XAU, XAU to USD, or USD to INR. Use it to keep FX transformations aligned with the API’s rate logic, avoiding mismatches between gold and FX sources.

Convert: example response

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

Developer notes:

• Use info.timestamp to align conversions with your Live/Latest read.
• Check unit to confirm ounces vs currency units in the result.
• For POND-22k in INR, either convert the ounce price to INR or compute via USD path and then apply FX on the result—be consistent.

Fluctuation for alerts and risk management

Day-to-day moves inform alerts, inventory revaluation, and risk scalers. The Fluctuation feature quantifies the change between two dates, returning absolute and percentage differences.

Fluctuation: example response

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

How to apply for POND-22k:

• Transform start/end XAU to INR and then to 22k per gram; compute change_pct in local INR terms if that’s your business KPI.
• Create alert thresholds (e.g., notify if 22k INR/g moves ±1%).
• Combine with Bid/Ask to assess whether moves are material after spreads and fees.

OHLC for charting and intraday analytics

Open/High/Low/Close gives you a compact daily state to chart volatility or support end-of-day reporting and compliance. It’s especially useful for candlestick charts and range analysis.

OHLC: example response

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

Usage patterns:

• Store OHLC for XAU and compute derived OHLC for 22k INR/g for candlestick views specific to POND-22k retail pricing.
• Evaluate intraday ranges to set pricing buffers for storefronts (e.g., only reprice if change exceeds a threshold).
• Calculate ATR-like measures from high/low bands to inform risk-based markups.

Bid/Ask for spreads and executable context

If your plan provides Bid/Ask, you can retrieve market spreads to estimate transaction costs, slippage, and realistic execution price assumptions for hedging or institutional quoting.

Bid/Ask: example response

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

For POND-22k INR/g:

• Derive 22k INR/g bid and ask to show retail buy/sell quotes transparently.
• Use spread to determine minimum viable markup for profitable quoting.
• Log spreads against time to improve internal execution strategies.

Lowest/Highest and Intraday for monitoring extremes

If you need a quick handle on the range, Lowest/Highest aggregates daily extremes, while Intraday (plan-dependent) can provide finer resolution during the day. Together, they support dynamic alerts and limit-setting in a pricing engine.

Design patterns:

• Compute INR/g 22k extremes from USD/XAU extremes and FX; push signals to your app.
• Drive UI badges such as “Near Day’s High” or “Off 52-Week Low” if you aggregate further.
• Align intraday TTLs and polling rates with plan limits to avoid unnecessary load.

Using the Carat feature for direct karat-based outputs

The Carat feature returns gold rates by karat, simplifying your pipeline. Rather than manually multiplying by 22/24, request carat-specific rates and then convert units as needed. This reduces logic surface area and potential rounding discrepancies.

Implementation tips:

• Confirm the carat to base mapping and ensure the returned unit remains “per troy ounce” (unless the endpoint specifies otherwise).
• Even with carat-based outputs, remember grams versus ounces for end-user display in India.
• Pair Carat with Convert to generate INR outputs quickly.

Data governance: audits, reproducibility, and compliance

• Persist raw JSON along with derived POND-22k INR/g and your local premium model inputs.
• Document transformation steps: base currency, conversion method, karat factor, unit conversion, and any rounding rules.
• Provide a “why” trail: market hours considerations, fallback to previous close, and timestamped rationale for prices shown to customers.

Advanced architecture for high-availability POND-22k pricing

• Edge caching: Put a short-lived CDN cache in front of your rate microservice to slash latency and shield core services.
• Roll-forward caching: If Latest is temporarily unavailable, continue serving last-known rates with a banner indicating staleness.
• Write-ahead storage: Stream new rates to a durable store (e.g., Kafka, Pub/Sub) and materialize INR/g 22k continuously for subscribers.
• Multi-region failover: Mirror your pricing service in multiple regions to withstand localized outages.

Endpoint-by-endpoint deep dive with examples, field usage, and troubleshooting

Latest Rates in detail

Purpose: Fetch the most recent rates for metals and currencies.

Key parameters to consider:

• access_key: Your API key.
• base: Usually “USD” by default; align with your conversion design.
• symbols: Include XAU (and optionally other metals) to reduce payload size.

Scenarios:

• Success with XAU present: Compute POND-22k INR/g.
• Success but stale timestamp: Show “last updated” and skip aggressive repricing.
• success=false: Retry with backoff; fall back to cached snapshot.

Optimization tactics:

• Cache Latest responses for a TTL in line with your plan’s update cadence.
• Use symbols to narrow your payload and reduce parsing time.

Historical Rates in detail

Purpose: Retrieve a dated snapshot for backfills, reconciliation, and chart baselines.

Key parameters:

• access_key: API key.
• date: Historical date in the supported format (YYYY-MM-DD as indicated by docs).
• base/symbols: Align with your historical data model.

Scenarios:

• Holiday: You may receive the last available price; annotate accordingly.
• Accounting: Persist raw snapshot and derived INR/g 22k for audits.

Troubleshooting:

• Ensure date boundaries are UTC-based; converting to local can cause off-by-one errors if not handled carefully.

Time-Series in detail

Purpose: Fetch multiple days of data for trend analysis and backtesting for retail pricing or hedging models.

Parameters:

• access_key: API key.
• start_date, end_date: Specify window; verify plan-specific limits.
• base/symbols: Keep consistent with other endpoints for apples-to-apples evaluation.

Strategies:

• Transform to 22k INR/g per day for BI dashboards.
• Identify rolling volatility and adjust markups or alert thresholds.

Fluctuation in detail

Purpose: Quantify changes between two dates; ideal for alerts and portfolio updates.

Parameters:

• access_key, start_date, end_date.
• symbols: Include XAU to focus on gold.

Response fields to use:

• rates.XAU.start_rate/end_rate: Anchor points for time delta.
• change/change_pct: Directly usable for dashboards; consider recomputing in INR/g 22k context.

Errors and edge cases:

• Non-trading days can compress ranges; communicate context in UIs.

Convert in detail

Purpose: Transform amounts across currencies and metals, keeping conversions consistent with API logic.

Parameters:

• from, to, amount, access_key.

Response fields:

• info.timestamp: Store with the conversion result for reproducibility.
• result and unit: Confirm unit semantics when metals are involved (“troy ounces”).

Implementation guidance:

• Use Convert to derive INR amounts at the same timestamp as XAU for coherent pricing.

OHLC in detail

Purpose: Retrieve open/high/low/close for daily range analysis and candlestick charts.

Parameters:

• access_key, date (per docs), base, symbols.

Response:

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

Practical tips:

• Convert each OHLC point to INR/g 22k to feed front-end chart libraries consistently.
• Store time-normalized OHLC; avoid mixing timezones.

Bid/Ask in detail

Purpose: Observe spreads for more execution-realistic models, price slippage estimates, and retail buy/sell quoting logic.

Fields to use:

• bid/ask/spread: Build spread-aware price displays and set minimum markups accordingly.

Edge cases:

• During illiquid periods, spreads may widen; adapt pricing buffers or temporarily slow repricing frequency.

Lowest/Highest and Intraday in detail

Purpose: Extract daily extremes and, if needed, intraday data to refine alerting and user messaging (e.g., “Price near day’s low”).

Considerations:

• Use extremes to derive normalized indicators like percent-of-day-range for POND-22k.
• Guard polling and caching to respect plan limits and keep latency low.

Carat in detail

Purpose: Retrieve gold rates by carat to avoid manual fineness calculations. For POND-22k, this provides a direct path to 22k pricing.

Usage guidance:

• Confirm the base and unit in responses remain consistent with your pipeline.
• Apply Convert to reach INR, then divide by grams per troy ounce for INR/g display.

Historical LME in detail

Purpose: Access historical LME-linked symbols (where applicable) dating back further, supporting long-horizon research and benchmarking.

Use cases:

• Run long-run volatility studies comparing gold to base metals exposure in your portfolio.
• Correlate gold and copper as a macro signal for manufacturing-linked pricing strategies.

Designing the POND-22k calculation pipeline end to end

1. Fetch Latest XAU and relevant FX (USD to INR) data.
2. Compute USD per ounce from XAU “per troy ounce” rates, or keep the reciprocal form consistently.
3. Convert to INR per ounce (via Convert or FX rate).
4. Divide by grams per troy ounce to get INR per gram (24k baseline).
5. Multiply by 22/24 to get INR per gram 22k.
6. Apply local premium/discount rules if desired (outside Metals-API data).
7. Cache the final numbers with timestamp and input lineage for audits.

Practical guidance: units, rounding, currency display, and weekend behavior

• Units: Always annotate “per troy ounce” internally and convert to grams for India-facing UIs.
• Rounding: Define deterministic rounding for INR/g 22k (e.g., 2 decimal places) and log pre-rounded values for reproducibility.
• Weekend/holidays: If updates pause, display “last updated” and provide EOD from prior session; consider dampening repricing to avoid user confusion.

Caching and performance best practices

• Memory cache: Store last-successful Latest and its derivatives (INR/g 22k) for sub-millisecond reads.
• Time-based invalidation: TTL aligned with your plan’s update frequency; consider jitter to avoid thundering herd.
• Background refresh: Update behind the scenes; if timestamp unchanged, skip publishing.
• Compression: Gzip/deflate API responses at your edge to cut bandwidth; responses are small, but this helps at scale.

Security and compliance

• API key hygiene: Keep access_key server-side; never embed in client apps.
• Least privilege: Restrict who can deploy or rotate keys; log key usage.
• Input validation: Sanitize query parameters (dates, symbols) to prevent injection into logs or dashboards.
• Secrets rotation: Automate key rotation and deploy without downtime.

Error handling, resilience, and recovery

• Check success flag before reading rates; log and alert on failures.
• Retry policy: Exponential backoff with jitter for transient network errors.
• Fallback: Serve cached values with explicit UI banners if the API is unreachable.
• Data integrity: Validate that required fields (e.g., rates.XAU) exist before calculations; short-circuit otherwise.

Data validation and sanitization at ingest

• Schema checks: Validate that “unit” is “per troy ounce” for gold responses you consume.
• Range checks: Ensure XAU rates and FX are within reasonable bounds to catch anomalies.
• Timestamp monotonicity: Detect time reversals or stale updates; gate publishing logic accordingly.

Analytics and modeling with POND-22k series

• Volatility targeting: Adjust markups based on rolling volatility derived from Time-Series or OHLC.
• Seasonality: Study festive season demand vs price changes to inform stocking and promotions.
• Macro overlays: Combine with macro data for demand forecasting and risk hedging.

Case studies: how teams deliver POND-22k with Metals-API

Jewelry e-commerce

• Objective: Real-time INR/g 22k pricing in product cards and carts.
• Approach: Latest + Convert + Carat, cached with 10–60 minute refresh; OHLC for trend badges.
• Outcome: Automated repricing, improved quote accuracy, fewer manual updates.

Trading desk risk

• Objective: Monitor INR exposure and manage hedges.
• Approach: Latest + Bid/Ask + Fluctuation; alerting on change_pct thresholds.
• Outcome: Tighter control over P&L swings and better execution planning.

Manufacturing ERP

• Objective: Standardize bullion cost for 22k inputs in INR.
• Approach: Daily Historical snapshots for accounting, Time-Series for procurement planning.
• Outcome: Auditable costs, streamlined purchasing, and consistent branch pricing.

Joining metals and FX: avoiding drift

When converting XAU to INR, ensure the FX rate (USD to INR) is timestamp-aligned with the gold rate. This prevents drift where gold and FX reflect different market moments. Store timestamps for both and consider atomic conversions via the Convert feature to keep your lineage clean.

Scaling and observability

• Metrics: Track API latency, success rate, cache hit rate, and time-to-publish.
• Tracing: Correlate rate fetches to downstream pricing updates and UI renders.
• Dashboards: Show current POND-22k INR/g, last updated, source timestamp, and spread-adjusted markers.

Integrations and ecosystem

• BI tools: Pipe derived POND-22k data to your warehouse for Looker/Power BI reports.
• Alerting: Integrate with Slack or email for threshold breaches on change_pct or spreads.
• Market references: For general market context and education, see resources like the LBMA at LBMA while sourcing executable data from Metals-API.

Reference JSON examples you’ll actually use

Latest + Convert combined flow

Fetch Latest for XAU, then Convert USD to INR for alignment.

{
"latest": {
"success": true,
"timestamp": 1789520045,
"base": "USD",
"date": "2026-09-16",
"rates": { "XAU": 0.000482 },
"unit": "per troy ounce"
},
"convert": {
"success": true,
"query": { "from": "USD", "to": "INR", "amount": 1 },
"info": { "timestamp": 1789520045, "rate": 83.25 },
"result": 83.25,
"unit": "INR"
}
}

Explanation:

• Align timestamps to avoid drift.
• Use USD -> INR rate to translate USD per ounce to INR per ounce, then per gram, then 22k.

Time-Series window for daily charts

{
"success": true,
"timeseries": true,
"start_date": "2026-09-09",
"end_date": "2026-09-16",
"base": "USD",
"rates": {
"2026-09-09": { "XAU": 0.000485 },
"2026-09-11": { "XAU": 0.000483 },
"2026-09-16": { "XAU": 0.000482 }
},
"unit": "per troy ounce"
}

Compute INR/g 22k for each date and render a clean series in your charts.

OHLC for a dashboard candle

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

Convert each point to INR/g 22k for candlesticks tailored to India retail.

Fluctuation for notification triggers

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

Re-express change_pct after INR/g 22k transformation to keep end-user language consistent.

Karat conversion cheat sheet

Karat	Fineness (relative to 24k)	Multiplier	Common Use
24k	1.0000	24/24	Bullion reference
22k	0.9167	22/24	India jewelry standard
18k	0.7500	18/24	Fine jewelry
14k	0.5833	14/24	Durable wear

Use the Carat feature to return karat-adjusted rates directly when available, or multiply the 24k baseline by the fineness to derive your POND-22k values.

Data integrity: reconciling POND-22k with internal books

• Each published price should cite its source timestamp and transformation steps.
• For accounting, pin daily close using OHLC close or a chosen snapshot time.
• Maintain separate columns for market rate, karat factor, FX rate, markup, and final displayed price.

Developer onboarding and documentation pointers

• Start at the Metals-API Website to get your free API key and explore plans.
• Review endpoint parameters and response fields in the Metals-API Documentation for production nuances.
• Confirm symbols (XAU, INR, and others) via the Metals-API Supported Symbols.

Frequently asked questions

How do I get a clean INR per gram 22k number for Pondicherry?

Fetch XAU via Latest, convert to INR (Convert or FX), divide INR per troy ounce by 31.1034768 to get INR per gram 24k, multiply by 22/24 for 22k, then apply your store-specific premium/discount if desired.

Can I request carat-specific rates directly?

Yes. Use the Carat feature to retrieve gold rates by karat. You’ll still convert units (ounces to grams) and currencies (USD to INR) as needed.

How should I handle weekends and holidays?

Expect reduced or paused updates. Display “last updated” based on the response timestamp, and optionally fall back to previous close or your last fetched snapshot.

What about bid/ask spreads?

If your plan includes Bid/Ask, use it to compute more realistic executable prices and spreads for retail buy/sell quotes and hedging decisions.

How do I ensure performance at scale?

Cache Latest for short TTLs, delta-update Time-Series windows, compress responses, and precompute INR/g 22k in your backend for instant front-end delivery.

Is my access key safe in the browser?

No. Keep the access_key on your server. Provide your own sanitized endpoints to clients as needed.

Can I backtest pricing strategies?

Yes. Use Historical and Time-Series to generate clean datasets, compute INR/g 22k for each date, and run your analyses or simulations accordingly.

Where can I learn more and start building?

Visit the Metals-API Website to get a free API key, check the Metals-API Documentation, and confirm symbols on the Metals-API Supported Symbols. Build your POND-22k INR/g pipeline in hours, not weeks.