> 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.

# List Regions

GET /v1/region/{iso}/{metric}/list

List all available regions for a specific forecast metric within an ISO.

Returns metadata for each region including. Use this endpoint to discover which geographic regions have
forecast data available for a specific metric.

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

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

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: openapi
  version: 1.0.0
paths:
  /region/{iso}/{metric}/list:
    get:
      operationId: list-regions-region-iso-metric-list-get
      summary: List Regions
      description: >-
        List all available regions for a specific forecast metric within an ISO.


        Returns metadata for each region including. Use this endpoint to
        discover which geographic regions have

        forecast data available for a specific metric.


        **Access:** Requires `core` subscription level.
      tags:
        - subpackage_regions
      parameters:
        - name: iso
          in: path
          description: ISO identifier.
          required: true
          schema:
            $ref: '#/components/schemas/RegionIsoMetricListGetParametersIso'
        - name: metric
          in: path
          description: Forecast metric type.
          required: true
          schema:
            $ref: '#/components/schemas/RegionIsoMetricListGetParametersMetric'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/RegionResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
servers:
  - url: /v1
components:
  schemas:
    RegionIsoMetricListGetParametersIso:
      type: string
      enum:
        - pjm
        - miso
        - spp
        - ercot
        - caiso
        - nyiso
        - isone
      description: ISO identifier.
      title: RegionIsoMetricListGetParametersIso
    RegionIsoMetricListGetParametersMetric:
      type: string
      enum:
        - demand
        - wind
        - solar
        - outage
        - poptemp
      description: Forecast metric type.
      title: RegionIsoMetricListGetParametersMetric
    RegionResponse:
      type: object
      properties:
        id:
          type: string
          description: >-
            Unique identifier for the region. Format typically follows
            '{ba}_{region_name}' pattern.
        name:
          type: string
          description: Human-readable name of the region.
        region_type:
          type: string
          description: >-
            Type or classification of the region. Common values: 'iso' (entire
            balancing authority), 'zone' (load zone), 'hub' (trading hub).
        iso:
          type: string
          description: >-
            Identifier of the parent Balancing Authority (ISO/RTO) that this
            region belongs to.
        timezone:
          type: string
          format: zoneinfo
          description: >-
            IANA timezone identifier for the region's local time (e.g.,
            'America/New_York'). Used for converting UTC timestamps to local
            time.
      required:
        - id
        - name
        - region_type
        - iso
        - timezone
      description: >-
        Metadata for a geographic forecast region.


        Regions represent areas within the electricity grid for which forecasts
        are available.

        They can be entire Balancing Authorities (ISOs), load zones, trading
        hubs, or other

        defined geographic boundaries. Each region has its own local timezone
        and belongs

        to a parent Balancing Authority.
      title: RegionResponse
    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/demand/list"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://v1/region/pjm/demand/list';
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/demand/list"

	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/demand/list")

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/demand/list")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

```csharp
using RestSharp;

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

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://v1/region/pjm/demand/list")! 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()
```