NYISO New York City Day-Ahead Price API

You need to pull the latest finance-grade NYISO New York City Day-Ahead power price and wire it into your pricing, P&L, or risk workflow. By the end of this guide, you will query a real Energy API endpoint, read the NYISO_NYC_DA symbol, understand the base/currency semantics, and ship code that safely parses rates, dates, and units for production use.

What you get from this feed

This feed exposes the latest day-ahead power price for New York City from the NYISO market, designed for finance applications like valuation, hedging analytics, and procurement dashboards. The symbol is NYISO_NYC_DA and values are quoted in USD per MWh, returned via a single latest endpoint that is optimized for fast retrieval and straightforward parsing.

The response includes three fields essential for financial integration:

• rates.NYISO_NYC_DA: numeric price value
• dates.NYISO_NYC_DA: ISO date for the specific symbol series
• currencies.NYISO_NYC_DA: the quote currency (USD for this symbol)

Origin catalog facts (verbatim)

• Symbol name: NYISO New York City Day-Ahead
• Symbol code: NYISO_NYC_DA
• Unit: USD/MWh
• Auth: api_key query parameter. Placeholder YOUR_API_KEY only.
• Do not pass base=USD when you also need TTF_GAS or EUA_CO2.
• No MCP host. Starter $19.99/mo, trial 7 days / 50 calls.
• curl: curl -G "https://energy-api.com/api/v1/latest" --data-urlencode "symbols=NYISO_NYC_DA" --data-urlencode "api_key=YOUR_API_KEY"
• Read rates.NYISO_NYC_DA, dates.NYISO_NYC_DA, currencies.NYISO_NYC_DA. base may be MIXED.

Quick-start: call the latest endpoint

Use the latest endpoint with GET to request the NYISO_NYC_DA symbol. Authentication is via api_key as a query parameter. Replace YOUR_API_KEY with your credential after you Register.

Official cURL (copy-paste)

curl -G "https://energy-api.com/api/v1/latest" --data-urlencode "symbols=NYISO_NYC_DA" --data-urlencode "api_key=YOUR_API_KEY"

Real response for NYISO New York City Day-Ahead

The following response is a real sample for the NYISO_NYC_DA symbol. Use it to validate your parser and tests. Do not alter the values in this block when building fixtures.

{"success":true,"date":"2026-10-05","base":"USD","rates":{"NYISO_NYC_DA":43.8354},"dates":{"NYISO_NYC_DA":"2026-10-05"},"currencies":{"NYISO_NYC_DA":"USD"},"base_filter_note":null}

Field usage in finance workflows:

• rates.NYISO_NYC_DA: 43.8354 is the latest day-ahead price (USD/MWh)
• dates.NYISO_NYC_DA: "2026-10-05" is the effective market date for this specific series
• base: "USD" is the dataset base in this response; for mixed multi-symbol requests, base may be "MIXED"
• currencies.NYISO_NYC_DA: "USD" confirms the quote currency for this symbol

Read the data in Python

The snippet below shows how to call the endpoint and read the fields your pricing function needs. It parses the rate, the series date, and the currency, and includes minimal checks you can adapt for production logging or alerts.

import os
import json
import urllib.parse
import urllib.request

API_URL = "https://energy-api.com/api/v1/latest"
API_KEY = os.getenv("ENERGY_API_KEY", "YOUR_API_KEY") # replace if not using env

params = {
"symbols": "NYISO_NYC_DA",
"api_key": API_KEY
}

url = f"{API_URL}?{urllib.parse.urlencode(params)}"

with urllib.request.urlopen(url) as resp:
body = resp.read().decode("utf-8")
data = json.loads(body)

# Minimal validation
if not data.get("success", False):
raise RuntimeError("Latest endpoint returned success=false")

rates = data.get("rates", {})
dates_map = data.get("dates", {})
curr_map = data.get("currencies", {})

# Extract the NYISO NYC Day-Ahead values
symbol = "NYISO_NYC_DA"
price = rates.get(symbol)
series_date = dates_map.get(symbol)
currency = curr_map.get(symbol)
base = data.get("base")

