Historical ISO-NE Massachusetts Day-Ahead Prices

Your team needs reliable historical ISO-NE Massachusetts Day-Ahead power prices to drive PPA valuation, forward curves, and risk reporting. By the end of this guide, you will be able to pull a clean time series for ISO-NE Massachusetts Day-Ahead (symbol: ISONE_MA_DA) from Energy’s Finance API, parse the fields you need, and integrate them into your pricing or analytics stack.

What you will query and what you get back

This guide focuses on a single Finance API endpoint that returns historical time series for power prices:

• HTTP method and path: GET /api/v1/timeseries
• Query parameters: start, end, symbols, api_key
• Symbol name: ISO-NE Massachusetts Day-Ahead
• Symbol code: ISONE_MA_DA
• Unit: USD/MWh
• Auth: api_key as a query parameter (use YOUR_API_KEY)

You should request a time-bounded window using start and end (YYYY-MM-DD). The response provides values in the rates object keyed by symbol, with currency information in currencies and the corresponding data date in dates.

Endpoint, parameters, and authentication

Use the Finance API time series endpoint with an API key sent as a query parameter:

• Base URL: https://energy-api.com/api/v1/timeseries
• Required parameters:
  • start: inclusive ISO date (YYYY-MM-DD)
  • end: inclusive ISO date (YYYY-MM-DD)
  • symbols: one or more comma-separated codes, e.g., ISONE_MA_DA
  • api_key: your account key (use YOUR_API_KEY in examples)

Do not include unrelated parameters. For example, do not pass a base=USD parameter when requesting ISONE_MA_DA; it is not required and may conflict with other instruments that use different currencies like TTF_GAS or EUA_CO2.

Quick start: cURL request for ISO-NE Massachusetts Day-Ahead

Run the following call to retrieve a historical window for ISONE_MA_DA.

curl -G "https://energy-api.com/api/v1/timeseries" --data-urlencode "start=2026-01-01" --data-urlencode "end=2026-03-31" --data-urlencode "symbols=ISONE_MA_DA" --data-urlencode "api_key=YOUR_API_KEY"

This returns a JSON payload containing the requested series in rates.ISONE_MA_DA, the series date in dates.ISONE_MA_DA, and the currency in currencies.ISONE_MA_DA. Always read units from currencies and the known unit definition (USD/MWh) to avoid accidental mixing in downstream financial models.

Understanding the JSON structure

The Finance API returns a consistent shape across instruments. Below is the official sample JSON structure you should expect, shown exactly as provided, so you can map fields without guesswork:

{
"success": true,
"date": "2026-10-22",
"base": "EUR",
"rates": {
"OMIE_ES_DA": 155.6276
},
"dates": {
"OMIE_ES_DA": "2026-10-22"
},
"currencies": {
"OMIE_ES_DA": "EUR"
},
"base_filter_note": null
}

Field usage you will rely on:

• success: boolean, check before parsing the payload.
• rates: object of symbol to numeric value. You will read rates.ISONE_MA_DA for ISO-NE Massachusetts Day-Ahead in your actual query.
• dates: object of symbol to data date (YYYY-MM-DD). Use dates.ISONE_MA_DA to align timestamps in your time series database.
• currencies: object of symbol to currency code. For ISONE_MA_DA, this is USD; bind this to your unit metadata to avoid currency confusion.
• base: the quote base shown for the response serialization; do not override it with a base parameter for ISONE_MA_DA.

Real ISO-NE Massachusetts Day-Ahead example response

When requesting ISONE_MA_DA, the fields map directly to the symbol of interest. Below is a real response sample for the instrument named in this article, copied verbatim:

How to read it for finance workflows:

• rates.ISONE_MA_DA: the numeric day-ahead price for Massachusetts in ISO-NE.
• dates.ISONE_MA_DA: the official date associated with the rate; use this as the observation date in your time series index.
• currencies.ISONE_MA_DA: "USD" — combine with the known unit USD/MWh for downstream calculations (valuation, VaR, or P&L explain).
• date (top-level): can indicate the service processing date; do not confuse it with the instrument-specific dates in the dates object.

JavaScript example: fetch and normalize the series

The following snippet uses fetch to call the endpoint, validates the response, and extracts the fields you need for a finance pipeline.

async function fetchIsoNeMaDaSeries(start, end, apiKey) {
const url = new URL("https://energy-api.com/api/v1/timeseries");
url.searchParams.set("start", start);
url.searchParams.set("end", end);
url.searchParams.set("symbols", "ISONE_MA_DA");
url.searchParams.set("api_key", apiKey); // Use YOUR_API_KEY in real calls

const res = await fetch(url.toString(), { method: "GET" });
if (!res.ok) {
throw new Error(`HTTP ${res.status}`);
}
const data = await res.json();
if (!data.success) {
throw new Error("API returned success=false");
}

// Read the ISO-NE Massachusetts DA price and metadata
const value = data.rates?.ISONE_MA_DA;
const priceDate = data.dates?.ISONE_MA_DA;
const currency = data.currencies?.ISONE_MA_DA;

if (typeof value !== "number" || !priceDate || !currency) {
throw new Error("Missing expected fields for ISONE_MA_DA");
}

return {
symbol: "ISONE_MA_DA",
date: priceDate,
value,
currency, // Expect "USD"
unit: "USD/MWh"
};
}

