--- title: "Retrieve a single process template and its version by version mask" method: GET path: "/spaces/{spaceIdentifier}/processtemplates/{slug}/{versionMask}" tags: ["ProcessTemplates"] --- # Retrieve a single process template and its version by version mask `GET /spaces/{spaceIdentifier}/processtemplates/{slug}/{versionMask}` ## Path parameters - `spaceIdentifier` string, required - `slug` string, required - `versionMask` string, required ## Response `200` The requested process template and its version - GetProcessTemplateByVersionMaskResponse - `ProcessTemplate` ProcessTemplateResource, required - `Description` string - `GitRef` string - `Icon` IconResource - `Color` string — Icon background colour, as a Hex string - `Id` string — Font Awesome Icon Id - `Id` string - `Name` string - `Parameters` ProcessTemplateParameterResource[] - `DisplaySettings` object - `HelpText` string - `IsOptional` boolean - `Label` string - `Name` string - `Values` TemplateParameterValueResource[] - `Scope` object, required - `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. - `Value` PropertyValueResource, required - `IsSensitive` boolean - `SensitiveValue` SensitiveValue - `HasValue` boolean - `Hint` string - `NewValue` string - `Value` string - `Slug` string - `Steps` DeploymentStepResource[] - `Actions` DeploymentActionResource[] - `ActionType` string - `AvailableStepPackageVersions` string[] - `CanBeUsedForProjectVersioning` boolean - `Channels` string[] - `ChannelsVariable` string - `CommunityActionTemplateSnapshot` CommunityActionTemplateSnapshotResource - `Id` string - `Parameters` ActionTemplateParameterResource[] - `DefaultValue` PropertyValueResource - … - `DisplaySettings` object - `HelpText` string - `Id` string - `Label` string - `Name` string - `Version` integer - `Condition` 'Success' | 'Variable' - `Container` DeploymentActionContainerResource - `Dockerfile` string - `FeedId` string - `GitUrl` string - `Image` string - `Environments` string[] - `EnvironmentsVariable` string - `ExcludedEnvironments` string[] - `ExcludedEnvironmentsVariable` string - `GitDependencies` GitDependencyResource[] - `DefaultBranch` string, required - `FilePathFilters` string[] - `GitCredentialId` string - `GitCredentialType` string, required - `GitHubConnectionId` string - `Name` string, required - `RepositoryUri` string, required - `StepPackageInputsReferenceId` string - `Id` string — Gets or sets a unique identifier for this resource. - `Inputs` StepPackageInputsResource - `Value` unknown - `IsDisabled` boolean - `IsRequired` boolean - `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. - `LastSavedStepPackageVersion` string - `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. - `Name` string - `Notes` string - `Packages` PackageReferenceResource[] - `AcquisitionLocation` string — The package-acquisition location. One of PackageAcquisitionLocationResource or a variable-expression - `FeedId` string — Feed ID, name or a variable-expression - `Id` string - `Name` string — A name for the package-reference. This may be empty. This is used to discriminate the package-references. Package ID isn't suitable because an action may potentially have multiple references to the same package ID (e.g. if you wanted to use different versions of the same package). Also, the package ID may be a variable-expression. - `PackageId` string — Package ID or a variable-expression - `Properties` object - `StepPackageInputsReferenceId` string — This reference identifier is populated when a step package step contains a package reference It allows us to correlate the reference within the step package inputs to this Server package reference - `Version` string — Specific version to use for this package. If not specified, package can be selected at release creation or runbook run time. - `Properties` object - `Slug` string - `StepPackageVersion` string - `TenantTags` string[] - `TenantTagsVariable` string - `WorkerPoolId` string - `WorkerPoolVariable` string - `Condition` 'Success' | 'Failure' | 'Always' | 'Variable' - `Id` string - `Name` string, required - `PackageRequirement` 'LetOctopusDecide' | 'BeforePackageAcquisition' | 'AfterPackageAcquisition' - `Properties` object - `Slug` string - `StartTrigger` 'StartAfterPrevious' | 'StartWithPrevious' - `Type` string — Either "Step" or "ProcessTemplateUsage". Defaults to "Step" if no type is provided. - `ProcessTemplateVersion` string, required ## 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)