---
updatedAt: 2026-07-28T13:52:47.000Z
---

# Get a list of schema versions

Use this API to get a list of schema versions that match the given parameters.<br><br><a href="https://api.solace.dev/cloud/reference/authentication">Token Permissions</a>: [ <code>event_designer:access</code> ]

# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "Event Portal - Designer",
    "description": "REST API Concepts\n\nSolace Event Portal provides REST APIs that you can use to manage your data in Solace Cloud. \nThe REST APIs allow you to model your event-driven architectures from your own client applications.\n\nThe following document describes the public REST APIs available for use in Event Portal 2.0. Objects created in this \nversion will not be available in Event Portal 1.0. APIs that display (Beta) in their summary are provided as-is and \nare subject to change or removal. They may not be of the quality expected for generally available APIs and have no \nguaranteed forward compatibility with the generally available version of the API.\n\n",
    "version": "2.13.2"
  },
  "servers": [
    {
      "url": "https://api.solace.cloud",
      "description": "Solace PubSub+ Cloud US EAST Region"
    },
    {
      "url": "https://api.solacecloud.com.au",
      "description": "Solace PubSub+ Cloud AU Region"
    },
    {
      "url": "https://api.solacecloud.eu",
      "description": "Solace PubSub+ Cloud EU Region"
    },
    {
      "url": "https://api.solacecloud.sg",
      "description": "Solace PubSub+ Cloud SG Region"
    }
  ],
  "security": [
    {
      "APIToken": []
    }
  ],
  "tags": [
    {
      "name": "Schemas"
    }
  ],
  "paths": {
    "/api/v2/architecture/schemaVersions": {
      "get": {
        "tags": [
          "Schemas"
        ],
        "summary": "Get a list of schema versions",
        "description": "Use this API to get a list of schema versions that match the given parameters.<br><br><a href=\"https://api.solace.dev/cloud/reference/authentication\">Token Permissions</a>: [ <code>event_designer:access</code> ]",
        "operationId": "getSchemaVersions",
        "parameters": [
          {
            "name": "pageSize",
            "in": "query",
            "description": "The number of schema versions to get per page.",
            "required": false,
            "schema": {
              "type": "integer",
              "format": "int32",
              "default": 20,
              "maximum": 100,
              "minimum": 1
            }
          },
          {
            "name": "pageNumber",
            "in": "query",
            "description": "The page number to get.",
            "required": false,
            "schema": {
              "type": "integer",
              "format": "int32",
              "default": 1,
              "minimum": 1
            }
          },
          {
            "name": "schemaIds",
            "in": "query",
            "description": "Match only schema versions of these schema IDs, separated by commas.",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "uniqueItems": true
            }
          },
          {
            "name": "ids",
            "in": "query",
            "description": "Match only schema versions with the given IDs, separated by commas.",
            "required": false,
            "schema": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "uniqueItems": true
            }
          },
          {
            "name": "customAttributes",
            "in": "query",
            "description": "Returns the entities that match the custom attribute filter.<br>To filter by custom attribute name and value, use the format: `customAttributes=<custom-attribute-name>==<custom-attribute-value>`. <br>To filter by custom attribute name, use the format: `customAttributes=<custom-attribute-name>`. <br>The filter supports the `AND` operator for multiple custom attribute definitions (not multiple values for a given definition). Use `;` (`semicolon`) to separate multiple queries with `AND` operation. <br>Note: the filter supports custom attribute values containing only the characters `[a-zA-Z0-9_\\-\\. ]`.",
            "required": false,
            "schema": {
              "type": "string"
            },
            "example": "color==red"
          }
        ],
        "responses": {
          "200": {
            "description": "Get a list of schema versions and the accompanying metadata.",
            "content": {
              "application/json;charset=UTF-8": {
                "schema": {
                  "$ref": "#/components/schemas/SchemaVersionsResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "404": {
            "description": "Not Found",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "405": {
            "description": "Method Not Allowed",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "501": {
            "description": "Not Implemented",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "CustomAttribute": {
        "type": "object",
        "properties": {
          "customAttributeDefinitionId": {
            "type": "string",
            "example": "acb2j5k3mly"
          },
          "customAttributeDefinitionName": {
            "type": "string",
            "example": "color",
            "pattern": "a-zA-Z0-9_\\-\\."
          },
          "value": {
            "type": "string",
            "example": "red",
            "pattern": "a-zA-Z0-9_\\-\\."
          },
          "stringValues": {
            "type": "string",
            "example": "red",
            "pattern": "a-zA-Z0-9_\\-\\."
          }
        }
      },
      "ErrorResponse": {
        "type": "object",
        "discriminator": {
          "propertyName": "errorType"
        },
        "properties": {
          "message": {
            "type": "string",
            "description": "A user-friendly message that describes the error.",
            "example": "An error occurred."
          },
          "errorId": {
            "type": "string",
            "description": "The UUID (Universally Unique Identifier) that is logged with an appropriate stack trace for a WARN or ERROR log that allows support to better determine what cause the error.",
            "example": "123e4567-e89b-12d3-a456-426655440000"
          },
          "meta": {
            "type": "object",
            "additionalProperties": {},
            "example": "'object': { 'field': 'description' }"
          },
          "validationDetails": {
            "type": "object",
            "additionalProperties": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "description": "When applicable, these are the details of issues with the fields provided for the REST call.",
            "example": "'name': ['Not unique']"
          },
          "errorType": {
            "type": "string",
            "writeOnly": true
          }
        }
      },
      "InvalidNonStateReference": {
        "type": "object",
        "properties": {
          "entityId": {
            "type": "string"
          },
          "entityType": {
            "type": "string"
          }
        }
      },
      "InvalidStateReference": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ErrorResponse"
          },
          {
            "type": "object",
            "properties": {
              "targetStateId": {
                "type": "string"
              },
              "inboundInvalidNonStateReferences": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/InvalidNonStateReference"
                }
              },
              "inboundInvalidStateReferences": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/InvalidStateReference"
                }
              },
              "outboundInvalidStateReferences": {
                "type": "array",
                "items": {
                  "$ref": "#/components/schemas/InvalidStateReference"
                }
              },
              "errorType": {
                "type": "string"
              }
            }
          }
        ]
      },
      "Pagination": {
        "type": "object",
        "properties": {
          "pageNumber": {
            "type": "integer",
            "format": "int32"
          },
          "count": {
            "type": "integer",
            "format": "int32"
          },
          "pageSize": {
            "type": "integer",
            "format": "int32"
          },
          "nextPage": {
            "type": "integer",
            "format": "int32"
          },
          "totalPages": {
            "type": "integer",
            "format": "int32"
          }
        }
      },
      "SchemaVersion": {
        "type": "object",
        "additionalProperties": true,
        "properties": {
          "createdTime": {
            "type": "string",
            "description": "The time the entity was created",
            "example": "2021-12-31T20:30:57.920Z",
            "readOnly": true
          },
          "updatedTime": {
            "type": "string",
            "description": "The time the entity was last updated",
            "example": "2021-12-31T20:30:57.920Z",
            "readOnly": true
          },
          "createdBy": {
            "type": "string",
            "description": "The user who created the entity",
            "example": 12345678,
            "readOnly": true
          },
          "changedBy": {
            "type": "string",
            "description": "The user who last updated the entity",
            "example": 12345678,
            "readOnly": true
          },
          "id": {
            "type": "string",
            "example": 12345678,
            "readOnly": true
          },
          "schemaId": {
            "type": "string",
            "example": 12345678
          },
          "description": {
            "type": "string",
            "example": "Schema created by Solace Cloud API documentation",
            "maxLength": 10000,
            "minLength": 0
          },
          "version": {
            "type": "string",
            "example": "1.0.0",
            "pattern": "^\\d+\\.\\d+\\.\\d+$"
          },
          "displayName": {
            "type": "string",
            "example": "Display name for the version",
            "maxLength": 40,
            "minLength": 0
          },
          "content": {
            "type": "string",
            "example": "{ \"$schema\": \"http://json-schema.org/draft-07/schema#\", \"$id\": \"http://example.com/root.json\",\"type\": \"object\", \"title\": \"An example schema\", \"required\": [ \"attribute\", ], \"properties\": { \"attribute\": { \"$id\": \"#/properties/attribute\", \"type\": \"string\", \"title\": \"An example of a string based attribute\", \"examples\": [ \"aValue\" ], \"pattern\": \"^(.*)$\" } }}"
          },
          "referencedByEventVersionIds": {
            "type": "array",
            "items": {
              "type": "string",
              "example": [
                "5h2km5khkj",
                "h5mk26hkm2"
              ],
              "readOnly": true
            }
          },
          "referencedBySchemaVersionIds": {
            "type": "array",
            "items": {
              "type": "string",
              "example": [
                "5h2km5khkj",
                "h5mk26hkm2"
              ],
              "readOnly": true
            }
          },
          "schemaVersionReferences": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SchemaVersionReferenceDTO"
            }
          },
          "customAttributes": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/CustomAttribute"
            }
          },
          "stateId": {
            "type": "string",
            "example": 1,
            "readOnly": true
          },
          "endOfLifeDate": {
            "type": "string",
            "example": "2021-12-31T20:30:57.920Z"
          },
          "type": {
            "type": "string",
            "readOnly": true
          }
        },
        "required": [
          "schemaId",
          "version"
        ]
      },
      "SchemaVersionReferenceDTO": {
        "type": "object",
        "properties": {
          "schemaVersionId": {
            "type": "string"
          }
        }
      },
      "SchemaVersionsResponse": {
        "type": "object",
        "properties": {
          "data": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/SchemaVersion"
            }
          },
          "meta": {
            "$ref": "#/components/schemas/meta"
          }
        }
      },
      "meta": {
        "type": "object",
        "properties": {
          "pagination": {
            "$ref": "#/components/schemas/Pagination"
          }
        }
      }
    },
    "securitySchemes": {
      "APIToken": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT"
      }
    }
  },
  "x-readme": {
    "explorer-enabled": true,
    "proxy-enabled": true
  }
}
```