NYISO New York City Day-Ahead (NYISO_NYC_DA) Price API

You need to price, hedge, and reconcile exposure to New York City day-ahead power in finance-grade workflows. By the end of this guide, you will know how to confirm the Energy symbol is listed, authenticate, fetch the latest NYISO New York City Day-Ahead (NYISO_NYC_DA) price, and safely parse the response fields you’ll use in risk, PnL, and settlement logic.

What the NYISO New York City Day-Ahead symbol represents in finance

NYISO New York City Day-Ahead (code: NYISO_NYC_DA) is a day-ahead power price expressed in USD/MWh. In financial workflows, it is commonly used for daily mark-to-market of power forwards and virtuals, settlement validation against ISOs, risk factor feeds in VaR engines, and pricing of load and generation positions localized to the NYC zone.

Because the unit is USD/MWh, you can directly multiply rates by MWh exposure to compute notional values and PnL impacts. This symbol is designed for portfolio analytics and reporting where energy price precision and correct currency attribution are critical.

Verify the symbol exists with GET /api/v1/symbols

Before integrating any downstream logic, confirm the symbol is available. Use the symbols listing endpoint:

• Method: GET
• Path: /api/v1/symbols
• Auth: api_key as a query parameter (api_key=YOUR_API_KEY)

Request the listing and search for the exact pair: “Symbol name: NYISO New York City Day-Ahead” and “Symbol code: NYISO_NYC_DA.” This confirms that the Energy symbol in the title is present and fetchable via the latest endpoint you will use below. If your catalog response is large, filter client-side by code equals NYISO_NYC_DA or by name equals NYISO New York City Day-Ahead.

Authentication, pricing, and plan notes

Authentication is via the api_key query parameter. Use YOUR_API_KEY in examples and store your real key securely in your secrets manager. Do not send keys in headers if your integration standardizes on query parameters; the documented flow here is query-based auth.

Plan details relevant for getting started: Starter is $19.99/mo with a 7-day trial that includes 50 calls. This is sufficient to wire an integration and validate end-to-end from symbol discovery to production fetches without exceeding a basic evaluation budget.

When fetching mixed commodity sets that include other symbols (for example TTF_GAS or EUA_CO2), do not pass base=USD. The API supports multi-currency responses and may return base=MIXED when symbols span currencies. For NYISO_NYC_DA alone, currency is USD, so you can read the USD value directly without conversion.

Fetch the latest NYISO_NYC_DA price with cURL

The latest endpoint returns recent values for one or more symbols. The request below is the official sample; copy-paste and replace YOUR_API_KEY with your own:

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

Official JSON response and the fields you will use

Below is the official response for the request above. Use these exact values when testing your parser:

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

Field usage in finance workflows:

• rates.NYISO_NYC_DA: The numeric price you will multiply by MWh exposure for valuation and PnL. Units: USD/MWh.
• dates.NYISO_NYC_DA: The symbol-specific date for the value. Use it to align daily snapshots, backfills, and settlement logic.
• currencies.NYISO_NYC_DA: The currency for the symbol. For NYISO_NYC_DA it’s USD, enabling direct aggregation with other USD-denominated risk factors.
• date (top-level): The API-level date context for the response set. When fetching a single symbol, rely on both the top-level date and the symbol-specific date for sanity checks.
• base: For single-symbol USD series like this, base=USD. When fetching multiple symbols with mixed currencies, base may be MIXED and the per-symbol currencies map becomes essential.

Python example: fetch, validate, and compute a position’s daily PnL

This Python snippet demonstrates how to call the latest endpoint, verify currency assumptions, read symbol-specific fields, and compute a basic mark for a long MWh position. Replace YOUR_API_KEY with your real key when running in your environment.

import sys
import json
import urllib.parse
import urllib.request

API_URL = "https://energy-api.com/api/v1/latest"
API_KEY = "YOUR_API_KEY"
SYMBOL = "NYISO_NYC_DA"

def fetch_latest(symbol):
params = {
"symbols": symbol,
"api_key": API_KEY
}
url = f"{API_URL}?{urllib.parse.urlencode(params)}"
req = urllib.request.Request(url, method="GET")
with urllib.request.urlopen(req, timeout=20) as resp:
data = resp.read().decode("utf-8")
return json.loads(data)

def validate_fields(payload, symbol):
if not payload.get("success", False):
raise RuntimeError("API reported success=false")

# Validate symbol is present in each symbol-scoped map
for k in ("rates", "dates", "currencies"):
if symbol not in payload.get(k, {}):
raise KeyError(f"Missing {k}.{symbol} in response")

# Optional: enforce expected currency for single-symbol usage
currency = payload["currencies"][symbol]
if currency != "USD":
raise ValueError(f"Unexpected currency for {symbol}: {currency}")

return True

def price_position_mtm(mwh_quantity):
payload = fetch_latest(SYMBOL)
validate_fields(payload, SYMBOL)

price = float(payload["rates"][SYMBOL]) # USD/MWh
value_date = payload["dates"][SYMBOL] # e.g., '2026-10-20'
currency = payload["currencies"][SYMBOL] # 'USD'
api_base = payload.get("base") # 'USD' or 'MIXED'

# Compute valuation for a physical or financial exposure in MWh
mtm_usd = mwh_quantity * price

# Return a structured record for downstream risk/reporting
return {
"symbol": SYMBOL,
"value_date": value_date,
"price_usd_per_mwh": price,
"position_mwh": mwh_quantity,
"mtm_usd": mtm_usd,
"currency": currency,
"api_base": api_base
}

