Ključne ugotovitve

• API, združljiv z OpenAI: DeepSeek sledi formatu OpenAI API -- preklopite s spremembo base_url in API ključa. OpenAI Python SDK, LangChain in LlamaIndex delujejo takoj po namestitvi.
• 90-odstotni prihranki s predpomnjenjem konteksta (context caching): Skupne predpone pozivov se samodejno predpomnijo po ceni $0.028/M tokens v primerjavi z $0.28/M za zgrešitve v predpomnilniku -- spremembe kode niso potrebne.
• 5 milijonov brezplačnih žetonov (tokens) za začetek: Novi računi prejmejo 5M brezplačnih žetonov (tokens) brez potrebe po kreditni kartici, kar zadostuje za obsežno eksperimentiranje.
• Dva načina: deepseek-chat za standardne naloge (največ 8K izhoda) in deepseek-reasoner za razmišljanje po korakih (Chain-of-Thought) (največ 64K izhoda) -- reasoner porabi več žetonov (tokens), vendar daje boljše rezultate pri težkih problemih.

DeepSeek V4 API vodič: Cene, nastavitev in primeri kode

DeepSeek je postal vodilni na področju cen LLM API-jev. S cenami, ki so za red velikosti nižje od OpenAI in Anthropic, ter polno združljivostjo z OpenAI SDK, preklop na DeepSeek traja približno pet minut. Ta vodič vas bo popeljal skozi vse: nastavitev računa, izračun cen, primere kode v Python in JavaScript, predpomnjenje konteksta (context caching) in migracijo z OpenAI.

Ne glede na to, ali gradite klepetalnico, pomočnika za kodiranje ali obdelujete celotne kode (codebases) z 1M žetonov (tokens) dolgim kontekstnim oknom, vas ta vodič pokriva.

---

Hitri začetek: Vaš prvi DeepSeek API klic

Začetek zahteva tri korake.

1. Ustvarite račun

Obiščite platform.deepseek.com in se prijavite. Novi računi prejmejo 5 milijonov brezplačnih žetonov (tokens) brez potrebe po kreditni kartici — dovolj za obsežno eksperimentiranje pred zavezo.

2. Ustvarite API ključ

V nadzorni plošči pojdite na API Keys. Kliknite Create new API key, mu dajte ime in takoj kopirajte ključ. Ponoven ogled ključa ne bo mogoč.

Shranite ključ kot okoljsko spremenljivko:

export DEEPSEEK_API_KEY="sk-your-key-here"

3. Izvedite svojo prvo zahtevo

Ker DeepSeek sledi formatu OpenAI API, lahko uporabite uradni OpenAI SDK. Najprej ga namestite:

pip install openai

Nato izvedite preprost klic za dokončanje klepeta (chat completion):

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-key-here",
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain Python decorators in three sentences."}
    ]
)

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

To je vse. Če ste že uporabljali OpenAI API, sta edini razliki base_url in vaš API ključ.

---

Pregled cen

DeepSeek-ov model cen je preprost in bistveno cenejši od konkurentov. Ključna prednost je predpomnjenje konteksta (context caching), ki zmanjša stroške vnosa za 90 % pri ponavljajočih se predponah pozivov.

DeepSeek API cene

Vrsta žetona (Token Type)	Cena na 1M žetonov (Tokens)
Vhod (zadetek v predpomnilniku/cache hit)	$0.028
Vhod (zgrešitev v predpomnilniku/cache miss)	$0.28
Izhod	$0.42

Kako se to primerja

Ponudnik / Model	Vhod (na 1M)	Izhod (na 1M)
DeepSeek V4 (cache hit)	$0.028	$0.42
DeepSeek V4 (cache miss)	$0.28	$0.42
OpenAI GPT-5.4	$2.50	$10.00
Anthropic Claude Opus 4.6	$15.00	$75.00
Google Gemini 3.1 Pro	$1.25	$5.00

Številke govorijo same zase. Z zadetki v predpomnilniku je DeepSeek približno 90-krat cenejši od OpenAI pri vhodnih žetonih (tokens) in 500-krat cenejši od Claude Opus. Tudi brez predpomnjenja je DeepSeek-ova tarifa za zgrešitev v predpomnilniku $0.28/M še vedno 9-krat cenejša od cen za vhod pri GPT-5.4.

Primer stroškov

Obdelava 100 zahtev, vsaka z 2,000 žetonov (tokens) dolgim sistemskim pozivom in 500 žetonov (tokens) dolgim uporabniškim vprašanjem, ki generira 1,000 žetonov (tokens) dolge odgovore:

