> This page is for API Reference & Tools.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.moveworks.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.moveworks.com/_mcp/server.

# List software access apps

GET https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps

Returns every software access app in your organization as a JSON array.

Reference: https://docs.moveworks.com/api-reference/configuration-api/access-skills/software-access-apps/list-software-access-apps

## Authentication

- `Authorization` header (bearer token, required) — JWT bearer token authentication. Include the Configuration API key in the Authorization header as 'Bearer \<token>'.

## Response

### 200

The software access apps in your organization

- `list of AccessSoftwareApp`

## Errors

### 401 Unauthorized Error

Unauthorized - the `Authorization` header is missing or the token is invalid

- `error` (ErrorResponseError, required)

### 403 Forbidden Error

Forbidden - the API key isn't allowed to change this configuration, or the configuration is frozen for your organization

- `error` (ErrorResponseError, required)

### 429 Too Many Requests Error

Too many requests - the organization exceeded the Configuration API rate limit. Back off and retry.

- `error` (ErrorResponseError, required)

### 500 Internal Server Error

Internal server error - retry the request

- `error` (ErrorResponseError, required)

## Types

### AccessSoftwareApp

A software application in the Software Access catalog, including who can request it and how access is provisioned.

- `id` (string, optional) — Unique identifier of the app, assigned by the server.
- `name` (string, optional) — Name of the app as users ask for it. Must be unique in the org and cannot be changed after creation.
- `in_assistant_enabled` (boolean, optional) — If true, users can request this app through the AI Assistant. Takes precedence over access_rule_dsl; use the access rule for more granular control.
- `access_rule_dsl` (string, optional) — DSL rule deciding which users can request this app. Use 'true' to allow all users, 'false' to allow none, or a DSL expression.
- `admins_email_addrs` (list of string, optional) — Email addresses of the app admins who can approve access. Required when the approval model includes app admin approval (APP_ADMIN, APP_ADMIN_THEN_MANAGER, or AUTO_APPROVE_FULL_TIME_ELSE_APP_ADMIN).
- `role_based_provisioning` (RoleBasedProvisioningConfig, optional) — Role-based provisioning: the user picks one of two or more roles (licenses, environments, versions) provisioned through your identity system. Set exactly one provisioning strategy.
- `group_based_provisioning` (GroupBasedProvisioningConfig, optional) — Group-based provisioning: membership in a single group grants access. Set exactly one provisioning strategy.
- `self_service_provisioning` (SelfServiceProvisioningConfig, optional) — Self-service provisioning: no automated provisioning; the user is shown instructions to get the app themselves. Set exactly one provisioning strategy.
- `app_links` (AppLinks, optional) — Links related to the app that are shown to the user.
- `updated_time` (datetime, optional) — When the configuration was last updated.
- `updated_by` (string, optional) — Who last updated the configuration.
- `version` (Version, optional) — Document version. On update, send back the num from your last read.

### ErrorResponseError

- `code` (string, optional) — A machine-readable error code.
- `message` (string, optional) — What went wrong, and for a rejected field, which rule it broke.

### RoleBasedProvisioningConfig

- `connector_id` (string, optional) — The provisioning system connector (e.g. Okta, Azure AD) that contains the groups for this app. ID of an existing connector (GET /configurations/v1alpha1/platform/connectors).
- `roles` (list of AccessSoftwareAppRole, optional) — Roles the user can choose from. If only one role exists, use group-based provisioning instead.
- `type` (enum, optional) — What the roles represent. One of ENVIRONMENT, LICENSE, ROLE, VERSION, or UNKNOWN.
  - Allowed values: `ENVIRONMENT`, `LICENSE`, `ROLE`, `VERSION`, `UNKNOWN`
- `base_config` (BaseDirectProvisioningConfig, optional) — Approval, question, and post-provisioning settings for this app.

### GroupBasedProvisioningConfig

- `connector_id` (string, optional) — The connector that contains the group granting access to this app. ID of an existing connector (GET /configurations/v1alpha1/platform/connectors).
- `external_id` (string, optional) — External ID of the group that grants access to this app.
- `base_config` (BaseDirectProvisioningConfig, optional) — Approval, question, and post-provisioning settings for this app.

### SelfServiceProvisioningConfig

- `title` (string, optional) — High-level title for the self-service instructions, e.g. 'You can download this app from their website'.
- `body` (string, optional) — Instructions guiding the user to get the app themselves, such as download links or who to contact for help.

