FTSE 100 (FTSE) Price History API

You need to chart FTSE 100 history, backfill a dashboard, or trigger alerts on a daily move. By the end of this guide you’ll be able to fetch the latest FTSE print you’ll chart against, understand how to derive an index level from the latest response, and plan a clean time-series backfill using Indices-API’s historical and timeseries endpoints.

What you’re building: a reliable FTSE 100 time series

The concrete workflow looks like this:

• Fetch today’s FTSE 100 reference via the Latest endpoint to pin your chart anchor or pre-market display.
• Backfill a daily series using the Time-Series endpoint between a start_date and an end_date in the past.
• Optionally grab day-level OHLC for candlesticks or validate moves with Fluctuation.

We’ll focus the code on the Latest endpoint so you can copy/paste and run immediately, then outline how to extend to history. All examples use the FTSE symbol only; confirm any additional symbols you need on the Indices-API Supported Symbols page.

How FTSE quotes are expressed (base, units, and derived index levels)

Indices-API responses are quoted relative to a base currency (USD by default). For FTSE, the Latest response will include both a compact “rate” and its inverse pair:

• rates.FTSE — the USD price per one unit of the FTSE index (USD per index).
• rates.USDFTSE — the inverse: index units per USD (per-USD index measure).

Practically, when you want to display something resembling an “index level” for FTSE in your UI, use rates.USDFTSE if it’s present in the payload; it represents how many FTSE index units one USD buys (the numeric scale is close to a familiar headline “level”). If you only have rates.FTSE, you can compute an equivalent index-like value as 1 / rates.FTSE.

Timezone and dates: responses include a UNIX timestamp (seconds) and an ISO date. Indices trade on business days; weekends and local holidays will not produce a new close. The Latest endpoint updates intraday depending on your plan (for example, every 60 minutes or every 10 minutes). Avoid assuming that today’s end-of-day is available before the market closes. For time-series queries, end_date must not be today; use yesterday or the most recent completed trading day.

One call to pin your chart: Latest FTSE

The Latest endpoint is the fastest way to anchor your daily chart or to validate if a new candle should be drawn. Use your access key in the access_key query parameter and scope to FTSE.

curl request

curl -s "https://indices-api.com/api/latest?access_key=YOUR_API_KEY&symbols=FTSE"

Real API response (copy/paste for testing)

{"data":{"success":true,"timestamp":1793148060,"date":"2026-10-28","base":"USD","rates":{"FTSE":7.0321918469888e-5,"USD":1,"USDFTSE":14220.317388357404}}}

Fields you’ll actually use:

• data.success — boolean success flag.
• data.timestamp — UNIX seconds for caching and staleness checks.
• data.date — calendar date of the print (ISO, not necessarily end-of-day until the session completes).
• data.base — the pricing base currency (USD).
• data.rates.FTSE — USD per FTSE index unit.
• data.rates.USDFTSE — FTSE index units per USD (useful to display a single “level”-like number).

JavaScript example: latest FTSE with derived display value

async function getLatestFTSE() {
  const url = "https://indices-api.com/api/latest?access_key=YOUR_API_KEY&symbols=FTSE";
  const res = await fetch(url, { headers: { "Accept": "application/json" } });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const payload = await res.json();
  const d = payload.data;

  // Core fields
  const ts = d.timestamp;      // UNIX seconds
  const date = d.date;         // "YYYY-MM-DD"
  const base = d.base;         // "USD"
  const rateFTSE = d.rates.FTSE;     // USD per index unit
  const invFTSE = d.rates.USDFTSE;   // index units per USD (preferred display if present)

  // Choose a display value for charts. If inverse is present, use it; otherwise invert the rate.
  const display = (typeof invFTSE === "number" && isFinite(invFTSE))
    ? invFTSE
    : (1 / rateFTSE);

  return {
    timestamp: ts,
    isoDate: date,
    base,
    rateFTSE,
    displayValue: display
  };
}

// Example usage:
getLatestFTSE()
  .then(({ isoDate, displayValue }) => {
    console.log(`FTSE latest for ${isoDate}: ${displayValue}`);
  })
  .catch(err => {
    console.error("Failed to fetch FTSE latest:", err);
  });

Production notes:

• Cache aggressively for your UI (e.g., 30–60 seconds) to avoid jitter when your update frequency is coarser than UI refresh rates.
• When markets are closed (weekends, holidays), the Latest timestamp and date may remain unchanged until the next session. Avoid forcing a new candle when the date hasn’t rolled.
• If you need a guaranteed previous close, fetch historical by explicit date (see below).

Backfilling FTSE price history

For charts, quant models, and alert baselines, you will typically backfill a daily series from a known start_date to a recent end_date (not today). Indices-API exposes two endpoints you’ll use for this:

