> 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.iot.telia.lt/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.iot.telia.lt/_mcp/server.

# List endpoints

GET https://iot.telia.lt/api/v1/endpoint

Retrieves all endpoints for your organization.
Use the query parameters to filter, sort, and paginate results.


Reference: https://docs.iot.telia.lt/developers/api/endpoint/get-endpoints

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

- `q` (string, optional) — Filters endpoints by field value. Use `<field>:<criteria>` format. Combine multiple filters with commas (for example, `status:0,tags:sensor`). `connectivity_status` accepts only the value `BLOCKED`, which returns the endpoints that are currently denied service (for example, after exceeding a traffic limit). It takes a single value, so wildcards and `||` lists aren't supported.
- `sort` (string, optional) — Sorts endpoints by field value. Use `<operator><field>` format. Combine multiple sort fields with commas (for example, `-status,id`). **Operators:** * `-` descending (Z-A for text, highest number first) * `+` ascending (A-Z for text, lowest number first) Defaults to ascending order if no operator is specified. Defaults to `id` if no sort field is specified. Endpoints with identical values are sorted by ascending `id`.
- `page` (integer, optional, default: 1) — Page number to retrieve. Starts at 1.
- `per_page` (integer, optional, default: 1000) — Number of endpoints to return per page.

## Response

### 200

Returns an array of endpoint objects. Pagination metadata is included in the response headers.

- `list of ApiV1EndpointGetResponsesContentApplicationJsonSchemaItems`

## Errors

### 403 Forbidden Error

Your role doesn't include the permission this endpoint requires. Most endpoints return `error_code`, `error_token`, and `message`. Some return only `status_code` and `message`.

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

## Types

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItems

- `status` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsStatus, required) — Endpoint connectivity status. Values are `0` (Enabled), `1` (Disabled), or `2` (Deleted).
- `tariff_profile` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTariffProfile, required) — Tariff profile that determines pricing and data limits for this endpoint.
- `service_profile` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsServiceProfile, required) — Service profile that determines network access settings for this endpoint.
- `id` (integer, optional) — Unique identifier for the endpoint.
- `created` (string, optional) — Date and time when the endpoint was created (ISO 8601 format).
- `last_updated` (string, optional) — Date and time when the endpoint was last modified (ISO 8601 format).
- `name` (string, optional) — Display name for the endpoint.
- `tags` (string, optional, nullable) — Comma-separated list of tags. Use `tag_assignments` for structured tag data.
- `ip_address` (string, optional) — Private IP address assigned to this endpoint within the IP address space.
- `imei` (string, optional, nullable) — International Mobile Equipment Identity with Software Version Number (IMEISV) (16 digits).
- `imei_lock` (boolean, optional) — If `true`, this endpoint only allows connections from the device with the specified IMEI.
- `tag_assignments` (list of ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTagAssignmentsItems, optional) — Structured tag data with color information. Alternative to the comma-separated `tags` field.
- `sim` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSim, optional, nullable) — SIM card assigned to this endpoint. `null` if no SIM is assigned.
- `ip_address_space` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsIpAddressSpace, optional) — IP address space that contains this endpoint's private IP address.
- `imei_with_luhn` (string, optional, nullable) — International Mobile Equipment Identity with Luhn check digit, without Software Version Number (SVN) (15 digits).
- `runtime_data` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsRuntimeData, optional) — Real-time network attachment data. Only present when the endpoint is connected.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsStatus

Endpoint connectivity status. Values are `0` (Enabled), `1` (Disabled), or `2` (Deleted).

- `id` (integer, required) — Status ID (`0` = Enabled, `1` = Disabled, `2` = Deleted).
- `description` (string, optional) — Human-readable status name.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTariffProfile

Tariff profile that determines pricing and data limits for this endpoint.

- `id` (integer, required) — Tariff profile ID.
- `name` (string, optional) — Tariff profile name.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsServiceProfile

Service profile that determines network access settings for this endpoint.

- `id` (integer, required) — Service profile ID.
- `name` (string, optional) — Service profile name.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTagAssignmentsItems

- `id` (integer, optional) — Tag ID.
- `name` (string, optional) — Tag name.
- `tag_color` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTagAssignmentsItemsTagColor, optional) — Color assigned to this tag for UI display.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSim

SIM card assigned to this endpoint. `null` if no SIM is assigned.