if __name__ == "__main__":
# Example: 12.5 MWh long exposure for the day-ahead period
result = price_position_mtm(12.5)
print(json.dumps(result, indent=2))

Implementation notes:

• Timeouts: The example uses a 20s timeout. Keep your production timeout consistent with your job SLA.
• Idempotency and retries: Only retry idempotent GETs and exponential backoff to prevent thundering herds during market open windows.
• Serialization: Store symbol-level dates and currencies alongside the price so downstream consumers can reconcile multi-asset reports even when base=MIXED.

Handling units, base currency, and mixed baskets

NYISO_NYC_DA is quoted in USD/MWh. Multiply the rate by MWh to compute a USD notional or PnL for day-ahead power exposure in the NYC zone. This prevents unit drift when you later combine with capacity, ancillary services, or other commodity exposures.

For single-symbol USD requests like NYISO_NYC_DA, base=USD and currencies.NYISO_NYC_DA=USD are aligned. If you extend your call to include other symbols that are not USD-denominated (for example, European energy or emissions), the API may return base=MIXED. In that case, use the currencies map to determine per-symbol currency, and do not pass base=USD if you also need TTF_GAS or EUA_CO2 in the same call. Perform FX normalization outside this request if you require portfolio-level USD aggregation.

Publication cadence, time zones, and caching

Day-ahead power prices generally update on a daily cadence aligned to market operations. Treat dates.NYISO_NYC_DA as the authoritative value date for financial purposes such as accruals and settlements. Align your ETL schedule with your internal EOD processes to avoid mixing prior and current value dates during rollovers.

When building caches, key your records by symbol and value date. If your system ingests multiple updates per day, prefer last-write-wins as long as the date key remains the same. Log the top-level date and base for auditability. Because weekends and market holidays can shift data availability, code defensively: if you do not see a new date, preserve yesterday’s mark and flag for review rather than forcing a stale overwrite.

Portfolio integration patterns for finance

Here are straightforward patterns to integrate NYISO_NYC_DA into finance pipelines without overengineering early iterations:

• Daily risk factors: Load the symbol’s price into your risk factor store keyed by (symbol, value_date). Use it in VaR and sensitivities for NYC day-ahead exposures.
• PnL explain: Break out daily PnL into quantity and price effects by comparing today’s price to yesterday’s price at a constant position.
• Settlement checks: Cross-check invoices and ISO settlements using the symbol’s USD/MWh rate for the corresponding delivery date, recording any tolerances or manual adjustments as separate fields.
• Reporting: Present price and exposure in the same unit system (USD and MWh), and add explicit currency tags to simplify auditor reviews.

End-to-end checklist to ship your integration

• Confirm listing: Call GET /api/v1/symbols with api_key=YOUR_API_KEY and verify “NYISO New York City Day-Ahead” and “NYISO_NYC_DA” are present.
• Fetch data: Use the official latest endpoint with symbols=NYISO_NYC_DA.
• Parse fields: Read rates.NYISO_NYC_DA, dates.NYISO_NYC_DA, currencies.NYISO_NYC_DA; store all three.
• Units: Treat values as USD/MWh; combine with MWh exposure for valuation.
• Currency hygiene: For multi-asset baskets, expect base=MIXED and do not pass base=USD when you also need TTF_GAS or EUA_CO2.
• Scheduling: Align ingestion with your EOD processing window; guard against holidays and late publishes.
• Observability: Log the top-level date, base, and the per-symbol date to trace back any discrepancies.

Troubleshooting quick wins

• Unexpected currency: If currencies.NYISO_NYC_DA is not USD, stop processing and alert—this indicates a mapping or request issue.
• Missing symbol key: If rates lacks NYISO_NYC_DA, re-check that symbols=NYISO_NYC_DA is URL-encoded and that your key is valid.
• Stale date: If dates.NYISO_NYC_DA equals your prior run, do not overwrite a fresher local cache; hold and retry later.
• Mixed base: If base=MIXED, aggregate at the per-symbol currency level first; apply FX normalization explicitly in your code.

FAQ

How do I confirm NYISO_NYC_DA is available before wiring PnL logic?

Call GET /api/v1/symbols with api_key=YOUR_API_KEY and verify the listing contains “Symbol name: NYISO New York City Day-Ahead” and “Symbol code: NYISO_NYC_DA.” Only proceed to pricing once this check passes.

Which fields do I need to compute daily valuation for NYC day-ahead exposure?

Use rates.NYISO_NYC_DA (USD/MWh) and multiply by your MWh quantity. Store dates.NYISO_NYC_DA as the value date, and record currencies.NYISO_NYC_DA for downstream reporting and audits.

How should I deal with multi-asset requests that include non-USD symbols?

Expect base=MIXED and rely on the currencies map for each symbol. Do not pass base=USD when you also need TTF_GAS or EUA_CO2. Normalize currencies in your own code if you need a USD-aggregated portfolio view.

Is there pagination on the latest endpoint?

For fetching the latest value of specified symbols, treat the response as a single payload keyed by symbol, without pagination. If you need more endpoints or historical data, see the product docs linked below.

What are the trial limits and how do I start?

The Starter plan is $19.99/month with a 7-day trial and 50 calls. This is typically enough to complete symbol discovery, build a basic integration, and test it in CI.

Register for an API key and start wiring NYISO_NYC_DA into your finance stack today: Register. For endpoint details and field references, read the Documentation.