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

# List Providers

GET https://api.projectmanager.com/api/data/integrations/providers

List all available IntegrationProviders that can be activated.
            
An IntegrationProvider is the name of an external application or service that can be connected to
ProjectManager.com.  The Integrations API is intended for use by ProjectManager and its business
development partners.  Please contact ProjectManager's sales team to request use of this API.

Reference: https://developer.projectmanager.com/api-reference/integration-provider/list-providers

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Headers

- `x-integration-name` (string, optional) — The name of the calling system passed along as a header parameter

## Response

### 200

Success

- `error` (AstroError, optional, nullable) — If the API call failed, this will contain information about the error that occurred.
- `success` (boolean, optional) — True if the API call succeeded; false otherwise.
- `hasError` (boolean, optional) — True if the API call failed.
- `statusCode` (enum, optional) — The HTTP code of the response.
  - Allowed values: `Continue`, `SwitchingProtocols`, `Processing`, `EarlyHints`, `OK`, `Created`, `Accepted`, `NonAuthoritativeInformation`, `NoContent`, `ResetContent`, `PartialContent`, `MultiStatus`, `AlreadyReported`, `IMUsed`, `MultipleChoices`, `MovedPermanently`, `Found`, `SeeOther`, `NotModified`, `UseProxy`, `Unused`, `TemporaryRedirect`, `PermanentRedirect`, `BadRequest`, `Unauthorized`, `PaymentRequired`, `Forbidden`, `NotFound`, `MethodNotAllowed`, `NotAcceptable`, `ProxyAuthenticationRequired`, `RequestTimeout`, `Conflict`, `Gone`, `LengthRequired`, `PreconditionFailed`, `RequestEntityTooLarge`, `RequestUriTooLong`, `UnsupportedMediaType`, `RequestedRangeNotSatisfiable`, `ExpectationFailed`, `MisdirectedRequest`, `UnprocessableEntity`, `Locked`, `FailedDependency`, `UpgradeRequired`, `PreconditionRequired`, `TooManyRequests`, `RequestHeaderFieldsTooLarge`, `UnavailableForLegalReasons`, `InternalServerError`, `NotImplemented`, `BadGateway`, `ServiceUnavailable`, `GatewayTimeout`, `HttpVersionNotSupported`, `VariantAlsoNegotiates`, `InsufficientStorage`, `LoopDetected`, `NotExtended`, `NetworkAuthenticationRequired`
- `data` (list of IntegrationProviderDto, optional) — If the API call succeeded, this will contain the results.

## Types

### AstroError

Information about an error that occurred within the ProjectManager API.

- `technicalError` (string, optional, nullable) — A technical description of the error that occurred. Not suitable for display to end users.
- `additionalErrors` (list of string, optional, nullable) — If additional errors beyond the main error in `Message` occurred, they will be listed here as individual messages.
- `validationErrors` (map from string to list of string, optional, nullable) — This contains a dictionary of validation errors. The key is the name of the field
- `message` (string, optional, nullable) — A description of the error that occurred. If your application has a user interface, show this message to explain what went wrong.

### IntegrationProviderDto

The Integrations API is intended for use by ProjectManager and its business development partners. Please contact ProjectManager's sales team to request use of this API.

- `id` (string, optional) — The unique identifier of this Provider.
- `name` (string, optional) — The friendly name of this Provider.
- `shortId` (string, optional) — A short ID that uniquely identifies this Provider.
- `summary` (string, optional) — A short summary of this Provider and their service.
- `description` (string, optional) — A longer description of this Provider and their service.
- `licenseSkus` (list of string, optional) — A list of available license SKUs for this Provider.
- `categoryShortIds` (list of string, optional) — A list of category IDs that this Provider exists within.
- `activated` (boolean, optional) — True if this Provider is available for use.
- `authenticated` (boolean, optional) — True if the current user has an active personal connection to this Provider. This is a user-level flag - each user connects their own account independently.
- `unauthorized` (boolean, optional) — True if this Provider is activated but the workspace-level connection has lost authorization (e.g. the OAuth refresh token has expired or been revoked). This is a workspace-level flag - it affects all users. Re-authentication by a workspace administrator is required before jobs can run again.
- `integrations` (list of IntegrationDto, optional) — The list of available Integrations for this Provider.
- `authSetup` (IntegrationAuthSetupDto, optional) — The list of available AuthSetup for this Provider.
- `createInWorkato` (boolean, optional) — Flag whether user/workspace needs to be setup in Workato