• S predpomnjenjem (99 zadetkov): ~ $0.05 skupaj
• Brez predpomnjenja: ~ $0.29 skupaj
• Enaka delovna obremenitev na GPT-5.4: ~ $3.75 skupaj

Pri aplikacijah z velikim obsegom se prihranki hitro povečujejo.

---

API načini: deepseek-chat proti deepseek-reasoner

DeepSeek ponuja dva različna načina modelov, od katerih je vsak optimiziran za različne naloge.

deepseek-chat

Standardni način za splošne naloge. Hitro, učinkovito in primerno za večino aplikacij.

Lastnost	Vrednost
Največ vhodnih žetonov (tokens)	1,000,000
Največ izhodnih žetonov (tokens)	8,192
Najboljše za	Klepet, povzemanje, generiranje kode, splošna vprašanja in odgovori

deepseek-reasoner

Omogoča razmišljanje po korakih (Chain-of-Thought - CoT). Model "razmišlja" korak za korakom, preden poda končni odgovor, kar bistveno izboljša natančnost pri težkih problemih.

Lastnost	Vrednost
Največ vhodnih žetonov (tokens)	1,000,000
Največ izhodnih žetonov (tokens)	64,000
Najboljše za	Matematiko, logične uganke, kompleksno iskanje napak, večstopenjsko razmišljanje

Reasoner vrne tako proces razmišljanja kot končni odgovor:

# Primer deepseek-reasoner
response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "Prove that the square root of 2 is irrational."}
    ]
)

# Veriga razmišljanja
print(response.choices[0].message.reasoning_content)

# Končni odgovor
print(response.choices[0].message.content)

Kdaj uporabiti reasoner: Če naloga zahteva večstopenjsko logiko, matematične dokaze ali kompleksno iskanje napak v kodi, uporabite deepseek-reasoner. Za vse ostalo je deepseek-chat hitrejši in cenejši.

---

Primeri kode

Python: Osnovno dokončanje klepeta (Chat Completion)

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

def ask_deepseek(prompt, system_prompt="You are a helpful assistant."):
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=2048
    )
    return response.choices[0].message.content

answer = ask_deepseek("Write a Python function to merge two sorted lists.")
print(answer)

Python: Pretočno predvajanje (Streaming)

Za dolge odgovore pretočno predvajanje (streaming) zagotavlja boljšo uporabniško izkušnjo z vračanjem žetonov (tokens), ko se ti generirajo:

stream = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "You are a senior software engineer."},
        {"role": "user", "content": "Review this code and suggest improvements:\n\ndef fib(n):\n  if n <= 1: return n\n  return fib(n-1) + fib(n-2)"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Python: Reasoner način

response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "Find all bugs in this code and explain why each is a bug:\n\ndef quicksort(arr):\n    if len(arr) <= 1:\n        return arr\n    pivot = arr[0]\n    left = [x for x in arr if x < pivot]\n    right = [x for x in arr if x > pivot]\n    return quicksort(left) + [pivot] + quicksort(right)"}
    ]
)

print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)

JavaScript / Node.js: Osnovni klepet

import OpenAI from "openai";

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

async function askDeepSeek(prompt) {
  const response = await client.chat.completions.create({
    model: "deepseek-chat",
    messages: [
      { role: "system", content: "You are a helpful assistant." },
      { role: "user", content: prompt },
    ],
  });

  return response.choices[0].message.content;
}

const answer = await askDeepSeek("Explain closures in JavaScript.");
console.log(answer);

JavaScript / Node.js: Pretočno predvajanje (Streaming)

const stream = await client.chat.completions.create({
  model: "deepseek-chat",
  messages: [
    { role: "user", content: "Write a REST API in Express.js with CRUD routes for a todo app." },
  ],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) {
    process.stdout.write(content);
  }
}

---

Predpomnjenje konteksta (context caching): 90-odstotni prihranki pri ponavljajočih se pozivih

DeepSeek-ovo predpomnjenje konteksta (context caching) je ena njegovih najmočnejših konkurenčnih prednosti in zahteva ničelne spremembe kode z vaše strani.

Kako deluje

Ko pošljete zahtevo, DeepSeek preveri, ali se začetek vašega poziva ujema s predhodno predpomnjeno predpono. Če je prvih N žetonov (tokens) identičnih nedavni zahtevi, se ti žetoni postrežejo iz predpomnilnika po znižani tarifi ($0.028/M namesto $0.28/M).

To se zgodi samodejno. Ni vam treba deklarirati ključev predpomnilnika, nastavljati TTL ali kakor koli spreminjati svojih API klicev.

