Getting Started

Models

Browse the models currently available through DEVUP AI.

DEVUP AI provides access to a wide variety of machine learning models through one unified API. Our live model catalog is the source of truth for all currently supported models, their capabilities, and pricing.

Browse Model Catalog Compare All Models

Model Categories

Our platform supports diverse model architectures across multiple categories to match your application's requirements.

Language & Reasoning

General purpose language tasks, coding, and complex reasoning logic.

Vision & Multimodal

Analyze and extract information from visual inputs alongside text.

Embeddings

Convert text into dense vector representations for semantic search.

Reranking

Cross-encoder models to improve search and RAG retrieval precision.

Image Generation

Generate and edit images based on natural language prompts.

Video Generation

Synthesize dynamic video content directly from text descriptions.

Speech Recognition

Transcribe audio into text using advanced ASR technology.

Text-to-Speech

Convert natural language text into high-quality human speech.

Specialized Inference

Task-specific models fine-tuned for specialized extraction and operations.

Choosing a Model

There is no single best model for all use cases. When evaluating models from the catalog, consider these key dimensions:

Required modality

Ensure the model supports your necessary inputs (e.g., text vs. images) and outputs.

Quality and latency

Larger models may offer stronger reasoning for some workloads, while smaller models often provide lower latency.

Context requirements

Check if the model's maximum context window can fit your intended prompts and conversational history.

Supported features

Check if the model supports specific API features like tool calling or JSON mode.

Pricing

Billing varies significantly by model complexity, context size, and workload type.

Model availability

Verify the current availability status and regional presence in the live catalog.

Model Identifiers

When making API requests, you must use the exact model identifier shown in the live catalog.

Example Identifier

To use DeepSeek-V4-Pro, your request must strictly specify:

deepseek-ai/DeepSeek-V4-Pro

Model Details

Each model in our catalog has a dedicated page providing technical details, which may include:

Model identifier

Supported capabilities

Input/output modalities

Context window

Pricing

Example usage

API compatibility

List Models API

Retrieve a list of all currently supported and published models available through DEVUP AI in an OpenAI-compatible format.

GEThttps://api.devupai.com/v1/models

Caching: The response is private to the caller, carries an ETag, and clients can send If-None-Match to receive 304 Not Modified.

Authentication: Send your API key as Authorization: Bearer <key> or in the x-api-key header. When both are sent, Authorization is used. Browser requests may send the x-api-key and anthropic-version headers. A request without a key returns HTTP 401 missing_api_key.

Response fields

