LME Aluminium Alloy (LME-ALUA) - Per Tonne Price API: Converting Units, Adjusting for Lot Size, and Normalization

Metals-API 9 min read
LME Aluminium Alloy (LME-ALUA) - Per Tonne Price API: Converting Units, Adjusting for Lot Size, and Normalization

Symbol: LME Aluminium Alloy (LME-ALUA) →

You need the live LME Aluminium Alloy price per metric tonne, converted to per‑kg or per‑lb, and scaled to your contract lot size so you can price orders, mark positions, or normalize feeds into your data warehouse. In this guide you’ll pull LME-ALUA from the API, understand the inverted quote, compute per‑unit prices, and derive a per‑lot value you can use in trading tools, ERP, and e‑commerce.

What exactly the API returns for LME-ALUA and why inversion matters

The Latest Rates endpoint from Metals-API returns exchange rates with a base of USD by default. For LME Aluminium Alloy, you’ll request the symbol LME-ALUA. With base=USD, rates.LME-ALUA is quoted as “tonnes per 1 USD,” which is the inverse of the more intuitive “USD per tonne.” To make consumption easy, Metals-API also returns the inverted pair USDLME-ALUA as “USD per 1 tonne.”

Illustration: LME Aluminium Alloy (LME-ALUA) - Per Tonne Price API: Converting Units, Adjusting for Lot Size, and Normalization

In short:

  • rates.LME-ALUA → tonnes per USD (t/USD)
  • rates.USDLME-ALUA → USD per tonne (USD/t)

When you only need a per‑tonne price to compute per‑kg/per‑lb/per‑lot values, use rates.USDLME-ALUA. If your workflow is built around the API’s default base logic or cross‑rates, use rates.LME-ALUA and invert when necessary.

To confirm symbol availability and exact naming, refer to the Metals-API Supported Symbols.

End-to-end workflow: per‑tonne to per‑kg/per‑lb and lot valuation

Typical downstream needs after fetching the per‑tonne price include:

  • Converting USD per tonne → USD per kilogram and USD per pound.
  • Scaling to a contract lot size (e.g., the LME lot size in tonnes; verify the current specification with the exchange before hard‑coding).
  • Normalizing values for analytics: consistent currency, unit (t, kg, lb), and quote timing.

Key conversions you’ll use repeatedly:

  • 1 metric tonne = 1,000 kilograms
  • 1 kilogram = 2.20462262185 pounds
  • 1 metric tonne = 2,204.62262185 pounds

Given USD per tonne, the formulas are:

  • USD per kilogram = USD_per_tonne / 1,000
  • USD per pound = USD_per_tonne / 2,204.62262185
  • USD per lot = USD_per_tonne × lot_size_tonnes

Replace lot_size_tonnes with the actual contract size you trade or procure. If you’re referencing the LME primary contract spec, verify the current lot size on the exchange site before deploying to production. For convenience, the LME maintains spec pages (for example, see LME Aluminium Alloy contract resources) where details such as lot size and delivery points are maintained: LME Aluminium Alloy contract information.

Get the latest LME Aluminium Alloy price (per tonne)

The Latest endpoint is the fastest way to retrieve current prices. You can start integrating with a single symbol request for LME-ALUA plus its inverted pair.

curl request

curl "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=LME-ALUA,USDLME-ALUA"

Official API response example

{"success":true,"timestamp":1793751000,"date":"2026-11-04","base":"USD","rates":{"LME-ALUA":0.00033333333333333,"USD":1,"USDLME-ALUA":3000.00000000003}}

What the fields mean for your pricing logic

  • success: API call status.
  • timestamp: Unix epoch seconds (UTC). Use this to align feeds and cache responses.
  • date: Calendar date corresponding to the price snapshot.
  • base: USD here. With base=USD, rates are quoted relative to one USD.
  • rates.LME-ALUA: Tonnes per USD (t/USD). Here, 0.00033333… t per 1 USD.
  • rates.USDLME-ALUA: USD per tonne (USD/t). Here, 3,000.00000000003 USD per tonne.

In production, use rates.USDLME-ALUA when you want “price per tonne” directly, without inverting rates.LME-ALUA yourself.

From per tonne to per kg, per lb, and per lot in code

