---
updatedAt: 2026-05-21T18:12:22.000Z
---

# Get details of a specific model.

Retrieves detailed information about a specific model, identified by its reference.<br>**Entitlement required:** readFlows, manageFlows.

# OpenAPI definition

```json
{
  "openapi": "3.0.1",
  "info": {
    "version": "1.0.0",
    "description": "IBM Verify API",
    "title": "IBM Verify API"
  },
  "servers": [
    {
      "url": "https://{tenanturl}",
      "variables": {
        "tenanturl": {
          "default": "{tenant_url}",
          "description": "URL of your IBM Security Verify tenant"
        }
      }
    }
  ],
  "tags": [
    {
      "name": "Flow management",
      "description": "Operations related to Flow management."
    }
  ],
  "paths": {
    "/v1.0/config/models/{reference}": {
      "get": {
        "tags": [
          "Flow management"
        ],
        "summary": "Get details of a specific model.",
        "description": "Retrieves detailed information about a specific model, identified by its reference.<br>**Entitlement required:** readFlows, manageFlows.",
        "parameters": [
          {
            "name": "reference",
            "in": "path",
            "description": "Reference of the model.",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "includeModelData",
            "in": "query",
            "description": "If set to true, includes the model data in the response.",
            "schema": {
              "type": "boolean",
              "default": true
            }
          },
          {
            "name": "showErrors",
            "in": "query",
            "description": "If set to true, returns issues pertaining the model. The model can still be saved in draft mode. However, all issues need to be fixed before publishing the model.",
            "schema": {
              "type": "boolean",
              "default": false
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Model details retrieved successfully.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ModelDetails"
                },
                "example": {
                  "tags": [
                    "access-request-approval"
                  ],
                  "create_time": 1752579876191,
                  "description": "Flow to seek approval for access request.",
                  "errors": [
                    {
                      "messageDescription": "The model cannot have multiple start nodes.",
                      "messageId": "CSIBZ0059E"
                    }
                  ],
                  "has_associations": false,
                  "id": "9cf65073-59ef-42e5-839e-cbfd2b12ab6a",
                  "model": {
                    "model": [
                      {
                        "id": "Event_Start_0onayf",
                        "name": "Start Event",
                        "taskType": "Start"
                      },
                      {
                        "id": "Event_Start_45fe83",
                        "name": "Start Event",
                        "taskType": "Start"
                      },
                      {
                        "id": "InitiateAccessRequestApproval",
                        "name": "InitiateAccessRequestApproval",
                        "taskType": "InitiateAccessRequestApproval"
                      },
                      {
                        "id": "CompleteApproval",
                        "name": "CompleteApproval",
                        "taskType": "CompleteApproval"
                      },
                      {
                        "id": "Event_0onayf9",
                        "name": "Event_09wf1br_customId",
                        "taskType": "End"
                      }
                    ],
                    "propertiesSchemaVersion": 1,
                    "reference": "flow_with_approval"
                  },
                  "name": "approvalflow",
                  "reference": "flow_with_approval",
                  "status": "draft",
                  "tenantId": "a81e7a14-f849-470b-952c-199c18c854e0",
                  "update_time": 1752579876191,
                  "version": 1
                }
              }
            }
          },
          "400": {
            "description": "Bad request.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage_1"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage_1"
                }
              }
            }
          },
          "403": {
            "description": "Forbidden.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage_1"
                }
              }
            }
          },
          "404": {
            "description": "Model not found.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage_1"
                }
              }
            }
          },
          "500": {
            "description": "Internal server error.",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorMessage_1"
                }
              }
            }
          }
        },
        "x-category": "IBM Verify API",
        "x-publicAPI": "true"
      }
    }
  },
  "components": {
    "schemas": {
      "Branch": {
        "type": "object",
        "properties": {
          "condition": {
            "$ref": "#/components/schemas/BranchCondition"
          },
          "next": {
            "$ref": "#/components/schemas/NextNode"
          }
        },
        "description": "Branch property used by conditionPoint tasks to define conditional execution paths. Each branch can have a condition expression and a next node to execute if the condition is met. If no condition is specified, the branch acts as a default path."
      },
      "BranchCondition": {
        "type": "object",
        "properties": {
          "type": {
            "type": "string",
            "description": "The type of condition evaluation. Supported condition type: 'basic'.",
            "example": "basic",
            "enum": [
              "basic"
            ]
          },
          "condition": {
            "type": "object",
            "description": "A set of attribute conditions to evaluate. Each element maps an attribute name (or context variable such as '@context.userid@') to a list of comparands.",
            "allOf": [
              {
                "$ref": "#/components/schemas/ConditionSet"
              }
            ]
          }
        },
        "description": "Condition expression that determines which branch is executed. If the condition evaluates to true, the flow follows this branch. If no condition is specified on a branch, that branch acts as the default path.",
        "example": {
          "type": "basic",
          "condition": [
            {
              "@context.userid@": [
                {
                  "op": "eq",
                  "vl": "scott"
                }
              ]
            }
          ]
        }
      },
      "ConditionSet": {
        "type": "array",
        "description": "An array of attribute conditions. Each element is an AttributeCondition object that maps attribute names to their comparands.",
        "items": {
          "$ref": "#/components/schemas/AttributeCondition"
        }
      },
      "AttributeCondition": {
        "type": "object",
        "additionalProperties": {
          "type": "array",
          "description": "List of comparands for the attribute",
          "items": {
            "$ref": "#/components/schemas/AttributeConditionComparand"
          }
        },
        "description": "A map of the attribute and its associated comparands. There can be more than one comparand with different operators and values."
      },
      "AttributeConditionComparand": {
        "type": "object",
        "properties": {
          "op": {
            "type": "string",
            "description": "Condition operator",
            "enum": [
              "eq",
              "neq",
              "lt",
              "lte",
              "gt",
              "gte",
              "isTrue",
              "isFalse",
              "hasProp",
              "notNull",
              "notEmpty"
            ]
          },
          "vl": {
            "type": "string",
            "description": "Condition value for binary operators (eq, neq, lt, lte, gt, gte). For unary operators (isTrue, isFalse, hasProp, notNull, notEmpty), set this to an empty string \"\".",
            "example": ""
          }
        },
        "description": "A comparand defining the operator and optional value for an attribute condition."
      },
      "FlowsDetails": {
        "type": "object",
        "properties": {
          "tags": {
            "type": "array",
            "description": "Tags associated with the model. Possible tag: 'access-request-approval'.",
            "items": {
              "type": "string"
            }
          },
          "create_time": {
            "type": "integer",
            "description": "Timestamp of model creation."
          },
          "description": {
            "type": "string",
            "description": "Description of the model."
          },
          "has_associations": {
            "type": "boolean",
            "description": "Indicates whether this flow is associated with one or more entities. If true, you must remove all associations before deleting the flow."
          },
          "id": {
            "type": "string",
            "description": "ID of the model."
          },
          "name": {
            "type": "string",
            "description": "Name of the model."
          },
          "reference": {
            "type": "string",
            "description": "Unique reference of the model."
          },
          "status": {
            "type": "string",
            "description": "Status of the model. Possible status: 'draft', 'published'."
          },
          "tenantId": {
            "type": "string",
            "description": "Tenant id."
          },
          "update_time": {
            "type": "integer",
            "description": "Timestamp of the latest update."
          }
        }
      },
      "ModelDetails": {
        "allOf": [
          {
            "$ref": "#/components/schemas/FlowsDetails"
          },
          {
            "type": "object",
            "properties": {
              "errors": {
                "type": "array",
                "description": "Validation errors (included if showErrors=true).",
                "items": {
                  "$ref": "#/components/schemas/ResponseWithValidationErrors"
                }
              },
              "model": {
                "type": "object",
                "properties": {
                  "model": {
                    "type": "array",
                    "description": "Array of tasks in the workflow model.",
                    "items": {
                      "$ref": "#/components/schemas/TaskType"
                    }
                  },
                  "propertiesSchemaVersion": {
                    "type": "integer",
                    "description": "Schema version of the model properties.",
                    "example": 1
                  },
                  "reference": {
                    "type": "string",
                    "description": "Reference identifier for the workflow model.",
                    "example": "flow_with_approval"
                  }
                },
                "description": "Model data as JSON (included if includeModelData=true)."
              }
            }
          }
        ]
      },
      "NextNode": {
        "type": "object",
        "properties": {
          "node": {
            "type": "string",
            "description": "Id of next task to be executed.",
            "example": "<id_of_next_task_to_execute>"
          }
        }
      },
      "ResponseWithValidationErrors": {
        "type": "object",
        "properties": {
          "messageDescription": {
            "type": "string",
            "description": "Description of the error.",
            "example": "<validation_error_description>"
          },
          "messageId": {
            "type": "string",
            "description": "Error code",
            "example": "<error_message_id>"
          },
          "nodeId": {
            "type": "string",
            "description": "Id of the task associated with the error, may be omitted entirely or set to null.",
            "nullable": true,
            "example": "<invalid_node_id>"
          },
          "nodeName": {
            "type": "string",
            "description": "Name of the node associated with the error, may be omitted entirely or set to null if it matches nodeId or is not provided.",
            "nullable": true,
            "example": "<invalid_node_name>"
          }
        }
      },
      "TaskType": {
        "type": "object",
        "properties": {
          "branches": {
            "type": "array",
            "items": {
              "$ref": "#/components/schemas/Branch"
            }
          },
          "id": {
            "type": "string",
            "description": "Unique id of the task.",
            "example": "<unique_task_id>"
          },
          "input": {
            "type": "object",
            "additionalProperties": {
              "type": "object",
              "properties": {}
            },
            "description": "Displays input property in tasks that supports it.",
            "example": "<task_specific_input_params_if_any>"
          },
          "next": {
            "$ref": "#/components/schemas/NextNode"
          },
          "output": {
            "type": "array",
            "description": "Displays output property in tasks that supports it.",
            "example": "<task_specific_output_params_if_any>",
            "items": {
              "type": "string"
            }
          },
          "taskName": {
            "type": "string",
            "description": "Unique task name (except for 'end' and 'conditionPoint').",
            "example": "<unique_task_name>"
          },
          "taskType": {
            "type": "string",
            "description": "Type of the task.",
            "example": "<task_type>"
          }
        }
      },
      "ErrorMessage_1": {
        "type": "object",
        "properties": {
          "messageDescription": {
            "type": "string",
            "description": "Description of the error.",
            "example": "<error_message>"
          },
          "messageId": {
            "type": "string",
            "description": "Error code",
            "example": "<error_message_id>"
          }
        }
      }
    }
  },
  "x-original-swagger-version": "2.0",
  "x-explorer-enabled": false
}
```