Real-Time Uranium Dec 2025 (UXZ25) - Per Pound Price for API Integration and Data Feeds

Metals-API Oct 27, 2026 9 min read

You need to display and stream the per‑pound price for the Uranium December 2025 futures symbol (UXZ25) into a dashboard, pricing engine, or alerting workflow. By the end of this guide, you will fetch the latest UXZ25 quote from Metals‑API, understand the inverse USD rate you’ll actually consume, handle symbol expiration gracefully, and compute/normalize to a per‑pound figure for downstream use.

What you’re integrating: UXZ25 via Metals‑API, and what “per pound” really means

UXZ25 is the Uranium December 2025 contract symbol. Futures symbols like this may represent standardized contract units (for example, a number of pounds) rather than a single physical ounce. Metals‑API returns both the direct rate and its USD inversion, which is what most pricing and UI layers prefer to use.

Illustration: Real-Time Uranium Dec 2025 (UXZ25) - Per Pound Price for API Integration and Data Feeds

Important: The unit behind UXZ25 (e.g., whether the quote equals “USD per pound” or “USD per contract”) is defined by the symbol specification, not by the API response. Before converting to “per pound,” verify the contract unit on the symbols page. See: Metals‑API Supported Symbols.

Also note this symbol is flagged as expired in the latest response below. You can still retrieve the last returned values and use historical endpoints for backfill, but you should design your integration to detect and handle expiration (details below).

Endpoints to use for a UXZ25 feed

Latest Rates: For current UXZ25 and its USD inversion. Good for streaming dashboards and price polling.
Convert: For currency conversions (e.g., expressing USDUXZ25 in EUR), or converting between units after you confirm the symbol’s base unit.
Time‑Series or Historical: For backfilling charts and computing returns before expiration dates. See the Documentation for date parameters.

Metals‑API updates “latest” at intervals that depend on plan level. Data is delivered relative to a base currency (USD by default). For more capabilities, browse the Metals‑API site and docs.

Get the latest UXZ25 quote (curl) and read the inverse USD rate

Copy and run this request. Replace YOUR_API_KEY with your key. Metals‑API does not offer a free trial; obtain a production key via the Register link at the end of this post.

curl "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=UXZ25,USDUXZ25,USD"

Official sample response (use these values verbatim in your tests to wire your parser):

{"success":true,"timestamp":1793059680,"date":"2026-10-27","base":"USD","rates":{"UXZ25":0.011104941699056,"USD":1,"USDUXZ25":90.05000000000064},"warnings":[{"symbol":"UXZ25","code":410,"type":"expired_symbol","info":"The requested symbol has expired and is no longer available."}]}

What fields you’ll actually use

base: "USD" — all rates are expressed relative to USD.
rates.UXZ25: 0.011104941699056 — the amount of UXZ25 per 1 USD (an inverted, quantity-per-USD quote).
rates.USDUXZ25: 90.05000000000064 — the USD price per 1 UXZ25 unit. In practice, most pricing UIs and alerts will use this field.
timestamp/date: When the quote was computed. Treat timestamp as Unix seconds (UTC).
warnings: Includes an expired_symbol notice for UXZ25. Your integration should surface or log this and consider switching to historical endpoints for backfill.

Turning USDUXZ25 into “USD per pound”

Your downstream needs a per‑pound figure. There are two common scenarios:

If the UXZ25 quote unit is already 1 pound, then rates.USDUXZ25 is already “USD per pound.” Use it directly.
If UXZ25 represents a different unit (e.g., a larger contract size), divide rates.USDUXZ25 by the contract’s pounds-per-unit to get “USD per pound.” You must confirm the contract unit from the symbol’s spec on the Symbols page or your futures venue.

If you ever need to convert weights yourself (for symbols quoted per troy ounce), the fixed factors are: 1 troy ounce = 31.1034768 grams; 1 pound = 453.59237 grams ≈ 14.583333 troy ounces. In that case: USD per pound = (USD per troy ounce) × 14.583333.