- `id` (integer, required) — Unique identifier for the SIM.
- `iccid` (string, optional) — Integrated Circuit Card Identifier without Luhn check digit (19 digits).
- `iccid_with_luhn` (string, optional) — Integrated Circuit Card Identifier with Luhn check digit (20 digits).
- `status` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSimStatus, optional) — SIM activation status.
- `imsi` (string, optional) — International Mobile Subscriber Identity. Identifies the SIM on the mobile network.
- `eid` (string, optional) — eUICC Identifier (32 digits). Present only for eSIM-capable SIMs.
- `msisdn` (string, optional) — Phone number assigned to this SIM.
- `sim_profile_type` (ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSimSimProfileType, optional) — Type of SIM profile.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsIpAddressSpace

IP address space that contains this endpoint's private IP address.

- `id` (integer, optional) — IP address space ID.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsRuntimeData

Real-time network attachment data. Only present when the endpoint is connected.

- `msc` (string, optional) — Mobile Switching Center identifier.
- `sgsn` (string, optional) — Serving GPRS Support Node identifier.
- `sgsn_ip_address` (string, optional) — IP address of the SGSN.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsTagAssignmentsItemsTagColor

Color assigned to this tag for UI display.

- `id` (integer, optional) — Color ID.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSimStatus

SIM activation status.

- `id` (integer, required) — Status ID.
- `description` (string, optional) — Human-readable status name.

### ApiV1EndpointGetResponsesContentApplicationJsonSchemaItemsSimSimProfileType

Type of SIM profile.

- `id` (integer, optional) — Profile type ID.

## Examples

### Default - List All Endpoints

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "created": "2024-01-15T10:30:00.000+0000",
    "last_updated": "2026-07-21T17:57:52.922+0300",
    "name": "Weather Station 01",
    "tags": "sensor,outdoor,weather",
    "ip_address": "10.0.0.1",
    "imei": "3561234567890123",
    "imei_lock": true,
    "tag_assignments": [
      {
        "id": 1,
        "name": "sensor",
        "tag_color": {
          "id": 3
        }
      },
      {
        "id": 2,
        "name": "outdoor",
        "tag_color": {
          "id": 5
        }
      },
      {
        "id": 3,
        "name": "weather",
        "tag_color": {
          "id": 7
        }
      }
    ],
    "sim": {
      "id": 500,
      "iccid": "8988303000001234567",
      "iccid_with_luhn": "89883030000012345671",
      "status": {
        "id": 1,
        "description": "Activated"
      },
      "imsi": "901430001234567",
      "msisdn": "882850001234567",
      "sim_profile_type": {
        "id": 1
      }
    },
    "ip_address_space": {
      "id": 1
    },
    "imei_with_luhn": "356123456789015"
  }
]
```

**SDK Code**

```python Default - List All Endpoints
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

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

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

print(response.json())
```

```javascript Default - List All Endpoints
const url = 'https://iot.telia.lt/api/v1/endpoint';
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 - List All Endpoints
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint"

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

url = URI("https://iot.telia.lt/api/v1/endpoint")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Default - List All Endpoints
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Default - List All Endpoints
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Default - List All Endpoints
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint")! 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 ICCID

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01",
    "tags": "sensor,outdoor",
    "tag_assignments": [
      {
        "id": 1,
        "name": "sensor",
        "tag_color": {
          "id": 3
        }
      },
      {
        "id": 2,
        "name": "outdoor",
        "tag_color": {
          "id": 5
        }
      }
    ],
    "sim": {
      "iccid": "8988303000001234567"
    }
  }
]
```

**SDK Code**

```python Filter by ICCID
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"iccid:8988303000001234567"}

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

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

print(response.json())
```

```javascript Filter by ICCID
const url = 'https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567';
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 ICCID
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by ICCID
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by ICCID
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=iccid%3A8988303000001234567")! 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 IMEI with Luhn

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01",
    "imei_with_luhn": "356123456789015"
  }
]
```

**SDK Code**

```python Filter by IMEI with Luhn
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"imei_with_luhn:356123456789015"}

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

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

