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

# List all providers (public)

GET https://api.talkif.ai/api/v1/models

GET /api/v1/models

Reference: https://docs.talkif.ai/api-reference/ai-models/list-providers-public

## Request

### Query parameters

- `useCase` (string, optional) — Filter by use case

## Response

### 200

All providers with models and pricing (public)

- `llm` (list of LlmProvider, required) — LLM providers with models and pricing
- `stt` (list of SttProvider, required) — STT providers with models and pricing
- `tts` (list of TtsProvider, required) — TTS providers with models and pricing

## Types

### LlmProvider

LLM provider with models and pricing

- `displayName` (string, required) — Display name (e.g., "OpenAI", "Anthropic")
- `models` (list of LlmModel, required) — Available models with pricing
- `provider` (string, required) — Provider identifier (e.g., "openai", "anthropic")

### SttProvider

STT provider with models and pricing

- `displayName` (string, required) — Display name (e.g., "Deepgram")
- `models` (list of SttModel, required) — Available models with pricing
- `provider` (string, required) — Provider identifier (e.g., "deepgram")

### TtsProvider

TTS provider with models and pricing

- `displayName` (string, required) — Display name (e.g., "ElevenLabs")
- `models` (list of TtsModel, required) — Available models with pricing
- `provider` (string, required) — Provider identifier (e.g., "elevenlabs")

### LlmModel

LLM model with pricing information

- `capabilities` (LlmCapabilities, required) — Model capabilities
- `modelId` (string, required) — Model identifier (e.g., "gpt-4o", "claude-3-5-sonnet")
- `name` (string, required) — Display name (e.g., "GPT-4o", "Claude 3.5 Sonnet")
- `contextWindow` (long, optional, nullable) — Context window size (tokens)
- `deprecation` (ModelDeprecation, optional, nullable) — Scheduled retirement of a model. Until `retiresOn` the model works as usual; from that day calls that name it run on `replacedBy` instead, so published agents keep working without changes.
- `description` (string, optional, nullable) — Model description
- `pricing` (LlmPricing, optional, nullable) — LLM pricing from database

### SttModel

STT model with pricing information

- `capabilities` (SttCapabilities, required) — Model capabilities
- `languages` (list of LanguageInfo, required) — Supported languages
- `modelId` (string, required) — Model identifier (e.g., "nova-2")
- `name` (string, required) — Display name (e.g., "Nova 2")
- `deprecation` (ModelDeprecation, optional, nullable) — Scheduled retirement of a model. Until `retiresOn` the model works as usual; from that day calls that name it run on `replacedBy` instead, so published agents keep working without changes.
- `description` (string, optional, nullable) — Model description
- `pricing` (SttPricing, optional, nullable) — STT pricing from database

### TtsModel

TTS model with pricing information

- `capabilities` (TtsCapabilities, required) — Model capabilities
- `languages` (list of LanguageInfo, required) — Supported languages
- `modelId` (string, required) — Model identifier (e.g., "eleven_turbo_v2_5")
- `name` (string, required) — Display name (e.g., "Turbo v2.5")
- `deprecation` (ModelDeprecation, optional, nullable) — Scheduled retirement of a model. Until `retiresOn` the model works as usual; from that day calls that name it run on `replacedBy` instead, so published agents keep working without changes.
- `description` (string, optional, nullable) — Model description
- `pricing` (TtsPricing, optional, nullable) — TTS pricing from database

### LlmCapabilities

LLM model capabilities

- `functionCalling` (boolean, required) — Supports function/tool calling
- `hasPriorityTier` (boolean, required) — Has priority tier option (typically 2x standard pricing)
- `jsonMode` (boolean, required) — Supports JSON mode
- `reasoning` (boolean, required) — Supports a reasoning/thinking mode
- `reasoningEffort` (list of string, required) — Effort values this model accepts for `reasoningEffort` on a flow's LLM service. Empty means the model takes no effort value — either it has no reasoning mode, or it uses an older budget-token API that rejects `effort` outright. Clients must offer only these values; anything else is stripped server-side before the flow reaches the bot.
- `streaming` (boolean, required) — Supports streaming
- `temperature` (boolean, required) — Supports custom temperature values (false for gpt-5 family with reasoning on by default)
- `vision` (boolean, required) — Supports vision/images

### ModelDeprecation

Scheduled retirement of a model. Until `retiresOn` the model works as usual; from that day calls that name it run on `replacedBy` instead, so published agents keep working without changes.

- `replacedBy` (string, required) — Model from the same provider that runs instead.
- `retiresOn` (string, required) — First day the model no longer runs (UTC date).

### LlmPricing

LLM pricing from database

- `inputPer1mTokensDisplay` (string, required) — Human-readable input rate (e.g., "$2.50")
- `inputPer1mTokensMicrocents` (long, required) — Rate per 1M input tokens in microcents
- `outputPer1mTokensDisplay` (string, required) — Human-readable output rate (e.g., "$10.00")
- `outputPer1mTokensMicrocents` (long, required) — Rate per 1M output tokens in microcents

### SttCapabilities

STT model capabilities

- `diarization` (boolean, required) — Supports speaker diarization
- `multilingual` (boolean, required) — Supports multiple languages in same audio
- `noiseHandling` (boolean, required) — Handles background noise
- `streaming` (boolean, required) — Supports real-time streaming
- `telephony` (boolean, required) — Optimized for telephony/phone calls

### LanguageInfo

Language information for API responses

- `code` (string, required) — Language code (e.g., "en", "es")
- `name` (string, required) — Display name in English (e.g., "English", "Spanish")
- `nativeName` (string, required) — Native name (e.g., "English", "Espanol")