Python example: fetch latest UXZ25 and compute USD per pound

This snippet reads the official fields, checks for expiration, and normalizes to per‑pound using a configurable unit mapping you control. Do not hardcode a pounds-per-unit value until you verify it from the symbol spec.

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

API_KEY = os.getenv("METALS_API_KEY", "YOUR_API_KEY")

# Configure your own mapping after verifying the contract unit on the Symbols page.
# Example: if 1 UXZ25 unit equals 1 pound, set to 1.0. If it equals 250 pounds, set to 250.0.
POUNDS_PER_UXZ25_UNIT = float(os.getenv("POUNDS_PER_UXZ25_UNIT", "1.0"))

params = {
    "access_key": API_KEY,
    "symbols": "UXZ25,USDUXZ25,USD"
}
url = "https://metals-api.com/api/latest?" + urllib.parse.urlencode(params)

try:
    with urllib.request.urlopen(url, timeout=10) as resp:
        data = json.loads(resp.read().decode("utf-8"))
except Exception as e:
    print(f"Request failed: {e}", file=sys.stderr)
    sys.exit(1)

if not data.get("success", False):
    print(f"API error: {data}", file=sys.stderr)
    sys.exit(1)

warnings = data.get("warnings", [])
expired = any(w.get("type") == "expired_symbol" and w.get("symbol") == "UXZ25" for w in warnings)

timestamp = data.get("timestamp")
as_of_utc = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp)) if timestamp else "NA"

rates = data.get("rates", {})
usd_per_uxz25 = rates.get("USDUXZ25")  # USD per 1 UXZ25 unit

if usd_per_uxz25 is None:
    print("Missing USDUXZ25 in response; cannot compute USD per pound.", file=sys.stderr)
    sys.exit(1)

# Normalize to USD per pound based on verified contract unit.
try:
    usd_per_pound = usd_per_uxz25 / POUNDS_PER_UXZ25_UNIT
except ZeroDivisionError:
    print("POUNDS_PER_UXZ25_UNIT must be > 0", file=sys.stderr)
    sys.exit(1)

print(json.dumps({
    "as_of_utc": as_of_utc,
    "expired": expired,
    "usd_per_uxz25_unit": usd_per_uxz25,
    "pounds_per_uxz25_unit": POUNDS_PER_UXZ25_UNIT,
    "usd_per_pound": usd_per_pound
}, indent=2))

How to use this output: - If expired is true, keep the last known value for continuity but start migrating to historical queries for time windows you need (intraday/daily as your plan allows). - If pounds_per_uxz25_unit = 1.0 (confirmed), then usd_per_pound equals usd_per_uxz25. - Otherwise, divide by the confirmed number of pounds per UXZ25 unit as shown.

Operational details that save time in production

Base and inversion: Metals‑API defaults to base=USD. For UXZ25 you’ll rely on rates.USDUXZ25 (USD per unit), not rates.UXZ25 (units per USD). Use the inversion field directly to avoid precision drift from computing 1 / UXZ25.
Timestamps and timezone: timestamp is Unix seconds; treat dates/times as UTC. Store both raw timestamp and a human-friendly UTC string.
Caching and polling: Respect your plan’s update cadence (e.g., updates every 60 or 10 minutes). Cache responses until the next update window to minimize calls.
Non-trading days: Futures don’t print new prices during weekends/holidays. Latest may repeat a prior mark. Your logic should compare timestamps and suppress “price changed” events if the timestamp hasn’t advanced.
Symbol lifecycle: The response above contains a warnings array with type=expired_symbol. For expired instruments, persist the last good value and switch your charts/backfills to historical/time‑series endpoints. List active and deprecated codes via Symbols.
Currency conversion: If your UI needs EUR, GBP, or JPY prices, call the Convert endpoint to convert the USD figure to your desired currency. See the precise parameters in the Documentation.
Units and weights: When converting to “per pound,” verify the symbol’s underlying unit. If you need to convert from troy ounces to pounds, use 1 lb ≈ 14.583333 troy ounces as your factor, applied to the per‑troy‑ounce USD figure.
Error handling: Check success, handle HTTP/network timeouts, and parse warnings. Log the entire warnings array for auditability.
Plan note: Metals‑API has no free trial. If you only need copper monthly, that plan is $19.99/mo. For uranium and broader coverage, select an appropriate plan after review.

