> This page is for Developers.

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

# List all Cloud Connect attachments of an organization

GET https://cdn.emnify.net/api/v1/cnc/breakout

Required permissions Beta [Learn more](/developers/api-guidelines/permissions#how-permissions-work)`CloudConnect.Breakout` + `List`Roles: Administrator User ObserverLists all Cloud Connect attachments of the logged in organisation if it is an Enterprise. For Master organisations
it lists all attachments of the direct child organisations. Deleted attachments are left out by default.Additionally the attachments can be filtered by status and type.
Master organisations can also filter by organisation ID of their direct child organisations.

Reference: https://docs.emnify.com/developers/api/cloud-connect/get-cloud-connect-attachments

## Authentication

- `Authorization` header (bearer token, required) — An `auth_token` should be provided to authenticate a session. To obtain an `auth_token`, see the [`/api/v1/authenticate` **POST** request](/developers/api/authentication/authenticate).

## Request

### Query parameters

- `status` (enum, optional) — Numerical ID of the Cloud Connect attachment status * `1` - Pending Customer Action * `2` - Pending AWS Activation * `3` - Pending EGN Activation * `4` - Pending CRG Activation * `5` - Active * `6` - Deactivation Pending * `7` - Deactivated * `8` - Rolling Back
  - Allowed values: `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`
- `type` (enum, optional) — Numerical ID of the Cloud Connect attachment type * `1` - Transit Gateway * `2` - IPSec VPN * `3` - IPSec VPN BGP * `4` - IPSec VPN BGP High Availability * `5` - Direct Connect * `6` - Shared * `7` - Transit Gateway (Classic) * `8` - IPSec VPN (Classic)
  - Allowed values: `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`
- `organisation` (double, optional) — Numerical ID of an Organization

## Response

### 200

OK

- `list of ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItems`

## Errors

### 403 Forbidden Error

Authentication token is valid, but user has no access permissions to the request resource

- `any`

## Types

### ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItems

- `id` (integer, optional)
- `name` (string, optional)
- `description` (string, optional)
- `user_id` (integer, optional)
- `creation_date` (string, optional) — The date this attachment was created in UTC
- `accept_attachment_expiry_date` (string, optional) — The expiry date of the accept attachment state in UTC. This will only be returned if the breakout is of type `Transit Gateway (type_id: 1)` and in Status `Pending AWS Actvation (status_id: 2)`
- `termination_date` (string, optional)
- `aws_transit_gateway_attachment_id` (string, optional)
- `aws_vpn_connection_id` (string, optional) — This is only set when the breakout is a VPN attachment
- `status` (ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItemsStatus, optional)
- `type` (ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItemsType, optional)
- `region` (string, optional) — The customer region that this attachment belongs to

### ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItemsStatus

- `id` (double, optional)
- `description` (string, optional)

### ApiV1CncBreakoutGetResponsesContentApplicationJsonSchemaItemsType

- `id` (double, optional)
- `description` (string, optional)

## Examples

### Default - No Filtering

**Response**

```json
[
  {
    "id": 75,
    "name": "Attachment to StrongSwan",
    "user_id": 123,
    "creation_date": "2019-10-21T10:19:02.000Z",
    "aws_transit_gateway_attachment_id": "tgw-attach-0abce8655d0bafb83",
    "aws_vpn_connection_id": "vpn-0085c553b38c5deeb",
    "status": {
      "id": 5,
      "description": "Active"
    },
    "type": {
      "id": 3,
      "description": "IPSec VPN BGP"
    },
    "region": "eu-west-2",
    "organisation_id": 123
  },
  {
    "id": 104,
    "name": "Attachment to VPC",
    "user_id": 123,
    "creation_date": "2019-10-22T07:59:26.000Z",
    "aws_transit_gateway_attachment_id": "tgw-attach-0f84169771fa2f4a3",
    "status": {
      "id": 5,
      "description": "Active"
    },
    "type": {
      "id": 1,
      "description": "Transit Gateway"
    },
    "region": "eu-west-1",
    "organisation_id": 123
  }
]
```

**SDK Code**

```python Default - No Filtering
import requests

url = "https://cdn.emnify.net/api/v1/cnc/breakout"

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

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

print(response.json())
```

```javascript Default - No Filtering
const url = 'https://cdn.emnify.net/api/v1/cnc/breakout';
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 Default - No Filtering
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/cnc/breakout"

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

url = URI("https://cdn.emnify.net/api/v1/cnc/breakout")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/cnc/breakout")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Default - No Filtering
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/cnc/breakout', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Default - No Filtering
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/cnc/breakout");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Default - No Filtering
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/cnc/breakout")! 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()
```

### Filter by Status - Active

**Response**

```json
[
  {
    "id": 75,
    "name": "Attachment to StrongSwan",
    "user_id": 123,
    "creation_date": "2019-10-21T10:19:02.000Z",
    "aws_transit_gateway_attachment_id": "tgw-attach-0abce8655d0bafb83",
    "aws_vpn_connection_id": "vpn-0085c553b38c5deeb",
    "status": {
      "id": 5,
      "description": "Active"
    },
    "type": {
      "id": 3,
      "description": "IPSec VPN BGP"
    },
    "region": "eu-west-2",
    "organisation_id": 123
  }
]
```

**SDK Code**

```python Filter by Status - Active
import requests

url = "https://cdn.emnify.net/api/v1/cnc/breakout"

querystring = {"status":"5"}

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

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

print(response.json())
```

```javascript Filter by Status - Active
const url = 'https://cdn.emnify.net/api/v1/cnc/breakout?status=5';
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 Filter by Status - Active
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/cnc/breakout?status=5"

	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 Filter by Status - Active
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/cnc/breakout?status=5")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/cnc/breakout?status=5")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by Status - Active
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/cnc/breakout?status=5', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by Status - Active
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/cnc/breakout?status=5");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by Status - Active
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/cnc/breakout?status=5")! 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()
```

### Filter by Type - Transit Gateway

**Response**

```json
[
  {
    "id": 104,
    "name": "Attachment to VPC",
    "user_id": 123,
    "creation_date": "2019-10-22T07:59:26.000Z",
    "aws_transit_gateway_attachment_id": "tgw-attach-0f84169771fa2f4a3",
    "status": {
      "id": 5,
      "description": "Active"
    },
    "type": {
      "id": 1,
      "description": "Transit Gateway"
    },
    "region": "eu-west-1",
    "organisation_id": 123
  }
]
```

**SDK Code**

```python Filter by Type - Transit Gateway
import requests

url = "https://cdn.emnify.net/api/v1/cnc/breakout"

querystring = {"type":"1"}

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

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

print(response.json())
```

```javascript Filter by Type - Transit Gateway
const url = 'https://cdn.emnify.net/api/v1/cnc/breakout?type=1';
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 Filter by Type - Transit Gateway
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/cnc/breakout?type=1"

	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 Filter by Type - Transit Gateway
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/cnc/breakout?type=1")

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 Filter by Type - Transit Gateway
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/cnc/breakout?type=1")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by Type - Transit Gateway
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/cnc/breakout?type=1', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by Type - Transit Gateway
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/cnc/breakout?type=1");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by Type - Transit Gateway
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/cnc/breakout?type=1")! 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()
```

### Filter by Status and Type

**Response**

```json
[
  {
    "id": 75,
    "name": "Attachment to StrongSwan",
    "user_id": 123,
    "creation_date": "2019-10-21T10:19:02.000Z",
    "aws_transit_gateway_attachment_id": "tgw-attach-0abce8655d0bafb83",
    "aws_vpn_connection_id": "vpn-0085c553b38c5deeb",
    "status": {
      "id": 5,
      "description": "Active"
    },
    "type": {
      "id": 3,
      "description": "IPSec VPN BGP"
    },
    "region": "eu-west-2",
    "organisation_id": 123
  }
]
```

**SDK Code**

```python Filter by Status and Type
import requests

url = "https://cdn.emnify.net/api/v1/cnc/breakout"

querystring = {"status":"5","type":"3"}

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

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

print(response.json())
```

```javascript Filter by Status and Type
const url = 'https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3';
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 Filter by Status and Type
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3"

	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 Filter by Status and Type
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3")

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 Filter by Status and Type
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by Status and Type
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by Status and Type
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by Status and Type
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/cnc/breakout?status=5&type=3")! 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()
```