### IntegrationDto

The Integrations API is intended for use by ProjectManager and its business development partners. Please contact ProjectManager's sales team to request use of this API.

- `id` (string, optional) — The unique identifier of this Integration
- `name` (string, optional) — The friendly name of this Integration
- `description` (string, optional) — A description of this Integration that can be shared with users
- `shortId` (string, optional) — A short ID that uniquely identifies this Integration
- `isMultiInstance` (boolean, optional) — True if this Integration allows multiple Instances. An example of a multi-Instance Integration is one that can be connected to many different folders or channels within a remote application.
- `licenseSkus` (list of string, optional) — The list of SKUS for this Integration.
- `instances` (list of IntegrationInstanceDto, optional) — For multi-Instance Integrations, this contains the list of IntegrationInstances.
- `enabled` (boolean, optional) — True if this Integration is enabled for the current Workspace.
- `authenticated` (boolean, optional) — True if the user has authenticated
- `autoEnabled` (boolean, optional) — True if the integration is auto-enabled
- `noAdminPermission` (boolean, optional) — No Admin Permission

### IntegrationAuthSetupDto

Integration Auth Setup for Provider.

- `masterConnection` (string, optional) — Master Connection for provider
- `userConnection` (string, optional) — UserConnection for Provider.
- `masterConnectionSchema` (map from string to IntegrationConnectionSchemeObjectDto, optional, nullable) — Master Connection scheme for Provider.

### IntegrationInstanceDto

The Integrations API is intended for use by ProjectManager and its business development partners. Please contact ProjectManager's sales team to request use of this API.

- `id` (string, optional) — The unique identifier of this IntegrationInstance
- `integrationShortId` (string, optional) — A short ID that uniquely identifies this IntegrationInstance
- `enabledBy` (string, optional) — The unique identifier of the user who enabled this IntegrationInstance
- `createDate` (string, optional) — Timestamp when this record was created
- `modifyDate` (string, optional) — Timestamp when this record was most recently modified
- `projectId` (string, optional) — The id of the project manager project this instance is related to
- `providerItemId` (string, optional) — The identifier in the integration provider, could be a reference to a file, task, project.
- `providerItemName` (string, optional) — The name of the item in the integration provider.

### IntegrationConnectionSchemeObjectDto

Master Connection Scheme for Providers

- `value` (string, optional) — The value of the property
- `type` (string, optional) — The type of the property
- `sendToClient` (boolean, optional) — Send to the client true/false

## Examples

**Response**

```json
{
  "error": {
    "technicalError": "string",
    "additionalErrors": [
      "string"
    ],
    "validationErrors": {},
    "message": "string"
  },
  "success": true,
  "hasError": true,
  "statusCode": "Continue",
  "data": [
    {
      "id": "string",
      "name": "string",
      "shortId": "string",
      "summary": "string",
      "description": "string",
      "licenseSkus": [
        "string"
      ],
      "categoryShortIds": [
        "string"
      ],
      "activated": true,
      "authenticated": true,
      "unauthorized": true,
      "integrations": [
        {
          "id": "string",
          "name": "string",
          "description": "string",
          "shortId": "string",
          "isMultiInstance": true,
          "licenseSkus": [
            "string"
          ],
          "instances": [
            {
              "id": "string",
              "integrationShortId": "string",
              "enabledBy": "string",
              "createDate": "2024-01-15T09:30:00Z",
              "modifyDate": "2024-01-15T09:30:00Z",
              "projectId": "string",
              "providerItemId": "string",
              "providerItemName": "string"
            }
          ],
          "enabled": true,
          "authenticated": true,
          "autoEnabled": true,
          "noAdminPermission": true
        }
      ],
      "authSetup": {
        "masterConnection": "string",
        "userConnection": "string",
        "masterConnectionSchema": {}
      },
      "createInWorkato": true
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.projectmanager.com/api/data/integrations/providers"

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

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

print(response.json())
```

```javascript
const url = 'https://api.projectmanager.com/api/data/integrations/providers';
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
package main

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

func main() {

	url := "https://api.projectmanager.com/api/data/integrations/providers"

	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
require 'uri'
require 'net/http'

url = URI("https://api.projectmanager.com/api/data/integrations/providers")

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
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.projectmanager.com/api/data/integrations/providers")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.projectmanager.com/api/data/integrations/providers', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.projectmanager.com/api/data/integrations/providers");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.projectmanager.com/api/data/integrations/providers")! 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()
```