// Example usage:
fetchIsoNeMaDaSeries("2026-01-01", "2026-03-31", "YOUR_API_KEY")
.then(console.log)
.catch(console.error);

Python example: ingest into a time series store

This Python snippet requests the same endpoint and prepares a dict you can upsert into your warehouse or time series database. Keep data types explicit to avoid downstream rounding or currency errors.

import requests

def get_isone_ma_da_series(start: str, end: str, api_key: str):
url = "https://energy-api.com/api/v1/timeseries"
params = {
"start": start,
"end": end,
"symbols": "ISONE_MA_DA",
"api_key": api_key # Use "YOUR_API_KEY" in examples
}
resp = requests.get(url, params=params, timeout=30)
resp.raise_for_status()
data = resp.json()

if not data.get("success", False):
raise RuntimeError("API success=false")

value = data.get("rates", {}).get("ISONE_MA_DA", None)
price_date = data.get("dates", {}).get("ISONE_MA_DA", None)
currency = data.get("currencies", {}).get("ISONE_MA_DA", None)

if value is None or price_date is None or currency is None:
raise KeyError("Missing fields for ISONE_MA_DA")

return {
"symbol": "ISONE_MA_DA",
"date": price_date,
"value": float(value),
"currency": currency, # Expect "USD"
"unit": "USD/MWh"
}

series_point = get_isone_ma_da_series("2026-01-01", "2026-03-31", "YOUR_API_KEY")
print(series_point)

Dates, time zones, and non-trading days

Use YYYY-MM-DD for start and end. The service responds with dates in YYYY-MM-DD under dates.ISONE_MA_DA. For the day-ahead market, weekends and holidays can still have day-ahead prices, but you may encounter gaps depending on ISO publishing calendars. Always key your database by the instrument’s dates field to ensure correct alignment.

Time zone alignment: the dates strings are calendar dates. If you convert to timestamps, bind them to the ISO-NE market calendar you use internally. For end-of-day processes, store the original date string and a normalized UTC timestamp for joins.

Currency and units

For ISO-NE Massachusetts Day-Ahead, the series is in USD and the physical unit is MWh. Combine currencies.ISONE_MA_DA ("USD") with unit metadata (USD/MWh) when calculating revenue, cost-of-serve, or hedge P&L. Avoid implicit conversions; do not attempt to pass a base currency parameter on this endpoint for this symbol.

Selecting windows and batching

Pull bounded ranges using start and end. For large backfills, iterate month-by-month to keep payloads small and easier to retry. If your job scheduler parallelizes requests, keep symbol lists scoped to your workflow to avoid mixing instruments with different currencies or calendars in the same response. If you expand beyond ISONE_MA_DA, keep separate requests per currency bucket to simplify valuation steps.

Caching and idempotency

Historical day-ahead prices are stable once published. Cache successfully retrieved windows keyed by [symbol, start, end]. When reprocessing, check your cache before hitting the API to stay within your account’s call limits. For job idempotency, write results to a staging table keyed by [symbol, date] and merge into production after validation.

Error handling and data validation

• Check HTTP status and success === true before parsing.
• Verify rates.ISONE_MA_DA is a number, dates.ISONE_MA_DA is present, and currencies.ISONE_MA_DA is "USD".
• Guard against empty windows (no observations in requested date range).
• Log the full request (start, end, symbols) so you can reproduce issues during audits.

Production checklist

• Use YOUR_API_KEY via a secure secret store or environment variable.
• Pin symbol codes explicitly: "ISONE_MA_DA" for ISO-NE Massachusetts Day-Ahead.
• Normalize units: USD/MWh; store currency per observation from currencies.ISONE_MA_DA.
• Persist dates from dates.ISONE_MA_DA as the primary series index.
• Batch by month for backfills; monitor for gaps around market holidays.
• Implement retries with exponential backoff on network timeouts.

Next steps and where to find details

Consult the official API parameter and response references to integrate more instruments or expand date windows. For end-to-end schema and parameter details, see the Documentation. To test against the live service, create an account and use the trial allocation.

FAQ

How do I authenticate?

Pass your key as the api_key query parameter. In examples, use the literal string YOUR_API_KEY. Do not put the key in headers for this endpoint.

Can I request multiple symbols at once?

Yes, pass a comma-separated list to symbols. For finance workflows, keep symbols with different currencies in separate requests to simplify valuation logic.

What if a date in my range has no value?

The API may omit a value for that date depending on market calendars. Treat missing observations as nulls and avoid forward-filling without an explicit business rule.

Do I need to set a base currency?

No. Do not pass base=USD for ISONE_MA_DA. Use currencies.ISONE_MA_DA and the known unit USD/MWh to maintain currency integrity.

Is there pagination?

The timeseries endpoint returns the requested window in one payload. For very large backfills, query smaller ranges sequentially.

Get access and start shipping your integration with a 7-day trial (50 calls) on the Starter plan ($19.99/mo after). Create your account here: Register.