• Historical endpoint — query a single past date’s rates to fetch a specific day (e.g., yesterday’s close or a key event date).
• Time-Series endpoint — fetch a continuous daily range between start_date and end_date to bootstrap or refresh a dataset.

Only FTSE should be requested when you’re building a dedicated FTSE time-series. If you require other symbols, confirm them on the Symbols page and then request those explicitly.

Picking dates and handling non-trading days

• Set end_date to the most recent completed session (yesterday in the exchange’s local time) because end_date cannot be today.
• Expect no data points for weekend or holiday dates; your series should handle gaps (or pre-fill with the last known close if your downstream logic requires continuity).
• Store both rate and inverse if present. For chart labels, you can display the inverse-like value (e.g., USDFTSE) for ease of interpretation, while keeping the base rate for calculations.

Which endpoints to use for FTSE?

Turning Latest into a historical point

A common pattern is to persist the Latest print on a schedule while markets are open, then overwrite the day’s final value after the session with a Historical or OHLC close for that date. This gives you a near-real-time chart during the day and a clean canonical close after hours.

• During session hours: poll Latest and display rates.USDFTSE when available (or 1 / rates.FTSE) with the data.date as your candle date.
• After session end: fetch Historical for that date (or OHLC) and store the official close aligned to the same date key.

Smart integration details that prevent surprises

• Base currency: USD. If you need to convert derived FTSE values into another currency, use the Convert endpoint. Keep your FTSE series in one base to avoid mixed units.
• Timestamps: Use data.timestamp for cache invalidation and to compute data freshness metrics. If timestamp hasn’t advanced since your last poll, you can skip downstream updates.
• Update cadence: Depending on your plan, Latest is updated every N minutes. Build a small jitter (±10%) into your polling schedule to avoid thundering herd behavior at the top of the minute.
• Retries: If you receive a non-200 or success=false, backoff and retry. Do not retry blindly on unchanged timestamps.
• end_date constraint: The timeseries end_date must be a past date; using today can return incomplete or no data. Always compute end_date as “yesterday” in the relevant market timezone.

Security, registration, and pricing

Authenticate with your API key via the access_key query parameter. Keep keys server-side in production; for local testing you can use environment variables or your shell profile. There’s a PRO plan at $49.99/mo with a 7-day trial, suitable for dashboards and research workloads that need frequent updates and historical backfills.

Get started in minutes: create your account and key here — Register.

Extending beyond the basics

When you’re ready to expand beyond a single symbol, or add intraday candles, explore the broader platform capabilities in the Indices-API Documentation. You’ll find details on endpoints for time-series, historical by date, OHLC, fluctuation, intraday, and conversion, along with request parameters and response field semantics. You can also learn about the platform’s multi-cloud delivery surface in MCP.

If you’re building analytics around technological innovation, market microstructure, or sustainability screens, the same FTSE flow applies: Latest to anchor, Time-Series to backfill, and OHLC to power candlesticks, volatility features, and alert thresholds. Combine this with your IoT telemetry or alternative datasets to correlate macro index moves with real-world signals.

Operational checklist for a production FTSE pipeline

• Symbol verification: confirm FTSE and any peers you plan to chart on the Symbols page before deploying.
• Polling: schedule Latest reads at or slightly below your plan’s update frequency.
• Cache: keep a short-lived cache (e.g., 30–60 seconds) and serve dashboards from it.
• Backfill: run a nightly batch to refresh yesterday’s OHLC/close and to append any missed days.
• Gaps: handle weekends/holidays explicitly; your charts should not assume daily continuity.
• Derived level: prefer rates.USDFTSE for the headline display; fall back to 1 / rates.FTSE.
• Validation: compare timestamp progression before triggering expensive downstream recomputes.

Additional references

• FTSE Russell (methodology and index facts): ftserussell.com
• London Stock Exchange trading calendar: LSE trading calendar

FAQ

How do I get a single number to plot as the FTSE “level” from Latest?
Use data.rates.USDFTSE if present. If it isn’t present, compute 1 / data.rates.FTSE. Both are derived from a USD base.

Why does my time-series request return fewer points than expected?
Time-series excludes non-trading days. Also ensure end_date is not today; set it to the most recent completed session (typically yesterday in the exchange’s timezone).

How often does the Latest endpoint update?
It depends on your subscription plan; for example, every 60 minutes or every 10 minutes. Cache your UI and avoid assuming tick-by-tick behavior.

Can I safely poll from the browser?
Keep your access_key on the server in production. Exposing keys client-side is risky. Use a thin proxy or serverless function to call the API and cache responses.

What if I need OHLC for candlesticks?
Use the OHLC endpoint for the specific date(s) you need. Store open, high, low, and close per day and render directly.

Ready to ship your FTSE chart or backfill pipeline? Create an account to get your API key and start integrating within minutes: Register.