CAC Mid 60 Index (France) Historical Price API: Getting Started Guide for Developers

You need to backfill and chart the CAC Mid 60 (France) index for a product dashboard, then keep it current with a daily job. By the end of this guide, you’ll be able to 1) confirm the correct CAC Mid 60 symbol, 2) fetch historical and latest prints from Indices-API, 3) parse and transform the payload into index-level values suitable for charting or alerts, and 4) handle practical details like non-trading days, caching, and the “today” boundary.

What you’re building: a reliable CAC Mid 60 daily time series

The concrete job here is a time series for the CAC Mid 60 with clean daily closes you can chart and query. We’ll focus on three endpoints that cover this flow:

Illustration: CAC Mid 60 Index (France) Historical Price API: Getting Started Guide for Developers

Latest: to sanity-check connectivity and confirm the symbol resolves.
Historical (single date): to pull a specific backfill date when you have gaps.
Time-series: to ingest a continuous window for initial backfill and rolling updates.

Indices-API quotes are returned relative to a base (default base is USD). That means each rates entry is a conversion rate from the base to a given index symbol (and, for many indices, the inverse pair is also present, e.g., USDGSPC as the inverted convenience rate). You’ll use this to compute the actual index level.

If you don’t already have access, start with the 7-day trial on the PRO plan ($49.99/mo). Get your key here: Register.

First step: confirm the CAC Mid 60 symbol code

The CAC Mid 60 (France) appears on Euronext and is commonly abbreviated as “CAC Mid 60,” but API symbol codes vary by vendor. Do not guess the symbol. Confirm the exact Indices-API symbol on the official list: Indices-API Supported Symbols.

Once you have the symbol (for example, suppose the Symbols page shows something like CACMD; use the actual code you find), you will use two forms in rates:

rates.<SYMBOL>: index units you get per 1 USD (base-to-symbol).
rates.USD<SYMBOL>: USD you get per 1 index unit (the inverse pair, when provided).

Both representations describe the same underlying value. If a convenience inverse pair is present (e.g., USDGSPC for S&P 500), prefer it because it avoids floating-point inversion in your code. If it is not present for your index, compute the inverse yourself with 1 / rates.<SYMBOL>.

Quick connectivity check with the Latest endpoint

Before wiring up backfills, verify you can reach the API and parse the fields you need. The latest endpoint is a fast sanity check and will return the default base (USD) and a rates map.

Copy-paste this and replace YOUR_API_KEY with your actual key:

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

Official sample payload you can rely on when testing

This is the real response format from Indices-API. We’re showing the fields using a GSPC example so you can see how rates, timestamp, and base fit together. For CAC Mid 60, apply the identical parsing pattern with the CAC Mid 60 symbol you confirmed on the Symbols page.

{"data":{"success":true,"timestamp":1790901480,"date":"2026-10-02","base":"USD","rates":{"GSPC":0.00013043404537279,"USD":1,"USDGSPC":7666.709999999825}}}

Fields you’ll use:

success: boolean status for the call.
timestamp: Unix epoch seconds for the quoted snapshot.
date: calendar date associated with the snapshot (YYYY-MM-DD).
base: the currency or base unit for rates; default is USD.
rates: a map of conversions from base to index symbols, and often the inverse pair (e.g., USDGSPC as USD-per-index).

Interpreting the example:

rates.GSPC = 0.000130434... means 1 USD equals 0.000130434 GSPC units.
rates.USDGSPC = 7666.71... is the inverse pair: 1 GSPC unit equals 7666.71 USD, i.e., the headline index level expressed in USD terms.

For the CAC Mid 60, read rates.USDCACMID60 (or similar) if present; otherwise compute 1 / rates.CACMID60. Again, don’t guess symbol strings—copy the exact code from the Symbols page.

Parse the Latest payload in code

The snippet below shows how to call the same endpoint and extract an index-level value from the rates map. It uses the real fields shown above. Replace the symbol strings after you confirm the CAC Mid 60 code.

import os
import requests
from datetime import datetime, timezone

