IDX COMPOSITE (JKSE) Price History: Daily OHLC Dataset for API Integration

You need to backfill and maintain a daily OHLC series for the Indonesia Composite Index so you can chart JKSE, calculate studies, and trigger alerts. By the end of this guide, you will pull the latest JKSE reading, request daily OHLC bars, and fetch a time series you can stream into your dashboard or research pipeline using Indices-API.

What we will build: a daily JKSE OHLC feed you can ship

This walkthrough focuses on a pragmatic, shippable flow for IDX COMPOSITE (JKSE):

Illustration: IDX COMPOSITE (JKSE) Price History: Daily OHLC Dataset for API Integration

Verify the JKSE symbol and plan the fields you will consume.
Query the Latest endpoint to sanity-check connectivity and capture the most recent trading day reference.
Use the OHLC endpoint to ingest daily bars for charting and analytics.
Use the Time-Series endpoint to backfill a historical range for JKSE.
Handle weekends/holidays, cache headers, and end-of-day nuances.

Confirm the symbol and scope

The symbol for IDX COMPOSITE is JKSE. Always confirm the current symbol code and related metadata on the Indices-API Supported Symbols page before you wire it into production. If you plan to add peer benchmarks (e.g., regional indices), validate those codes there as well.

If you are unfamiliar with trading days in Indonesia, bookmark the official exchange calendar to understand non-trading dates and suspensions: Indonesia Stock Exchange (IDX).

Step 1 — Pull the latest JKSE snapshot

Start with a connectivity and data-shape check using the Latest endpoint. This endpoint is USD-based; the base field is USD, and the response contains one or more rate keys you can use for conversion math. You will parse the following fields to anchor your pipeline:

timestamp: seconds since epoch when the payload was generated
date: the data date associated with the payload
base: USD (quotes are expressed relative to USD)
rates: the map of symbols and derived pairs you will consume (e.g., JKSE, USD, USDJKSE)

curl: Latest JKSE

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

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

{"data":{"success":true,"timestamp":1793000460,"date":"2026-10-26","base":"USD","rates":{"JKSE":3.3623909481423,"USD":1,"USDJKSE":0.2974074149683557}}}

What to read from this payload:

success: true indicates the call completed without API-level errors.
timestamp: 1793000460 represents the server-side generation time.
date: 2026-10-26 is the data date in YYYY-MM-DD format. For daily workflows, treat this as your “market date.”
base: USD means the “rates” are quoted relative to USD.
rates:
- JKSE: a JKSE-relative figure in the USD-based quoting system. Do not treat this as the standalone index level for charting.
- USD: 1 is the USD base reference.
- USDJKSE: a cross you can use for conversion math in USD terms. When you need true index levels, prefer the OHLC endpoint shown below.

Practically speaking, you will rely on OHLC for open/high/low/close index points and use Latest to quickly detect the active data date and confirm feed freshness.

Python sample: parse the Latest payload

import requests
from datetime import datetime

API_KEY = "YOUR_API_KEY"
url = "https://indices-api.com/api/latest"
resp = requests.get(url, params={"access_key": API_KEY}, timeout=10)
resp.raise_for_status()
data = resp.json()["data"]

# Core fields you will typically log/monitor.
success = data.get("success")
ts = data.get("timestamp")
asof_date = data.get("date")
base = data.get("base")
rates = data.get("rates", {})

jkse_quote = rates.get("JKSE")
usdjkse = rates.get("USDJKSE")

print(f"Success: {success}")
print(f"As-of date: {asof_date}, Timestamp: {ts} ({datetime.utcfromtimestamp(ts)} UTC)")
print(f"Base: {base}")
print(f"rates.JKSE: {jkse_quote}")
print(f"rates.USDJKSE: {usdjkse}")

# Use OHLC for actual index levels (open/high/low/close).
# Latest is ideal for freshness checks and conversion math when needed.

Documentation for request/response semantics is here: Indices-API Documentation. If you don’t yet have credentials, grab an API key: Register.

Step 2 — Daily JKSE OHLC for charting and end-of-day analytics

The Open/High/Low/Close endpoint returns daily bars so you can chart the index, compute indicators, and run risk models. For production use, call this endpoint after the market close (Jakarta time) and store the bar keyed by the data date returned by the API. If you are stitching a continuous series, you will use Time-Series (next section) to fill historical gaps and this endpoint for the most recent bar.

Endpoint overview (parameters omitted for brevity):

Path: open-high-low-close/YYYY-MM-DD
Method: GET
Auth: access_key query parameter
Response fields you will use: success, timestamp, base, date, and rates.JKSE.{open,high,low,close}

Notes that save you time:

Index levels are delivered as numeric values per day. Use those directly for your OHLC chart.
If you query for the current calendar date before daily settlement is available, you may not receive a final close; use the last available business day instead.
Weekends and Indonesian public holidays will not produce a new daily bar. Your application should roll over to the previous trading day’s bar in those cases.

For request shape and additional parameters, refer to the OHLC section of the Indices-API Documentation. If you need trading status context for Indonesia (e.g., holiday lists), use the official IDX website along with your own schedule logic.

