Getting started with Silver Apr 2026 (SIJ26) - Per Troy Ounce Price API

You need a reliable way to fetch a Silver Apr 2026 (SIJ26) per troy ounce price for pricing, charting, or analytics. By the end of this guide, you will query the SIJ26 price via Metals-API, interpret USD/oz vs oz/USD correctly, handle the “expired symbol” case, and integrate the result into your app with production-ready code and caching tips.

What you’ll build: a per-oz price feed for SIJ26 you can ship today

We’ll focus on a minimal, working setup that returns the Silver Apr 2026 contract’s price, makes it usable as USD per troy ounce, and protects your app from common pitfalls (symbol retirement, weekend data, and unit confusion). We’ll use the Latest endpoint and show how to read both SIJ26 and its inverted pair USDSIJ26 so you can pick whichever your system expects.

A quick note on SIJ26, units, and inversion

Metals-API returns rates relative to a base currency (default is USD). For metals symbols, two representations matter:

• SIJ26: ounces per USD (how many troy ounces you get for 1 USD).
• USDSIJ26: USD per ounce (how many USD you pay for 1 troy ounce).

Because the base is USD, SIJ26 is “per 1 USD.” If you need USD/oz (what most pricing and charts use), either use USDSIJ26 directly (when available) or invert SIJ26 (USD/oz = 1 / SIJ26).

Weight unit is troy ounce, not avoirdupois. 1 troy ounce ≈ 31.1034768 grams. If your UI needs grams or kilograms, convert from troy ounces after you get the rate.

Get the latest SIJ26 price (curl you can paste)

We’ll query the Latest endpoint for both SIJ26 and USDSIJ26. Replace YOUR_API_KEY with your key. If you don’t have one yet, you can get it here: Register.

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

Below is an official sample JSON for that request. Use it to wire your parser before going live.

{"success":true,"timestamp":1791158940,"date":"2026-10-05","base":"USD","rates":{"SIJ26":0.014741435226134,"USD":1,"USDSIJ26":67.83599999999824},"warnings":[{"symbol":"SIJ26","code":410,"type":"expired_symbol","info":"The requested symbol has expired and is no longer available."}]}

How to read the response

• success: Request execution status. Check this before using rates.
• timestamp: Unix seconds. Treat as UTC and convert to your display timezone if needed.
• date: The server’s date for these rates. On non-trading days, this can lag the current calendar date.
• base: USD is the base currency.
• rates.SIJ26: Ounces per 1 USD (oz/USD).
• rates.USDSIJ26: USD per 1 ounce (USD/oz). This is often what your UI needs directly.
• warnings: Metadata you must handle. Here, SIJ26 is expired (code 410). Your integration should gracefully fall back when a contract symbol is retired.

Important: The warning indicates SIJ26 has expired and is no longer available. If you request it post-expiry, handle the warning and decide your fallback path (e.g., switch to a current contract month, use a spot silver symbol, or disable trading for this instrument). For current symbols, refer to the live catalog: Metals-API Supported Symbols.

Production-grade parsing in Python

This script fetches the latest SIJ26 and USDSIJ26, normalizes to USD/oz, and handles the “expired_symbol” warning. It also shows how to invert oz/USD to USD/oz safely when USDSIJ26 is not present.

import os
import time
import requests

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

params = {
"access_key": API_KEY,
"symbols": "SIJ26,USDSIJ26"
}

resp = requests.get(URL, params=params, timeout=10)
resp.raise_for_status()
data = resp.json()

if not data.get("success", False):
raise SystemExit(f"Metals-API error: {data}")

timestamp = data.get("timestamp")
as_of_utc = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp)) if timestamp else "N/A"
rates = data.get("rates", {}) or {}
warnings = data.get("warnings", []) or []

expired = any(w.get("symbol") == "SIJ26" and w.get("type") == "expired_symbol" for w in warnings)

usd_per_oz = None
if "USDSIJ26" in rates and isinstance(rates["USDSIJ26"], (int, float)):
usd_per_oz = rates["USDSIJ26"]
elif "SIJ26" in rates and isinstance(rates["SIJ26"], (int, float)) and rates["SIJ26"] != 0:
usd_per_oz = 1.0 / rates["SIJ26"]

