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

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

Required permissions Beta [Learn more](/developers/api-guidelines/permissions#how-permissions-work)`Sim` + `List`Roles: Administrator User ObserverReturns a list of SIMs filtered, sorted, and paged according to query parameters.

Reference: https://docs.emnify.com/developers/api/sim/sim-per-page-sort-by-q-and-page-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).

## Request

### Query parameters

- `q` (string, optional) — Filter parameter in `<field>:<criteria>` format. Expects a comma-separated list from the allowed fields: * `id` * `issuer_org` * `reseller_org` * `customer_org` * `iccid` * `iccid_with_luhn` * `status` * `production_date` * `imsi` * `msisdn` * `endpoint` * `model` * `eid` * `satellite_capable`
- `sort` (string, optional) — Sort parameter in `<operator><field>` format. Sort properties according to a comma-separated list from the allowed fields: * `id` * `issuer_org` * `reseller_org` * `customer_org` * `iccid` * `eid` * `status` * `production_date` * `endpoint` * `model` If no sorting options are specified, the response will be sorted by `id`. Supported operators: * `-`: Descending order * `+`: Ascending order The response will be shown in ascending order if no operator is specified.
- `page` (integer, optional) — Current page number
- `per_page` (integer, optional, default: 2000) — Defines the number of items per page (max. 2500)

## Response

### 200

Successfully returned a list of SIMs.

- `list of ApiV1SimGetResponsesContentApplicationJsonSchemaItems`

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

### ApiV1SimGetResponsesContentApplicationJsonSchemaItems

- `id` (integer, optional)
- `iccid` (string, optional)
- `eid` (string, optional)
- `production_date` (string, optional)
- `activation_date` (string, optional)
- `status` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsStatus, optional)
- `customer_org` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsCustomerOrg, optional)
- `issuer_org` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsIssuerOrg, optional)
- `reseller_org` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsResellerOrg, optional)
- `endpoint` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsEndpoint, optional)
- `imsi` (string, optional)
- `msisdn` (string, optional)
- `model` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModel, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsStatus

