Retrieve Model

Retrieve a model.

Retrieve detailed information about a specific model, including its capabilities, provider, and supported features.

Args: model_id: The ID of the model to retrieve (e.g., ‘openai/gpt-4’, ‘anthropic/claude-3-5-sonnet-20241022’) user: Authenticated user obtained from API key validation

Returns: Model: Information about the requested model

Raises: HTTPException:

401 if authentication fails
404 if model not found or not accessible with current API key
500 if internal error occurs

Requires: Valid API key with ‘read’ scope permission

Example:

import dedalus_sdk

client = dedalus_sdk.Client(api_key="your-api-key")
model = client.models.retrieve("openai/gpt-4")

print(f"Model: {model.id}")
print(f"Owner: {model.owned_by}")

Response:

{
    "id": "openai/gpt-4",
    "object": "model",
    "created": 1687882411,
    "owned_by": "openai"
}

GET

models

{model_id}

Typescript

const client = new Dedalus();

const result = await client.models.retrieve(modelID);

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.dedaluslabs.ai/v1/models/{model_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dedaluslabs.ai/v1/models/{model_id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

require 'uri'
require 'net/http'

url = URI("https://api.dedaluslabs.ai/v1/models/{model_id}")

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

{
  "id": "<string>",
  "created_at": "2023-11-07T05:31:56Z",
  "display_name": "<string>",
  "description": "<string>",
  "version": "<string>",
  "capabilities": {
    "text": true,
    "vision": true,
    "image_generation": true,
    "audio": true,
    "tools": true,
    "structured_output": true,
    "streaming": true,
    "thinking": true,
    "input_token_limit": 123,
    "output_token_limit": 123
  },
  "defaults": {
    "temperature": 123,
    "top_p": 123,
    "top_k": 123,
    "max_output_tokens": 123
  },
  "provider_info": {
    "routing": [
      {}
    ]
  },
  "provider_declared_generation_methods": [
    "<string>"
  ]
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

Overview

Retrieve detailed information about a specific model, including capabilities, pricing, token limits, and routing. The model_id uses the provider/model format (e.g., openai/gpt-4o, anthropic/claude-opus-4-5).

Usage Examples

curl https://api.dedaluslabs.ai/v1/models/openai/gpt-4o \
  -H "x-api-key: $DEDALUS_API_KEY"

from dedalus_labs import Dedalus

client = Dedalus(api_key="YOUR_API_KEY")

model = client.models.retrieve("openai/gpt-4o")

print(f"Model: {model.display_name}")
print(f"Context window: {model.token_limits.input:,} tokens")
print(f"Pricing: ${model.pricing.input_per_million}/M input")

import { Dedalus } from "dedalus-labs";

const client = new Dedalus({
  apiKey: "YOUR_API_KEY",
});

const model = await client.models.retrieve("openai/gpt-4o");
console.log(model.display_name, model.pricing);

Example Response

{
  "id": "openai/gpt-4o",
  "provider": "openai",
  "created_at": "2024-05-13T00:00:00Z",
  "display_name": "GPT-4o",
  "description": "Fast, multimodal flagship model.",
  "capabilities": {
    "text": true,
    "vision": true,
    "tools": true,
    "structured_output": true,
    "streaming": true
  },
  "token_limits": {
    "input": 128000,
    "output": 16384
  },
  "pricing": {
    "input_per_million": 2.5,
    "output_per_million": 10.0,
    "cached_input_per_million": 1.25
  },
  "provider_info": {
    "routing": [
      {
        "endpoint": "/v1/chat/completions",
        "upstream_api": "openai/chat/completions"
      }
    ],
    "status": "enabled"
  }
}

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Path Parameters

model_id

string

required

Response

Successful Response

Unified model metadata across all providers.

Combines provider-specific schemas into a single, consistent format. Fields that aren't available from a provider are set to None.

string

required

Unique model identifier with provider prefix (e.g., 'openai/gpt-4')

provider

enum<string>

required

Provider that hosts this model

Available options:

openai,

anthropic,

google,

xai,

deepseek,

mistral,

groq,

fireworks,

cohere,

together,

cerebras,

perplexity,

moonshot

created_at

string<date-time>

required

When the model was released (RFC 3339)

display_name

string | null

Human-readable model name

description

string | null

Model description

version

string | null

Model version identifier

capabilities

ModelCapabilities · object | null

Normalized model capabilities

Show child attributes

defaults

ModelDefaults · object | null

Provider-declared default parameters

Show child attributes

provider_info

ModelProviderInfo · object | null

Typed provider-specific metadata

Show child attributes

provider_declared_generation_methods

string[] | null

Provider-specific generation method names (None = not declared)

Last modified on April 21, 2026

⌘I

Typescript

const client = new Dedalus();

const result = await client.models.retrieve(modelID);

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.dedaluslabs.ai/v1/models/{model_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dedaluslabs.ai/v1/models/{model_id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

require 'uri'
require 'net/http'

url = URI("https://api.dedaluslabs.ai/v1/models/{model_id}")

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

{
  "id": "<string>",
  "created_at": "2023-11-07T05:31:56Z",
  "display_name": "<string>",
  "description": "<string>",
  "version": "<string>",
  "capabilities": {
    "text": true,
    "vision": true,
    "image_generation": true,
    "audio": true,
    "tools": true,
    "structured_output": true,
    "streaming": true,
    "thinking": true,
    "input_token_limit": 123,
    "output_token_limit": 123
  },
  "defaults": {
    "temperature": 123,
    "top_p": 123,
    "top_k": 123,
    "max_output_tokens": 123
  },
  "provider_info": {
    "routing": [
      {}
    ]
  },
  "provider_declared_generation_methods": [
    "<string>"
  ]
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}

​Overview

​Usage Examples

​Example Response

Authorizations

Path Parameters

Response

Overview

Usage Examples

Example Response