Historical S&P/BYMA Argentina General (IBG) Prices — daily time series for API ingestion

You need to backfill and keep a daily time series of the S&P/BYMA Argentina General index (IBG) for charts, analytics, or alerting. By the end of this guide you’ll have a reproducible pattern to fetch the latest IBG print, build and maintain a daily historical series, and handle edge cases like weekends, caching, and date cutoffs using Indices-API.

What you’re building: a reliable IBG daily series you can ingest

The concrete outcome is a process that:

• Pings the latest endpoint to get today’s IBG rate relative to USD.
• Backfills daily values over a date range with the time-series endpoint.
• Normalizes fields (base, date, timestamp, rates) into your storage schema.
• Handles non-trading days and API update frequency.

We’ll use at most two endpoints: latest for incremental updates and time-series for backfills. If you haven’t confirmed the exact symbol code for your index, look it up first on the Indices-API Supported Symbols page. For this article, we’ll use IBG as the symbol for S&P/BYMA Argentina General.

How IBG quotes work in Indices-API

Indices-API returns rates relative to a base currency. By default, the base is USD. The response includes:

• base: The base currency used for the rates (usually “USD”).
• date and timestamp: Coordinated date and a UNIX timestamp for the snapshot.
• rates: A map of symbols to numeric rates relative to base.

For IBG, you will typically see two relevant fields under rates:

• rates.IBG — the rate expressed relative to USD (USD per 1 IBG unit).
• rates.USDIBG — the inverse mapping (IBG units per 1 USD).

Use rates.IBG directly if you want a single series where every value is quoted “in USD per index.” If your downstream logic prefers the inverse (e.g., “index units per USD”), use rates.USDIBG. The exact unit semantics in your analytics should be consistent from ingestion through visualization. If your use case demands a different base, see the Indices-API Documentation for options and examples.

Fetching the latest IBG print for incremental updates

To keep your series current (e.g., an hourly or daily cron), call the latest endpoint. Depending on plan, the latest endpoint updates as frequently as every 10 minutes; other plans may update every 60 minutes. Treat the API as eventually consistent intraday; if your job runs before the next update window, cache and retry later.

Latest endpoint: one curl you can copy

Replace YOUR_API_KEY with your key. If you don’t have one, you can get a free 7-day trial (PRO is $49.99/mo) here: Register.

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

Official response sample (use these exact values to validate your parser):

{"data":{"success":true,"timestamp":1792827660,"date":"2026-10-24","base":"USD","rates":{"IBG":1.2308280350745e-5,"USD":1,"USDIBG":81246.11818250237}}}

Fields you will use:

• data.success — boolean for request success. Fail fast if false.
• data.timestamp — UNIX epoch for the snapshot; good for idempotency and cache keys.
• data.date — trading date of the snapshot. Note: on weekends/holidays, this may be the most recent trading day.
• data.base — the base currency (USD).
• data.rates.IBG — the IBG rate (USD per index unit).
• data.rates.USDIBG — inverse (index units per USD) if you prefer that orientation.

Python example: read rates, base, date, timestamp

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"
params = {"access_key": API_KEY}

resp = requests.get(url, params=params, timeout=10)
resp.raise_for_status()
payload = resp.json()

# Basic validation
if not payload.get("data", {}).get("success"):
    raise RuntimeError(f"Indices-API not successful: {payload}")

data = payload["data"]
snapshot_ts = data["timestamp"]            # int UNIX epoch
snapshot_dt = datetime.fromtimestamp(snapshot_ts, tz=timezone.utc)
snapshot_date = data["date"]               # "YYYY-MM-DD"
base = data["base"]                        # "USD"
rates = data["rates"]

ibg_usd_per_index = rates.get("IBG")       # float, USD per 1 IBG unit
usd_to_ibg = rates.get("USDIBG")           # float, IBG units per 1 USD

# Persist the fields you actually need for your time series
record = {
    "symbol": "IBG",
    "date": snapshot_date,
    "timestamp": snapshot_ts,
    "base": base,
    "rate_usd_per_index": ibg_usd_per_index,
    "inverse_index_per_usd": usd_to_ibg
}

print(record)

Implementation notes:

• Use timestamp as the canonical version for the day; if you re-fetch later and the timestamp changed, update your record for that date.
• Cache responses keyed by date to avoid unnecessary traffic in the same update window.
• On weekends and Argentine market holidays, expect no new trading data. The API may return the last available trading date.

Backfilling a daily IBG time series

For history, use the time-series endpoint with a start_date and end_date in YYYY-MM-DD. For best results, specify a closed interval that does not include today, because end_date cannot be today. If you need today’s value, fetch latest separately and append it after your backfill completes.

Pattern for backfill runs:

1. Run time-series in batches that fit your date coverage and any plan constraints.
2. Skip weekends and local holidays if the API returns null/no print for those days. Persist only dates that include a valid IBG rate.
3. Use date as the primary key and keep the original base (USD) along with rate values and timestamp for traceability.
4. Re-run with the same date window to idempotently fill gaps after temporary failures.

Field handling is the same as for latest: normalize base, date, timestamp, and rates per day. For all time-series parameters and edge cases, refer to the Documentation.

