> 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 public breakout IP ranges

GET https://cdn.emnify.net/api/v1/breakout_ip_range

Required permissions Beta [Learn more](/developers/api-guidelines/permissions#how-permissions-work)No permission required. Available to all roles.Returns the current public IPv4 egress ranges used for internet breakout,
grouped by breakout region. Use these CIDR ranges to keep firewall and
allowlist rules up to date.

Reference: https://docs.emnify.com/developers/api/lookups/breakout-ip-range-get

## 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).

## Response

### 200

Success

- `updated_at` (string, required) — Date and time when the published dataset was last updated.
- `internet_breakout` (map from string to list of string, required) — Public IPv4 CIDR ranges grouped by breakout region.

## Errors

### 401 Unauthorized Error

Missing or invalid Authorization header.

- `error_code` (integer, optional)
- `error_token` (string, optional)
- `message` (string, optional)

### 403 Forbidden Error

The user does not have permission to list public breakout IP ranges.

- `error_code` (integer, optional)
- `error_token` (string, optional)
- `message` (string, optional)

### 500 Internal Server Error

Unexpected error while checking permissions.

- `error_code` (integer, optional)
- `error_token` (string, optional)
- `message` (string, optional)

## Examples

**Response**

```json
{
  "updated_at": "2026-08-13T13:08:01Z",
  "internet_breakout": {
    "eu-central-1": [
      "185.57.219.0/24"
    ],
    "eu-central-2": [
      "16.62.16.66/32"
    ],
    "eu-west-1": [
      "185.57.216.0/24"
    ]
  }
}
```

**SDK Code**

```python Public Breakout IP Ranges
import requests

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

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

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

print(response.json())
```

```javascript Public Breakout IP Ranges
const url = 'https://cdn.emnify.net/api/v1/breakout_ip_range';
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 Public Breakout IP Ranges
package main

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

func main() {

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

	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 Public Breakout IP Ranges
require 'uri'
require 'net/http'

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

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

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

```php Public Breakout IP Ranges
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp Public Breakout IP Ranges
using RestSharp;

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

```swift Public Breakout IP Ranges
import Foundation

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

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