---
updatedAt: 2026-05-20T06:31:23.000Z
---

Fetch the complete documentation index at: https://docs.blockdaemon.com/llms.txt. Use this file to discover all available pages before exploring further. Append .md to any documentation page URL to get its markdown version.

# List of customer's staking plans

This endpoint allows you to get a list of your staking plans.

Staking plans are created by Blockdaemon on your behalf. They are a means to deploy white-label validators or get access to public Blockdaemon validators (depending on the protocol being used in the staking API).

If you do not yet have a staking plan, please [contact Blockdaemon sales](https://blockdaemon.com/get-in-touch/) to get started with our industry-leading staking API.

# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "version": "1.0.0",
    "title": "Staking API",
    "description": "The Blockdaemon Staking API simplifies and streamlines institutional cryptocurrency staking. The API allows developers to interact with blockchain networks and perform various staking-related operations, such as delegating and undelegating tokens, in a single, unified interface.\n\nWith the Staking API, you can quickly and easily build and deploy applications that automate staking activities and increase efficiency in your blockchain operations.",
    "contact": {
      "name": "Blockdaemon",
      "email": "info@blockdaemon.com",
      "url": "https://blockdaemon.com"
    },
    "x-logo": {
      "url": "https://assets-global.website-files.com/633c5e06513fa35f3391a5f9/645d33beb6fa65f6cfb95eb8_BD%20Logo%20Stack%20-%20Purple.svg",
      "backgroundColor": "#fafafa",
      "altText": "Blockdaemon logo"
    }
  },
  "x-readme": {
    "explorer-enabled": false
  },
  "servers": [
    {
      "url": "https://svc.blockdaemon.com/boss"
    }
  ],
  "components": {
    "securitySchemes": {
      "ApiKeyAuth": {
        "description": "When signing up for a staking account, you are provided with an API key.\n\nTo authenticate a Staking API request, pass your API key in the `X-API-Key` header.",
        "type": "apiKey",
        "in": "header",
        "name": "X-API-KEY"
      }
    },
    "parameters": {
      "Networks": {
        "name": "networks",
        "in": "query",
        "required": false,
        "description": "A filter on the type of networks.",
        "schema": {
          "type": "array",
          "items": {
            "$ref": "#/components/schemas/Network"
          }
        }
      },
      "Page": {
        "in": "query",
        "name": "page",
        "required": false,
        "schema": {
          "type": "integer",
          "format": "int64",
          "minimum": 1,
          "default": 1
        },
        "description": "The result set page to view"
      },
      "PerPage": {
        "in": "query",
        "name": "per_page",
        "required": false,
        "schema": {
          "type": "integer",
          "format": "int64",
          "minimum": 1,
          "maximum": 1000,
          "default": 250
        },
        "description": "The number of items to include on a single page"
      },
      "Protocols": {
        "name": "protocols",
        "in": "query",
        "required": false,
        "description": "A filter on the type of protocols.",
        "schema": {
          "type": "array",
          "items": {
            "$ref": "#/components/schemas/Protocol"
          }
        }
      },
      "Providers": {
        "name": "providers",
        "in": "query",
        "required": false,
        "description": "A filter on the type of providers.",
        "schema": {
          "type": "array",
          "items": {
            "$ref": "#/components/schemas/Provider"
          }
        }
      },
      "Regions": {
        "name": "regions",
        "in": "query",
        "required": false,
        "description": "A filter on the type of regions.",
        "schema": {
          "type": "array",
          "items": {
            "$ref": "#/components/schemas/Region"
          }
        }
      },
      "MevEnabled": {
        "in": "query",
        "name": "mev_enabled",
        "required": false,
        "schema": {
          "type": "boolean"
        },
        "description": "A filter on MEV on/off"
      },
      "ClientID": {
        "name": "X-Client-ID",
        "in": "header",
        "description": "Unique ID of the client/customer",
        "schema": {
          "type": "string",
          "minLength": 1
        },
        "required": true
      }
    },
    "responses": {
      "InternalServerError": {
        "description": "Internal server error.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        }
      },
      "InvalidRequest": {
        "description": "Invalid request.",
        "content": {
          "application/json": {
            "schema": {
              "type": "object",
              "description": "Error response envelope",
              "required": [
                "code",
                "message"
              ],
              "properties": {
                "code": {
                  "type": "integer",
                  "format": "int32",
                  "description": "Error code",
                  "example": 400
                },
                "message": {
                  "type": "string",
                  "description": "Error Message",
                  "example": "Detailed human-readable diagnostic message regarding any invalid request parameters"
                }
              }
            }
          }
        }
      },
      "ListPlans": {
        "description": "Successful operation",
        "content": {
          "application/json": {
            "schema": {
              "type": "object",
              "required": [
                "plans",
                "pagination"
              ],
              "properties": {
                "pagination": {
                  "$ref": "#/components/schemas/Pagination"
                },
                "plans": {
                  "type": "array",
                  "items": {
                    "$ref": "#/components/schemas/Plan"
                  }
                }
              }
            }
          }
        }
      },
      "Unauthorized": {
        "description": "Header 'X-API-Key' missing.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/UnauthorizedError"
            }
          }
        }
      }
    },
    "schemas": {
      "CosmosAccountAddress": {
        "type": "string",
        "description": "Public Key of an asymmetric key-pair.",
        "format": "bech32",
        "pattern": "^cosmos[1-9a-zA-Z]{39}$",
        "example": "cosmos1wvvhhfm387xvfnqshmdaunnpujjrdxznr5d5x9"
      },
      "CustomerId": {
        "type": "string",
        "description": "Unique identifier for a customer",
        "example": "SatoshiNakamoto-xUYJbPw9hw",
        "minimum": 1
      },
      "Error": {
        "type": "object",
        "description": "Error response envelope",
        "required": [
          "code",
          "message"
        ],
        "properties": {
          "code": {
            "type": "integer",
            "format": "int32",
            "description": "Error code",
            "example": 500
          },
          "message": {
            "type": "string",
            "description": "Error Message",
            "example": "A descriptive error message"
          }
        }
      },
      "EthereumAddress": {
        "type": "string",
        "description": "Hex-encoded Ethereum [account or smart contract address](https://ethereum.org/en/developers/docs/accounts/).",
        "format": "hex",
        "pattern": "^0x[a-fA-F0-9]{40}$",
        "example": "0x00000000219ab540356cBB839Cbe05303d7705Fa"
      },
      "Mev": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "ID of the MEV fee recipient. optional"
          },
          "enabled": {
            "type": "boolean"
          },
          "relays": {
            "$ref": "#/components/schemas/Relays"
          }
        }
      },
      "Minimum": {
        "description": "minimum number of validators to be available. required for white label plans",
        "type": "integer",
        "format": "int64"
      },
      "Network": {
        "type": "string",
        "description": "Protocol-specific network.",
        "enum": [
          "mainnet",
          "localnet",
          "goerli",
          "prater",
          "hoodi",
          "testnet",
          "devnet",
          "kusama",
          "westend",
          "preprod",
          "fuji",
          "local"
        ]
      },
      "Pagination": {
        "type": "object",
        "description": "encapsulates pagination properties",
        "required": [
          "page",
          "per_page",
          "total"
        ],
        "properties": {
          "page": {
            "description": "current page number",
            "type": "integer",
            "format": "int64"
          },
          "per_page": {
            "description": "number of results per page",
            "type": "integer",
            "format": "int64"
          },
          "total": {
            "description": "total number of results",
            "type": "integer",
            "format": "int64"
          }
        }
      },
      "Plan": {
        "type": "object",
        "description": "staking plan for validators",
        "required": [
          "id",
          "protocol",
          "network",
          "config",
          "customer_id",
          "staking_plan_type",
          "title"
        ],
        "properties": {
          "id": {
            "$ref": "#/components/schemas/PlanId"
          },
          "customer_id": {
            "$ref": "#/components/schemas/CustomerId"
          },
          "protocol": {
            "$ref": "#/components/schemas/Protocol"
          },
          "network": {
            "$ref": "#/components/schemas/Network"
          },
          "provider": {
            "$ref": "#/components/schemas/Provider"
          },
          "region": {
            "$ref": "#/components/schemas/Region"
          },
          "minimum": {
            "$ref": "#/components/schemas/Minimum"
          },
          "config": {
            "oneOf": [
              {
                "$ref": "#/components/schemas/PlanEthereumConfig"
              },
              {
                "$ref": "#/components/schemas/PlanSolanaConfig"
              },
              {
                "$ref": "#/components/schemas/PlanPolygonConfig"
              },
              {
                "$ref": "#/components/schemas/PlanCardanoConfig"
              },
              {
                "$ref": "#/components/schemas/PlanAvalancheConfig"
              },
              {
                "$ref": "#/components/schemas/PlanCosmosConfig"
              },
              {
                "$ref": "#/components/schemas/PlanBinanceConfig"
              }
            ]
          },
          "total_pending": {
            "$ref": "#/components/schemas/TotalPending"
          },
          "total_available": {
            "$ref": "#/components/schemas/TotalAvailable"
          },
          "total_active": {
            "$ref": "#/components/schemas/TotalActive"
          },
          "staking_plan_type": {
            "$ref": "#/components/schemas/StakingPlanType"
          },
          "title": {
            "$ref": "#/components/schemas/PlanTitle"
          },
          "total_reserved": {
            "$ref": "#/components/schemas/TotalReserved"
          },
          "sync_status": {
            "$ref": "#/components/schemas/sync_status"
          },
          "supported_withdrawal_types": {
            "$ref": "#/components/schemas/ListWithdrawalType"
          }
        }
      },
      "PlanEthereumConfig": {
        "type": "object",
        "description": "Ethereum staking plan config",
        "required": [
          "inventory_type"
        ],
        "properties": {
          "suggested_fee_recipient": {
            "type": "string",
            "description": "the suggested fee recipient address",
            "minimum": 1
          },
          "mev": {
            "$ref": "#/components/schemas/Mev"
          },
          "inventory_type": {
            "$ref": "#/components/schemas/PlanInventoryType"
          },
          "execution_client": {
            "$ref": "#/components/schemas/ExecutionClient"
          },
          "consensus_client": {
            "$ref": "#/components/schemas/ConsensusClient"
          },
          "remote_signer": {
            "$ref": "#/components/schemas/RemoteSigner"
          }
        }
      },
      "PlanCardanoConfig": {
        "type": "object",
        "description": "Cardano staking plan config",
        "required": [
          "stake_pool_id"
        ],
        "properties": {
          "stake_pool_id": {
            "type": "object",
            "required": [
              "mainnet",
              "preprod"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/CardanoPoolId"
              },
              "preprod": {
                "$ref": "#/components/schemas/CardanoPoolId"
              }
            }
          }
        }
      },
      "PlanId": {
        "type": "string",
        "description": "This feature enables you to stake to validators from the specified plan(s). When no plan id is specified, validators across all plans that match the API route will be available for staking. If it is a shared plan, you can to stake to validators on a shared node from the specified plan.",
        "example": "plan_Wgx98Rbi8nQuL9ddn3mTk1"
      },
      "PlanInventoryType": {
        "type": "string",
        "description": "Indicates if the quantity of validators for the staking plan is static or dynamic. Static is a once off deployment of a specified quantity of validators. Dynamic is where an initial quantity of validators is deployed with a threshold of available validators also configured. If the number of available validators within the validator inventory drops below the threshold (by being reserved as part of a stake intents API call) then the dynamic plan will automatically deploy the required infrastructure to bring the number of available validators above the threshold.",
        "enum": [
          "static",
          "dynamic",
          "remote_signer"
        ]
      },
      "PlanPolygonConfig": {
        "type": "object",
        "description": "Polygon staking plan config",
        "required": [
          "validator_share_address"
        ],
        "properties": {
          "validator_share_address": {
            "type": "object",
            "required": [
              "mainnet",
              "testnet"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/EthereumAddress"
              },
              "testnet": {
                "$ref": "#/components/schemas/EthereumAddress"
              }
            }
          }
        }
      },
      "PlanSolanaConfig": {
        "type": "object",
        "description": "Solana staking plan config",
        "required": [
          "validator_address"
        ],
        "properties": {
          "validator_address": {
            "type": "object",
            "required": [
              "mainnet",
              "testnet"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/SolanaPublicKey"
              },
              "testnet": {
                "$ref": "#/components/schemas/SolanaPublicKey"
              }
            }
          }
        }
      },
      "PlanTitle": {
        "type": "string",
        "description": "Plan title for display purposes"
      },
      "Protocol": {
        "type": "string",
        "description": "Blockchain protocol.",
        "enum": [
          "ethereum",
          "polkadot",
          "solana",
          "cosmos",
          "polygon",
          "near",
          "cardano",
          "avalanche",
          "binance"
        ]
      },
      "Provider": {
        "description": "Cloud provider which will host the node.",
        "x-go-type": "models.ProviderID",
        "x-go-type-import": {
          "path": "go.blockdaemon.com/nodeq-server/pkg/models",
          "name": "models"
        }
      },
      "PublicKey": {
        "type": "string",
        "description": "A BLS public Key.",
        "format": "base64",
        "example": "0xa1d1ad0714035353258038e964ae9675dc0252ee22cea896825c01458e1807bfad2f9969338798548d9858a571f7425c"
      },
      "Region": {
        "description": "cloud provider's zone code",
        "type": "string"
      },
      "SolanaPublicKey": {
        "type": "string",
        "description": "Public Key of an asymmetric key-pair.",
        "format": "base58",
        "pattern": "^[1-9A-HJ-NP-Za-km-z]{44}$",
        "example": "5xot9PVkphiX2adznghwrAuxGs2zeWisNSxMW6hU6Hkj"
      },
      "StakingPlanType": {
        "type": "string",
        "description": "Indicates if the staking plan requires a Blockdaemon validator launch or it is associated to a public validator.",
        "enum": [
          "white_label",
          "public"
        ]
      },
      "UnauthorizedError": {
        "type": "object",
        "description": "Error response envelope",
        "required": [
          "code",
          "message"
        ],
        "properties": {
          "code": {
            "type": "integer",
            "format": "int32",
            "description": "Error code",
            "example": 401
          },
          "message": {
            "type": "string",
            "description": "Error Message",
            "example": "A human-readable diagnostic message detailing any authorization failure"
          }
        }
      },
      "TotalPending": {
        "description": "total number of pending validators in a staking plan",
        "type": "integer",
        "format": "int64"
      },
      "TotalAvailable": {
        "description": "total number of available validators in a staking plan",
        "type": "integer",
        "format": "int64"
      },
      "TotalActive": {
        "description": "total number of active validators in a staking plan",
        "type": "integer",
        "format": "int64"
      },
      "TotalReserved": {
        "description": "total number of reserved validators in a staking plan",
        "type": "integer",
        "format": "int64"
      },
      "CardanoPoolId": {
        "type": "string",
        "description": "bech32 encoded pool id.",
        "format": "bech32",
        "example": "pool1ev8fwfccn8gr0zcz3uyps0t0mcrefc6s95wjc6aed3ngc86y5rk"
      },
      "AvalancheValidatorAddress": {
        "type": "string",
        "description": "Avalanche validator node address",
        "pattern": "^NodeID-[A-Za-z0-9]{43}$",
        "example": "NodeID-B19uSxUKerjjnA215czAJLHMqNJMbsAMWuSxUKerjjW"
      },
      "PlanAvalancheConfig": {
        "type": "object",
        "description": "Avalanche staking plan config",
        "required": [
          "validator_address"
        ],
        "properties": {
          "validator_address": {
            "type": "object",
            "required": [
              "mainnet",
              "fuji"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/AvalancheValidatorAddress"
              },
              "fuji": {
                "$ref": "#/components/schemas/AvalancheValidatorAddress"
              }
            }
          }
        }
      },
      "PlanCosmosConfig": {
        "type": "object",
        "description": "Cosmos staking plan config",
        "required": [
          "validator_address"
        ],
        "properties": {
          "validator_address": {
            "type": "object",
            "required": [
              "mainnet",
              "testnet"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/CosmosAccountAddress"
              },
              "testnet": {
                "$ref": "#/components/schemas/CosmosAccountAddress"
              }
            }
          }
        }
      },
      "PlanBinanceConfig": {
        "type": "object",
        "description": "Binance staking plan config",
        "required": [
          "validator_address"
        ],
        "properties": {
          "validator_address": {
            "type": "object",
            "required": [
              "mainnet",
              "testnet"
            ],
            "properties": {
              "mainnet": {
                "$ref": "#/components/schemas/BinanceValidatorAddress"
              },
              "testnet": {
                "$ref": "#/components/schemas/BinanceValidatorAddress"
              }
            }
          }
        }
      },
      "BinanceValidatorAddress": {
        "type": "string",
        "description": "Binance beacon chain validator address.",
        "format": "bech32",
        "pattern": "^bva[0-9a-zA-Z]*$",
        "example": "bva1mrpf5n5e5knn3z9qng5pnex3m9pvyhg6434j0t"
      },
      "Relays": {
        "type": "array",
        "description": "List of Relay urls",
        "items": {
          "$ref": "#/components/schemas/Relay"
        },
        "minItems": 1
      },
      "Relay": {
        "type": "string",
        "format": "uri",
        "description": "Relay url"
      },
      "ExecutionClient": {
        "type": "string",
        "description": "The execution client to use on the node",
        "enum": [
          "geth",
          "besu",
          "nethermind"
        ]
      },
      "WithdrawalType": {
        "type": "string",
        "description": "Specifies the type of validator withdrawal credential. - `0x01`: Standard withdrawal type with manual reward management. - `0x02`: Auto-compounding withdrawal type, allowing higher staking limits and requiring manual skimming for early reward access.\n",
        "enum": [
          "0x01",
          "0x02"
        ]
      },
      "RemoteSigner": {
        "type": "object",
        "properties": {
          "public_keys": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/PublicKey"
            }
          },
          "url": {
            "type": "string"
          }
        }
      },
      "sync_status": {
        "description": "Indicates node's sync status",
        "type": "boolean"
      },
      "ListWithdrawalType": {
        "type": "array",
        "description": "List of supported Withdrawal Types",
        "minItems": 1,
        "items": {
          "$ref": "#/components/schemas/WithdrawalType"
        }
      },
      "ConsensusClient": {
        "type": "string",
        "description": "The consensus client to use on the node",
        "enum": [
          "lighthouse",
          "nimbus",
          "prysm",
          "teku"
        ]
      }
    }
  },
  "security": [
    {
      "ApiKeyAuth": []
    }
  ],
  "paths": {
    "/v1/plans": {
      "get": {
        "summary": "List of customer's staking plans",
        "operationId": "listCustomerPlans",
        "tags": [
          "General"
        ],
        "description": "This endpoint allows you to get a list of your staking plans.\n\nStaking plans are created by Blockdaemon on your behalf. They are a means to deploy white-label validators or get access to public Blockdaemon validators (depending on the protocol being used in the staking API).\n\nIf you do not yet have a staking plan, please [contact Blockdaemon sales](https://blockdaemon.com/get-in-touch/) to get started with our industry-leading staking API.",
        "parameters": [
          {
            "$ref": "#/components/parameters/MevEnabled"
          },
          {
            "$ref": "#/components/parameters/ClientID"
          },
          {
            "$ref": "#/components/parameters/Protocols"
          },
          {
            "$ref": "#/components/parameters/Networks"
          },
          {
            "$ref": "#/components/parameters/Providers"
          },
          {
            "$ref": "#/components/parameters/Regions"
          },
          {
            "$ref": "#/components/parameters/Page"
          },
          {
            "$ref": "#/components/parameters/PerPage"
          }
        ],
        "responses": {
          "200": {
            "$ref": "#/components/responses/ListPlans"
          },
          "400": {
            "$ref": "#/components/responses/InvalidRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          },
          {
            "BearerAuth": []
          }
        ]
      }
    }
  },
  "tags": [
    {
      "name": "General",
      "description": "General endpoints"
    }
  ]
}
```