API_KEY = os.getenv("INDICES_API_KEY", "YOUR_API_KEY")
URL = "https://indices-api.com/api/latest"

def fetch_latest_index_level(symbol_code):
    """
    Fetch latest for a given index symbol.
    If USD<SYMBOL> exists, use it directly; otherwise invert rates[SYMBOL].
    """
    resp = requests.get(URL, params={"access_key": API_KEY}, timeout=10)
    resp.raise_for_status()
    payload = resp.json().get("data", {})
    if not payload.get("success", False):
        raise RuntimeError("API call unsuccessful")

    base = payload.get("base")  # expected "USD"
    ts = payload.get("timestamp")
    dt = datetime.fromtimestamp(ts, tz=timezone.utc) if ts else None
    rates = payload.get("rates", {})

    # Example with GSPC to show the pattern.
    # For CAC Mid 60, set `symbol_code` to the exact string from the Symbols page.
    if f"USD{symbol_code}" in rates:
        index_level = rates[f"USD{symbol_code}"]
    else:
        # Fallback: invert base-to-symbol rate
        base_to_symbol = rates.get(symbol_code)
        if not base_to_symbol or base_to_symbol == 0:
            raise ValueError(f"Missing or zero rate for {symbol_code}")
        index_level = 1.0 / base_to_symbol

    return {
        "symbol": symbol_code,
        "timestamp": ts,
        "asof_utc": dt.isoformat() if dt else None,
        "base": base,
        "index_level": index_level
    }

if __name__ == "__main__":
    # Demonstration with GSPC using the official payload structure above.
    # Swap 'GSPC' with the confirmed CAC Mid 60 symbol from the Symbols page.
    print(fetch_latest_index_level("GSPC"))

Backfilling the CAC Mid 60: time-series and single-date pulls

With the symbol confirmed, you’ll use two patterns:

Time-series endpoint: fetch a contiguous historical window (e.g., 1–3 years) for your initial backfill and for rolling daily updates.
Historical endpoint: fetch a single date to correct a gap, rebuild a specific day, or verify a daily close.

Both endpoints return the same shape for base and rates—you’ll compute the index level exactly as shown in the Latest example (prefer USD<SYMBOL> if present; otherwise invert <SYMBOL>).

Time-series endpoint

Use time-series to build your CAC Mid 60 daily line chart and to backfill a date range. The endpoint returns a date-keyed map under rates. For each date, read the same fields you saw in the Latest example, but namespaced by calendar day.

Important implementation notes:

Date window: the endpoint accepts start_date and end_date (inclusive). The exact per-request limits vary—check the Documentation.
End date cannot be “today”: request up to the most recent completed trading day. If you ask for today and the market hasn’t closed, you may get partial data or none.
Weekends and holidays: expect missing calendar dates; only trading days will have entries. In your chart, forward-fill only if your product demands it; otherwise plot just the trading days.

Historical (single date) endpoint

When you need a specific date (e.g., for a repair job), call the historical endpoint with the date in YYYY-MM-DD format. The response mirrors the Latest shape: base, a date, and a rates map for that day. Compute the index level with USD<SYMBOL> if it exists; otherwise invert <SYMBOL>.

How quotes are expressed and how to compute the index level

Indices-API returns exchange-like pairs for indices relative to the base. With base = "USD":

rates.SYMBOL means “how many SYMBOL units per 1 USD.”
rates.USDSYMBOL means “how many USD per 1 SYMBOL unit.”

Your chart typically needs the headline index level: use USDSYMBOL directly when it’s present; else compute 1 / rates.SYMBOL. Store both the raw rates and your derived headline value to keep auditing simple.

Operational details you’ll want to get right

Update frequency: the Latest endpoint updates depending on your plan (commonly every 60 minutes or every 10 minutes). Verify specifics in the Documentation.
Caching: cache Latest results for at least one update interval to avoid unnecessary calls. For time-series and historical, cache results by date because those do not change after the official close.
Timezone and cutover: use the timestamp field to anchor snapshots. If your product presents “as of” labels, convert the Unix epoch to your display timezone but store UTC for consistency.
End-of-day boundary: do not request end_date=today in time-series; target the most recent completed trading day. Schedule the job after the market’s official close window.
Missing days: weekends and French exchange holidays will not have prints. Expect gaps in calendar time and handle them explicitly in your chart or analytics.
Symbol audits: symbol universes evolve. If your integration runs for months, periodically re-check the Symbols list for updates.

