DeepSeek Family

Open Frontier Models Built for Million-Token Context

DeepSeek builds open-weight frontier models around a single engineering constraint: making very long context economically real. From Multi-head Latent Attention through to today's hybrid sparse and compressed attention stacks, every generation has attacked the two costs that make million-token inference impractical — per-token compute and key-value cache size. The result is a family that spans direct-answer chat models and deep reasoning systems with switchable effort levels, all sharing one API surface. Available on DEVUP AI through a single OpenAI-compatible endpoint.

Explore 9 Models API Documentation

Overview & Architecture

DeepSeek's models are defined less by scale than by a consistent architectural argument: that a very long context window is worth nothing if it cannot be served affordably. Each generation has restructured attention to make the window usable rather than nominal. Multi-head Latent Attention compressed the key-value cache into a latent representation. The current generation pairs Compressed Sparse Attention with Heavily Compressed Attention, cutting per-token inference compute to roughly a quarter and cache footprint to roughly a tenth at full context.

Sparsity carries the same logic. These are Mixture-of-Experts models where only a small fraction of total parameters activate on any given token — a few percent in the current generation. Total capacity stays large while the cost of using it stays close to that of a far smaller model.

The family splits along one axis that matters more than size. Earlier models answer directly, with reasoning behaviour distilled into their responses but no visible trace to handle. Current models reason explicitly before answering, returning that reasoning in a separate field, with three effort levels selectable per request. The gap between the fastest and deepest setting is not incremental: on hard mathematics and competitive programming it can more than double the score. Choosing the wrong level does not produce a slightly worse answer — it produces a qualitatively different one.

Within the current generation the split is between a lightweight model and a flagship. The lightweight model activates a small fraction of the flagship's parameters and, at maximum reasoning effort, reaches comparable reasoning quality. The flagship separates itself on world knowledge and on the most complex agentic workflows — knowledge being the one axis where more reasoning cannot substitute for what a model does not know.

Every model in this family is available on DEVUP AI through the same OpenAI-compatible endpoint, with one API key, billing in Algerian Dinar, and local payment methods. Switching between them is a change to the model field, not an integration.

Direct-answer generation

No reasoning trace

Answers immediately, no deliberation pass
Nothing to strip before display
128K context
Best for latency-sensitive paths

Lightweight reasoning

Three effort levels

Small active parameter count
Near-flagship reasoning at max effort
1M context
Best default for production traffic

Flagship reasoning

Three effort levels

Largest active parameter count
Leads on world knowledge
1M context
Best for complex agents and long documents

Available DeepSeek Models

Deploy and access all published models in this family with unified DZD pricing and zero foreign card requirement.

Model	Context	DZD in / 1M tokens	DZD out / 1M tokens	Actions
DeepSeek-V4-Pro-0813deepseek-ai/DeepSeek-V4-Pro-0813	1M Tokens	455	910	View model
DeepSeek-V4-Flash-0731deepseek-ai/DeepSeek-V4-Flash-0731	1M Tokens	32	72	View model
DeepSeek-V3-0324deepseek-ai/DeepSeek-V3-0324	163K Tokens	70	269.5	View model
DeepSeek-R1-0528deepseek-ai/DeepSeek-R1-0528	163K Tokens	175	752.5	View model
DeepSeek-V3.2deepseek-ai/DeepSeek-V3.2	163k Tokens	91	133	View model
DeepSeek-V3.1deepseek-ai/DeepSeek-V3.1	163k Tokens	73.5	276.5	View model
DeepSeek-V3deepseek-ai/DeepSeek-V3	131K Tokens	112	312	View model
DeepSeek-V4-Flashdeepseek-ai/DeepSeek-V4-Flash	1M Tokens	35	70	View model
DeepSeek-V4-Prodeepseek-ai/DeepSeek-V4-Pro	1M Tokens	455	910	View model

Call any DeepSeek model

Every model on this page uses the same API key and standard OpenAI-compatible endpoint. The example below uses the featured model deepseek-ai/DeepSeek-V4-Pro.

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro",
    messages=[
        {"role": "user", "content": "Hello world!"}
    ],
    max_tokens=1024
)

print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEVUP_API_KEY,
  baseURL: "https://api.devupai.com/v1",
});

async function main() {
  const response = await client.chat.completions.create({
    model: "deepseek-ai/DeepSeek-V4-Pro",
    messages: [
      { role: "user", content: "Hello world!" },
    ],
    max_tokens: 1024,
  });

  console.log(response.choices[0]?.message?.content);
}

main();

curl -X POST "https://api.devupai.com/v1/chat/completions" \
  -H "Authorization: Bearer $DEVUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-V4-Pro",
    "messages": [
      { "role": "user", "content": "Hello world!" }
    ],
    "max_tokens": 1024
  }'

Frequently Asked Questions

Start with a current-generation lightweight model at medium reasoning effort. It handles most production work, and at maximum effort it approaches the flagship on reasoning tasks. Move to the flagship when your workload is knowledge-heavy, involves very long documents, or runs complex multi-step agents. Every model shares the same API surface, so switching is a change to one field.

It controls how much the model deliberates before answering. The lowest setting answers immediately; the highest produces an extended reasoning pass first. On reasoning-heavy work such as mathematics and competitive programming the difference is dramatic. On procedural work such as software engineering the gap narrows considerably, so the cheapest setting is often close to the most expensive.

Reasoning arrives in a separate reasoning_content field, not inside content. Read it explicitly and null-check it, since not every model on the platform populates it. Never merge it into content — doing so breaks JSON parsing on structured-output paths and shows users an unpolished draft of an answer they never asked to see.

On the current generation, yes — long-context retrieval scores are high enough that passing a document whole is usually better than chunking it, since chunking discards exactly the cross-references the model is good at finding. One caveat: long-context recall improves substantially with reasoning effort. Pairing an enormous input with the fastest setting is the one combination to avoid.

Yes. Function calling uses the standard OpenAI schema, and structured output is supported. Current-generation models reason about which tool to call before emitting the call, which reduces wrong-tool and wrong-argument failures. Always bound your agent loops with an iteration ceiling, and consider a scoped token limited to one model with a spending cap.

The catalogue covers both the previous and current generations, including direct-answer and reasoning models. Model IDs follow the namespaced form used across the platform. Check the model list on this page for what is live right now.