> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.withpersona.com/2020-05-18/api-reference/connect/connections/list-all-connect-connections/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.withpersona.com/_mcp/server.

# List all Connections

GET https://api.withpersona.com/api/v1/connect/connections

Returns a list of connect connections associated with your organization, including both outbound connections your organization created and inbound connections where your organization is the destination. Results are returned in reverse chronological order, with the most recently created objects first.

Reference: https://docs.withpersona.com/api-reference/connect/connections/list-all-connect-connections

## Authentication

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

## Request

### Query parameters

- `page` (ConnectConnectionsGetParametersPage, optional)
- `fields` (map from string to string, optional) — Comma-separated list(s) of attributes to include in the response. This can be used to customize which attributes will be serialized in the response. See [Serialization](https://docs.withpersona.com/serialization#sparse-fieldsets) for more details.
- `filter` (ConnectConnectionsGetParametersFilter, optional)

### Headers

- `Key-Inflection` (enum, optional) — Determines casing for the API response.
  - Allowed values: `camel`, `kebab`, `snake`
- `Idempotency-Key` (string, optional) — Ensures the request is idempotent.
- `Persona-Version` (enum, optional) — Server API version. More info on versioning can be found [here](https://docs.withpersona.com/versioning).
  - Allowed values: `2025-12-08`, `2025-10-27`, `2023-01-05`, `2022-09-01`, `2021-08-18`, `2021-07-05`, `2021-02-21`, `2020-05-18`

## Response

### 200

This endpoint returns a collection of Connections.

- `data` (list of connect-connection, required) — An array of Connections
- `links` (ConnectConnectionsGetResponsesContentApplicationJsonSchemaLinks, required)

## Errors

### 400 Bad Request Error

The request was unacceptable, often due to invalid parameters.

- `errors` (list of ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 401 Unauthorized Error

An invalid API key was provided.

- `errors` (list of ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 403 Forbidden Error

The given API key doesn’t have permissions to perform the request or a quota has been exceeded.

- `errors` (list of ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 404 Not Found Error

The requested resource doesn’t exist.

- `errors` (list of ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

### 429 Too Many Requests Error

Your organization’s rate limit has been exceeded. We recommend an exponential backoff on requests.

- `errors` (list of ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems, optional)

## Types

### ConnectConnectionsGetParametersPage

- `after` (string, optional) — Object ID for pagination cursor
- `before` (string, optional) — Object ID for pagination cursor
- `size` (double, optional) — Limit on the number of objects returned

### ConnectConnectionsGetParametersFilter

- `status` (string, optional) — Filter connections by status
- `destination-organization-id` (string, optional) — Filter connections by destination organization ID — the organization authorized to access data through the connection.

### connect-connection

A Connect Connection object. This object represents a connection between organizations for sharing access to Persona objects.

- `type` ("connect/connection", optional)
- `id` (string, optional)
- `attributes` (ConnectConnectionAttributes, optional)
- `relationships` (ConnectConnectionRelationships, optional)

### ConnectConnectionsGetResponsesContentApplicationJsonSchemaLinks

- `prev` (string, required, nullable) — URL pointing to the previous page of data, or null if on the first page.
- `next` (string, required, nullable) — URL pointing to the next page of data, or null if on the last page.

### ConnectConnectionsGetResponsesContentApplicationJsonSchemaErrorsItems

- `title` (string, optional)
- `details` (string, optional)

### ConnectConnectionAttributes

- `status` (string, optional) — The current status of the connection. One of `pending`, `active`, or `inactive`.
- `destination-organization-id` (string, optional) — The organization authorized to access objects through this connection.
- `source-organization-id` (string, optional) — The organization that created and owns this connection.
- `created-at` (datetime, optional) — The date and time when this connection was created
- `updated-at` (datetime, optional) — The date and time when this connection was last updated

### ConnectConnectionRelationships

- `creator` (ConnectConnectionRelationshipsCreator, optional)

### ConnectConnectionRelationshipsCreator

- `data` (ConnectConnectionRelationshipsCreatorData, required)

### ConnectConnectionRelationshipsCreatorData

- `id` (string, required)
- `type` (string, required) — The type of the creator entity

## Examples

**Response**

```json
{
  "data": [
    {
      "type": "connect/connection",
      "id": "cxn_ABC123",
      "attributes": {
        "status": "active",
        "destination-organization-id": "org_XYZ789",
        "source-organization-id": "org_ABC123",
        "created-at": "2018-06-01T00:00:00.000Z",
        "updated-at": "2018-06-01T00:00:00.000Z"
      }
    },
    {
      "type": "connect/connection",
      "id": "cxn_XYZ789",
      "attributes": {
        "status": "pending",
        "destination-organization-id": "org_ABC123",
        "source-organization-id": "org_XYZ789",
        "created-at": "2018-06-01T00:00:00.000Z",
        "updated-at": "2018-06-01T00:00:00.000Z"
      }
    }
  ],
  "links": {
    "prev": null,
    "next": "/api/v1/connect/connections?page%5Bafter%5D=cxn_XYZ789"
  }
}
```

**SDK Code**

```python Success
import requests

url = "https://api.withpersona.com/api/v1/connect/connections"

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

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

print(response.json())
```

```javascript Success
const url = 'https://api.withpersona.com/api/v1/connect/connections';
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 Success
package main

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

func main() {

	url := "https://api.withpersona.com/api/v1/connect/connections"

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

url = URI("https://api.withpersona.com/api/v1/connect/connections")

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

HttpResponse<String> response = Unirest.get("https://api.withpersona.com/api/v1/connect/connections")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.withpersona.com/api/v1/connect/connections', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://api.withpersona.com/api/v1/connect/connections");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.withpersona.com/api/v1/connect/connections")! 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()
```