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

# List enabled inference models

GET https://api.islo.dev/inference/models

Reference: https://docs.islo.dev/api-reference/inference/list-inference-models

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Response

### 200

Successful Response

- `effort` (EffortCatalog, optional) — Everything about reasoning effort, in one place. Deliberately not on `InferenceModelCatalogEntry`: that row exists for gateway egress allowlisting, alias rewriting and billing, and effort is a harness CLI concern with no bearing on any of them.
- `models` (list of InferenceModelCatalogEntry, optional)

## Errors

### 401 Unauthorized Error

Unauthorized

- `code` (enum, required)
  - Allowed values: `AUTH_REQUIRED`, `INVALID_REQUEST`, `NOT_FOUND`, `VALIDATION_ERROR`, `SANDBOX_NOT_FOUND`, `SANDBOX_ALREADY_EXISTS`, `SANDBOX_INVALID_STATE`, `SANDBOX_PROVISIONING_FAILED`, `RESOURCE_NOT_FOUND`, `FILE_NOT_FOUND`, `COMMAND_NOT_FOUND`, `EXEC_FAILED`, `FILE_OPERATION_ERROR`, `RESOURCE_UNAVAILABLE`, `ACCESS_DENIED`, `CACHE_CONFLICT`, `BILLING_NOT_ALLOWED`, `TENANT_SUSPENDED`, `TENANT_DELETED`, `RATE_LIMITED`, `TIMEOUT`, `GONE`, `BAD_GATEWAY`, `INTERNAL_ERROR`
- `message` (string, required)
- `available` (long, optional, nullable)
- `limit` (long, optional, nullable)
- `request_id` (string, optional, nullable)
- `requested` (long, optional, nullable)
- `resource` (string, optional, nullable) — Optional capacity fields populated for `InsufficientResources` errors so clients (including peer agents) can recover the typed payload across HTTP boundaries instead of collapsing it to an opaque message.

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

## Types

### EffortCatalog

Everything about reasoning effort, in one place. Deliberately not on `InferenceModelCatalogEntry`: that row exists for gateway egress allowlisting, alias rewriting and billing, and effort is a harness CLI concern with no bearing on any of them.

- `aliases` (list of EffortAlias, optional)
- `levels` (list of EffortLevelRule, optional)

### InferenceModelCatalogEntry

- `id` (string, required)
- `upstream_model_id` (string, required)
- `aliases` (list of string, optional)
- `cache_write_input_cents_per_1m_tokens` (string, optional, nullable)
- `cached_input_cents_per_1m_tokens` (string, optional, nullable)
- `client_apis` (list of enum, optional)
  - Allowed values: `openai_chat_completions`, `openai_responses`, `anthropic_messages`, `typesafe_system_one`
- `display_name` (string, optional, nullable)
- `enabled` (boolean, optional, default: true)
- `input_cents_per_1m_tokens` (string, optional, nullable)
- `output_cents_per_1m_tokens` (string, optional, nullable)
- `pricing_tiers` (list of PricingTier, optional, nullable)
- `upstream_provider` (enum, optional)
  - Allowed values: `fireworks`, `anthropic`, `openai`, `xai`, `thesean`, `databricks`, `alien`, `valarai`, `typesafe`

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)
- `ctx` (ValidationErrorCtx, optional)
- `input` (any, optional)

### EffortAlias

A `(model, effort)` pair and the harness model id it resolves to. Only needed where the harness encodes effort in the id rather than taking a flag. `effort: None` marks the pair a bare model resolves through, which is the only way `cursor-grok-4.6` works — it is not a usable id on its own. Those null rows pin a reasoning level for every bare-base manifest, so their provenance matters: each is the row `cursor-agent --list-models` labels with no effort word, which is how Cursor marks a family's own default. Hence `gpt-5.6-sol` → `-medium` ("GPT-5.6 Sol 1M") while the other four → `-high`. Confirmed by running each bare base and reading back the resolved model name. Regenerate from the CLI rather than editing by hand, and strip the `(current)` suffix the CLI appends to whichever model is selected.

- `harness` (enum, required)
  - Allowed values: `codex`, `cursor`, `claude`, `opencode`