### AppLinks

- `pretext` (string, optional) — Brief context shown above the links, e.g. 'Click the link below to install'.
- `mw_urls` (list of MWUrl, optional) — External links related to the app.

### Version

- `num` (integer, optional) — Version number set by the server. On update, send the num from your last read; a stale num is rejected as a conflict.
- `change_description` (string, optional) — A short note describing this change. Required on every create and update.

### AccessSoftwareAppRole

- `canonical_name` (string, optional) — Unique name of the role within this app.
- `description` (string, optional) — Information that helps the user decide whether this role is right for them.
- `user_facing_name` (string, optional) — Human-readable name of the role shown to users.
- `external_id` (string, optional) — External ID of the group that grants this role.
- `item_ref` (string, optional) — Server-assigned row identifier. Leave unset on create; send back the value from your last read on update so the row keeps its identity.

### BaseDirectProvisioningConfig

- `approval_key` (ApprovalKey, optional) — Approval model for requests to this app: a built-in trust model or a custom approval workflow.
- `questions` (list of string, optional) — Additional information to collect from the user before they can submit the request. At most one question.
- `provisioning_disabled` (boolean, optional) — If true, access is not provisioned even when the request is approved.
- `post_provisioning_messages` (PostProvisioningMessages, optional) — Messages shown to the user after the request is successfully handled.

### MWUrl

- `url` (string, optional) — The link URL.
- `text` (string, optional) — Display text for the link.
- `item_ref` (string, optional) — Server-assigned row identifier. Leave unset on create; send back the value from your last read on update so the row keeps its identity.

### ApprovalKey

- `built_in_key` (enum, optional) — A predefined trust model, such as MANAGER, APP_ADMIN, or AUTO_APPROVE. Set this or custom_key.
  - Allowed values: `APP_ADMIN`, `APP_ADMIN_THEN_MANAGER`, `AUTO_APPROVE`, `AUTO_APPROVE_FULL_TIME_ELSE_MANAGER`, `AUTO_APPROVE_FULL_TIME_ELSE_APP_ADMIN`, `IT_RESTRICTED_CHECK`, `MANAGER`, `IT_ADMIN_GROUP_APPROVAL`, `MOST_RESTRICTIVE_TRUST_MODEL`
- `custom_key` (string, optional) — Name of a custom approval workflow to use. Set this or built_in_key. ID of an existing approval_workflow (GET /configurations/v1alpha1/tool/access-software/workflows).

### PostProvisioningMessages

- `title` (string, optional) — Title shown when the software request has been successfully handled.
- `body` (string, optional) — Message body shown when the software request has been successfully handled.

## Examples

**Response**

```json
[
  {
    "id": "3f6c1e2a-8b4d-4c7e-9a1f-2d5b6c7e8f90",
    "name": "example-name",
    "in_assistant_enabled": true,
    "access_rule_dsl": "true",
    "role_based_provisioning": {
      "connector_id": "<connector-uuid>",
      "roles": [
        {
          "canonical_name": "example-name",
          "description": "What this is for",
          "user_facing_name": "example-name",
          "external_id": "<external-id>",
          "item_ref": "<string>"
        }
      ],
      "type": "ENVIRONMENT",
      "base_config": {
        "approval_key": {
          "built_in_key": "APP_ADMIN"
        },
        "questions": [
          "<string>"
        ],
        "provisioning_disabled": true,
        "post_provisioning_messages": {
          "title": "Example title",
          "body": "<string>"
        }
      }
    },
    "updated_time": "2026-11-12T18:04:11Z",
    "updated_by": "admin@example.com",
    "version": {
      "num": 2,
      "change_description": "Initial setup"
    }
  }
]
```

**SDK Code**

```python Software Access Apps endpoints_listSoftwareAccessApps_example
import requests

url = "https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Software Access Apps endpoints_listSoftwareAccessApps_example
const url = 'https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go Software Access Apps endpoints_listSoftwareAccessApps_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby Software Access Apps endpoints_listSoftwareAccessApps_example
require 'uri'
require 'net/http'

url = URI("https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java Software Access Apps endpoints_listSoftwareAccessApps_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Software Access Apps endpoints_listSoftwareAccessApps_example
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp Software Access Apps endpoints_listSoftwareAccessApps_example
using RestSharp;

var client = new RestClient("https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Software Access Apps endpoints_listSoftwareAccessApps_example
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.moveworks.ai/configurations/v1alpha1/tool/access-software/apps")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```