---
title: "Get a list of Variable Sets."
method: GET
path: "/{spaceId}/variables/all"
tags: ["Variables"]
---

# Get a list of Variable Sets.

`GET /{spaceId}/variables/all`

Lists all the Variable Sets in the supplied Space.

## Path parameters

- `spaceId` string, required

## Query parameters

- `ids` string[]

## Response `200`

The requested list of Variable Sets

- VariableSetResource[]
  - `Id` string — Gets or sets a unique identifier for this resource.
  - `LastModifiedBy` string — Gets or sets the username of the user who last modified this resource.
  - `LastModifiedOn` string, date-time — Gets or sets the date/time that this resource was last modified.
  - `Links` object — Gets or sets a dictionary of links to other related resources. These links can be used to navigate the resources on the server.
  - `OwnerId` string — Gets or sets the ID of the document that owns these variables.
  - `ScopeValues` VariableScopeValues
    - `Actions` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `Channels` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `EnvironmentParameters` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `Environments` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `Machines` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `Processes` ProcessReferenceDataItem[]
      - `Id` string
      - `Name` string
      - `ProcessType` 'Deployment' | 'Runbook'
    - `ProcessTemplateSteps` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `Roles` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `TargetTagParameters` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `TenantTagParameters` ReferenceDataItem[]
      - `Id` string
      - `Name` string
    - `TenantTags` ReferenceDataItem[]
      - `Id` string
      - `Name` string
  - `SpaceId` string
  - `Variables` VariableResource[] — Gets the collection of variables.
    - `Description` string
    - `Id` string
    - `IsEditable` boolean
    - `IsSensitive` boolean
    - `Name` string
    - `Prompt` VariablePromptOptions
      - `Description` string
      - `DisplaySettings` object
      - `Label` string
      - `Required` boolean
    - `Scope` object
      - `Project` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Environment` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Machine` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Role` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `TargetRole` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Action` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `User` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Trigger` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `ParentDeployment` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Private` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Channel` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `TenantTag` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `Tenant` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `ProcessOwner` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `ProjectTemplate` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `TemplatedProject` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `ProcessTemplateStep` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `EnvironmentParameter` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `TargetTagParameter` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
      - `TenantTagParameter` string[] — The current implementation holds the strings in an insertion-sorted List, rather than a HashSet. This means that when enumerated, it will return values in a predictable order, but you should not make assumptions about this from outside the class. This tradeoff is deliberate, it improves enumeration and equality-comparison performance, but we lose the ability to do fast Contains() lookups. ScopeValue does not expose any Contains() method, so we can be fairly confident the tradeoff is good.
    - `Type` string
    - `Value` string
  - `Version` integer — Gets or sets the version number.

## Other responses

- `400` — Bad request. Either the payload was not structurally valid or business rules did not permit the operation.
- `404` — Not found. One or more of the entities involved in the operation was not found.

---

[API](https://skmtc.net/octopus/apis/octopus-server-api.md) · [All operations](https://skmtc.net/octopus/apis/octopus-server-api/llms.txt) · [OpenAPI document](https://skmtc-service-staging.skmtc.workers.dev/v1/apis/octopus/octopus-server-api/revisions/b296c3a60aa5/schema)