Putting it together: a minimal integration blueprint

Symbol verification: Confirm UXZ25’s unit (pounds per unit or contract size) on the Symbols page and in your execution venue’s specs.
Polling schedule: Poll the Latest endpoint at or just after your plan’s update interval. Cache until the next expected tick.
Normalization: Read rates.USDUXZ25 and divide by pounds-per-unit (as verified) to produce USD per pound.
Display/alerts: Round according to your UI spec (e.g., 2 decimals), but store the full precision internally.
Lifecycle handling: If warnings indicate expired_symbol, freeze the live stream for UXZ25, switch charts to historical/time‑series, and update your symbol map to the next relevant contract.

Convert to another currency (outline)

Once you have USD per pound, use the Convert endpoint to translate into your settlement currency (e.g., EUR). Provide from=USD, to=your currency, amount=usd_per_pound. The precise request/response format is documented in the Documentation. Cache the FX leg on a similar cadence to reduce conversions.

Historical and time‑series backfill (outline)

For charts and performance metrics around contract expiry, use the Historical or Time‑Series endpoints with UXZ25 as the symbol. Fetch daily data between your chosen start and end dates, normalize to per‑pound using the same unit mapping, and compute returns or drawdowns from the daily USD per pound series. Endpoint specifics and date limits are in the Documentation.

Pragmatic notes on uranium market context

Many uranium market references quote U3O8 settlement prices on a per‑pound basis, which aligns neatly with “USD per pound” in applications. If you need background or cross‑reference pricing norms, consult independent sources such as the U.S. Energy Information Administration’s nuclear fuel pages (EIA nuclear) or the World Nuclear Association’s market overviews (WNA uranium markets). Use these only to understand units and conventions; your system of record for quotes should remain your Metals‑API feed.

Security, environments, and governance

Key management: Keep your access_key in environment variables or a secret manager. Rotate keys on your own schedule.
Versioning: Wrap your Metals‑API client in a small internal module so you can alter endpoints or symbol maps without sweeping code changes.
Monitoring: Alert on stale timestamps, missing USDUXZ25, or expired_symbol warnings so your team notices contract roll deadlines.

FAQ

Is UXZ25 still live?
The latest response includes a warning with type=expired_symbol for UXZ25. You can continue to read the last returned quote, but for new data you should switch to historical/time‑series for backfill and roll to the next active contract as appropriate.

Which field should I show in my UI?
Use rates.USDUXZ25 — it’s the USD price per one UXZ25 unit. If that unit equals one pound, you already have USD per pound. Otherwise, divide by the confirmed pounds-per-unit.

How do I convert to EUR per pound?
First compute USD per pound as described. Then call the Convert endpoint to convert that USD figure to EUR. See parameters in the Documentation.

What about non‑trading days or flat prints?
If the timestamp doesn’t advance, the price hasn’t updated. Cache and display the last known value, and avoid firing false “price changed” alerts.

Can I try this for free?
No. Metals‑API has no free trial. Select a plan that fits your symbols and update frequency needs. If you only need copper monthly, that plan is $19.99/mo; for uranium and related futures, choose an appropriate plan after reviewing the docs and symbols.

Spin up your UXZ25 per‑pound feed now. Get an API key here: Register. If you need managed connectivity and control, explore MCP. For implementation specifics, keep the Documentation open, and verify symbol details anytime in Symbols.