The following JavaScript example requests LME-ALUA and USDLME-ALUA, converts to per‑kg and per‑lb, and calculates a notional per‑lot value. You can drop this into your Node.js backend, a Cloud Function, or any JS runtime with fetch available.

async function fetchLmeAlua() {
  const url = "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=LME-ALUA,USDLME-ALUA";
  const res = await fetch(url);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const data = await res.json();

  // Validate presence of required fields
  if (!data.success || !data.rates || data.base !== "USD") {
    throw new Error("Unexpected API response format");
  }

  // Prefer direct USD per tonne from the inverted pair
  const usdPerTonne = data.rates["USDLME-ALUA"];
  if (typeof usdPerTonne !== "number") {
    // Fallback: invert tonnes per USD if inverted pair absent
    const tonnesPerUsd = data.rates["LME-ALUA"];
    if (typeof tonnesPerUsd !== "number" || tonnesPerUsd === 0) {
      throw new Error("Missing LME-ALUA rates for conversion");
    }
    // USD per tonne
    // 1 / (tonnes per USD) gives USD per tonne
    // e.g., if 0.00033333 t/USD → 3000 USD/t
    // (1 / 0.00033333) ≈ 3000
    // Guard against floating point division by zero
    const eps = 1e-12;
    if (Math.abs(tonnesPerUsd) < eps) throw new Error("Invalid LME-ALUA rate");
    // Invert
    const inverted = 1 / tonnesPerUsd;
    // Assign
    usdPerTonne = inverted;
  }

  // Unit conversions
  const usdPerKg = usdPerTonne / 1000;
  const lbPerTonne = 2204.62262185;
  const usdPerLb = usdPerTonne / lbPerTonne;

  // Lot valuation: set this to your traded/quoted lot size in tonnes
  const lotSizeTonnes = 20; // Example only; confirm contract spec before use
  const usdPerLot = usdPerTonne * lotSizeTonnes;

  return {
    timestamp: data.timestamp,        // seconds since epoch (UTC)
    date: data.date,                  // YYYY-MM-DD
    usdPerTonne,
    usdPerKg,
    usdPerLb,
    usdPerLot,
  };
}

fetchLmeAlua()
  .then(console.log)
  .catch(console.error);

Note: The lot size is set to 20 only as an example. Always confirm the current LME Aluminium Alloy contract specifications (including lot size and prompt structure) before deploying. The figures you compute should be treated as notional until reconciled with official exchange specs and your broker’s execution rules.

Normalization patterns that keep your data warehouse consistent

When you onboard LME-ALUA, set standards that keep calculations consistent across your stack:

  • Quote currency: Keep USD as your canonical currency if you consume USDLME-ALUA. If your accounting currency differs, convert at the point of ingestion or in a downstream model. The API provides currency rates; see the Documentation for conversion details.
  • Units: Store a normalized “price_per_tonne_usd,” plus derived “price_per_kg_usd” and “price_per_lb_usd.” Add explicit unit fields so analytics and pricing engines can pivot as needed.
  • Timestamping: Persist both the API’s timestamp (UTC epoch seconds) and an ingestion timestamp from your system clock. This helps you reconcile when upstream markets are closed or when you’re backfilling.
  • Market calendar: LME and OTC markets have weekend/holiday closures. During closures, the latest snapshot may not change; keep the date/time fields so you can distinguish last-trade/last-fix snapshots from rolling retrieval times. Treat the API’s timestamp as authoritative for the snapshot.
  • Lot-based values: If you price or hedge by lots, persist a “lot_size_tonnes” for each instrument so per‑lot valuations are reproducible if lot specs change.

Practical details that save time in production

  • Base currency and inversion: With base=USD, LME-ALUA is tonnes per USD. Use USDLME-ALUA for USD per tonne; it’s already inverted by the API.
  • Units: LME-ALUA is a per‑tonne market convention. Do not use precious metal troy ounce logic. Keep conversions explicit: 1 t = 1,000 kg = 2,204.62262185 lb.
  • Timestamps and timezone: timestamp is Unix seconds in UTC, which is safe for cross‑region processing. Convert to your local timezone at the UI edge only.
  • Caching: If you poll more frequently than your business needs, implement a 30–60s memory cache and invalidate only when the timestamp or date changes. For downstream batch jobs, store snapshots keyed by date and hour.
  • Weekends/closures: Expect repeated timestamps across weekend polls. Your logic should avoid treating repeated snapshots as “new ticks.”
  • Rounding: Present prices rounded at the UI (e.g., per‑kg to 4 decimals; per‑lb to 4 decimals; per‑tonne to 2 decimals) but store full precision from the API for auditability.
  • Validation: Guard against divide‑by‑zero when inverting rates.LME-ALUA if you ever need to (the inverted pair usually makes this unnecessary).