Kdaj se predpomnjenje aktivira

Predpomnjenje se aktivira, ko:

• Isti sistemski poziv v več zahtevah. Če se vsaka zahteva začne z "You are a senior Python developer...", se ta predpona predpomni po prvem klicu.
• Skupna zgodovina pogovora. V pogovorih z več zavoji se akumulirana zgodovina iz prejšnjih zavojev predpomni.
• Paketna obdelava z doslednimi predlogami. Izvajanje istega analiznega poziva na različnih vnosih pomeni, da polno ceno povzroči le spremenljivi del.

Maksimiranje zadetkov v predpomnilniku (cache hits)

Da bi kar najbolje izkoristili predpomnjenje:

1. Postavite statično vsebino na začetek. Strukturirajte svoja sporočila tako, da sistemski poziv in vsa fiksna navodila pridejo pred spremenljivo vsebino.
2. Sistemski pozivi naj bodo identični. Že ena sama razlika v znaku prekine ujemanje v predpomnilniku.
3. Podobne zahteve pošiljajte v paketu. Pošiljajte zahteve s skupnimi predponami v hitrem zaporedju, da predpomnilnik ostane "topel".
4. Samozavestno uporabljajte dolge sistemske pozive. Sistemski poziv z 10,000 žetoni (tokens) ne stane skoraj nič po prvi zahtevi, če ostane predpomnjen.

---

Migracija z OpenAI

Če trenutno uporabljate OpenAI API, je preklop na DeepSeek sprememba dveh vrstic. Format API je identičen.

Prej (OpenAI)

from openai import OpenAI

