Get Accurate Lithium Aug 2025 (LMQ25) - Per kg Prices in Multiple Currencies with this API (spot and futures comparison)
Need accurate Lithium Aug 2025 (LMQ25) per‑kg pricing in multiple currencies to drive real-time pricing, hedging, and analytics? This guide shows how to pull LME lithium August 2025 futures prices via Metals-API, convert them to per‑kilogram values, and compare them with spot benchmarks in your apps and data pipelines. We will focus on three essentials: querying the latest LMQ25 quote, pulling a small historical window for backfills or charts, and converting those prices to different currencies and units for operational use. Along the way, we’ll highlight best practices around units (tonnes vs. kg), base currency, timestamps, caching, and weekend/market-closure handling—so your pricing stays reliable even when the market is shut.
Why developers want LMQ25 per‑kg prices in multiple currencies
LMQ25 is the August 2025 LME lithium futures contract. Developers and data teams in EV supply chains, battery manufacturing, and commodity platforms often need the following:
- Real-time or near-real-time LMQ25 futures quotes for decision support and hedging dashboards.
- Per‑kg conversions (from LME’s typical per‑metric‑tonne quotations) to normalize across BOM cost models and SKU-level analytics.
- Multi-currency normalization (USD, EUR, CNY, GBP, etc.) to align with supplier contracts and regional pricing.
- Spot vs. futures comparison to inform procurement strategy and forward curves for planning and risk modeling.
- Time series backfills to populate charts, alerting logic, and statistical models.
With Metals-API, you can build this pipeline cleanly using a simple JSON REST interface. Start by checking the symbol and unit, query the latest or a history window, then convert to the currencies and units your business uses. See the full reference at the Metals-API Documentation and confirm availability on the Metals-API Supported Symbols page.
About LMQ25 and lithium pricing: contracts, units, and digital transformation
Lithium markets are in the midst of rapid digital transformation. As EV demand scales, data-driven approaches help teams navigate volatility and plan procurement. Futures such as LMQ25 (Lithium August 2025) represent standardized forward prices that can be used for hedging and forecasting. While LME contracts are typically quoted per metric tonne, operational models often need per‑kilogram values. Metals-API makes it straightforward to obtain a futures quote and convert it into actionable, per-unit pricing across currencies—essential for smart technology integration in ERP, e-commerce, risk engines, and trading tools.
Throughout this guide, we’ll keep the focus tightly on LMQ25 for futures and discuss how to align or compare that with spot reference data. If you are exploring additional lithium-related references, always verify symbol codes and units via the Metals-API Supported Symbols.
Endpoints used in this guide
We will use up to three endpoints to keep implementation focused and production-friendly:
- Latest Rates: obtain the current LMQ25 quote and base currency context.
- Time-series: backfill daily quotes for a date range to build a historical chart.
- Convert: transform LMQ25 values across currencies and units (e.g., per tonne to per kg, USD to EUR).
These endpoints are enough to power most lithium per‑kg, multi-currency workflows. For other capabilities (like OHLC, bid/ask, intraday, fluctuation), see the Metals-API Documentation. If you are building with additional LME instruments, confirm each symbol on the Metals-API Supported Symbols page.
Authentication, base currency, and units
All requests require an access_key. Sign up for your key at the Metals-API Website and start testing within minutes. The API returns prices by default relative to USD unless you specify a different base. For LME futures like LMQ25, the unit commonly reflects per metric tonne. You will always see the declared unit in the response (check the unit field). To get per‑kg pricing, divide the per‑tonne price by 1,000. We will show exactly how to do that below.
Quick start: get the latest LMQ25 quote and convert to per‑kg in EUR
This section provides an end-to-end example that you can adapt directly:
- Pull the latest LMQ25 rate (base USD).
- Invert if needed to get USD per tonne.
- Convert USD per tonne to EUR per tonne with the Convert endpoint.
- Divide by 1,000 to get EUR per kg.
Step 1 — Latest LMQ25 (base USD)
Request the latest LMQ25 rate. In the Metals-API schema, the rates map returns the quantity of the instrument per one unit of the base currency. That is, if base is USD, rates[LMQ25] represents “contract units per USD.” To obtain “USD per contract unit,” invert the rate (1 / rate). For LME futures, interpret the price as per metric tonne unless the unit indicates otherwise.
curl -s "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=LMQ25&base=USD"
Example JSON response (fields shown are illustrative of the Metals-API format; the symbol and unit are aligned to LMQ25):
{
"success": true,
"timestamp": 1789690786,
"base": "USD",
"date": "2026-09-18",
"rates": {
"LMQ25": 0.00005
},
"unit": "per metric tonne"
}
How to read this:
- base: USD means the denominator is USD.
- rates.LMQ25: 0.00005 tonne per USD (per the declared unit).
- To compute USD per tonne: price_usd_per_tonne = 1 / 0.00005 = 20,000 USD/tonne.
- To compute USD per kg: 20,000 / 1000 = 20 USD/kg.
Always use the unit value returned to confirm that you’re dividing by the correct factor when converting to kg. For metric-tonne quotes, divide by 1000. If a different unit is ever reported, adapt the conversion accordingly.
Step 2 — Convert to another currency (e.g., EUR)
Use the Convert endpoint to translate a USD-denominated amount to EUR (or another currency). If you’ve computed USD per tonne, you can convert that amount directly with Convert. Alternatively, you can request the latest LMQ25 with base=EUR to avoid manual conversion. Below we’ll show a numeric Convert request for flexibility and caching control.
curl -s "https://metals-api.com/api/convert?access_key=YOUR_API_KEY&from=USD&to=EUR&amount=20000"
Example JSON response:
{
"success": true,
"query": {
"from": "USD",
"to": "EUR",
"amount": 20000
},
"info": {
"timestamp": 1789690786,
"rate": 0.92
},
"result": 18400.0,
"unit": "currency"
}
Interpretation:
- result: 18,400 EUR per metric tonne.
- Per kg: 18,400 / 1000 = 18.4 EUR/kg.
Complete example (JavaScript fetch)
The following snippet ties the steps together—fetch the latest LMQ25, compute USD/tonne, convert to EUR, then express per kg. This is suitable for backend or frontend use with secure key handling (see the security notes later). Replace YOUR_API_KEY with your key from the Metals-API Website.
async function getLMQ25PerKgEUR() {
const key = process.env.METALS_API_KEY || "YOUR_API_KEY";
const latestUrl = `https://metals-api.com/api/latest?access_key=${key}&symbols=LMQ25&base=USD`;
const latestRes = await fetch(latestUrl);
const latest = await latestRes.json();
if (!latest.success) {
throw new Error("Latest LMQ25 request failed");
}
const rateTonnePerUSD = latest.rates.LMQ25; // tonne per 1 USD
const priceUsdPerTonne = 1.0 / rateTonnePerUSD; // USD per tonne
const convertUrl = `https://metals-api.com/api/convert?access_key=${key}&from=USD&to=EUR&amount=${priceUsdPerTonne}`;
const convertRes = await fetch(convertUrl);
const converted = await convertRes.json();
if (!converted.success) {
throw new Error("Currency conversion failed");
}
const eurPerTonne = converted.result; // EUR per tonne
const eurPerKg = eurPerTonne / 1000.0;
return {
timestamp: latest.timestamp,
base: latest.base,
unit: latest.unit,
usdPerTonne: priceUsdPerTonne,
eurPerTonne,
eurPerKg
};
}
Returned object fields you will actually use:
- timestamp: use as the data as-of instant (UTC epoch seconds). This is vital for audit trails and cache keys.
- unit: confirm that you’re converting from the correct base unit (metric tonne expected for LMQ25).
- usdPerTonne / eurPerTonne / eurPerKg: plug into pricing, BOM, or dashboards.
Spot vs. futures: how to line them up without confusion
Futures (LMQ25) and spot represent different points on the curve. To compare them responsibly:
- Synchronize timestamps. Align spot and LMQ25 by the latest common timestamp or near-real-time window. If either market is shut, hold or annotate the last value with its timestamp.
- Normalize units. Ensure both are in per kg or per tonne, not mixed. For LMQ25, that’s typically per tonne; spot references may vary—convert both to kg for apples-to-apples comparisons.
- Normalize currency. Convert both to the same currency (e.g., EUR), then compute basis, spreads, and ratios.
- Annotate contract month. Futures are month-specific; ensure any analytics clearly reference “Aug 2025” to avoid month roll confusion.
In practice, you can store an internal structure like: { ts, symbol: "LMQ25", currency: "EUR", unit: "kg", value: 18.4 } and compare it with your spot record { ts, symbol: "LITHIUM_SPOT", currency: "EUR", unit: "kg", value: 17.9 }, then compute spread = 18.4 - 17.9 = 0.5 EUR/kg. If you plan automated hedging, alert on the spread crossing thresholds.
Time-series: backfill and chart LMQ25
For quant models, dashboards, and alerting, you’ll likely want a rolling window of daily LMQ25 values. The time-series endpoint returns daily rates in a single call across a date range. For each day, you’ll extract the LMQ25 rate and compute per‑tonne and per‑kg prices (and optionally convert currency with a cached FX quote for performance).
Time-series request (LMQ25, base USD)
curl -s "https://metals-api.com/api/timeseries?access_key=YOUR_API_KEY&start_date=2026-09-11&end_date=2026-09-18&base=USD&symbols=LMQ25"
Example JSON response:
{
"success": true,
"timeseries": true,
"start_date": "2026-09-11",
"end_date": "2026-09-18",
"base": "USD",
"rates": {
"2026-09-11": { "LMQ25": 0.0000505 },
"2026-09-12": { "LMQ25": 0.0000504 },
"2026-09-13": { "LMQ25": 0.0000503 },
"2026-09-16": { "LMQ25": 0.0000502 },
"2026-09-17": { "LMQ25": 0.0000501 },
"2026-09-18": { "LMQ25": 0.0000500 }
},
"unit": "per metric tonne"
}
Notes and usage:
- Weekends and exchange holidays may be absent or hold the last known rate; design your backfill logic to handle missing dates gracefully.
- Each rate is in “tonne per USD.” To derive USD per tonne, invert per day: price_usd_per_tonne[day] = 1.0 / rates[day].LMQ25.
- To get per‑kg, divide each day’s per‑tonne price by 1,000.
- If you also need EUR, call Convert once per day with the USD per tonne amount, or cache a single daily USD→EUR FX rate and multiply for each day to limit requests.
Common pitfalls when working with time series
- Timezone assumptions: Timestamps are UTC. When plotting in a local timezone, annotate the axis, or convert to local time on the fly.
- Weekend gaps: Avoid interpolating over weekends for trading signals; either show gaps or carry forward the last valid close with a visual indicator.
- Recomputation drift: If you recompute USD→EUR daily from FX, store both the USD base values and the FX rate per day to ensure future reproducibility.
Detailed field walkthrough: what matters in production
- success: Boolean; if false, do not trust other fields. Implement centralized error handling and retries with exponential backoff.
- timestamp: Epoch seconds (UTC). Use as “as-of” time for the rates; it’s crucial for audit trails and cache keys.
- base: The base currency (often USD). Drives the denominator side of the rates map.
- date: ISO date corresponding to the rates snapshot. For historical/time-series, this is your primary index key.
- rates: A dictionary keyed by symbol (LMQ25), where each value is “unit per base currency.” For LME futures, expect metric tonnes per unit base currency.
- unit: The physical unit context. For LMQ25, “per metric tonne.” Always branch your unit conversions based on this field.
Currency conversion patterns for lithium workflows
There are two common patterns to support multi-currency per‑kg outputs:
- Convert after computing per‑tonne USD:
- Compute USD/tonne = 1 / rate.
- Convert USD/tonne to target currency using Convert endpoint.
- Divide by 1,000 for per‑kg.
- Request latest/time-series with base equal to the target currency (e.g., EUR) and invert directly to get EUR/tonne, then divide by 1,000. This can be efficient when your downstream systems quote in a single non-USD currency.
The Convert endpoint offers flexibility if your app needs many currencies on-demand. If your price display defaults to a single currency (say, EUR), requesting base=EUR in the original LMQ25 call reduces extra steps and simplifies caching.
Caching, rate hygiene, and weekend logic
- Cache by symbol, base currency, and timestamp (or date for daily). Include unit in your metadata to detect unexpected changes.
- Respect update cadence. Many production systems refresh on a schedule aligned with market hours. Avoid hammering the API when the exchange is closed; cache and reuse the last value with its timestamp.
- Weekend and holiday fallback. When you detect a non-trading day, display the last close and add an “as of” label. For calculations that require a continuous series, explicitly fill with the prior trading day’s close and record the fill policy.
- Batching. When pulling LMQ25 plus a small set of related instruments, request them in a single call (symbols=LMQ25,...) to reduce network overhead. For this article we focus solely on LMQ25 to keep the example tight.
Security best practices
- Do not expose your API key in client-side code for public apps. Proxy requests via your backend and inject the key server-side.
- Store the key in a secrets manager or environment variables (e.g., AWS Secrets Manager, HashiCorp Vault).
- Rotate keys periodically and on any suspected compromise.
- Validate all inputs (dates, symbols, bases) on your server to prevent SSRF or parameter injection attacks against your own infrastructure.
From futures to per‑kg retail price: a practical pipeline
Here’s a simple architecture used by procurement analytics teams:
- Ingest: Cron triggers to call Latest LMQ25 hourly during market hours; daily time-series backfill overnight for the past N days.
- Normalize: Convert to USD/tonne, adjust to EUR/tonne if needed, then derive per‑kg.
- Compare: Pull or receive spot references from your chosen source. Align timestamps and compute spreads.
- Persist: Store both raw API payloads and normalized derived values. Keep a separate table for FX used on each conversion to maintain full auditable lineage.
- Serve: Expose a lightweight read-optimized API or cache layer for frontend dashboards and ERP integrations.
- Alert: Threshold alerts on spreads, percentage changes, or rolling z-scores for proactive decisioning.
Latest endpoint: purpose, parameters, and examples
The Latest endpoint retrieves the current (near real-time, plan-dependent) rate for your specified symbols. For LMQ25, this is the simplest way to keep dashboards up to date and to feed short-term alerts.
Key parameters
- access_key: Your API key.
- symbols: LMQ25 (limit to what you need for performance).
- base: Optional; default is USD. Set to your desired currency if you want to avoid a separate conversion step.
Example: Latest LMQ25 in EUR directly
curl -s "https://metals-api.com/api/latest?access_key=YOUR_API_KEY&symbols=LMQ25&base=EUR"
{
"success": true,
"timestamp": 1789690786,
"base": "EUR",
"date": "2026-09-18",
"rates": {
"LMQ25": 0.00005435
},
"unit": "per metric tonne"
}
Compute EUR per tonne = 1 / 0.00005435 ≈ 18,400 EUR/tonne, then per kg ≈ 18.4 EUR/kg. This mirrors the earlier USD→EUR Convert example but performs the currency normalization at source.
Performance and optimization
- Symbol scoping: Request only LMQ25 if that’s all you need to reduce response size and parsing overhead.
- Conditional fetch: If your cache has a fresh value newer than your display SLA (e.g., 10 minutes), reuse it to save calls and keep UI snappy.
Time-series endpoint: purpose, parameters, and examples
The time-series endpoint returns daily rates between start_date and end_date (inclusive, subject to market days). It’s ideal for charts, statistical features (e.g., rolling means), and backfills after downtime.
Key parameters
- access_key: Your API key.
- start_date: YYYY-MM-DD
- end_date: YYYY-MM-DD
- symbols: LMQ25
- base: Optional; default is USD. Choose a target base if you prefer.
Multiple scenario examples
USD base, 5 trading days:
{
"success": true,
"timeseries": true,
"start_date": "2026-09-11",
"end_date": "2026-09-18",
"base": "USD",
"rates": {
"2026-09-11": { "LMQ25": 0.0000505 },
"2026-09-12": { "LMQ25": 0.0000504 },
"2026-09-13": { "LMQ25": 0.0000503 },
"2026-09-16": { "LMQ25": 0.0000502 },
"2026-09-18": { "LMQ25": 0.0000500 }
},
"unit": "per metric tonne"
}
EUR base for the same dates (handy when your reporting currency is fixed):
{
"success": true,
"timeseries": true,
"start_date": "2026-09-11",
"end_date": "2026-09-18",
"base": "EUR",
"rates": {
"2026-09-11": { "LMQ25": 0.00005441 },
"2026-09-12": { "LMQ25": 0.00005430 },
"2026-09-13": { "LMQ25": 0.00005419 },
"2026-09-16": { "LMQ25": 0.00005408 },
"2026-09-18": { "LMQ25": 0.00005435 }
},
"unit": "per metric tonne"
}
In both cases, invert daily rates to get currency-per-tonne, then divide by 1000 for per‑kg. For analytics, compute:
- Daily returns: r[t] = (price[t] / price[t-1]) - 1
- Rolling mean/volatility for risk dashboards
- Spreads vs. spot (aligned by date)
Troubleshooting time-series
- Missing dates: If a day is absent, assume a market closure or no print. Do not impute values for PnL unless your risk policy permits it; otherwise, carry forward with an “as of” label.
- Outliers: Occasionally, thin markets can produce outlier prints. Consider median-of-3 smoothing or robust outlier detection for display, while retaining raw values for audit.
Convert endpoint: purpose, parameters, and examples
The Convert endpoint is a general-purpose currency conversion tool. For LMQ25 workflows, it’s most useful after you’ve derived the per‑tonne amount in a base currency and want to quote it in multiple target currencies.
Key parameters
- access_key: Your API key.
- from: Source currency code (e.g., USD).
- to: Target currency code (e.g., EUR).
- amount: Numeric value to convert (e.g., USD per tonne you computed from LMQ25).
Example: Batch converting per‑tonne amount to multiple currencies
Make one Convert call per currency (or prefetch FX rates if supported by your plan and perform conversions locally):
{
"success": true,
"query": { "from": "USD", "to": "EUR", "amount": 20000 },
"info": { "timestamp": 1789690786, "rate": 0.92 },
"result": 18400.0,
"unit": "currency"
}
Then per kg: 18,400 / 1000 = 18.4 EUR/kg.
Optimization
- Cache FX quotes for a chosen TTL (e.g., 10–60 minutes) to avoid repeated Convert calls for multiple products or SKUs referencing the same base commodity price.
- If you quote mostly in one currency, request Latest/Time-series with base set to that currency to save calls.
Putting it all together: spot-versus-futures comparison logic
While this guide focuses API calls on LMQ25, many real-world systems compare futures and spot. Here’s how to integrate:
- Get LMQ25 per‑kg in your reporting currency (as shown above).
- Obtain spot per‑kg values from your chosen source and convert to the same currency.
- Align timestamps to the nearest common time bucket (e.g., daily close or a defined intraday window).
- Compute basis (futures - spot), percentage premium, and a rolling z-score to identify unusual dislocations.
- Trigger alerts when deviations exceed your thresholds; store both raw and derived values for audit.
For decision support, you might flag opportunities such as locking in supply contracts when LMQ25 trades at a discount to your spot benchmark adjusted for carry and logistics, or highlight hedging needs when the futures premium widens beyond historical bands.
Data governance: unit, currency, and audit trails
- Persist raw payloads from Metals-API with the response timestamp and unit.
- Persist derived values with explicit formula references (e.g., “price_usd_per_tonne = 1 / rates.LMQ25”).
- Store the FX rate and source timestamp used for currency conversions per record.
- Version your unit conversion logic (e.g., tonne→kg multiplier) in code and note in metadata for change management.
Resilience: error handling and recovery strategies
- Check success. If success=false, back off and retry with exponential delays; if retries fail, serve last known good value with a warning banner in UI.
- Outage fallback. Maintain an on-disk or database cache of the last N valid values. If API is unavailable, surface cached data with a visible timestamp.
- Circuit breaker. If error rate spikes, stop calling the API briefly to avoid exacerbating issues and hammering the network.
Scalability strategies for high-throughput apps
- Edge caching: Place a CDN or edge cache in front of your backend “quote aggregator” endpoint that consolidates Metals-API results for your frontend clients.
- Delta fetches: If your use case only needs updates when prices change materially, schedule fetches based on volatility regimes or only during trading sessions.
- Batched jobs: For multi-symbol portfolios, request symbols in batches and fan out conversions locally.
Security considerations beyond the key
- HTTPS everywhere. Communicate with Metals-API over TLS only and validate certificates via your platform defaults.
- Secrets lifecycle. Rotate and revoke keys via your CI/CD pipeline as part of regular releases; never hardcode in source control.
- Rate governance. Throttle client requests on your side to prevent misuse or accidental storms from client bugs.
Testing and validation checklist
- Unit test: Validate tonne→kg conversion and base currency inversion math with fixed inputs.
- Integration test: Mock Metals-API responses (success and failure) to exercise retry and fallback paths.
- Data drift monitor: Alert if unit field changes or if rate inversion implies an implausible per‑kg value (e.g., sanity bounds).
UI/UX tips for pricing displays
- Always show “as of” timestamp and timezone (UTC) to communicate recency.
- Include unit in labels (“EUR/kg” vs “EUR/t”).
- Provide a toggle between per‑kg and per‑tonne views to match user mental models.
- Annotate market closures and weekends with subtle visual cues or tooltips.
Accessibility and documentation links
To explore capabilities, rate cadences, and additional endpoints such as OHLC or bid/ask, consult the official resources:
- Metals-API Website — Get your free API key to start building today.
- Metals-API Documentation — Endpoint reference, parameters, and examples.
- Metals-API Supported Symbols — Verify LMQ25 and related instruments.
Example: latest and time-series responses explained
Below are concise examples annotated for quick reference.
Latest LMQ25 (USD base)
{
"success": true,
"timestamp": 1789690786,
"base": "USD",
"date": "2026-09-18",
"rates": { "LMQ25": 0.00005 },
"unit": "per metric tonne"
}
- USD per tonne = 1 / 0.00005 = 20,000
- USD per kg = 20,000 / 1,000 = 20
Time-series LMQ25 (EUR base)
{
"success": true,
"timeseries": true,
"start_date": "2026-09-11",
"end_date": "2026-09-18",
"base": "EUR",
"rates": {
"2026-09-11": { "LMQ25": 0.00005441 },
"2026-09-18": { "LMQ25": 0.00005435 }
},
"unit": "per metric tonne"
}
- EUR per tonne (2026-09-18) = 1 / 0.00005435 ≈ 18,400
- EUR per kg (2026-09-18) ≈ 18.4
Architecture reference implementation
Production teams often wrap Metals-API calls in a small internal service:
- Endpoint: /pricing/lithium/lmq25/latest?currency=EUR&unit=kg
- Logic:
- Fetch latest LMQ25 with base=EUR (or base=USD and Convert).
- Compute per‑kg (divide by 1000).
- Return JSON: { value, currency: "EUR", unit: "kg", timestamp }.
- Cache: 5–10 minutes TTL during trading hours; longer when markets are closed.
- Audit: Log raw API payloads with correlation IDs.
Monitoring and SLOs
- Freshness SLO: e.g., 95% of requests return data fewer than X minutes old during trading hours.
- Error budget: Allow a small percentage of fallbacks to cached data; alert if exceeded.
- Anomaly detection: Watch for sudden multi-sigma moves; flag to human review.
Frequently asked questions
How do I get started?
Visit the Metals-API Website, create a free account, and obtain your API key. Then try the Latest endpoint with LMQ25 and base=USD or EUR.
What symbol should I use for Lithium August 2025?
Use LMQ25 (Lithium Aug 2025). Always confirm availability and exact symbol spelling on the Metals-API Supported Symbols page.
How do I convert per metric tonne to per kilogram?
Divide the per‑tonne price by 1,000. Double-check the unit field in the response to confirm the base unit is “per metric tonne.”
Can I get prices in EUR, GBP, or CNY directly?
Yes. Set base to your target currency in the request (e.g., base=EUR), or use the Convert endpoint to translate from USD to your desired currency.
How should I handle weekends and holidays?
Expect missing or unchanged values during closures. Display the last known price with its timestamp and label it clearly as “as of” the last business day.
How do I compare LMQ25 futures with a spot benchmark?
Normalize both series to the same currency and unit (e.g., EUR/kg), align timestamps (daily close or chosen window), and compute spreads. Trigger alerts for deviations beyond your chosen thresholds.
Where can I find full endpoint details?
Refer to the Metals-API Documentation for request parameters, response schema, and additional endpoints beyond the scope of this article.