Historical context and analytics without overfetching

If you’re building charts or running factor models, you’ll usually need daily closes and not intraday noise. Metals-API provides endpoints for historical and time series retrieval you can use to backfill and resample your data. For supported date limits and request parameters, see the Documentation. Keep the following in mind:

  • Choose the minimal date range you need (e.g., last 30–90 days for charts), then cache server-side to avoid repeated pulls.
  • Normalize everything to USD per tonne before storing derived metrics, so backtests and production logic share the same unit baseline.
  • When merging LME-ALUA with other materials or FX, store the original symbols and the normalized fields side-by-side for traceability.

Integrating with trading tools, ERP, and e‑commerce

Common integration patterns using USDLME-ALUA from Metals-API:

  • ERP pricing: Take USD per tonne, convert to per‑kg, add fabrication premium, delivery, and margin to compute SKU list prices. Round per business rules.
  • Trading dashboards: Display real‑time USD/t and per‑lot notional alongside position sizes. Keep the timestamp visible to highlight staleness.
  • Quote engines: Convert to customer currency at the final step while retaining the USD/t canonical value in your pricing service.

If you need managed connectivity or to operationalize feeds across multiple teams, explore MCP as part of your deployment planning.

Quality checks and handling edge cases

  • Null or missing inverted pair: If USDLME-ALUA is temporarily absent, invert LME-ALUA cautiously with epsilon guards. Log and alert if both are missing.
  • Currency normalization: If you must quote in a non‑USD currency, perform the currency conversion as a final step after computing USD/t. Consult the Documentation for the conversion endpoint and supported currency symbols.
  • Lot size drift: Treat exchange lot size as configuration, not a constant in code. Keep it in a database table or environment variable so updates don’t require redeploys.
  • Premiums and basis: If you price delivered material, model regional premiums and logistics as separate terms. Keep exchange USD/t as a transparent base component.

Security, deployment, and budgeting notes

  • API keys: Store your Metals-API key in a secrets manager or environment variable; don’t commit it to your repo.
  • Server-side calls: Prefer backend calls; if you must call from a browser, proxy through your API to avoid exposing your key.
  • Request frequency: Align polling frequency with your plan and use case. Many use a 30–60 second poll for dashboards and less for ERP pricing.
  • Costs: Choose the plan that matches your symbol set and refresh cadence. If you need copper or other instruments alongside LME-ALUA, plan accordingly.

Where to find symbols, parameters, and next steps

Before you ship, verify symbols and parameters here:

When you’re ready to integrate, create an account and generate your key: Register for an API key.

Frequently asked questions

1) Is LME-ALUA quoted per tonne or per troy ounce?
Per tonne. Do not apply precious‑metal troy ounce logic here. Use USDLME-ALUA for USD per tonne, or invert LME-ALUA if necessary.

2) How do I convert to per kilogram and per pound?
Divide USD per tonne by 1,000 to get USD/kg. Divide USD per tonne by 2,204.62262185 to get USD/lb. Keep these conversions centralized so every service uses the same constants.

3) How do I handle lot sizes?
Use a configurable lot_size_tonnes in your pricing service and compute USD per lot = USD per tonne × lot_size_tonnes. Always verify the current exchange spec for the contract you trade before hard‑coding lot sizes.

4) What does the API timestamp represent?
It’s a Unix epoch in UTC for the snapshot you received. On weekends and holidays, this may not change between polls. Use it for cache invalidation and staleness checks.

5) Can I get historical or time‑series LME-ALUA?
Yes—historical and timeseries endpoints are available for supported symbols and dates. See the Documentation for parameters, date ranges, and usage notes. Normalize to USD per tonne before saving to your warehouse.

Ready to integrate LME Aluminium Alloy into your pricing, trading, or analytics stack? Create your account and get your key now: Register. If you’re planning broader rollout and governance, review MCP for deployment options. For symbols and coverage, check the Symbols list.