### SttPricing

STT pricing from database

- `ratePerMinuteDisplay` (string, required) — Human-readable rate (e.g., "$0.0077")
- `ratePerMinuteMicrocents` (long, required) — Rate per minute in microcents

### TtsCapabilities

TTS model capabilities

- `emotion` (boolean, required) — Supports emotion control (Cartesia Sonic v3)
- `speakerBoost` (boolean, required) — Supports speaker boost (ElevenLabs)
- `speedControl` (boolean, required) — Supports speed control (Cartesia Sonic v3)
- `streaming` (boolean, required) — Supports streaming output
- `style` (boolean, required) — Supports style parameter (ElevenLabs)
- `voiceConversion` (boolean, required) — Supports voice conversion (ElevenLabs)
- `volumeControl` (boolean, required) — Supports volume control (Cartesia Sonic v3)
- `emotionOptions` (list of EmotionOption, optional, nullable) — Available emotion options (only present when emotion=true)
- `generationConfigSchema` (GenerationConfigSchema, optional, nullable) — Generation config schema for Cartesia Sonic v3

### TtsPricing

TTS pricing from database

- `ratePer1kCharsDisplay` (string, required) — Human-readable rate (e.g., "$0.10")
- `ratePer1kCharsMicrocents` (long, required) — Rate per 1000 characters in microcents (1 cent = 10,000 microcents)

### EmotionOption

Selectable emotion for a TTS voice.

- `label` (string, required) — Human-readable display name
- `value` (string, required) — Emotion value to send to API

### GenerationConfigSchema

Generation config schema for Cartesia Sonic v3

- `speed` (RangeSchema, required) — Speed range configuration
- `volume` (RangeSchema, required) — Volume range configuration

### RangeSchema

Range schema for numeric parameters

- `default` (double, required) — Default value
- `max` (double, required) — Maximum value
- `min` (double, required) — Minimum value
- `step` (double, required) — Step increment for UI sliders

## Examples

**Response**

```json
{
  "llm": [
    {
      "displayName": "OpenAI",
      "models": [
        {
          "capabilities": {
            "functionCalling": true,
            "hasPriorityTier": false,
            "jsonMode": true,
            "reasoning": true,
            "reasoningEffort": [
              "low",
              "medium",
              "high",
              "xhigh",
              "max"
            ],
            "streaming": true,
            "temperature": true,
            "vision": true
          },
          "modelId": "gpt-4o",
          "name": "GPT-4o",
          "contextWindow": 128000,
          "deprecation": {
            "replacedBy": "eleven_v4_turbo",
            "retiresOn": "2026-10-13"
          },
          "description": "Multimodal model with strong reasoning and fast inference",
          "pricing": {
            "inputPer1mTokensDisplay": "$2.50",
            "inputPer1mTokensMicrocents": 2500000,
            "outputPer1mTokensDisplay": "$10.00",
            "outputPer1mTokensMicrocents": 10000000
          }
        }
      ],
      "provider": "openai"
    }
  ],
  "stt": [
    {
      "displayName": "Deepgram",
      "models": [
        {
          "capabilities": {
            "diarization": true,
            "multilingual": false,
            "noiseHandling": true,
            "streaming": true,
            "telephony": true
          },
          "languages": [
            {
              "code": "en",
              "name": "English",
              "nativeName": "English"
            }
          ],
          "modelId": "nova-2",
          "name": "Nova 2",
          "deprecation": {
            "replacedBy": "eleven_v4_turbo",
            "retiresOn": "2026-10-13"
          },
          "description": "High-accuracy speech recognition optimized for telephony",
          "pricing": {
            "ratePerMinuteDisplay": "$0.0077",
            "ratePerMinuteMicrocents": 7700
          }
        }
      ],
      "provider": "deepgram"
    }
  ],
  "tts": [
    {
      "displayName": "ElevenLabs",
      "models": [
        {
          "capabilities": {
            "emotion": false,
            "speakerBoost": true,
            "speedControl": false,
            "streaming": true,
            "style": true,
            "voiceConversion": false,
            "volumeControl": false,
            "emotionOptions": [
              {
                "label": "Happiness",
                "value": "happiness"
              }
            ],
            "generationConfigSchema": {
              "speed": {
                "default": 1,
                "max": 2,
                "min": 0.5,
                "step": 0.1
              },
              "volume": {
                "default": 1,
                "max": 2,
                "min": 0.5,
                "step": 0.1
              }
            }
          },
          "languages": [
            {
              "code": "en",
              "name": "English",
              "nativeName": "English"
            }
          ],
          "modelId": "eleven_multilingual_v2",
          "name": "Multilingual v2",
          "deprecation": {
            "replacedBy": "eleven_v4_turbo",
            "retiresOn": "2026-10-13"
          },
          "description": "High-quality multilingual text-to-speech model",
          "pricing": {
            "ratePer1kCharsDisplay": "$0.1000",
            "ratePer1kCharsMicrocents": 100000
          }
        }
      ],
      "provider": "elevenlabs"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.talkif.ai/api/v1/models"

response = requests.get(url)

print(response.json())
```

```javascript
const url = 'https://api.talkif.ai/api/v1/models';
const options = {method: 'GET'};

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.talkif.ai/api/v1/models"

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

	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.talkif.ai/api/v1/models")

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

request = Net::HTTP::Get.new(url)

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.talkif.ai/api/v1/models")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.talkif.ai/api/v1/models');

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

```csharp
using RestSharp;

var client = new RestClient("https://api.talkif.ai/api/v1/models");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://api.talkif.ai/api/v1/models")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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()
```