if usd_per_oz is None:
raise SystemExit("Missing both USDSIJ26 and invertible SIJ26. Cannot compute USD/oz.")

print(f"As of {as_of_utc} UTC (base {data.get('base')}):")
print(f" USD per troy ounce (SIJ26): {usd_per_oz:,.6f}")
if expired:
print(" Note: SIJ26 is expired. Consider switching to an active symbol from the Symbols catalog.")

In a production service:

• Cache the response until the next expected update interval. The Latest endpoint updates on a plan-dependent cadence (e.g., every 60 or 10 minutes). Avoid hammering the API faster than the update frequency.
• Check both date and timestamp so you don’t present stale data when markets are closed.
• Guard against zero or missing rate fields before inverting SIJ26.

When a contract expires: resilient behavior

Futures-style symbols like SIJ26 age out. Metals-API will include a warning array with code 410 and type expired_symbol. Your app should:

• Detect the warning and log it with symbol + timestamp for auditability.
• Decide policy: disable trading/ordering for SIJ26, or automatically switch to a current month symbol your business supports.
• Validate any automatic switch against your allowlist from the catalog at Metals-API Supported Symbols.

If you do switch, make the change explicit to users (e.g., “Silver Front-Month”) and record it in your event log for compliance.

Turn the feed into quotes, charts, and alerts

Common downstream uses of USD per troy ounce:

• E-commerce pricing: Multiply USD/oz by item weight (e.g., 0.5 oz) and add making costs and margins.
• Manufacturing ERP: Convert USD/oz to cost per gram: USD/g = (USD/oz) / 31.1034768. Round conservatively to avoid under-costing.
• Trading dashboards: Use USDSIJ26 directly to plot intraday or EOD charts. If USDSIJ26 is missing, invert SIJ26.
• Alerts: Compare the current USDSIJ26 to your last cached value and fire a notification when absolute or percentage change exceeds a threshold.

Which endpoints matter for SIJ26 right now

Stay focused on 2–3 endpoints that help you launch fast. Full details live in the Metals-API Documentation.

• Latest: For the current SIJ26 and USDSIJ26 values. Use it to price and refresh UI tiles.
• OHLC: For open, high, low, close by date. Good for charts, backtesting EOD signals, or validating intraday moves. Use SIJ26 where supported.
• Time-Series: For a daily series between start_date and end_date. Ideal for populating historical charts or calculating rolling vol. Query the exact symbol (e.g., SIJ26) over its active window.

Note: Because SIJ26 is expired in the sample response, some historical endpoints may return only within the contract’s life. For ongoing coverage, keep an inventory of active symbols from the Symbols catalog and rotate accordingly.

Practical details that save you time

1) Units: troy ounces and conversions

• All rates are per troy ounce. If your app needs grams, divide USD/oz by 31.1034768 to get USD/g.
• For kilograms, multiply USD/g by 1,000.
• If you display both oz and g, lock rounding rules to avoid small arbitrage windows in your UI.

2) Base currency and inversion rules

• Default base is USD. SIJ26 returns oz per 1 USD. USDSIJ26 is the direct USD per oz pair.
• If USDSIJ26 is absent, compute USD/oz by 1 / SIJ26. Validate SIJ26 ≠ 0 before inverting.

3) Timestamps, timezone, and market hours

• timestamp is Unix epoch seconds (treat as UTC). Convert to local display if needed.
• On weekends and market holidays, the API may return the latest available price. Check the date field and avoid assuming “today” equals “last trade.”
• For compliance, store the timestamp you used in each price decision.

4) Caching and refresh cadence

• Don’t poll the Latest endpoint faster than your plan’s update interval. Cache until the next boundary (e.g., minute 10 or 60, depending on plan).
• Use conditional refresh in your app layers (e.g., CDN or memory cache) to fan out a single API response to many UI clients.

5) Error handling and symbol lifecycle

