Free Gold Price API: What 100 Requests a Month Can Do

What can a free gold price API realistically do?

A free gold price API is the quickest way to put real gold prices into a prototype, a hobby site or an internal report without a purchase order. It is also easy to expect too much from one. Free plans exist so that you can build and test an integration and run small workloads that need a price once a day. They are not designed to drive a checkout that has to follow the market minute by minute.

This article describes MetalAPI's Free plan as it is, including what it leaves out. It then shows how to make 100 requests a month cover a surprising amount of work, and how to tell when you have outgrown it. If you are comparing several providers, the checklist near the end applies to any free metals API.

What is included in MetalAPI's free plan?

The Free plan costs nothing and needs no credit card. In summary:

Some features need a paid plan:

• Gold prices by karat from /carat: Lite and above. On Free you can still calculate karat prices from the 24K price yourself.
• Bid and ask prices, such as XAU-BID and XAU-ASK: Standard and above.
• Price alerts: by email from Lite, by webhook from Advanced.
• Realtime streaming over Server-Sent Events: Pro and above.
• Uptime SLA: Business and Enterprise.

An API request for something outside your plan returns error 106 (plan_restriction) with an upgrade_url, and that request is not billed. The Free plan also works with the MetalAPI MCP server, so an AI assistant can look up gold prices on your free quota, at the same daily freshness.

How often does a free gold price API update?

The most important line in that table is the update interval. On Free, the API takes one price snapshot per day, at midnight UTC, and every /latest request until the next midnight returns that snapshot. A response looks like this, with the example values from the MetalAPI documentation:

{
  "success": true,
  "timestamp": 1792713600,
  "date": "2026-10-23",
  "base": "USD",
  "rates": {
    "XAU": 0.0002501319446,
    "USDXAU": 3997.89
  },
  "rate_limit": {
    "limit": 100,
    "remaining": 99,
    "reset": 1793491200,
    "used": 1,
    "plan": "Free",
    "reset_date": "2026-11-01T00:00:00.000Z"
  }
}

USDXAU is the price of one troy ounce of gold in dollars, and XAU is its inverse. timestamp is the time of the data, here 00:00 UTC on 23 October 2026, and the rate_limit block shows how much of the month's quota is left.

Two consequences follow. First, calling /latest more than once a day on Free spends quota without ever returning a newer price. Second, Free fits the jobs where a once-a-day price is the right price:

• Daily valuation of holdings, stock or a portfolio.
• End-of-day reports, newsletters and internal dashboards.
• Accounting and invoices that need the gold price of a given day.
• Prototypes, student projects and learning the API before choosing a plan.

It doesn't fit a shop that reprices gold products during the day, a trading screen, or anything that promises customers a live price.

How far do 100 requests a month go?

Every successful call to a data endpoint counts as one request, however many symbols it returns. That rule is what makes a small quota workable. A realistic monthly budget for a small site:

Compare that with patterns that don't fit:

• Refreshing every hour: about 744 requests a month, for a price that changes once a day.
• One request per metal per day for gold, silver, platinum and palladium: about 124, where one combined request costs 31.
• Calling the API from the browser on every page view: a hundred visits use up the month.

Seven ways to stretch a free quota

1. Ask for every symbol in one call. currencies=XAU,XAG,XPT,XPD,EUR,GBP costs one request. Leaving out currencies returns every symbol, also for one request.
2. Cache until the next midnight UTC. On Free there is nothing newer to fetch before then. Keep the last good response and serve it if a call fails.
3. Convert locally. Grams and kilograms are exact multiples of the troy ounce (1 troy ounce = 31.1034768 g), and cross rates come from one snapshot: gold in euros is USDXAU ÷ USDEUR. One request in dollars per ounce can feed every unit and currency you display.
4. Store history once. Past closing prices never change. Fetch a range once, keep it in a database or file, and only request new days.
5. Validate before you send. Validation errors (codes 201 to 210) and 300 (no results) count as requests. Check dates and symbols first; /symbols lists every valid code and never counts towards the quota.
6. Keep calls on the server. A key in browser code is visible to everyone and spends a request per visitor. Fetch on the server and serve the cached result, or embed a widget, whose page views don't use your quota.
7. Watch the counter. Every response carries the rate_limit block and X-RateLimit-* headers, and /usage returns the same numbers without being billed. Rejections for rate limits (104), plan restrictions (106), origins (107) and server errors aren't billed either, so retrying those costs nothing.

Put together, the core of a Free integration is one scheduled job. This Node.js script runs once a day shortly after midnight UTC, makes a single request, and writes gold, silver, platinum and palladium prices per ounce and per gram in three currencies to a JSON file that your pages read:

// Run once a day after 00:00 UTC, e.g. with cron: 5 0 * * *  (server clock on UTC)
import { writeFile } from "node:fs/promises";

