[NEW] LiteLLM Model Catalog API

[ishaan-jaff]

LiteLLM Model Catalog API

Free API to query pricing, context windows, and capabilities for 2,500+ models.

Base URL: https://api.litellm.ai/

Quick Start

curl "https://api.litellm.ai/model_catalog?provider=openai&supports_vision=true&page_size=1"

Response:

{
  "object": "list",
  "data": [
    {
      "id": "chatgpt-4o-latest",
      "provider": "openai",
      "mode": "chat",
      "max_input_tokens": 128000,
      "max_output_tokens": 4096,
      "input_cost_per_token": 0.000005,
      "output_cost_per_token": 0.000015,
      "cache_read_input_token_cost": null,
      "input_cost_per_audio_token": null,
      "output_cost_per_reasoning_token": null,
      "deprecation_date": null,
      "supports_function_calling": true,
      "supports_vision": true,
      "supports_audio_input": null,
      "supports_reasoning": null,
      "supports_response_schema": null,
      "supports_prompt_caching": true,
      "supports_web_search": null,
      "supports_pdf_input": true
    }
  ],
  "total_count": 98,
  "has_more": true,
  "page": 1,
  "page_size": 1
}

What's Included Per Model

• Context window sizes (input/output tokens)
• Per-token pricing (input, output, caching, audio, reasoning)
• Capability flags (vision, function calling, reasoning, audio, prompt caching, response schema, web search, PDF input)
• Deprecation dates

Filter Parameters

Parameter	Description
provider	openai, anthropic, bedrock, vertex_ai, etc.
mode	chat, embedding, image_generation
model	Substring match or regex with re: prefix
supports_vision	true / false
supports_function_calling	true / false
supports_reasoning	true / false
page / page_size	Pagination (up to 500 per page)

Single Model Lookup

curl "https://api.litellm.ai/model_catalog/gpt-4o"

Interactive Docs

https://api.litellm.ai/docs

[KeepALifeUS]

The Model Catalog API is a great idea. Here is a design pattern that scales:

Catalog Schema Design

from dataclasses import dataclass, field
from typing import List, Dict, Optional
from enum import Enum

class ModelCapability(Enum):
    CHAT = "chat"
    COMPLETION = "completion"
    EMBEDDING = "embedding"
    VISION = "vision"
    FUNCTION_CALLING = "function_calling"
    JSON_MODE = "json_mode"
    STREAMING = "streaming"

@dataclass
class ModelSpec:
    # Identity
    id: str  # litellm model name
    provider: str  # openai, anthropic, etc
    base_model: str  # underlying model name
    
    # Capabilities
    capabilities: List[ModelCapability] = field(default_factory=list)
    context_window: int = 4096
    max_output_tokens: int = 4096
    
    # Pricing
    input_cost_per_token: float = 0.0
    output_cost_per_token: float = 0.0
    
    # Metadata
    deprecated: bool = False
    successor: Optional[str] = None
    release_date: Optional[str] = None
    
    # Performance hints
    latency_tier: str = "standard"  # fast, standard, slow
    quality_tier: str = "standard"  # economy, standard, premium

@dataclass
class ModelCatalog:
    models: Dict[str, ModelSpec] = field(default_factory=dict)
    
    def find_by_capability(self, *caps: ModelCapability) -> List[ModelSpec]:
        return [
            m for m in self.models.values()
            if all(c in m.capabilities for c in caps)
        ]
    
    def find_cheapest(self, capability: ModelCapability) -> Optional[ModelSpec]:
        candidates = self.find_by_capability(capability)
        if not candidates:
            return None
        return min(candidates, key=lambda m: m.input_cost_per_token + m.output_cost_per_token)
    
    def get_successor(self, model_id: str) -> Optional[ModelSpec]:
        model = self.models.get(model_id)
        if model and model.successor:
            return self.models.get(model.successor)
        return None

API Endpoints

GET /models                    # List all
GET /models/{id}               # Get specific
GET /models?capability=vision  # Filter by capability
GET /models?provider=anthropic # Filter by provider
GET /models/cheapest?cap=chat  # Find cheapest for capability

Use Case: Smart Model Selection

catalog = get_model_catalog()

# Need vision + function calling, prefer fast
candidates = catalog.find_by_capability(
    ModelCapability.VISION,
    ModelCapability.FUNCTION_CALLING
)
model = min(candidates, key=lambda m: m.latency_tier)

This pattern helps agents make intelligent model choices at runtime.

More on agent patterns: https://github.com/KeepALifeUS/autonomous-agents

[xXMrNidaXx]

This is incredibly useful! Model discovery and pricing comparison is a constant pain point.

Use cases this unlocks:

1. Dynamic model routing

   async def get_cheapest_vision_model(provider: str):
       resp = await client.get(
           "https://api.litellm.ai/model_catalog",
           params={"provider": provider, "supports_vision": True}
       )
       models = sorted(resp.json()["data"], key=lambda m: m["input_cost_per_token"])
       return models[0]["id"]

2. Cost estimation before calls

   def estimate_cost(model_id: str, input_tokens: int, output_tokens: int):
       model = catalog.get(model_id)
       return (
           input_tokens * model["input_cost_per_token"] +
           output_tokens * model["output_cost_per_token"]
       )

3. Capability-based fallbacks
   If primary model lacks feature, auto-find alternative that supports it.

Feature requests:

1. Latency hints — avg response time per model would help routing decisions
2. Reliability scores — uptime/error rates from LiteLLM proxy data
3. Webhook for model updates — know when new models drop or deprecate

Question: How often is the catalog updated? Real-time or periodic sync?

We build model routing systems at Revolution AI — this API is going straight into our tooling. Great addition! 🔥

[xXMrNidaXx]

Model Catalog API is great! At RevolutionAI (https://revolutionai.io) we use LiteLLM for multi-provider routing.

Use cases:

• Dynamic model discovery
• Cost comparison
• Capability filtering

What we would want:

from litellm import catalog

# List models by capability
models = catalog.list(
    capabilities=["vision", "function_calling"],
    max_cost_per_1k=0.01
)

# Get model details
info = catalog.get("gpt-4-turbo")
print(info.context_window)  # 128000
print(info.cost_per_1k_input)  # 0.01

Feature requests:

• Filter by context window
• Sort by cost
• Include latency benchmarks

This would make model selection much easier!

[maxrabin]

The API seems to be out of date, I don't see pricing for Opus 4.6 on it. Nor does it differentiate between the AWS Global vs Regional inference profiles (eg global.anthropic.claude-opus-4-6 has different pricing than us.anthropic.claude-opus-4-6)