• Always parse warnings. For SIJ26, expect code 410 when expired. Implement fallback routing to a supported symbol you control.
• Log both the symbol and the warning info for traceability.

Industrial and digital integrations that benefit from SIJ26

Silver’s role stretches far beyond bullion. If you build for:

• Smart manufacturing: Feed USD/oz into MES/ERP to re-cost silver-bearing components dynamically as part of a digital bill of materials.
• Electronics and sensor makers: Silver’s conductivity and antimicrobial properties drive demand variability; automating pricing models against USD/oz reduces lag in procurement cycles.
• Supply chain technology: Combine USD/oz with vendor lead times to schedule purchase orders just-in-time and hedge price exposure with rules-driven thresholds.
• Quant analytics: For a retired contract like SIJ26, archive its life-cycle series and splice to the next active month for continuous strategies (document your roll logic).

If you need multi-commodity planning, see the MCP page. Note that plan specifics vary; as one reference point, Copper Monthly is $19.99/mo. Evaluate plans in the dashboard before production rollout.

Testing checklist: from dev to prod

• Sandbox a parser against the official JSON above; assert that you can read timestamp, SIJ26, USDSIJ26, and warnings.
• Unit test inversion (USD/oz = 1/SIJ26) and verify numeric stability at small values.
• Add a guardrail that refuses to publish quotes older than your SLA (e.g., >1 hour old) unless a manual override is active.
• Run a failover drill: simulate an expired_symbol warning and confirm your symbol-rotation logic flips to an allowed active symbol.
• Validate cache behavior aligns with your update frequency to avoid unnecessary calls.

Going further: historical series and OHLC for SIJ26

Once your live pricing works, you can add history:

• Time-Series endpoint: pull daily SIJ26 values over a date window within the contract’s active period for chart backfills and factor calculations.
• OHLC endpoint: fetch open, high, low, and close per day to build candlesticks or compute ATR/volatility. Use SIJ26 where applicable and adhere to the contract’s active range.

For endpoint parameters, limits, and date constraints, consult the Metals-API Documentation. Always confirm you’re querying supported symbols from the Symbols list before scheduling batch jobs.

Security, governance, and auditability

• Store raw API responses (or hashes) with timestamps for reconciliation and compliance reviews.
• Use per-environment API keys and restrict deploy-time secrets appropriately.
• Treat warnings as high-signal events. Expired futures symbols should open incidents or at least structured logs to ensure downstream systems adjusted.

Reference links and resources

• Product site for capabilities and subscription: Metals-API homepage
• Full reference and parameters: Metals-API Documentation
• Live, searchable symbol catalog: Metals-API Supported Symbols
• Register for your key: Register
• Multi-commodity planning overview: MCP
• Background reading (external): Investopedia: Silver basics
• Contract context (external): CME Group Silver Futures Specs

FAQ

Q1: Why do I see a warning that SIJ26 is expired?
Because the April 2026 silver contract has aged out. Metals-API includes a warnings array with type expired_symbol so you can handle it deterministically. Switch to an active symbol from the catalog, or suppress trading for this instrument.

Q2: Which field should I display to users: SIJ26 or USDSIJ26?
Display USD/oz. If rates.USDSIJ26 is present, use it directly. If not, compute 1 / rates.SIJ26 (after validating it’s nonzero and present).

Q3: Are prices always “live” on weekends/holidays?
No. The Latest endpoint returns the most recent price available. Check both date and timestamp to decide if the data meets your freshness requirements before using it for pricing or P&L.

Q4: How often should I poll?
Match your plan’s update cadence (e.g., every 60 or 10 minutes). Cache responses until the next expected update tick and fan them out to clients from your cache.

Q5: Can I get historical SIJ26 data for backfills?
Yes, within the contract’s active period via Time-Series or OHLC. For parameters and date constraints, see the Documentation and confirm the symbol is supported in the Symbols list.

Ready to wire this into your stack? Get your API key and start calling the Latest endpoint for SIJ26 and USDSIJ26 in minutes: Register. For broader planning and multi-commodity workflows, explore MCP. Visit metals-api.com anytime for capabilities and updates.