- `id` (integer, required)
- `description` (string, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsCustomerOrg

- `id` (integer, optional)
- `name` (string, optional)
- `country` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsCustomerOrgCountry, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsIssuerOrg

- `id` (integer, optional)
- `name` (string, optional)
- `country` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsIssuerOrgCountry, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsResellerOrg

- `id` (integer, optional)
- `name` (string, optional)
- `country` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsResellerOrgCountry, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsEndpoint

- `id` (integer, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModel

- `id` (integer, optional)
- `description` (string, optional)
- `memory_size` (integer, optional)
- `formfactor` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModelFormfactor, optional)
- `manufacturer` (ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModelManufacturer, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsCustomerOrgCountry

- `id` (integer, optional)
- `name` (string, optional)
- `country_code` (integer, optional)
- `mcc` (integer, optional)
- `iso_code` (string, optional)
- `latitude` (float, optional)
- `longitude` (float, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsIssuerOrgCountry

- `id` (integer, optional)
- `name` (string, optional)
- `country_code` (integer, optional)
- `mcc` (integer, optional)
- `iso_code` (string, optional)
- `latitude` (float, optional)
- `longitude` (float, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsResellerOrgCountry

- `id` (integer, optional)
- `name` (string, optional)
- `country_code` (integer, optional)
- `mcc` (integer, optional)
- `iso_code` (string, optional)
- `latitude` (float, optional)
- `longitude` (float, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModelFormfactor

- `id` (integer, optional)
- `name` (string, optional)

### ApiV1SimGetResponsesContentApplicationJsonSchemaItemsModelManufacturer

- `id` (integer, optional)
- `name` (string, optional)

## Examples

### Default - List All SIMs

**Response**

```json
[
  {
    "id": 123457,
    "iccid": "8988303000123456789",
    "eid": "89049011803455664400046832584675",
    "production_date": "2019-08-01T11:49:46.000+0000",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization",
      "country": {
        "id": 74,
        "name": "Germany"
      }
    },
    "issuer_org": {
      "id": 2,
      "name": "Example Issuer",
      "country": {
        "id": 219,
        "name": "NonTerrestrial 883"
      }
    },
    "endpoint": {
      "id": 12345,
      "ip_address": "10.1.1.2",
      "name": "endpoint 2",
      "tags": null
    },
    "imsi": "123456789123456",
    "msisdn": "12345678912",
    "model": {
      "id": 8,
      "description": "Classic",
      "formfactor": {
        "id": 6,
        "name": "1/2/3FF (3in1)"
      }
    },
    "iccid_with_luhn": "89883030001234567890"
  }
]
```

**SDK Code**

```python Default - List All SIMs
import requests

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

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

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

print(response.json())
```

```javascript Default - List All SIMs
const url = 'https://cdn.emnify.net/api/v1/sim';
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 SIMs
package main

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

func main() {

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

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

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

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

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

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

$client = new \GuzzleHttp\Client();

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

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

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

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

```swift Default - List All SIMs
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/sim")! 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
[
  {
    "id": 456789,
    "iccid": "8988303000008013931",
    "production_date": "2020-03-15T08:22:10.000+0000",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    },
    "issuer_org": {
      "id": 2,
      "name": "Example Issuer"
    },
    "iccid_with_luhn": "89883030000080139312"
  }
]
```

**SDK Code**

```python Filter by ICCID
import requests

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

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

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

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

print(response.json())
```

```javascript Filter by ICCID
const url = 'https://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931';
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://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931"

	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://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931")

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://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by ICCID
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931");
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://cdn.emnify.net/api/v1/sim?q=iccid%3A8988303000008013931")! 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 SIM ID

**Response**

```json
[
  {
    "id": 123,
    "iccid": "8988303000012345678",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    }
  }
]
```

**SDK Code**

```python Filter by SIM ID
import requests

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

querystring = {"q":"id:123"}

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

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

print(response.json())
```

```javascript Filter by SIM ID
const url = 'https://cdn.emnify.net/api/v1/sim?q=id%3A123';
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 SIM ID
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/sim?q=id%3A123"

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

url = URI("https://cdn.emnify.net/api/v1/sim?q=id%3A123")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/sim?q=id%3A123")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/sim?q=id%3A123', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by SIM ID
using RestSharp;

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

```swift Filter by SIM ID
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/sim?q=id%3A123")! 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
[
  {
    "id": 789012,
    "iccid": "8988303000098765432",
    "eid": "89049011803455664400046832584675",
    "production_date": "2021-05-20T14:30:00.000+0000",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    }
  }
]
```

**SDK Code**

```python Filter by EID
import requests

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

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

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

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

print(response.json())
```

```javascript Filter by EID
const url = 'https://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675';
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://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675"

	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://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675")

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://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by EID
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675");
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://cdn.emnify.net/api/v1/sim?q=eid%3A89049011803455664400046832584675")! 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 Satellite Capability

**Response**

```json
[
  {
    "id": 234567,
    "iccid": "8988303000023456789",
    "production_date": "2023-01-10T09:15:30.000+0000",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    },
    "satellite_capable": true
  }
]
```

**SDK Code**

```python Filter by Satellite Capability
import requests

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

querystring = {"q":"satellite_capable:true"}

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

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

print(response.json())
```

```javascript Filter by Satellite Capability
const url = 'https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue';
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 Satellite Capability
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue"

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

url = URI("https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue")

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

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Filter by Satellite Capability
using RestSharp;

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

```swift Filter by Satellite Capability
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/sim?q=satellite_capable%3Atrue")! 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 - Model and Issuer Organization

**Response**

```json
[
  {
    "id": 345678,
    "iccid": "8988303000034567890",
    "production_date": "2022-07-18T16:45:00.000+0000",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    },
    "issuer_org": {
      "id": 11,
      "name": "Specific Issuer"
    },
    "model": {
      "id": 1,
      "description": "Standard"
    }
  }
]
```

**SDK Code**

```python Multiple Filters - Model and Issuer Organization
import requests

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

querystring = {"q":"model:1,issuer_org:11"}

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

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

print(response.json())
```

```javascript Multiple Filters - Model and Issuer Organization
const url = 'https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11';
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 - Model and Issuer Organization
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11"

	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 - Model and Issuer Organization
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11")

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 - Model and Issuer Organization
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php Multiple Filters - Model and Issuer Organization
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Multiple Filters - Model and Issuer Organization
using RestSharp;

var client = new RestClient("https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Multiple Filters - Model and Issuer Organization
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://cdn.emnify.net/api/v1/sim?q=model%3A1%2Cissuer_org%3A11")! 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 and ID (Descending)

**Response**

```json
[
  {
    "id": 123456,
    "iccid": "8988303000012345678",
    "status": {
      "id": 2,
      "description": "Suspended"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    }
  },
  {
    "id": 123457,
    "iccid": "8988303000123456789",
    "status": {
      "id": 1,
      "description": "Activated"
    },
    "customer_org": {
      "id": 1234,
      "name": "Example Organization"
    }
  }
]
```

**SDK Code**

```python Sort by Status and ID (Descending)
import requests

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

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

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

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

print(response.json())
```

```javascript Sort by Status and ID (Descending)
const url = 'https://cdn.emnify.net/api/v1/sim?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 by Status and ID (Descending)
package main

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

func main() {

	url := "https://cdn.emnify.net/api/v1/sim?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 by Status and ID (Descending)
require 'uri'
require 'net/http'

url = URI("https://cdn.emnify.net/api/v1/sim?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 by Status and ID (Descending)
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

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

```php Sort by Status and ID (Descending)
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

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

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

```csharp Sort by Status and ID (Descending)
using RestSharp;

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

```swift Sort by Status and ID (Descending)
import Foundation

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

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