if price is None or series_date is None or currency is None:
raise KeyError("Missing expected NYISO_NYC_DA fields in response")

print(f"Symbol: {symbol}")
print(f"Price: {price} {currency}/MWh")
print(f"Series date: {series_date}")
print(f"Dataset base: {base}")

Key notes:

• Use dates.NYISO_NYC_DA as the definitive series date for the symbol; do not assume it matches the top-level date for every possible multi-symbol response.
• Use currencies.NYISO_NYC_DA to display the proper unit label (e.g., USD/MWh).
• If you expand to multiple symbols (e.g., other power hubs), be prepared for base to equal "MIXED".

Interpreting base, units, and currency

For NYISO_NYC_DA, the quote currency is USD and the unit is USD/MWh. The latest endpoint returns a top-level base field that can be “USD” or “MIXED” depending on your symbol set. In single-symbol requests like the one above, base may be “USD”.

Important cross-symbol note: when requesting other Energy symbols such as TTF_GAS or EUA_CO2 together with NYISO_NYC_DA, do not force base=USD. Mixed currency baskets are supported, and base may be returned as “MIXED” while each symbol has its own currencies.[symbol] entry. For this guide’s focus—NYISO_NYC_DA alone—no base parameter is required.

Practical integration details that matter in finance

• Units: NYISO_NYC_DA is denominated in USD/MWh. Make the unit explicit in UI and calculations to avoid mixing with kWh or different currencies.
• Timestamps and dates: The API provides dates as ISO calendar dates (YYYY-MM-DD). Use dates.NYISO_NYC_DA as the effective date for the series. If you store snapshots, index by that series date plus retrieval timestamp from your system clock.
• Caching: Prices refresh when the market updates; treat the latest endpoint as event-driven rather than streaming. Introduce a small cache (e.g., 5–15 minutes) if your app polls frequently to stay under your trial or plan quotas.
• Pagination: The latest endpoint returns a compact, single payload structure; no pagination is needed for this call.
• Non-trading days and publication cadence: Day-ahead auctions have specific publication schedules. Always trust dates.NYISO_NYC_DA to represent the applicable market date for the series; consult the Documentation for cadence details when building roll-over logic.
• Starter plan and trial: Starter is $19.99/mo and the trial lasts 7 days with 50 calls. Track your call volume during testing to avoid unnecessary retries or tight polling loops.

Finance-first usage patterns

For valuation, risk, and settlement workflows, treat NYISO_NYC_DA as a daily fix series keyed by dates.NYISO_NYC_DA. In your data model, store:

• symbol = "NYISO_NYC_DA"
• series_date = dates.NYISO_NYC_DA
• price = rates.NYISO_NYC_DA
• currency = currencies.NYISO_NYC_DA
• unit = "USD/MWh"

When converting or comparing across hubs or instruments with different currencies, operate at the symbol currency level. If you later build multi-symbol baskets, design your pipeline to accept base="MIXED" without attempting to coerce a single currency at the top-level.

Monitoring and data quality checks

Simple checks that can save debugging time:

• Null and type checks: Validate that rates.NYISO_NYC_DA is a number and dates.NYISO_NYC_DA is a valid ISO date.
• Staleness guardrail: If the new series_date equals the prior stored date for N consecutive polls, log an info message rather than raising; align this behavior with the market’s publication schedule.
• Currency/unit assertion: Assert currencies.NYISO_NYC_DA equals "USD" and annotate “/MWh” in UIs and exports.

Official additional example (verbatim block)

The following official sample demonstrates the same endpoint structure with a different symbol set. It is useful for testing your generic parser across symbols, base values, and currencies fields. Copy it as-is for your integration tests.

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

NYISO NYC Day-Ahead: repeated full sample for fixture tests

Use this identical JSON as a second test case for your NYISO_NYC_DA fixture to validate idempotent parsing, schema stability, and duplicate detection logic in your pipeline.

{"success":true,"date":"2026-10-05","base":"USD","rates":{"NYISO_NYC_DA":43.8354},"dates":{"NYISO_NYC_DA":"2026-10-05"},"currencies":{"NYISO_NYC_DA":"USD"},"base_filter_note":null}

