Home
Blog
S&P 500 Growth (IGX) Price Change API

S&P 500 Growth (IGX) Price Change API

S&P 500 Growth (IGX) Price Change API

You need to track how much the S&P 500 Growth index (IGX) moved today and plug that number into a dashboard, an alert, or a backtest. In this guide you’ll pull the latest IGX level from the API, understand how quotes are expressed, and set yourself up to calculate day-over-day price change using the right endpoints and caching rules.

What you’ll build: reliable IGX price change for dashboards and alerts

The S&P 500 Growth (IGX) is a style slice of the S&P 500, emphasizing companies with higher growth characteristics. If you’re building a smart market screen, automating portfolio rebalances, or monitoring factor tilts, you need a clean way to read the latest IGX level and compute its change across a day, week, or month.

Illustration: S&P 500 Growth (IGX) Price Change API

We’ll use the Latest endpoint for the current IGX print, and outline two ways to measure change:

  • Day-over-day change: Yesterday’s close to the latest level (via Time-Series or Historical).
  • Windowed change: A bounded period (via Fluctuation).

We’ll also cover practical concerns: base currency, units, non-trading days, update cadence, and response fields you’ll actually use.

Confirm the right symbol before you code

This article uses IGX for S&P 500 Growth. If you’re working with a different style or regional index, always confirm the exact symbol code on the official list before you query. See the catalog at Indices-API Supported Symbols.

Endpoints you’ll use to measure IGX price change

We’ll focus on two endpoints to cover the full price-change job:

  • Latest: Get the current IGX quote in real time (update frequency depends on your plan).
  • Time-Series or Historical: Get a prior trading day’s close to compute day-over-day change. You’ll use a date in the past; end_date cannot be today.

For period-over-period summaries (e.g., week-to-date change), the Fluctuation endpoint is designed for that. We’ll point to how to use it without fabricating example numbers.

Full parameter details are in the Indices-API Documentation. If you don’t have an API key yet, start a 7‑day trial (PRO $49.99/mo) here: Register.

Get the latest S&P 500 Growth (IGX) reading

The Latest endpoint returns a JSON payload with a base currency and a rates map. By default, the base is USD and rates are expressed per index (see notes on units below). Call it like this:

curl "https://indices-api.com/api/latest?access_key=YOUR_API_KEY"

Here’s a real response for IGX. Use these exact fields and their meanings in your code:

{"data":{"success":true,"timestamp":1793580120,"date":"2026-11-02","base":"USD","rates":{"IGX":0.00018445209059844,"USD":1,"USDIGX":5421.462000000001}}}

How to read these fields

  • success: Boolean flag indicating a successful response.
  • timestamp: Unix time (seconds) for the quote snapshot. Treat it as UTC.
  • date: ISO date for the snapshot. This is the trading date, not necessarily your local timezone date.
  • base: The pricing currency. Defaults to USD.
  • rates.IGX: USD per one index unit (per index point). To get the current index level, invert this value.
  • rates.USD: The base currency reference (1 when base=USD).
  • rates.USDIGX: Index points per 1 USD. This is the inverse of rates.IGX and directly equals the current index level.

With the example above:

  • IGX in USD per index = 0.00018445209059844
  • IGX index level = USDIGX = 5421.462000000001 (which is 1 / 0.00018445209059844)

Compute day-over-day price change for IGX

To compute day-over-day change, you need two numbers:

  1. Today’s latest level from the Latest endpoint (rates.USDIGX or 1 / rates.IGX).
  2. Yesterday’s close (prior trading day) from the Historical or Time-Series endpoint.

Important details you must account for:

  • Trading days vs. weekends/holidays: If today is Monday, “yesterday” is Friday (or the most recent trading day). Use Time-Series to fetch a small window and pick the most recent date before today.
  • end_date cannot be today: Query up to yesterday (or the latest known past date), not the current date.
  • Update frequency: Latest updates depend on your plan interval. Cache accordingly (see caching guidance below).

While we won’t fabricate a historical JSON example here, the process is straightforward:

  • Call Latest for IGX to get today’s snapshot.
  • Call Time-Series with a start_date several business days back and end_date set to yesterday to capture the prior close.
  • Compute change = latest_level − prior_close; change_pct = change / prior_close.

Refer to the endpoint specifics and query parameters in the Indices-API Documentation.

JavaScript example: fetch latest IGX and derive the index level

This snippet pulls the latest IGX payload and derives the current index level you’ll use in charts, alerts, or downstream analytics. It reads the same fields shown in the curl example above.

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

  // Navigate to the data object (matches the real response shape above)
  const data = payload.data;

  if (!data || !data.success) {
    throw new Error("API returned an unsuccessful response");
  }

  const base = data.base;               // "USD"
  const date = data.date;               // e.g., "2026-11-02"
  const ts = data.timestamp;            // epoch seconds (UTC)
  const rateUSDperIndex = data.rates.IGX;     // USD per one index unit
  const levelIndexPoints = data.rates.USDIGX; // index points per one USD (current IGX level)

  // If USDIGX is present, prefer it as the direct index level.
  // Otherwise compute as 1 / IGX (defensive coding).
  const igxLevel = typeof levelIndexPoints === "number"
    ? levelIndexPoints
    : (1 / rateUSDperIndex);

  return {
    base,
    date,
    timestamp: ts,
    igxUSDperIndex: rateUSDperIndex,
    igxLevel
  };
}

