> 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 LMP Nodes

GET /v1/lmp/{iso}/{type}/list

List all available LMP nodes for a specific market type within an ISO.

Currently, only Day-Ahead LMP (`dalmp`) forecasts are available.

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

Reference: https://docs.isoview.io/api-reference/isoview-api/lmp/list-nodes-lmp-iso-type-list-get

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: openapi
  version: 1.0.0
paths:
  /lmp/{iso}/{type}/list:
    get:
      operationId: list-nodes-lmp-iso-type-list-get
      summary: List LMP Nodes
      description: |-
        List all available LMP nodes for a specific market type within an ISO.

        Currently, only Day-Ahead LMP (`dalmp`) forecasts are available.

        **Access:** Requires `core` subscription level.
      tags:
        - subpackage_lmp
      parameters:
        - name: iso
          in: path
          description: ISO identifier.
          required: true
          schema:
            $ref: '#/components/schemas/LmpIsoTypeListGetParametersIso'
        - name: type
          in: path
          description: LMP market type.
          required: true
          schema:
            $ref: '#/components/schemas/LmpIsoTypeListGetParametersType'
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/LmpNodeResponse'
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
servers:
  - url: /v1
components:
  schemas:
    LmpIsoTypeListGetParametersIso:
      type: string
      enum:
        - pjm
        - miso
        - spp
        - ercot
        - caiso
        - nyiso
        - isone
      description: ISO identifier.
      title: LmpIsoTypeListGetParametersIso
    LmpIsoTypeListGetParametersType:
      type: string
      enum:
        - dalmp
        - rtlmp
      description: LMP market type.
      title: LmpIsoTypeListGetParametersType
    LmpNodeResponse:
      type: object
      properties:
        id:
          type: string
          description: Unique identifier for the LMP node or hub.
        name:
          type: string
          description: Human-readable name of the LMP node or hub.
        iso:
          type: string
          description: >-
            Identifier of the Balancing Authority (ISO/RTO) that operates this
            pricing node.
        timezone:
          type: string
          format: zoneinfo
          description: >-
            IANA timezone identifier for the node's local time (e.g.,
            'America/New_York'). Used for converting UTC timestamps to local
            time.
      required:
        - id
        - name
        - iso
        - timezone
      description: >-
        Metadata for a Locational Marginal Price (LMP) node or hub.


        LMP nodes represent specific locations on the electric grid where
        electricity prices

        are calculated. These can be individual buses, aggregated hubs, or load
        zones.

        Prices reflect the marginal cost of serving an additional unit of load
        at that location.
      title: LmpNodeResponse
    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/lmp/pjm/dalmp/list"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://v1/lmp/pjm/dalmp/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/lmp/pjm/dalmp/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/lmp/pjm/dalmp/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/lmp/pjm/dalmp/list")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

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

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

```csharp
using RestSharp;

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

```swift
import Foundation

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