How to Use DeepSeek in 2026: App, API, Self-Host & Real Costs

DeepSeek is the cheapest frontier-class model of 2026, and there are three ways to use it: the free chat app for everyday questions, the very cheap API for building, or self-hosting the open weights for full data control. This guide walks each route, how to get an API key, a worked code example, what DeepSeek actually costs across real workloads, how its context-caching discount works, when self-hosting is worth the GPUs, and which DeepSeek model to pick.

Three ways to use DeepSeek

• Chat app (chat.deepseek.com) — free, for everyday questions and quick tasks. No code.
• API (api.deepseek.com) — cheap, OpenAI-compatible, for building applications.
• Self-host — download the open weights (MIT) and run them on your own GPUs for full data control.

Get a DeepSeek API key

1. Sign up at platform.deepseek.com and verify your account.
2. Create a key in the API keys section; copy it once.
3. Add credit (new accounts often get trial credit). Store the key as export DEEPSEEK_API_KEY=...

What DeepSeek costs to run

DeepSeek's reputation is "cheap," but the real story is how cheap on actual traffic. Here's the modeled monthly cost across five canonical workloads, with two frontier models for contrast:

A RAG app on V3.2 runs about $53/month versus $1,500 on Claude Opus — roughly 28x cheaper for quality within a few points on many tasks. That gap is the whole reason DeepSeek became the default cheap option.

Why it's so cheap

On output price — usually the bigger half of the bill — DeepSeek undercuts the Western frontier by an order of magnitude:

How to call it (worked example)

The API is OpenAI-compatible — use the OpenAI SDK with DeepSeek's base URL, stream long output, and handle errors:

from openai import OpenAI, APIError
client = OpenAI(base_url="https://api.deepseek.com/v1", api_key="$DEEPSEEK_API_KEY")

try:
    stream = client.chat.completions.create(
        model="deepseek-v4-pro",            # or deepseek-v4-flash for the cheap tier
        messages=[{"role": "user", "content": "Review this function..."}],
        stream=True,
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
except APIError as e:
    print("DeepSeek API error:", e.status_code, e.message)   # 401 key, 429 rate, 402 balance

The context-caching discount

DeepSeek bills repeated input prefixes at a much lower context-cache-hit rate than fresh input. If your app resends a large fixed context — a long system prompt, tool schemas, or a retrieved document — every turn, those repeated tokens are served from cache cheaply. For agents and RAG this is a real lever: keep the stable part of the prompt at the front and the variable user turn at the end, so the prefix stays cacheable across calls. The input-heavy rows of the cost table above (RAG, batch extraction) drop meaningfully once caching kicks in.

Which DeepSeek model

Self-hosting the open weights

DeepSeek V4 is open-weights (MIT), downloadable from Hugging Face, so you can run it on your own GPUs for full data control. The catch is scale: V4-Pro is a large mixture-of-experts model (trillion-plus total parameters with a smaller active set per token), so it needs serious multi-GPU hardware to serve at speed. The math usually works only when volume is very high or data must never leave your infrastructure — otherwise the cheap hosted API beats the all-in cost of GPUs, power, and ops. A common hybrid: self-host for the sensitive, high-volume path and call the API for everything else.

Using DeepSeek through a gateway

To use DeepSeek alongside other models — with failover — call it through a gateway. DataLLM Lab carries DeepSeek V3.2 with one OpenAI-compatible key:

client = OpenAI(base_url="https://www.datallmlab.com/v1", api_key="$DATALLMLAB_API_KEY")
resp = client.chat.completions.create(model="deepseek/deepseek-v3.2", messages=[{"role":"user","content":"Hello"}])

FAQ