Step 3 — Backfill a JKSE time series (daily granularity)

To populate historical charts or compute studies that require a lookback window, query the Time-Series endpoint for a chosen range. A few practical rules:

Choose a start_date and end_date in YYYY-MM-DD format.
end_date should not be today; request up to yesterday to avoid incomplete trading days.
Trading gaps will be present for weekends and holidays; do not forward-fill OHLC bars unless your analytics require it.
If your range is large, segment requests by month or quarter and stitch the results client-side.

Typical workflow:

Run Time-Series for historical backfill into your data store (e.g., 3–10 years back as your use case dictates).
Nightly (post close), run OHLC for the new date and append to the series.
Use Latest as a quick sanity check on freshness and API health during market hours.

If you are integrating multiple markets and need to reason about update latencies or precision across venues, the MCP page provides additional context.

How to interpret currencies, units, and dates

Base currency: Responses are USD-based (base: "USD"). That means the “rates” object is expressed relative to USD. In Latest responses, you may see a pair such as USDJKSE in addition to JKSE. Use OHLC for the canonical index levels (open, high, low, close). Use Latest for freshness checks and, where needed, conversion math that references USD.

Units: Treat OHLC values as index points (no currency conversion needed to chart). Do not derive index levels from the Latest endpoint; that payload is not designed to replace OHLC for charting.

Dates and “as-of”: The date field denotes the data date (e.g., 2026-10-26). Use it as your primary key per bar. If you request the current calendar date but markets have not closed or data has not settled, you may receive a prior business day—design your job scheduler accordingly.

Performance, caching, and update frequency

Update cadence: The Latest endpoint is updated periodically (for example, every 60 minutes or every 10 minutes depending on your plan). Design your polling loop based on your subscription level.
Caching: Respect cache headers where present. For batch backfills (Time-Series), caching is highly effective; store responses to avoid redundant network calls.
Retry policy: Use idempotent GETs with exponential backoff. Log success flags and timestamps to detect stale payloads.
Pagination: If your time range is large, segment requests into smaller windows so you can resume from the last checkpoint on failure.

Putting it together: a minimal JKSE ingestion job

High-level steps you can copy into your pipeline:

Verify symbol JKSE via the Symbols page and seed your metadata table.
Run a one-time Time-Series job for historical JKSE OHLC bars. Store bars keyed by date with fields open, high, low, close.
Schedule a daily OHLC fetch after Jakarta close to append the final bar for the day.
Optionally poll Latest during market hours to monitor freshness and log the as-of date and timestamp.
Normalize your upstream: align timestamps to UTC in storage; annotate each bar with the source timestamp and the data date.
Chart directly from OHLC; avoid manufacturing index levels from Latest.

Plan, trial, and rollout

You can start quickly with the 7-day trial and move into PRO at $49.99/month when ready. Obtain your key here: Register. Keep the Documentation open while you wire requests, and confirm symbols at Symbols when you expand coverage.

For a quick entry point to the platform, visit indices-api.com. You can incorporate these endpoints progressively as you evolve from a prototype to production.

Operational tips for production

Time zones: Store server-side timestamp values (timestamp) in UTC for monitoring, but key your OHLC bars by the data date returned by the API.
Non-trading days: If your scheduled job runs daily, have it detect weekends/holidays and pause or use the last business day’s bar instead of creating gaps.
Data completeness: Do not assume today’s date will return a final close. Many pipelines request up to T-1 (yesterday) for time-series backfills.
Observability: Log success, timestamp, date, and symbol count for each call. Alert if the as-of date does not advance within your expected cadence.
Version control of schemas: While the field names here are stable, keep your decoder defensive. Validate presence of keys before database writes.

FAQ

Q: Which field represents JKSE’s actual open/high/low/close levels?
A: Use the OHLC endpoint and read rates.JKSE.open, .high, .low, and .close for daily bars. Do not derive index levels from the Latest endpoint.

Q: Why does the Latest response show base: "USD" and a USDJKSE field?
A: The API is USD-based. Latest includes USD-relative keys for conversion math and quick freshness checks. For actual chartable index points, use the OHLC endpoint.

Q: Can I request a time series with end_date equal to today?
A: Avoid using today as end_date. Request up to yesterday (T-1) to ensure you receive a complete bar. Daily settlement timing can vary by market.

Q: How often does Latest update during the day?
A: The Latest endpoint’s refresh cadence depends on your plan tier (for example, every 60 minutes or every 10 minutes). Design your polling interval accordingly and consult the Documentation.

Q: How do I handle weekends and Indonesian public holidays?
A: Expect no new daily bar on non-trading days. Your job should either skip those dates or carry forward the last business day’s bar only for display contexts that require continuity. Refer to the IDX calendar for official schedules.

Get your key and stand up your JKSE OHLC feed in under an hour: Register. Explore endpoint specifics while you integrate in the Documentation, confirm symbols at Symbols, and read market coverage notes on MCP. For general navigation, start at indices-api.com.

Ready to use Indices-API?

Try it now!