How to extend to multi-symbol requests without breaking finance logic

If you later decide to request multiple symbols in one call, ensure your downstream logic reads per-symbol values from rates, dates, and currencies rather than over-indexing on the top-level base. For baskets that include instruments like TTF_GAS or EUA_CO2, do not force base=USD; accept that base may be MIXED, and treat currencies.[symbol] as the canonical source for currency labeling and conversion steps.

When rendering dashboards or reports, build a column from currencies.[symbol] and append “/MWh” for power indices. For valuation pipelines, keep currency conversion as a separate, explicit step with your FX data source; do not assume automatic normalization at the dataset base level.

Production hardening checklist

• Secure storage: Keep YOUR_API_KEY in a secret store or environment variable.
• Retry policy: Use exponential backoff for transient network issues. Avoid aggressive retry storms to stay within your plan limits.
• Observability: Log the symbol, series_date, price, and currency. Alert on schema changes like missing keys or unexpected types.
• Data lineage: Persist both the series date (dates.NYISO_NYC_DA) and your retrieval timestamp to trace exact retrieval windows for finance audits.

Validation via a minimal JS snippet (optional alternative)

If you prefer JavaScript during initial testing, this small snippet validates your environment and field parsing for NYISO_NYC_DA.

const API_URL = "https://energy-api.com/api/v1/latest";
const params = new URLSearchParams({
symbols: "NYISO_NYC_DA",
api_key: "YOUR_API_KEY"
});

fetch(`${API_URL}?${params.toString()}`)
.then(r => r.json())
.then(data => {
if (!data.success) throw new Error("API returned success=false");
const sym = "NYISO_NYC_DA";
const price = data.rates?.[sym];
const seriesDate = data.dates?.[sym];
const ccy = data.currencies?.[sym];
const base = data.base;

if (price == null || !seriesDate || !ccy) {
throw new Error("Missing expected NYISO_NYC_DA fields");
}

console.log(`Price: ${price} ${ccy}/MWh, date: ${seriesDate}, base: ${base}`);
})
.catch(err => {
console.error("Fetch or parse error:", err);
});

Complete JSON example index for your tests

Use these blocks directly in your unit tests. They are complete, unchanged responses aligned to this guide.

Example A — NYISO New York City Day-Ahead (complete)

{"success":true,"date":"2026-10-05","base":"USD","rates":{"NYISO_NYC_DA":43.8354},"dates":{"NYISO_NYC_DA":"2026-10-05"},"currencies":{"NYISO_NYC_DA":"USD"},"base_filter_note":null}

Example B — Official sample with OMIE_ES_DA (complete)

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

Example C — NYISO New York City Day-Ahead (duplicate for parser stability)

{"success":true,"date":"2026-10-05","base":"USD","rates":{"NYISO_NYC_DA":43.8354},"dates":{"NYISO_NYC_DA":"2026-10-05"},"currencies":{"NYISO_NYC_DA":"USD"},"base_filter_note":null}

FAQ

How do I authenticate?
Pass your key via the api_key query parameter. Example: api_key=YOUR_API_KEY. Keep the placeholder exactly as shown in your fixtures; replace with your real key in production.

Which fields should I store for finance-grade reproducibility?
Store symbol, rates.NYISO_NYC_DA, dates.NYISO_NYC_DA, currencies.NYISO_NYC_DA, the top-level base, and your retrieval timestamp. Always display “USD/MWh” for NYISO_NYC_DA.

Do I need to set a base currency for this symbol?
No. For NYISO_NYC_DA, request the symbol directly without a base parameter. If you add symbols like TTF_GAS or EUA_CO2, do not force base=USD; allow base to be MIXED and rely on currencies.[symbol].

Is there pagination?
No. The latest endpoint returns a single compact payload; no paging is required for this call.

What are the plan and trial details?
Starter is $19.99/mo. The trial is 7 days with 50 calls. Monitor your polling frequency to stay within limits during development.

Next step: get an API key and ship your integration. Create your account on the Register page, then wire the endpoint into your app using this guide and the full Documentation.