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

# Retrieve Flow Logs by destination

GET https://cdn.emnify.net/api/v1/endpoint/{endpointId}/flowlogs/destination

Required permissions Beta [Learn more](/developers/api-guidelines/permissions#how-permissions-work)`Endpoint.FlowLogs.Destination` + `List`Roles: AdministratorRetrieves Flow Log activity for an endpoint, grouped by destination hostname, IP address, port, and protocol.By default, the response covers the last hour.
Use `started_from` in the `q` parameter to look back up to **30 days**.Filters follow the standard `q=<field>:<criteria>` syntax:- Combine multiple filters on different fields with `,` (AND).
- Combine multiple values for the same field with `||` (OR).Use `sort` to order the results and `page` / `per_page` to paginate.

Reference: https://docs.emnify.com/developers/api/flow-logs/list-endpoint-flow-logs-by-destination

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

### Path parameters

- `endpointId` (double, required)

### Query parameters

- `per_page` (integer, optional, default: 25) — Number of destination groups to return per page.
- `page` (integer, optional, default: 1) — Page number to retrieve. Starts at `1`.
- `sort` (string, optional, default: -started_on) — Sorts destination groups by field value. Use `<operator><field>` format. Operators: `-` descending, `+` ascending. You can also combine multiple sort fields with commas (for example, `-started_on,destination_hostname`).
- `q` (string, optional) — Filters destination groups by field value. Use `<field>:<criteria>` format. Combine multiple filters with commas (for example, `protocol:TCP,destination_hostname:api.example.com`). Use `||` within one field for multiple values (for example, `protocol:TCP||UDP`). Time window (optional, each as `<field>:<ISO-8601 UTC>`): * `started_from` - Lower bound on flow start * Defaults to 1 hour ago * Maximum look-back 30 days. * `started_until` - Upper bound on flow start * Defaults to now. * `completed_from` / `completed_until` - Bounds on flow completion time. Window fields must use `:` only (no other operators).

## Response

### 200

Destination groups for the requested window.

- `list of ApiV1EndpointEndpointIdFlowlogsDestinationGetResponsesContentApplicationJsonSchemaItems`

## Errors

### 400 Bad Request Error

The request is malformed. Common causes: - Invalid filter expression syntax in `q` - Invalid value for a filter or sort field - Datetime not in ISO-8601 format - Requested window exceeds the 30-day maximum

- `status_code` (integer, optional)
- `message` (string, optional)

### 401 Unauthorized Error

No token given.

- `message` (string, optional)

### 403 Forbidden Error

Caller lacks permission or the feature is not enabled for the organization.

- `status_code` (integer, optional)
- `message` (string, optional)

### 404 Not Found Error

Endpoint with ID \<number> not found.

- `status_code` (integer, optional)
- `message` (string, optional)

## Types

### ApiV1EndpointEndpointIdFlowlogsDestinationGetResponsesContentApplicationJsonSchemaItems

- `destination_hostname` (string, optional, nullable) — Hostname of the destination, if resolved.
- `destination_ip` (string, optional) — IP address of the destination.
- `destination_port` (integer, optional) — Destination port number.
- `protocol` (string, optional) — Transport protocol (for example, `TCP`, `UDP`).
- `started_on` (string, optional) — Earliest start time across the aggregated flows.
- `completed_on` (string, optional) — Latest completion time across the aggregated flows.
- `bytes_up` (integer, optional) — Total bytes uploaded to the destination.
- `bytes_down` (integer, optional) — Total bytes downloaded from the destination.
- `flow_count` (integer, optional) — Number of flows aggregated into this destination group.

## Examples

### Default - Last Hour

**Response**

```json
[
  {
    "destination_hostname": "api.example.com",
    "destination_ip": "93.184.216.34",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T13:42:17.000Z",
    "completed_on": "2026-05-11T13:58:04.000Z",
    "bytes_up": 18432,
    "bytes_down": 245760,
    "flow_count": 27
  },
  {
    "destination_hostname": null,
    "destination_ip": "203.0.113.45",
    "destination_port": 53,
    "protocol": "UDP",
    "started_on": "2026-05-11T13:40:02.000Z",
    "completed_on": "2026-05-11T13:55:11.000Z",
    "bytes_up": 1840,
    "bytes_down": 5120,
    "flow_count": 12
  }
]
```

**SDK Code**

```python Default - Last Hour
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

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

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

print(response.json())
```

```javascript Default - Last Hour
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination';
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 - Last Hour
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

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

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination")

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

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

```php Default - Last Hour
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp Default - Last Hour
using RestSharp;

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

```swift Default - Last Hour
import Foundation

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

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

**Response**

```json
[
  {
    "destination_hostname": "example.com\"",
    "destination_ip": "151.101.1.140",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T13:44:03.000Z",
    "completed_on": "2026-05-11T13:57:18.000Z",
    "bytes_up": 9216,
    "bytes_down": 184320,
    "flow_count": 14
  }
]
```

**SDK Code**

```python Filter by Hostname
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

querystring = {"q":"destination_hostname:example.com"}

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

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

print(response.json())
```

```javascript Filter by Hostname
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com';
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 Hostname
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com"

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

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by Hostname
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by Hostname
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=destination_hostname%3Aexample.com")! 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()
```

### Sort by Bytes Uploaded

**Response**

```json
[
  {
    "destination_hostname": "api.example.com",
    "destination_ip": "93.184.216.34",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T13:42:17.000Z",
    "completed_on": "2026-05-11T13:58:04.000Z",
    "bytes_up": 18432,
    "bytes_down": 245760,
    "flow_count": 27
  },
  {
    "destination_hostname": null,
    "destination_ip": "203.0.113.45",
    "destination_port": 53,
    "protocol": "UDP",
    "started_on": "2026-05-11T13:40:02.000Z",
    "completed_on": "2026-05-11T13:55:11.000Z",
    "bytes_up": 1840,
    "bytes_down": 5120,
    "flow_count": 12
  }
]
```

**SDK Code**

```python Sort by Bytes Uploaded
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

querystring = {"sort":"-bytes_up"}

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

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

print(response.json())
```

```javascript Sort by Bytes Uploaded
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up';
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 Sort by Bytes Uploaded
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up"

	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 Sort by Bytes Uploaded
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Sort by Bytes Uploaded
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Sort by Bytes Uploaded
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Sort by Bytes Uploaded
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?sort=-bytes_up")! 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()
```

### Custom Start Date

**Response**

```json
[
  {
    "destination_hostname": "telemetry.example.com",
    "destination_ip": "198.51.100.10",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T12:15:00.000Z",
    "completed_on": "2026-05-11T12:45:00.000Z",
    "bytes_up": 4096,
    "bytes_down": 65536,
    "flow_count": 8
  }
]
```

**SDK Code**

```python Custom Start Date
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

querystring = {"q":"started_from:2026-05-11T12:00:00.000Z"}

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

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

print(response.json())
```

```javascript Custom Start Date
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z';
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 Custom Start Date
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z"

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

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Custom Start Date
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Custom Start Date
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z")! 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()
```

### Custom Upper Bound

**Response**

```json
[
  {
    "destination_hostname": "updates.example.com",
    "destination_ip": "192.0.2.44",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T12:30:00.000Z",
    "completed_on": "2026-05-11T12:59:59.000Z",
    "bytes_up": 2048,
    "bytes_down": 32768,
    "flow_count": 5
  }
]
```

**SDK Code**

```python Custom Upper Bound
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

querystring = {"q":"started_until:2026-05-11T13:00:00.000Z"}

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

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

print(response.json())
```

```javascript Custom Upper Bound
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z';
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 Custom Upper Bound
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z"

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

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Custom Upper Bound
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Custom Upper Bound
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_until%3A2026-05-11T13%3A00%3A00.000Z")! 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()
```

### Apply a Filter, Sort, and Start Date

**Response**

```json
[
  {
    "destination_hostname": "example.com\"",
    "destination_ip": "151.101.1.140",
    "destination_port": 443,
    "protocol": "TCP",
    "started_on": "2026-05-11T12:20:00.000Z",
    "completed_on": "2026-05-11T12:55:00.000Z",
    "bytes_up": 12288,
    "bytes_down": 98304,
    "flow_count": 11
  }
]
```

**SDK Code**

```python Apply a Filter, Sort, and Start Date
import requests

url = "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination"

querystring = {"q":"started_from:2026-05-11T12:00:00.000Z,destination_hostname:example.com","sort":"-bytes_up"}

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

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

print(response.json())
```

```javascript Apply a Filter, Sort, and Start Date
const url = 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up';
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 Apply a Filter, Sort, and Start Date
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up"

	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 Apply a Filter, Sort, and Start Date
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up")

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 Apply a Filter, Sort, and Start Date
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Apply a Filter, Sort, and Start Date
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Apply a Filter, Sort, and Start Date
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Apply a Filter, Sort, and Start Date
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/endpoint/12345/flowlogs/destination?q=started_from%3A2026-05-11T12%3A00%3A00.000Z%2Cdestination_hostname%3Aexample.com&sort=-bytes_up")! 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()
```