Linking this to your product workflow

Here’s a pragmatic flow you can implement in a morning sprint:

Look up the CAC Mid 60 symbol on the Indices-API Supported Symbols page.
Run the Latest endpoint to confirm connectivity and to verify that either USDSYMBOL exists or that you can invert SYMBOL.
Use the time-series endpoint to ingest the last N years for the symbol. Persist one row per trading day: date, base, timestamp, raw rates, derived headline index level, and source metadata.
Set a daily job to extend the window by one business day after the French market close. If you ingest intraday, throttle queries to the update frequency noted in the docs.
Add a repair function that calls the historical endpoint for any missing dates returned by your QA checks.

About the CAC Mid 60 and practical symbol considerations

The CAC Mid 60 tracks 60 mid-cap French equities and is administered by Euronext Paris. If you want a domain reference while you confirm your symbol, refer to Euronext’s CAC family pages (for example, Euronext Indices Directory) and then match the exact Indices-API symbol using the Symbols list. Don’t paste a vendor-specific code from another provider without verification.

Building alerts and analytics

Once you have a clean CAC Mid 60 time series, you can layer on alerting—e.g., day-over-day percent changes, rolling 20-day highs/lows, or divergence against broader French or Eurozone benchmarks. For day-over-day change, compare derived headline levels between the last two trading days; for intraday drift, poll Latest on your plan’s update cadence.

If you need OHLC, fluctuation metrics, or intraday intervals, these are also available. Keep the scope tight for your initial ship, then expand with endpoints like OHLC or Fluctuation as needed and as documented in the Documentation.

Reference links for implementing and validating

Indices-API product homepage: indices-api.com
Start your free 7-day trial (PRO $49.99/mo): Register
Endpoint details and parameters: Documentation
Find the CAC Mid 60 symbol: Symbols
Managed connectivity practices for ingest (network and retries): MCP

Gotchas that save you an hour

Don’t request today as end_date in a time-series job; use the last completed trading day to avoid partials.
When in doubt, look for the inverse pair (USD<SYMBOL>) to avoid accidental inversion bugs, rounding drift, or zero-division on sparse days.
Persist timestamp in UTC; if your display is in Europe/Paris, convert only at render time.
Some endpoints return many symbols in one shot. If you only need the CAC Mid 60, filter for just that symbol to reduce processing and storage.
If the CAC Mid 60 symbol ever changes, migrate by writing both the old and new symbol for a period, verifying that USD<SYMBOL> parity is consistent across the cutover date, then retire the old code.

FAQ

How do I find the exact CAC Mid 60 symbol?
Use the official list here: Indices-API Supported Symbols. Copy the code exactly as shown.

Why is there both SYMBOL and USDSYMBOL in rates?
The API quotes relative to a base (USD). rates.SYMBOL is SYMBOL-per-USD; rates.USDSYMBOL is USD-per-SYMBOL (often the headline index level). They are inverses; use USDSYMBOL when present to avoid doing the inversion yourself.

Can I call the time-series endpoint with today as end_date?
Avoid it. Use the last completed trading day. Markets close at different times; calling for “today” may return partial or no data.

What about weekends and French holidays?
Expect no entries on non-trading days. The time-series will have gaps in calendar dates; your chart should plot trading days only or forward-fill by design choice.

How often should I poll Latest?
Match the update cadence indicated by your plan tier in the Documentation. Cache results for at least one interval to avoid redundant calls.

Ship your CAC Mid 60 integration now: confirm the symbol, fetch Latest to validate parsing, then backfill with time-series and keep it fresh with a daily job. If you don’t have keys yet, start your 7-day trial and get a PRO key here: Register. For parameter specifics, limits, and additional endpoints, see the Documentation and keep the indices-api.com site handy while you build.

Ready to use Indices-API?

Try it now!