---
title: "Get a list of Variable Sets included in the Release's current Variable Snapshot"
method: GET
path: "/{spaceId}/projects/{projectId}/releases/{id}/variables"
tags: ["Releases"]
---

# Get a list of Variable Sets included in the Release's current Variable Snapshot

`GET /{spaceId}/projects/{projectId}/releases/{id}/variables`

## Request

- Base URL: `https://demo.octopus.app/api`
- URL: `https://demo.octopus.app/api/{spaceId}/projects/{projectId}/releases/{id}/variables`
- Auth: one of:
  - API key in header `X-Octopus-ApiKey`
  - API key in query parameter `ApiKey`
  - API key in header `X-NuGet-ApiKey`

## Path parameters

- `spaceId` string, required
- `projectId` string, required
- `id` string, required

## Response `200`

The requested list of Variables

- 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.dev/octopus/apis/octopus-server-api.md) - [All operations](https://skmtc.dev/octopus/apis/octopus-server-api/llms.txt) - [OpenAPI document](https://skmtc.dev/octopus/apis/octopus-server-api/revisions/fe937c07da34?raw)