fetchLatestIGX()
  .then(({ base, date, timestamp, igxUSDperIndex, igxLevel }) => {
    console.log(`Base: ${base}`);
    console.log(`Date (UTC): ${date}`);
    console.log(`Timestamp: ${timestamp}`);
    console.log(`IGX USD per index: ${igxUSDperIndex}`);
    console.log(`IGX level (index points): ${igxLevel}`);
  })
  .catch(err => {
    console.error("Failed to fetch IGX:", err);
  });

Use Fluctuation for windowed price change (no hand-rolled math)

If your requirement is “How much did IGX move between start_date and end_date?”, call the Fluctuation endpoint. It returns start_rate, end_rate, absolute change, and change_pct for your window. This is ideal for:

  • Daily email summaries: last business day to yesterday’s close.
  • Weekly recaps: last Monday to last Friday.
  • Event windows: pre/post earnings season, macro events, or reconstitution dates.

Keep in mind:

  • Choose dates that reflect trading days; if a date is a weekend/holiday, the API will use available business days in the window.
  • end_date cannot be today. Use yesterday at most.

For exact query parameters and response shapes, see the Indices-API Documentation. Do not rely on today’s date for end_date; schedule runs after market close and settle on the most recent business day.

Production details that save time

Base currency and units

  • base: By default, USD. All rates are quoted relative to base.
  • Rates convention: “per index.” For IGX, rates.IGX is USD per index unit; invert to get the index level. rates.USDIGX is already the level in index points.

Trading days, weekends, and holidays

  • Non-trading days produce no new closes. When computing day-over-day changes, step back to the most recent business day.
  • Use Time-Series over a small date span to reliably find “yesterday’s close” when the previous calendar day is not a trading day.

Update frequency and caching

  • The Latest endpoint updates on a cadence determined by your plan (e.g., every 60 minutes, every 10 minutes, etc.).
  • Cache TTL: Set your cache to the update interval of your plan and add a small jitter (e.g., +10%) to avoid thundering herds at boundary minutes.
  • Don’t cache across sessions for price-change analytics that require precision at market close; fetch a fresh snapshot after known settlement windows.

Timestamps and timezone

  • timestamp is Unix epoch seconds. Treat values as UTC unless documented otherwise.
  • date is the reporting date for the snapshot; it may differ from your local timezone date.

end_date cannot be today

  • Historical and Time-Series queries must end on or before the last completed trading day. Avoid today’s date for end_date when markets are open.

Verifying IGX and related symbols

Why IGX price change matters for modern analytics

Style indices like IGX are central to factor-aware risk and performance analysis. Tying your pipelines directly to an index API makes it easier to:

  • Build factor dashboards that mix real-time prints with historical context.
  • Trigger alerts when a style tilt moves beyond a threshold, using Fluctuation windows.
  • Power research notebooks that recompute exposures with each incoming print.

If you track methodology or compliance around factor definitions, bookmark MCP for references and integration notes. For background on growth vs. value construction, see the S&P Dow Jones Indices style methodology and related primers on growth indices.

A minimal plan to ship

  1. Get an API key: Register (7‑day trial; PRO is $49.99/mo).
  2. Implement Latest for IGX and parse rates.USDIGX (or 1 / rates.IGX) as the index level.
  3. Implement a Time-Series query for a small window up to yesterday and pick the last business day close.
  4. Compute change and change_pct; persist both with timestamp for auditability.
  5. Add caching aligned to your plan’s update frequency; avoid today as end_date.

As you expand, wire Fluctuation for standardized windowed moves, and consult the Indices-API Documentation for request limits and endpoint nuances.

FAQ

How do I get the actual IGX index level from the API?
Use rates.USDIGX (index points per USD) directly if it’s present. Otherwise compute 1 / rates.IGX (since rates.IGX is USD per index unit with base “USD”).

Why is my end_date rejected when I pass today’s date?
Historical and Time-Series endpoints require completed periods. Use the most recent business day (yesterday) for end_date; do not use today.

How should I handle weekends and holidays for day-over-day change?
Query a small Time-Series window (e.g., the last 7 calendar days) and pick the most recent date before today. That guards against non-trading days.

How fresh is Latest, and how should I cache it?
Freshness depends on your plan’s update interval. Cache to that interval (e.g., 10–60 minutes) plus a small jitter. Avoid reusing cached values beyond the plan’s cadence if you’re computing intraday changes.

Where can I verify the IGX symbol and look up others?
Use the catalog at Indices-API Supported Symbols. Confirm the exact code before integrating into production.

Ship your IGX price-change integration today. Start your 7‑day trial and get your API key here: Register. Then explore parameters, payloads, and additional endpoints in the Documentation and confirm symbols as you expand coverage.

Ready to use Indices-API?

Try it now!

Search

Recent Posts