- `id` (string, required)
- `model` (string, required)
- `effort` (string, optional, nullable)

### EffortLevelRule

Which effort tokens are legal, for one harness or one harness+model. Keyed this way because that is how the data actually is. `claude --effort` reports the same five values whatever `--model` is set to, and codex's `model_reasoning_effort` is a static API enum — both are harness facts, not model facts. Cursor is the exception: its token is part of the model id, so every family has its own set. `model: None` is the harness default. A row naming a model overrides it, including to `[]` for the nano and image rows, which cannot reason. No matching row means the harness has no effort control. Cursor deliberately has no default: its token is part of the model id, so a model outside the transcribed families has no vocabulary to offer, and validation falls through to the alias guard rather than guessing one.

- `harness` (enum, required)
  - Allowed values: `codex`, `cursor`, `claude`, `opencode`
- `label` (string, optional, nullable) — Display name for a harness model absent from the models array. Only set where the picker has no other source for it.
- `levels` (list of string, optional)
- `model` (string, optional, nullable)

### PricingTier

- `cached_input_cents_per_1m_tokens` (string, required)
- `input_cents_per_1m_tokens` (string, required)
- `output_cents_per_1m_tokens` (string, required)
- `cache_write_input_cents_per_1m_tokens` (string, optional, nullable)
- `max_input_tokens` (integer, optional, nullable)
- `min_input_tokens` (integer, optional, default: 0)

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## Examples

**Response**

```json
{
  "effort": {
    "aliases": [
      {
        "harness": "codex",
        "id": "string",
        "model": "string",
        "effort": "string"
      }
    ],
    "levels": [
      {
        "harness": "codex",
        "label": "string",
        "levels": [
          "string"
        ],
        "model": "string"
      }
    ]
  },
  "models": [
    {
      "id": "string",
      "upstream_model_id": "string",
      "aliases": [
        "string"
      ],
      "cache_write_input_cents_per_1m_tokens": "string",
      "cached_input_cents_per_1m_tokens": "string",
      "client_apis": [
        "openai_chat_completions"
      ],
      "display_name": "string",
      "enabled": true,
      "input_cents_per_1m_tokens": "string",
      "output_cents_per_1m_tokens": "string",
      "pricing_tiers": [
        {
          "cached_input_cents_per_1m_tokens": "string",
          "input_cents_per_1m_tokens": "string",
          "output_cents_per_1m_tokens": "string",
          "cache_write_input_cents_per_1m_tokens": "string",
          "max_input_tokens": 1,
          "min_input_tokens": 0
        }
      ],
      "upstream_provider": "fireworks"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.islo.dev/inference/models"

headers = {
    "X-Islo-Api-Version": "X-Islo-Api-Version",
    "Authorization": "Bearer <api_key>"
}

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

print(response.json())
```

```javascript
const url = 'https://api.islo.dev/inference/models';
const options = {
  method: 'GET',
  headers: {'X-Islo-Api-Version': 'X-Islo-Api-Version', Authorization: 'Bearer <api_key>'}
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://api.islo.dev/inference/models"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-Islo-Api-Version", "X-Islo-Api-Version")
	req.Header.Add("Authorization", "Bearer <api_key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.islo.dev/inference/models")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-Islo-Api-Version"] = 'X-Islo-Api-Version'
request["Authorization"] = 'Bearer <api_key>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.islo.dev/inference/models")
  .header("X-Islo-Api-Version", "X-Islo-Api-Version")
  .header("Authorization", "Bearer <api_key>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.islo.dev/inference/models', [
  'headers' => [
    'Authorization' => 'Bearer <api_key>',
    'X-Islo-Api-Version' => 'X-Islo-Api-Version',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.islo.dev/inference/models");
var request = new RestRequest(Method.GET);
request.AddHeader("X-Islo-Api-Version", "X-Islo-Api-Version");
request.AddHeader("Authorization", "Bearer <api_key>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "X-Islo-Api-Version": "X-Islo-Api-Version",
  "Authorization": "Bearer <api_key>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.islo.dev/inference/models")! 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()
```