Data modeling for ingestion pipelines

Store data in a schema that allows you to re-compute derived views without re-calling the API:

• symbol: “IBG”.
• date: trading date (YYYY-MM-DD) from the API.
• timestamp: UNIX epoch from the API for the snapshot.
• base: “USD”.
• rate_usd_per_index: rates.IBG.
• inverse_index_per_usd: rates.USDIBG (optional, but useful for conversions).
• source: “indices-api/latest” or “indices-api/timeseries”.

This structure supports downstream transforms such as:

• Charting the daily USD-per-index series.
• Converting USD-denominated amounts to IBG units using inverse_index_per_usd.
• Cross-index normalization if you ingest other symbols using the same base.

Operational details that save you time

• Base currency: Unless you request otherwise, values are relative to USD. Keep base alongside the value.
• Units: Treat rates.IBG as “USD per index” and rates.USDIBG as “index per USD.” Use one consistently in your analytics to avoid confusion.
• Trading days vs weekends: Expect no new data on weekends and Argentine public holidays. Your daily scheduler can either skip those dates or record the last available print with that prior date. For strict EOD series, store only dates present in the time-series response.
• Update frequency: The latest endpoint updates at different cadences by plan (e.g., every 60 or 10 minutes). Use ETag/If-Modified-Since style caching on your side (store the last timestamp and skip processing if it hasn’t changed).
• Cutoffs: Don’t set time-series end_date to today. Fetch up through yesterday, then optionally add today via latest.
• Error handling: If success is false or rates is missing the symbol, retry with backoff and log the timestamp and date for diagnostics.
• Caching and idempotency: Cache by (symbol, date). If you later refetch with the same date window, merge deterministically by date key.

Endpoint quick reference for this workflow

For parameters, authentication, and advanced usage, see the full Documentation. Confirm IBG and any other symbols you need on the Symbols page.

Charting IBG without surprises

Once you have a stable daily series, keep the following in mind to avoid chart artifacts:

• Use the date field from the API as the x-axis. Don’t re-derive it from timestamp without preserving UTC, or you can slip a day around DST transitions.
• If your charting library expects numeric continuity, decide whether to forward-fill weekends or omit them entirely. If forward-filling, mark those points as “non-trading” in your metadata for transparency.
• When mixing IBG with other indices, normalize units first. Because all rates are relative to USD by default, you can plot multiple series consistently on the same axis or provide per-series axes.

Production tips for dashboards and research pipelines

• Scheduling: Run a daily backfill just after market close in Argentina time, and an intraday latest fetch aligned to your plan’s update interval.
• Storage: Append-only for raw snapshots, then materialize a daily “as-of” view keyed by date. This allows reproducibility if you need to re-generate a chart to historical standards.
• Monitoring: Alert on missing IBG for a business day by a certain UTC cutoff. Keep a small queue to retry until the day is finalized.
• Validation: If your downstream metric is sensitive to inverse vs direct orientation, add a unit check that asserts exactly one of (rate_usd_per_index, inverse_index_per_usd) is the primary source for charts.
• Docs and MCP: For integrations that need additional controls or marketplace connectivity, review MCP resources and the main Indices-API site.

IBG context and external references

IBG tracks broad performance for Argentine equities listed on BYMA and is part of the family of S&P/BYMA benchmarks. When integrating, remember:

• Local holidays and trading hours will affect data availability on given dates.
• Indices may have methodology changes over time; if you do long-span analysis, track any announced changes from the index administrator.

For background research, you can consult BYMA and S&P index overview pages (e.g., BYMA and S&P index methodology pages) alongside your API-driven series from Indices-API.

End-to-end workflow checklist

• Get your key: Register (7-day trial; PRO $49.99/mo).
• Confirm IBG on the Symbols page.
• Implement latest fetch with caching by timestamp; parse base, date, timestamp, and rates.
• Implement time-series backfill with start_date and end_date (end_date should be ≤ yesterday).
• Normalize units and store a single canonical series for your charts and analytics.

FAQ

Q: What symbol should I use for S&P/BYMA Argentina General?
A: Use IBG. If you’re unsure or need other symbols, confirm on the Symbols page.

Q: Why is the end_date on time-series not returning today?
A: The time-series endpoint does not support end_date set to today. Backfill up to yesterday, then call latest for today’s snapshot and append it to your series.

Q: Do I use rates.IBG or rates.USDIBG?
A: Both are provided relative to USD. rates.IBG is “USD per index,” while rates.USDIBG is the inverse “index per USD.” Pick one orientation and be consistent across your pipeline.

Q: How often does the latest endpoint update?
A: Update frequency depends on your plan tier (for example, every 60 minutes or every 10 minutes). If you fetch more frequently than the update cadence, implement caching keyed by the last timestamp to avoid redundant processing.

Q: How should I handle weekends and Argentine market holidays?
A: Expect no new daily print on non-trading days. Either omit those dates in your EOD series or forward-fill with explicit non-trading metadata in your UI, depending on your product’s needs.

Ready to ship your IBG integration? Get your API key and start ingesting the daily series now: Register. Implementation details and advanced parameters are in the Documentation.