Field	Type	Description
object	string	Always `"list"`.
data	array	List of model objects.
data[].id	string	The unique model identifier to pass in API requests (e.g. `deepseek-ai/DeepSeek-V4-Pro`).
data[].name	string	The model's human-readable display name.
data[].object	string	Always `"model"`.
data[].created	integer	Unix timestamp (in seconds) of when the model was created or added.
data[].owned_by	string	Organization or owner identifier.
data[].type	string	Primary model category or modality (e.g. `"text-generation"`, `"embeddings"`).
data[].context_window	integer \| null	Integer, or `null`. The maximum context size (input + output tokens) as DEVUP serves the model. Use this value for calculations.
data[].context_length	string \| optional	String. A short display label for the context size.
data[].max_output_tokens	integer \| optional	Integer. The model's own output limit, which differs from model to model: the largest value the model accepts for `max_tokens` and `max_completion_tokens` on `POST /v1/chat/completions`, for `max_output_tokens` on `POST /v1/responses`, and for `max_tokens` on `POST /anthropic/v1/messages`. A larger value returns HTTP 400 invalid_max_tokens, with a message that names the parameter you sent and the model's limit (on `POST /anthropic/v1/messages`, the same message in an `invalid_request_error`). A request that sends none of these parameters is limited to the model's default output length, which is at most this value. The field is listed for models that generate text (type `text-generation`).
data[].is_replaced	boolean	Indicates whether the model has been superseded or replaced.
data[].pricing	object	Object. Pricing rates in Algerian Dinar (DZD), containing `unit`, `currency`, `input`, and optional `output`, `formula`, and `cached` rates.
data[].capabilities	array	Array of strings. List of high-level capability flags supported by the model.
data[].supports	object	Object. Feature support flags, always present: `tools` (the model takes `tools` and can return tool calls), `vision` (images in messages), `reasoning` (the model reasons, always or when asked), `structured_output` (a `response_format` of type `json_schema` returns JSON that matches the schema), `audio_input` and `video_input` (audio or video in messages), and `reasoning_can_be_disabled` (the model can answer without reasoning). `supports.reasoning: true` with no `reasoning`object means the model's reasoning mode is not known yet.
data[].tool_calls	object \| optional	Object. Tool calling details for the model. Each key is present only when known; the object is omitted when none is known. `chat_completions`: `false` when tool calls for this model are served on `/v1/responses`, and a `POST /v1/chat/completions` request with `tools` returns HTTP 400 use_responses_api; `true` when they are served on `/v1/chat/completions`. `parallel`: `true` when the model can return several tool calls in one reply; `false` when it returns at most one tool call per reply.
data[].tool_choice	object \| optional	Object. For each `tool_choice` value whose handling is known, `true` when the model enforces it and `false` when it selects tools on its own. Keys: `none`, `required` and `function` (a named function). `auto` is not listed: the model always decides. A value that is not listed is not known yet; the object is omitted when none is known. A request with a value marked `false` is answered with the notice tool_choice_not_enforced.
data[].reasoning	object \| optional	Object. `mode`: `"always"` (the model reasons without being asked), `"on_request"` (it reasons when asked) or `"none"` (no configurable reasoning mode; a reasoning parameter is answered with the notice reasoning_not_available). When known, `parameter` is the request parameter that turns reasoning on or sets its level (for example `reasoning_effort`). `values` lists the reasoning levels you can send to this model with `parameter`, from least to most reasoning. `none`, when listed, turns reasoning off. How much each level changes the reasoning depends on the model. Some models list a single value, which turns reasoning on. For `reasoning_effort`, the values come from `none`, `minimal`, `low`, `medium`, `high`, `xhigh` and `max`, in that order. `parameter` and `values` can appear with mode `"always"`, where they set the level, and with `"on_request"`. The object is omitted while the mode is not known. See reasoning controls.

Example

Request model catalog:

bash

curl -X GET https://api.devupai.com/v1/models \
  -H "Authorization: Bearer $DEVUP_API_KEY"

Example response:

json

{
  "object": "list",
  "data": [
    {
      "id": "deepseek-ai/DeepSeek-V4-Pro",
      "name": "DeepSeek-V4-Pro",
      "object": "model",
      "created": 1780741344,
      "owned_by": "deepseek-ai",
      "type": "text-generation",
      "is_replaced": false,
      "tool_choice": { "required": false, "function": false }
    }
  ]
}

Abridged: each model object also carries context_length, context_window, pricing and supports, max_output_tokens for models that generate text, tool_calls when known, and reasoningonce the model's reasoning mode is known, described in the field table above.

Retrieve Model API

Retrieve one model by its identifier. The response is the same model object as that model's entry in GET /v1/models, with the fields described above.

GEThttps://api.devupai.com/v1/models/{model}

Model ID in the path: Send the identifier as-is, including its slash, for example /v1/models/deepseek-ai/DeepSeek-V4-Pro. The URL-encoded form /v1/models/deepseek-ai%2FDeepSeek-V4-Pro also works.

Authentication and caching: The same as GET /v1/models: Authorization: Bearer <key> or x-api-key, and Cache-Control: private, max-age=300 with an ETag for If-None-Match requests.

Unknown model: HTTP 404 model_not_found with the message The model "<id>" does not exist. List available models with GET /v1/models.

Example

Retrieve one model:

bash

curl https://api.devupai.com/v1/models/deepseek-ai/DeepSeek-V4-Pro \
  -H "Authorization: Bearer $DEVUP_API_KEY"

Example response (abridged):

json

{
  "id": "deepseek-ai/DeepSeek-V4-Pro",
  "name": "DeepSeek-V4-Pro",
  "object": "model",
  "created": 1780741344,
  "owned_by": "deepseek-ai",
  "type": "text-generation",
  "is_replaced": false
}

Abridged: the object also carries the other fields described above, among them max_output_tokens, this model's own output limit.

Model Lifecycle

Models may be updated, replaced, or removed over time.

Review the model catalog and platform notices before depending on a specific model identifier in production.

Need a different model?

If you have a specific model requirement for your workload, let us know. We review all requests based on infrastructure capabilities and developer utility.

Suggest a Model

Quickstart

Chat Completions