client = OpenAI(
    api_key="sk-openai-key-here"
    # base_url privzeto nastavljen na https://api.openai.com/v1
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

Potem (DeepSeek)

from openai import OpenAI

client = OpenAI(
    api_key="sk-deepseek-key-here",
    base_url="https://api.deepseek.com"  # <-- dodajte to vrstico
)

response = client.chat.completions.create(
    model="deepseek-chat",              # <-- spremenite ime modela
    messages=[{"role": "user", "content": "Hello"}]
)

To je celotna migracija. Spremenjeni sta dve vrstici: base_url in model. Vse ostalo — format sporočil, pretočno predvajanje, klicanje funkcij, JSON način — deluje na enak način.

Pristop z okoljsko spremenljivko

Za projekte, ki morajo zlahka preklapljati med ponudniki:

import os
from openai import OpenAI

provider = os.getenv("LLM_PROVIDER", "deepseek")

config = {
    "deepseek": {
        "api_key": os.getenv("DEEPSEEK_API_KEY"),
        "base_url": "https://api.deepseek.com",
        "model": "deepseek-chat"
    },
    "openai": {
        "api_key": os.getenv("OPENAI_API_KEY"),
        "base_url": "https://api.openai.com/v1",
        "model": "gpt-4o"
    }
}

client = OpenAI(
    api_key=config[provider]["api_key"],
    base_url=config[provider]["base_url"]
)

---

Uporaba DeepSeek z odprtokodnimi orodji

Ker je DeepSeek združljiv z OpenAI, deluje z rastočim ekosistemom odprtokodnih AI orodij za kodiranje. Tukaj so najbolj priljubljena.

OpenCode

OpenCode je odprtokodni pomočnik za kodiranje v terminalu. Konfigurirajte ga za uporabo DeepSeek tako, da nastavite ponudnika v svoji konfiguraciji:

{
  "provider": {
    "name": "deepseek",
    "apiKey": "sk-your-key",
    "baseURL": "https://api.deepseek.com",
    "model": "deepseek-chat"
  }
}

Aider

Aider je AI parni programer v ukazni vrstici. Usmerite ga na DeepSeek z okoljskimi spremenljivkami:

export OPENAI_API_BASE="https://api.deepseek.com"
export OPENAI_API_KEY="sk-your-deepseek-key"
aider --model openai/deepseek-chat

Continue (VS Code razširitev)

Continue je odprtokodni AI pomočnik za kodo za VS Code in JetBrains. Dodajte DeepSeek v svoj ~/.continue/config.json:

{
  "models": [
    {
      "title": "DeepSeek V4",
      "provider": "openai",
      "model": "deepseek-chat",
      "apiBase": "https://api.deepseek.com",
      "apiKey": "sk-your-key"
    }
  ]
}

Vsa tri orodja obravnavajo DeepSeek kot neposredno zamenjavo za OpenAI. Posebni adapterji ali vtičniki niso potrebni.

---

Izkoristek 1M žetonov (tokens) dolgega kontekstnega okna

DeepSeek-ovo 1 milijon žetonov (tokens) dolgo kontekstno okno odpira možnosti za delovne procese, ki so bili prej nepraktični.

Analiza celotne kode (Full Codebase Analysis)

Tipičen srednje velik projekt (50,000 vrstic kode) obsega približno 500,000 žetonov (tokens). Z DeepSeek-ovim 1M kontekstom lahko celotno kodo vstavite v en sam poziv za:

• Preglede arhitekture. Prosite model, da prepozna krožne odvisnosti, manjkajoče abstrakcije ali nedosledne vzorce v celotnem projektu.
• Refaktoriranje med datotekami. Opišite želeno spremembo in pustite modelu, da generira usklajene urede v več datotekah.
• Varnostne revizije. Preglejte celotno kodo za SQL injection, XSS in druge ranljivosti v enem prehodu.

Praktični nasveti za velike kontekste

1. Najprej podajte drevesno strukturo datotek (file tree). Svoj poziv začnite z imenikom struktur, da model razume postavitev projekta, preden začne brati posamezne datoteke.
2. Uporabite jasna ločila. Vsako datoteko zavijte v oznake, kot je --- FILE: src/auth.py ---, da se model lahko sklicuje na določene datoteke v svojem odgovoru.
3. Zastavljajte usmerjena vprašanja. 1M kontekstno okno ne pomeni, da potrebujete nejasne pozive. Bodite specifični glede tega, kaj želite analizirati.
4. Kombinirajte s predpomnjenjem. Če izvajate več poizvedb nad isto kodo, se del s kodo po prvi zahtevi predpomni — naslednja vprašanja stanejo le delček prvotnega klica.

---

Best Practices za optimizacijo stroškov

1. Strukturirajte pozive za maksimalne zadetke v predpomnilniku

Najdaljšo, najbolj stabilno vsebino postavite na začetek polja sporočil. Sistemski pozivi, primeri (few-shot examples) in referenčna dokumentacija naj pridejo pred spremenljivo uporabniško vprašanje.

2. Privzeto uporabljajte deepseek-chat

Rezervirajte deepseek-reasoner za naloge, ki resnično zahtevajo večstopenjsko razmišljanje. Za preprosto generiranje, povzemanje in dopolnjevanje kode je deepseek-chat hitrejši in porabi manj žetonov (tokens).

3. Nastavite ustrezne max_tokens

Ne nastavljajte max_tokens višje, kot potrebujete. Če pričakujete 200 žetonov (tokens) dolg odgovor, nastavitev max_tokens: 8192 sama po sebi ne bo stala več, vendar preprečuje modelu, da bi se ustavil predčasno, če začne preveč razpredati.

4. Pakiranje podobnih zahtev

Združite zahteve, ki imajo isti sistemski poziv, in jih pošljite v hitrem zaporedju. To ohranja predpomnilnik "topel" in zagotavlja, da večina zahtev zadene predpomnjeno predpono.

5. Spremljajte porabo žetonov (tokens)

Preverite polje usage v API odgovorih, da sledite svoji dejanski porabi:

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Hello"}]
)

print(f"Input tokens: {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
print(f"Cache hit tokens: {response.usage.prompt_cache_hit_tokens}")
print(f"Cache miss tokens: {response.usage.prompt_cache_miss_tokens}")

6. Uporabite pretočno predvajanje (Streaming) za dolge izhode

Pretočno predvajanje ne prihrani denarja, vendar izboljša zaznano zakasnitev (latency). Uporabniki vidijo prve žetone (tokens) v nekaj milisekundah, namesto da bi čakali na generiranje celotnega odgovora.

---

Zaključek

DeepSeek API združuje agresivno oblikovanje cen, združljivost z OpenAI in 1M žetonov (tokens) dolgo kontekstno okno v paket, ki ga je težko prezreti. Pot migracije z OpenAI je trivialna — spremenite dve vrstici kode in vaša obstoječa aplikacija deluje. Predpomnjenje konteksta (context caching) prinaša samodejne prihranke stroškov brez kakršnih koli sprememb kode. In ekosistem odprtokodnih orodij že podpira DeepSeek kot prvorazrednega ponudnika.

Za razvijalce, ki gradijo stroškovno občutljive aplikacije, cevovode za obdelavo velikih količin podatkov ali orodja za analizo celotne kode, je DeepSeek V4 vreden resnega razmisleka. Začnite s 5 milijoni brezplačnih žetonov (tokens), opravite primerjalne teste s svojim trenutnim ponudnikom in pustite, da vas številke vodijo pri odločitvi.