print(response.json())
```

```javascript Filter by IMEI with Luhn
const url = 'https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015';
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 IMEI with Luhn
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Filter by IMEI with Luhn
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by IMEI with Luhn
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by IMEI with Luhn
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=imei_with_luhn%3A356123456789015")! 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 IMEI

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01",
    "imei": "3561234567890123"
  }
]
```

**SDK Code**

```python Filter by IMEI
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"imei:3561234567890123"}

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

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

print(response.json())
```

```javascript Filter by IMEI
const url = 'https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123';
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 IMEI
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by IMEI
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by IMEI
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=imei%3A3561234567890123")! 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 EID

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 2,
    "name": "Fleet Tracker 02",
    "sim": {
      "eid": "89001012912345678901234567890123"
    }
  }
]
```

**SDK Code**

```python Filter by EID
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"eid:89001012912345678901234567890123"}

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

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

print(response.json())
```

```javascript Filter by EID
const url = 'https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123';
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 EID
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by EID
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by EID
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=eid%3A89001012912345678901234567890123")! 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 tags

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01",
    "tags": "sensor,outdoor",
    "tag_assignments": [
      {
        "id": 1,
        "name": "sensor",
        "tag_color": {
          "id": 3
        }
      },
      {
        "id": 2,
        "name": "outdoor",
        "tag_color": {
          "id": 5
        }
      }
    ]
  }
]
```

**SDK Code**

```python Filter by tags
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"tags:sensor"}

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

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

print(response.json())
```

```javascript Filter by tags
const url = 'https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor';
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 tags
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by tags
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by tags
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=tags%3Asensor")! 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 connectivity status

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 3,
    "name": "Vending Machine 07"
  }
]
```

**SDK Code**

```python Filter by connectivity status
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"connectivity_status:BLOCKED"}

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

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

print(response.json())
```

```javascript Filter by connectivity status
const url = 'https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED';
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 connectivity status
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by connectivity status
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Filter by connectivity status
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=connectivity_status%3ABLOCKED")! 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()
```

### Multiple filters

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01",
    "tags": "sensor,outdoor",
    "tag_assignments": [
      {
        "id": 1,
        "name": "sensor",
        "tag_color": {
          "id": 3
        }
      },
      {
        "id": 2,
        "name": "outdoor",
        "tag_color": {
          "id": 5
        }
      }
    ]
  }
]
```

**SDK Code**

```python Multiple filters
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"q":"status:0,tags:outdoor"}

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

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

print(response.json())
```

```javascript Multiple filters
const url = 'https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor';
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 Multiple filters
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Multiple filters
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Multiple filters
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?q=status%3A0%2Ctags%3Aoutdoor")! 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 status

**Response**

```json
[
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01"
  },
  {
    "status": {
      "id": 1,
      "description": "Disabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 2,
    "name": "Fleet Tracker 02"
  }
]
```

**SDK Code**

```python Sort by status
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"sort":"status"}

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

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

print(response.json())
```

```javascript Sort by status
const url = 'https://iot.telia.lt/api/v1/endpoint?sort=status';
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 status
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?sort=status"

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

url = URI("https://iot.telia.lt/api/v1/endpoint?sort=status")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?sort=status")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?sort=status', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Sort by status
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?sort=status");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Sort by status
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?sort=status")! 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 descending with secondary sort

**Response**

```json
[
  {
    "status": {
      "id": 1,
      "description": "Disabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 2,
    "name": "Fleet Tracker 02"
  },
  {
    "status": {
      "id": 0,
      "description": "Enabled"
    },
    "tariff_profile": {
      "id": 100,
      "name": "Global IoT Plan"
    },
    "service_profile": {
      "id": 200,
      "name": "Standard IoT"
    },
    "id": 1,
    "name": "Weather Station 01"
  }
]
```

**SDK Code**

```python Sort descending with secondary sort
import requests

url = "https://iot.telia.lt/api/v1/endpoint"

querystring = {"sort":"-status,id"}

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

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

print(response.json())
```

```javascript Sort descending with secondary sort
const url = 'https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid';
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 descending with secondary sort
package main

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

func main() {

	url := "https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid"

	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 descending with secondary sort
require 'uri'
require 'net/http'

url = URI("https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid")

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

HttpResponse<String> response = Unirest.get("https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Sort descending with secondary sort
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Sort descending with secondary sort
using RestSharp;

var client = new RestClient("https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Sort descending with secondary sort
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://iot.telia.lt/api/v1/endpoint?sort=-status%2Cid")! 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()
```