> ## Documentation Index
> Fetch the complete documentation index at: https://support.tulip.co/llms.txt
> Use this file to discover all available pages before exploring further.

# /api/users/v1/users

> Retrieves a paginated, filtered, sorted list of users.


## OpenAPI

````json GET /api/users/v1/users
{
  "openapi": "3.0.3",
  "info": {
    "title": "Tulip API",
    "version": "v1"
  },
  "tags": [
    {
      "name": "machines",
      "description": "An API for managing machines and their types"
    },
    {
      "name": "stations",
      "description": "An API for managing and updating stations."
    },
    {
      "name": "users",
      "description": "An API for managing users and their roles/permissions."
    }
  ],
  "paths": {
    "/api/users/v1/users": {
      "get": {
        "operationId": "listUsers",
        "description": "Retrieves a paginated, filtered, sorted list of users.\n",
        "tags": [
          "users"
        ],
        "x-tulip-visibility": "public",
        "parameters": [
          {
            "name": "limit",
            "description": "The number of items to return in the response.",
            "in": "query",
            "required": "false",
            "schema": {
              "$ref": "#/components/schemas/PaginationParamLimit"
            }
          },
          {
            "name": "offset",
            "description": "The number of items to skip before collecting the result.",
            "in": "query",
            "required": "false",
            "schema": {
              "$ref": "#/components/schemas/PaginationParamOffset"
            }
          },
          {
            "name": "search",
            "description": "A matcher for a user's `name/full`, `email/address`, and `badgeId` fields.",
            "in": "query",
            "required": "false",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "filter",
            "description": "An OData field filter. Supported fields are:\n- `id`\n- `badgeId`\n- `email/verified`\n- `name/full`\n- `workspaceRoleAssignments`\n  (using a lambda function will allow for filtering on the `userRoleId` and `workspaceId`\n  subfields)\n- `globalRoleId`\n\nNote that filtering on roles that apply across all workspaces must be performed through\nthe `globalRoleId` field. All other roles must be filtered using `workspaceRoleAssignments`.\n",
            "in": "query",
            "required": "false",
            "schema": {
              "type": "string"
            }
          },
          {
            "name": "archived",
            "description": "When set to `false` (the default), only active users are returned.\nWhen set to `true`, only deactivated users are returned.\n",
            "in": "query",
            "required": "false",
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "A list of available users\n",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "type": "object",
                      "properties": {
                        "items": {
                          "type": "array",
                          "items": {
                            "$ref": "#/components/schemas/User"
                          }
                        }
                      }
                    },
                    {
                      "$ref": "#/components/schemas/PaginatedResponse"
                    }
                  ]
                }
              }
            }
          },
          "400": {
            "description": "An error occurred. The Tulip error codes `generic.customerIdRequired`, `generic.workspaceIdRequired`, `generic.invalidParams`, `http.invalidBodyJson`, `http.invalidHeaders`, `http.multiValueHeader`, `generic.filterParamUnsupportedOperation`, `generic.filterParamUnsupportedField`, `generic.limitParamNonNegativeInt`, `generic.limitParamBounds`, `generic.offsetParamNonNegativeInt`, and `users.invalidFilter` all use the 400 HTTP status code. See the documentation of the response content schema for details on these specific Tulip errors that could result in this status code.",
            "content": {
              "application/json": {
                "schema": {
                  "oneOf": [
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The request was missing information about the Tulip customer context.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.customerIdRequired"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The request was missing information about the Tulip workspace context.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.workspaceIdRequired"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The request parameters were invalid.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.invalidParams"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The HTTP request body could not be decoded as JSON.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "http.invalidBodyJson"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The HTTP request headers were invalid.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "http.invalidHeaders"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "An HTTP request header contained multiple values.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "http.multiValueHeader"
                              ]
                            },
                            "details": {
                              "type": "object",
                              "properties": {
                                "headerName": {
                                  "description": "The name of the given HTTP header which had multiple values.\n",
                                  "type": "string"
                                }
                              },
                              "required": [
                                "headerName"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable",
                            "details"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The filter parameter for this endpoint used an unsupported operation.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.filterParamUnsupportedOperation"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The filter parameter for this endpoint used an unsupported field.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.filterParamUnsupportedField"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The limit parameter for this endpoint was not a non-negative integer.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.limitParamNonNegativeInt"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The limit parameter for this endpoint was out of bounds.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.limitParamBounds"
                              ]
                            },
                            "details": {
                              "type": "object",
                              "properties": {
                                "upperBound": {
                                  "description": "The maximum allowed value for the limit parameter.\n",
                                  "type": "integer"
                                }
                              },
                              "required": [
                                "upperBound"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable",
                            "details"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The offset parameter for this endpoint was not a non-negative integer.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "generic.offsetParamNonNegativeInt"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/components/schemas/ApiError"
                        },
                        {
                          "type": "object",
                          "description": "The user filter provided is invalid.\n\nThis error is not automatically retryable.",
                          "properties": {
                            "errorCode": {
                              "enum": [
                                "users.invalidFilter"
                              ]
                            },
                            "retryable": {
                              "enum": [
                                "false"
                              ]
                            }
                          },
                          "required": [
                            "errorCode",
                            "retryable"
                          ]
                        }
                      ]
                    }
                  ]
                }
              }
            }
          },
          "401": {
            "description": "The request was missing required authentication information.\n\nThis error is not automatically retryable.",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "$ref": "#/components/schemas/ApiError"
                    },
                    {
                      "type": "object",
                      "description": "The request was missing required authentication information.\n\nThis error is not automatically retryable.",
                      "properties": {
                        "errorCode": {
                          "enum": [
                            "generic.authRequired"
                          ]
                        },
                        "retryable": {
                          "enum": [
                            "false"
                          ]
                        }
                      },
                      "required": [
                        "errorCode",
                        "retryable"
                      ]
                    }
                  ]
                }
              }
            }
          },
          "429": {
            "description": "Too many requests have been made to this endpoint in a short time period.\n\nThis error is not automatically retryable.",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "$ref": "#/components/schemas/ApiError"
                    },
                    {
                      "type": "object",
                      "description": "Too many requests have been made to this endpoint in a short time period.\n\nThis error is not automatically retryable.",
                      "properties": {
                        "errorCode": {
                          "enum": [
                            "http.endpointRateLimitExceeded"
                          ]
                        },
                        "details": {
                          "type": "object",
                          "properties": {
                            "details": {
                              "description": "Additional details about this endpoint's rate limits.\n",
                              "type": "string"
                            }
                          }
                        },
                        "retryable": {
                          "enum": [
                            "false"
                          ]
                        }
                      },
                      "required": [
                        "errorCode",
                        "retryable",
                        "details"
                      ]
                    }
                  ]
                }
              }
            }
          },
          "500": {
            "description": "An internal server error occurred. Please contact [support@tulip.co](mailto:support@tulip.co)\nif the error persists.\n\nThis error is not automatically retryable.",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "$ref": "#/components/schemas/ApiError"
                    },
                    {
                      "type": "object",
                      "description": "An internal server error occurred. Please contact [support@tulip.co](mailto:support@tulip.co)\nif the error persists.\n\nThis error is not automatically retryable.",
                      "properties": {
                        "errorCode": {
                          "enum": [
                            "generic.internal"
                          ]
                        },
                        "retryable": {
                          "enum": [
                            "false"
                          ]
                        }
                      },
                      "required": [
                        "errorCode",
                        "retryable"
                      ]
                    }
                  ]
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "PaginationParamLimit": {
        "description": "The maximum number of items to return in the response. If this is set to 0, the endpoint will\nreturn a default number of items specific to the endpoint.\n",
        "type": "integer",
        "minimum": "0",
        "example": "1"
      },
      "PaginationParamOffset": {
        "description": "The number of items to skip before collecting items for the response.\n",
        "type": "integer",
        "minimum": "0",
        "example": "0"
      },
      "User": {
        "allOf": [
          {
            "$ref": "#/components/schemas/UserProfile"
          },
          {
            "oneOf": [
              {
                "type": "object",
                "properties": {
                  "workspaceRoleAssignments": {
                    "type": "array",
                    "items": {
                      "$ref": "#/components/schemas/WorkspaceRoleAssignment"
                    }
                  }
                },
                "required": [
                  "workspaceRoleAssignments"
                ]
              },
              {
                "type": "object",
                "properties": {
                  "globalRoleId": {
                    "allOf": [
                      {
                        "description": "The unique identifier for a global role.\n",
                        "type": "string",
                        "enum": [
                          "owner"
                        ]
                      }
                    ]
                  }
                },
                "required": [
                  "globalRoleId"
                ]
              }
            ]
          },
          {
            "description": "A user's profile information and role assignments across workspaces."
          }
        ]
      },
      "PaginatedResponse": {
        "type": "object",
        "properties": {
          "count": {
            "description": "The total number of items that matched the list parameters.\n",
            "type": "number",
            "example": "10"
          },
          "nextPage": {
            "description": "A URL at which the next page of results can be fetched.\n",
            "type": "string",
            "format": "url"
          },
          "prevPage": {
            "description": "A URL at which the previous page of results can be fetched.\n",
            "type": "string",
            "format": "url"
          },
          "items": {
            "type": "array",
            "items": {}
          },
          "errors": {
            "type": "array",
            "description": "A list of errors per item that is omitted from the paginated response, if any.\n",
            "items": {
              "$ref": "#/components/schemas/PaginatedItemError"
            }
          }
        },
        "required": [
          "items"
        ]
      },
      "ApiError": {
        "description": "An error response returned by a Tulip API.\n",
        "type": "object",
        "properties": {
          "errorCode": {
            "description": "A machine-readable code identifying the type of error.\n",
            "type": "string",
            "pattern": "^[a-zA-Z0-9.]$"
          },
          "message": {
            "description": "A human-readable description of the error intended for debugging purposes only.\n\nThe exact content of this message is not stable.\n",
            "type": "string"
          },
          "retryable": {
            "description": "Whether the request can be automatically retried by the client.\n",
            "type": "boolean"
          }
        },
        "required": [
          "errorCode",
          "retryable"
        ]
      },
      "UserProfile": {
        "type": "object",
        "description": "A user's profile information.\n",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/UserId"
          },
          "name": {
            "type": "object",
            "description": "The user's name.\n",
            "properties": {
              "full": {
                "type": "string",
                "description": "The user's full name.\n"
              }
            },
            "required": [
              "full"
            ]
          },
          "avatarUrl": {
            "type": "string",
            "description": "The url which host's a user's profile picture.\n"
          },
          "language": {
            "$ref": "#/components/schemas/SupportedLanguages"
          },
          "email": {
            "type": "object",
            "description": "The user's email address and whether or not it is verified.\n",
            "properties": {
              "address": {
                "type": "string",
                "description": "The user's email address.\n"
              },
              "verified": {
                "type": "boolean",
                "description": "Whether a user's email address has been confirmed.\n"
              }
            },
            "required": [
              "address",
              "verified"
            ]
          },
          "phone": {
            "type": "object",
            "description": "The user's phone number and whether or not it is verified.\n",
            "properties": {
              "number": {
                "type": "string",
                "description": "The user's phone number.\n"
              },
              "verified": {
                "type": "boolean",
                "description": "Whether a user's phone number has been confirmed.\n"
              }
            },
            "required": [
              "number",
              "verified"
            ]
          },
          "badgeId": {
            "type": "string",
            "description": "A unique string which identifies a user for Player authentication.\n"
          },
          "saml": {
            "type": "object",
            "description": "Information about the user's identity in an external SAML identity provider.\n",
            "properties": {
              "nameId": {
                "type": "string",
                "description": "The user's SAML NameID. This is a unique identifier for the user in the external identity\nprovider.\n"
              },
              "verified": {
                "type": "boolean",
                "description": "Whether the user's SAML NameID has been verified to be correct by the external identity\nprovider.\n\nIf this is `false`, the user's NameID has been set in Tulip and has not been confirmed to\nbe correct according to the identity provider.\n"
              }
            },
            "required": [
              "nameId",
              "verified"
            ]
          },
          "invited": {
            "allOf": [
              {
                "$ref": "#/components/schemas/CRUDMetadata"
              },
              {
                "description": "When and by whom a user was most recently invited to configure their Tulip account by email.\n"
              }
            ]
          },
          "created": {
            "$ref": "#/components/schemas/OptionalCreated"
          },
          "lastModified": {
            "$ref": "#/components/schemas/OptionalLastModified"
          },
          "archived": {
            "$ref": "#/components/schemas/OptionalArchived"
          }
        },
        "required": [
          "id",
          "name",
          "created",
          "lastModified"
        ],
        "example": {
          "id": "78M2aGebq5MjhKafN",
          "name": {
            "full": "John Doe"
          },
          "email": {
            "address": "john.doe@tulip.co",
            "verified": "true"
          },
          "created": {
            "at": "2023-05-06T17:41:08+00:00",
            "by": {
              "type": "user",
              "id": "Acbu9bbP7jHHDSq8e"
            }
          },
          "lastModified": {
            "at": "2024-01-18T07:11:17+00:00",
            "by": {
              "type": "user",
              "id": "ieW7gygymmFY253Ew"
            }
          }
        }
      },
      "WorkspaceRoleAssignment": {
        "type": "object",
        "description": "One of a a user's member workspaces and its associated role.\n",
        "properties": {
          "workspaceId": {
            "$ref": "#/components/schemas/WorkspaceId"
          },
          "userRoleId": {
            "$ref": "#/components/schemas/UserRoleId"
          }
        },
        "required": [
          "workspaceId",
          "userRoleId"
        ]
      },
      "PaginatedItemError": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ApiError"
          },
          {
            "description": "An error for a single paginated list item that is omitted from the paginated list response.\n"
          },
          {
            "type": "object",
            "properties": {
              "retryable": {
                "enum": [
                  "false"
                ]
              },
              "details": {
                "type": "object",
                "properties": {
                  "id": {
                    "description": "The ID of the omitted record.",
                    "type": "string"
                  }
                }
              }
            },
            "required": [
              "details"
            ]
          }
        ],
        "example": {
          "errorCode": "generic.internal",
          "message": "Something went wrong.",
          "retryable": "false",
          "details": {
            "id": "invalidRecordId"
          }
        }
      },
      "UserId": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RandomId"
          },
          {
            "description": "The ID of a Tulip User.\n"
          },
          {
            "$ref": "#/components/schemas/RandomId"
          },
          {
            "description": "A random string which uniquely identifies a user.\n"
          }
        ]
      },
      "SupportedLanguages": {
        "description": "ISO-639-1 Language codes supported within the Tulip platform.\n",
        "type": "string",
        "enum": [
          "bg",
          "cs",
          "da",
          "de",
          "el",
          "en",
          "en-GB",
          "es",
          "et",
          "fi",
          "fr",
          "hu",
          "id",
          "it",
          "ja",
          "ko",
          "lt",
          "lv",
          "nb",
          "nl",
          "pl",
          "pt-PT",
          "pt-BR",
          "ro",
          "ru",
          "sk",
          "sl",
          "sv",
          "tr",
          "vi",
          "uk",
          "zh-Hans"
        ],
        "example": "en"
      },
      "CRUDMetadata": {
        "description": "When and by whom an action was performed on a resource.\n",
        "type": "object",
        "properties": {
          "at": {
            "$ref": "#/components/schemas/DateTime"
          },
          "by": {
            "$ref": "#/components/schemas/ActorMetadata"
          }
        }
      },
      "OptionalCreated": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CRUDMetadata"
          },
          {
            "description": "When and by whom a resource was created.\n"
          }
        ]
      },
      "OptionalLastModified": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CRUDMetadata"
          },
          {
            "description": "When and by whom a resource was last modified.\n"
          }
        ]
      },
      "OptionalArchived": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CRUDMetadata"
          },
          {
            "description": "When and by whom a resource was archived. This field will be absent if and only if the\nresource is not currently archived.\n"
          }
        ]
      },
      "WorkspaceId": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RandomId"
          },
          {
            "description": "The ID of a Tulip Workspace.\n",
            "example": "DEFAULT",
            "type": "string"
          }
        ]
      },
      "UserRoleId": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/BuiltInUserRoleId"
          },
          {
            "$ref": "#/components/schemas/CustomUserRoleId"
          }
        ]
      },
      "RandomId": {
        "description": "A randomly generated unique identifier.\n\nTypically has ~98 bits of entropy.\n",
        "example": "g56RCoZCtzv7borvp",
        "type": "string",
        "pattern": "^[a-zA-Z0-9_]+$"
      },
      "DateTime": {
        "description": "A date-time string as defined by\n[RFC 3339 §5.6](https://tools.ietf.org/html/rfc3339#section-5.6).\n",
        "example": "2022-11-21T19:59:10+00:00",
        "type": "string",
        "format": "date-time"
      },
      "ActorMetadata": {
        "description": "Represents a user, api-token, or device.\n",
        "type": "object",
        "properties": {
          "type": {
            "$ref": "#/components/schemas/ActorType"
          },
          "id": {
            "$ref": "#/components/schemas/UserId"
          }
        },
        "required": [
          "type",
          "id"
        ]
      },
      "BuiltInUserRoleId": {
        "description": "The possible ID/names a builtin user role can have.\n",
        "type": "string",
        "enum": [
          "operator",
          "operator-with-registration",
          "shop-floor-operator",
          "apps-approver-admin",
          "apps-builder-admin",
          "apps-admin",
          "tables-admin",
          "connectors-admin",
          "shop-floor-admin",
          "viewer",
          "viewer-with-player",
          "admin",
          "workspace-owner",
          "owner"
        ]
      },
      "CustomUserRoleId": {
        "allOf": [
          {
            "$ref": "#/components/schemas/RandomId"
          },
          {
            "description": "The unique identifier for a custom role. Cannot be a built-in role's name.\n"
          }
        ]
      },
      "ActorType": {
        "description": "The type of actor performing an action.\n",
        "type": "string",
        "enum": [
          "user",
          "client",
          "api-token",
          "app-exchange-api-token",
          "celosx-api-token",
          "automation",
          "instance-init",
          "scim",
          "unknown"
        ]
      }
    }
  }
}
````