---
updatedAt: 2026-05-28T13:22:33.000Z
agentTools:
  projectIndex: https://api.help.mabl.com/llms.txt
---

# Get flow metadata

Get the unversioned metadata of an existing flow

# OpenAPI definition

```json
{
  "openapi": "3.0.3",
  "info": {
    "title": "mabl API",
    "description": "APIs for interacting with mabl services",
    "version": "0.563.3-2026-10-09.1791576280-jbaldassari-1791576682-SNAPSHOT"
  },
  "servers": [
    {
      "url": "https://api.mabl.com/"
    }
  ],
  "components": {
    "securitySchemes": {
      "basicAuth": {
        "type": "http",
        "scheme": "basic"
      },
      "bearerAuth": {
        "type": "apiKey",
        "name": "Authorization",
        "in": "header"
      }
    },
    "schemas": {
      "FlowMetadata": {
        "allOf": [
          {
            "$ref": "#/components/schemas/Invariant"
          },
          {
            "properties": {
              "reuse_browser_state_in_plan_run": {
                "type": "boolean",
                "description": "Shares the browser state this flow produces with the rest of a cloud plan run.\n\nTests that reach the flow before any state has been stored each run it and store\ntheir own result. The tests in a plan stage start together, so that is the common\ncase; a test that starts once state already exists for the same application and\ncredentials begins from that stored state instead.\n\nTo sign in once per plan run, put a test that runs this flow in an earlier plan\nstage, against the same application URL and with the same credentials. Stages run\nin order, so the tests of later stages all start from the state that test stored.\n\nA marked flow still runs every time. It is not skipped, so it must decide for\nitself whether there is anything left to do — a login flow, for example, should\nwrap its sign-in steps in a condition that only holds when the login page is\nactually showing. A marked flow that unconditionally repeats its work will do so\non a browser that already carries the session.\n\nThe stored state lasts only for the plan run. Has no effect on local CLI runs.\n"
              },
              "import_source_version": {
                "description": "Version of the import tool used to import this flow",
                "type": "string"
              },
              "flow_type": {
                "allOf": [
                  {
                    "$ref": "#/components/schemas/FlowTypeEnum"
                  }
                ],
                "description": "Type of flow. Set at create and immutable afterwards: the value sent to either PATCH is ignored, and a create that omits it is classified from the step content the request carries."
              },
              "mobile_platform": {
                "$ref": "#/components/schemas/MobilePlatformEnum"
              },
              "minimize_execution_overhead": {
                "type": "boolean",
                "description": "When enabled, mabl will not capture screenshots, network logs, DOM snapshots,\nor other test artifacts in order to report the most accurate flow execution time\n"
              },
              "name": {
                "type": "string",
                "description": "The display name of the flow. Required (non-blank) for reusable flows.\nWhen absent on older reusable data, the API serves the description value\nhere; non-reusable flows are never given a name they did not have.\n"
              },
              "description": {
                "type": "string",
                "description": "Usage notes and considerations for the flow. Historically this field held\nthe flow's display name; that role has moved to `name`. To rename a flow,\nwrite `name` — writing this field edits the description only. When a flow\nhas no description, the API serves the flow's name here for backwards\ncompatibility.\n"
              },
              "labels": {
                "type": "array",
                "description": "User provided labels",
                "items": {
                  "$ref": "#/components/schemas/Label"
                }
              },
              "import_source_id": {
                "description": "Framework the flow was imported from",
                "$ref": "#/components/schemas/ImportSourceId"
              }
            }
          }
        ],
        "type": "object"
      },
      "MobilePlatformEnum": {
        "type": "string",
        "enum": [
          "ios",
          "android"
        ]
      },
      "ErrorResponseGeneric": {
        "properties": {
          "code": {
            "type": "integer",
            "format": "int32",
            "minimum": 100,
            "maximum": 599
          },
          "id": {
            "type": "string"
          },
          "message": {
            "type": "string"
          }
        }
      },
      "Label": {
        "type": "object",
        "required": [
          "name"
        ],
        "properties": {
          "name": {
            "description": "name",
            "type": "string"
          }
        }
      },
      "Invariant": {
        "type": "object",
        "properties": {
          "workspace_id": {
            "type": "string",
            "description": "Workspace Id"
          },
          "created_time": {
            "type": "integer",
            "format": "int64",
            "description": "Time the test was created in epoch milliseconds"
          },
          "last_updated_time": {
            "type": "integer",
            "format": "int64",
            "description": "Time the test was last updated in epoch milliseconds"
          },
          "last_updated_by_id": {
            "type": "string",
            "description": "The ID of the user who last updated this test"
          },
          "id": {
            "type": "string",
            "description": "Unique identifier",
            "maxLength": 50
          },
          "created_by_id": {
            "type": "string",
            "description": "The ID of the user who created this test"
          }
        }
      },
      "ImportSourceId": {
        "type": "string",
        "enum": [
          "postman",
          "selenium_node_proxy",
          "selenium_java_agent"
        ]
      },
      "FlowTypeEnum": {
        "description": "the type of flow",
        "type": "string",
        "enum": [
          "validate_page",
          "login",
          "verify_url",
          "mablscript",
          "check_links",
          "visual_page_validation",
          "api",
          "mobile"
        ]
      }
    },
    "responses": {
      "ErrorResponse": {
        "description": "Unknown error",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponseGeneric"
            }
          }
        }
      },
      "ErrorResponse401": {
        "description": "User not authenticated",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponseGeneric"
            }
          }
        }
      },
      "ErrorResponse404": {
        "description": "Entity not found",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponseGeneric"
            }
          }
        }
      },
      "ErrorResponse403": {
        "description": "User not authorized",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponseGeneric"
            }
          }
        }
      },
      "ErrorResponse400": {
        "description": "Invalid or missing parameter",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ErrorResponseGeneric"
            }
          }
        }
      }
    }
  },
  "security": [
    {
      "basicAuth": []
    },
    {
      "bearerAuth": []
    }
  ],
  "paths": {
    "/flows/{id}/metadata": {
      "get": {
        "summary": "Get flow metadata",
        "operationId": "getFlowMetadata",
        "description": "Get the unversioned metadata of an existing flow",
        "responses": {
          "200": {
            "description": "The flow metadata",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/FlowMetadata"
                }
              }
            }
          },
          "400": {
            "$ref": "#/components/responses/ErrorResponse400"
          },
          "401": {
            "$ref": "#/components/responses/ErrorResponse401"
          },
          "403": {
            "$ref": "#/components/responses/ErrorResponse403"
          },
          "404": {
            "description": "Flow not found",
            "$ref": "#/components/responses/ErrorResponse404"
          },
          "default": {
            "$ref": "#/components/responses/ErrorResponse"
          }
        },
        "parameters": [
          {
            "schema": {
              "type": "string"
            },
            "in": "path",
            "name": "id",
            "description": "ID of the flow",
            "required": true
          }
        ],
        "tags": [
          "Flow"
        ]
      }
    }
  },
  "tags": [
    {
      "name": "Flow"
    }
  ]
}
```