> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.isoview.io/llms.txt.
> For full documentation content, see https://docs.isoview.io/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.isoview.io/_mcp/server.

# Get ISO Summary

GET /v1/region/{iso}/summary

Retrieve a comprehensive summary of all forecast metrics for an ISO.

The response includes both forecast and actual timeseries data (where available) for
each metric, aligned on an hourly frequency. Actual data is included from 4 days
before the forecast model run through the end of the forecast horizon.

Historical data is only available from January 1, 2023 onwards.

**Access:** Requires `core` subscription level.

Reference: https://docs.isoview.io/api-reference/isoview-api/regions/summary-region-iso-summary-get

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: openapi
  version: 1.0.0
paths:
  /region/{iso}/summary:
    get:
      operationId: summary-region-iso-summary-get
      summary: Get ISO Summary
      description: >-
        Retrieve a comprehensive summary of all forecast metrics for an ISO.


        The response includes both forecast and actual timeseries data (where
        available) for

        each metric, aligned on an hourly frequency. Actual data is included
        from 4 days

        before the forecast model run through the end of the forecast horizon.


        Historical data is only available from January 1, 2023 onwards.


        **Access:** Requires `core` subscription level.
      tags:
        - subpackage_regions
      parameters:
        - name: iso
          in: path
          description: ISO identifier.
          required: true
          schema:
            $ref: '#/components/schemas/RegionIsoSummaryGetParametersIso'
        - name: as_of
          in: query
          required: false
          schema:
            type: string
            format: date-time
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/TimeseriesResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
servers:
  - url: /v1
components:
  schemas:
    RegionIsoSummaryGetParametersIso:
      type: string
      enum:
        - pjm
        - miso
        - spp
        - ercot
        - caiso
        - nyiso
        - isone
      description: ISO identifier.
      title: RegionIsoSummaryGetParametersIso
    TimeseriesResponse:
      type: object
      properties:
        model:
          type:
            - string
            - 'null'
          description: >-
            Identifier of the weather model used for this forecast (e.g.,
            'optimized', 'iso'). Null for historical actuals or composite
            responses.
        created_at:
          type:
            - string
            - 'null'
          format: date-time
          description: >-
            Timestamp (UTC) when this forecast was created/published. Represents
            the model run time. Null for continuous/stitched forecasts or
            historical actuals.
        units:
          type: string
          description: >-
            Measurement units for all data values in the response. Common
            values: 'MW' (megawatts), '°C' (degrees Celsius), 'USD/MWh',
            '$/MMBtu'.
        timezone:
          type: string
          format: zoneinfo
          description: >-
            IANA timezone identifier used for the `time_local` field. Typically
            matches the region's local timezone.
        time_utc:
          type: array
          items:
            type: string
            format: date-time
          description: >-
            Array of timestamps in Coordinated Universal Time (UTC). Each entry
            corresponds to one row in the `values` matrix. Always
            timezone-aware.
        time_local:
          type: array
          items:
            type: string
            format: date-time
          description: >-
            Array of timestamps in local time (timezone specified in `timezone`
            field). Each entry corresponds to one row in the `values` matrix.
            Parallel to `time_utc`.
        columns:
          type: array
          items:
            type: array
            items:
              type: string
          description: >-
            Metadata describing each column in the `values` matrix. Each entry
            is a list of one or more level labels — single-level columns are
            returned as length-1 sublists (e.g. ['pjm_total']); naturally
            multi-level data uses one entry per level (e.g. ['pjm_total',
            'demand']). Clients can rebuild a pandas MultiIndex via
            `pd.MultiIndex.from_tuples(columns)`.
        values:
          type: array
          items:
            type: array
            items:
              type:
                - number
                - 'null'
              format: double
          description: >-
            2D matrix of numeric forecast or actual values in column-major
            order. Each inner list represents a series (corresponding to
            `columns`), and each element within that list corresponds to a
            timestamp (corresponding to `time_utc`/`time_local`). Missing or
            unavailable data is represented as null.
      required:
        - model
        - created_at
        - units
        - timezone
        - time_utc
        - time_local
        - columns
        - values
      description: >-
        Standardized timeseries data response format.


        This is the primary response structure for all forecast and historical
        data endpoints.

        It efficiently represents matrix-like timeseries data with parallel
        arrays for timestamps

        (both UTC and local time) and values. The format is optimized for
        client-side processing

        and visualization.


        **Structure:** Data is in column-major order. Each inner list in
        `values` corresponds to

        a series described in `columns`. Each element within that list
        corresponds to a timestamp

        in `time_utc`/`time_local`.
      title: TimeseriesResponse
    ValidationErrorLocItems:
      oneOf:
        - type: string
        - type: integer
      title: ValidationErrorLocItems
    ValidationErrorCtx:
      type: object
      properties: {}
      title: ValidationErrorCtx
    ValidationError:
      type: object
      properties:
        loc:
          type: array
          items:
            $ref: '#/components/schemas/ValidationErrorLocItems'
        msg:
          type: string
        type:
          type: string
        input:
          description: Any type
        ctx:
          $ref: '#/components/schemas/ValidationErrorCtx'
      required:
        - loc
        - msg
        - type
      title: ValidationError
    HTTPValidationError:
      type: object
      properties:
        detail:
          type: array
          items:
            $ref: '#/components/schemas/ValidationError'
      title: HTTPValidationError
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: X-API-Key
      description: >-
        API key for authentication. Can also be provided in the api_key query
        parameter.

```

## SDK Code Examples

```python
import requests

url = "https://v1/region/pjm/summary"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://v1/region/pjm/summary';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://v1/region/pjm/summary"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://v1/region/pjm/summary")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://v1/region/pjm/summary")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://v1/region/pjm/summary');

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://v1/region/pjm/summary");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://v1/region/pjm/summary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```