const GRAMS_PER_TROY_OZ = 31.1034768;
const METALS = ["XAU", "XAG", "XPT", "XPD"];
const CURRENCIES = ["EUR", "GBP"];

const params = new URLSearchParams({ base: "USD", currencies: [...METALS, ...CURRENCIES].join(",") });
const res = await fetch(`https://metalapi.com/api/v1/latest?${params}`, {
  headers: { "X-API-Key": process.env.METALAPI_KEY },
  signal: AbortSignal.timeout(10_000),
});
const data = await res.json();
if (!data.success) {
  // Leave yesterday's file in place, so pages keep showing the last good prices.
  throw new Error(`MetalAPI ${data.error.code} (${data.error.type}): ${data.error.info}`);
}

const prices = {};
for (const metal of METALS) {
  const usdPerOz = data.rates[`USD${metal}`];
  prices[metal] = {};
  for (const cur of ["USD", ...CURRENCIES]) {
    const perOz = cur === "USD" ? usdPerOz : usdPerOz / data.rates[`USD${cur}`];
    prices[metal][cur] = { perOz, perGram: perOz / GRAMS_PER_TROY_OZ };
  }
}

await writeFile("prices.json", JSON.stringify({ asOf: data.timestamp, prices }, null, 2));
console.log(`Saved. ${data.rate_limit.remaining} requests left this month.`);

At one run per day, the job uses 28 to 31 requests a month and leaves the rest for history and testing. On serverless platforms, write the result to a key-value store or your framework's data cache instead of a file.

For history, the 30-day range limit means one request per calendar month: a year of daily gold prices takes 12 requests. Historical gold and silver prices via API has a backfill script and storage tips; on Free, change its yearly windows to calendar months.

How to evaluate any free gold price API

If you are comparing free metals APIs, the headline numbers say less than the details. These questions are worth answering for any provider, ours included:

• How fresh is the free data? Real-time, delayed or daily, and does each response say when its prices are from?
• What counts as a request? One call for many symbols, or one per symbol? Are failed or rejected calls billed?
• Which endpoints are included? Latest prices only, or history, conversion and time series too?
• How much history, in what slices? How far back the data goes, and how many days one range request may cover.
• Units and currencies. Grams, kilograms and your local currency, or only troy ounces in US dollars?
• Usage terms. May the data appear on a commercial website, and what is excluded?
• What happens at the limit? A hard stop with a clear error, or automatic charges? How fast does an upgrade take effect?
• Key handling. Can the key travel in a header rather than in the URL, where it ends up in logs?

Then run a short hands-on test with your own symbols and currencies; a free key is enough for that. How to choose a precious metals price API turns these questions into a full checklist with a comparison template.

For MetalAPI the answers are above and in the documentation: daily snapshots with a timestamp on Free; one request per call however many symbols it returns; rate-limit, plan, origin and server-error rejections not billed; history, conversion and time series included; any unit and any of 57 currencies; use of the data in your own websites, apps and reports, including showing prices to your users, but no redistribution of the raw feed; a hard stop with error 105 at the quota and no overage fees; keys in a header or in the query string.

When to upgrade from the free plan

The Free plan is enough as long as a daily price is the right price and 100 requests cover your month. These are the usual signs that it no longer is:

Upgrades take effect immediately, so a key that has hit error 105 (quota_exceeded) works again as soon as you change plan; otherwise it waits for the reset on the 1st. Yearly billing saves up to 25%. The pricing page has current prices and the full comparison, and Rate limits & plans explains quotas and per-minute limits in detail.

The quickest way to find out whether Free is enough for your project is to try it. Create a free account, copy your API key from the dashboard and make your first request with the getting started guide. No credit card is needed, and you can switch to a paid plan whenever your project needs fresher prices.

FAQ

Is there a completely free gold price API?

Yes. MetalAPI's Free plan costs nothing, needs no credit card and includes gold, silver, platinum, palladium and every other symbol, with 100 requests a month and prices updated once a day.

How often does the free plan update gold prices?

Once a day. The Free plan sees one snapshot taken at midnight UTC, and every request until the next midnight returns the same prices. Paid plans update every 30 minutes on Lite and as often as every 5 seconds on Enterprise.

Can I use a free gold price API on a commercial website?

With MetalAPI, yes. The data may be used in your own websites, apps, internal systems and reports, including showing prices to your users. Redistributing the raw feed, for example by offering it as your own API, needs a separate written agreement.

What happens when I use up 100 requests?

Further requests return error 105 (quota_exceeded) with HTTP status 429 until the quota resets on the 1st of the month at 00:00 UTC. There are no automatic overage charges, and upgrading lifts the limit immediately.

Does the free plan include historical gold prices?

Yes. Free keys can query the full history, back to 2000 for gold, and can use /timeframe and /change with ranges of up to 30 days per request.