Kluczowe wnioski
- API kompatybilne z OpenAI: DeepSeek stosuje format OpenAI API -- przełącz się, zmieniając base URL i API key. OpenAI Python SDK, LangChain oraz LlamaIndex działają natychmiastowo.
- 90% oszczędności dzięki context caching: Współdzielone prefiksy promptów są cachowane automatycznie w cenie $0.028/1M tokens w porównaniu do $0.28/1M przy cache misses -- nie wymaga to zmian w kodzie.
- 5 milionów darmowych tokens na start: Nowe konta otrzymują 5M darmowych tokens bez wymaganej karty kredytowej, co wystarcza na szeroko zakrojone eksperymenty.
- Dwa tryby: deepseek-chat do standardowych zadań (maksymalnie 8K output) i deepseek-reasoner do rozumowania Chain-of-Thought (maksymalnie 64K output) -- reasoner zużywa więcej tokens, ale daje lepsze wyniki w trudnych problemach.
Przewodnik po DeepSeek V4 API: Cennik, konfiguracja i przykłady kodu
DeepSeek stał się liderem kosztowym w obszarze LLM API. Dzięki cenom, które są o rząd wielkości niższe niż w OpenAI i Anthropic, oraz pełnej kompatybilności z OpenAI SDK, przejście na DeepSeek zajmuje około pięciu minut. Ten przewodnik przeprowadzi Cię przez wszystko: konfigurację konta, kalkulację cenową, przykłady kodu w Python i JavaScript, context caching oraz migrację z OpenAI.
Niezależnie od tego, czy budujesz chatbota, asystenta kodowania, czy przetwarzasz całe bazy kodu za pomocą okna kontekstowego 1M tokens, ten przewodnik zawiera wszystkie potrzebne informacje.
Szybki start: Twoje pierwsze zapytanie do DeepSeek API
Rozpoczęcie pracy wymaga trzech kroków.
1. Utwórz konto
Wejdź na stronę platform.deepseek.com i zarejestruj się. Nowe konta otrzymują 5 milionów darmowych tokens bez wymaganej karty kredytowej — to wystarczy, aby intensywnie eksperymentować przed podjęciem zobowiązań.
2. Wygeneruj API Key
Przejdź do sekcji API Keys w panelu sterowania. Kliknij Create new API key, nadaj mu nazwę i natychmiast skopiuj klucz. Nie będziesz mógł go zobaczyć ponownie.
Zapisz klucz jako zmienną środowiskową:
export DEEPSEEK_API_KEY="sk-your-key-here"
3. Wykonaj pierwsze zapytanie
Ponieważ DeepSeek jest zgodny z formatem OpenAI API, możesz użyć oficjalnego OpenAI SDK. Najpierw je zainstaluj:
pip install openai
Następnie wykonaj proste wywołanie 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 wszystko. Jeśli korzystałeś wcześniej z OpenAI API, jedynymi różnicami są base_url oraz Twój API key.
Szczegółowy cennik
Model cenowy DeepSeek jest przejrzysty i drastycznie tańszy od konkurencji. Kluczowym wyróżnikiem jest context caching, który obniża koszty inputu o 90% w przypadku powtarzających się prefiksów promptów.
Cennik DeepSeek API
| Typ tokena | Koszt za 1M Tokens |
|---|---|
| Input (cache hit) | $0.028 |
| Input (cache miss) | $0.28 |
| Output | $0.42 |
Porównanie
| Dostawca / Model | Input (za 1M) | Output (za 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 |
Liczby mówią same za siebie. Przy cache hits, DeepSeek jest około 90x tańszy niż OpenAI w przypadku tokens wejściowych i 500x tańszy niż Claude Opus. Nawet bez cachowania, stawka DeepSeek za cache-miss wynosząca $0.28/M jest wciąż 9x tańsza niż cena wejściowa GPT-5.4.
Przykład kosztów
Przetwarzanie 100 żądań, każde z 2,000-tokenowym promptem systemowym i 500-tokenowym zapytaniem użytkownika, generujących odpowiedzi o długości 1,000 tokens:
- Z cachowaniem (99 cache hits): ok. $0.05 łącznie
- Bez cachowania: ok. $0.29 łącznie
- To samo zadanie w GPT-5.4: ok. $3.75 łącznie
W przypadku aplikacji o dużym natężeniu ruchu, oszczędności kumulują się błyskawicznie.
Tryby API: deepseek-chat vs deepseek-reasoner
DeepSeek oferuje dwa różne tryby modelu, z których każdy jest zoptymalizowany pod kątem innych zadań.
deepseek-chat
Standardowy tryb do zadań ogólnego przeznaczenia. Szybki, wydajny i odpowiedni dla większości aplikacji.
| Właściwość | Wartość |
|---|---|
| Max input tokens | 1,000,000 |
| Max output tokens | 8,192 |
| Najlepszy do | Chat, podsumowania, generowanie kodu, ogólne Q&A |
deepseek-reasoner
Umożliwia rozumowanie Chain-of-Thought (CoT). Model "myśli" krok po kroku przed wygenerowaniem ostatecznej odpowiedzi, co drastycznie poprawia dokładność w trudnych problemach.
| Właściwość | Wartość |
|---|---|
| Max input tokens | 1,000,000 |
| Max output tokens | 64,000 |
| Najlepszy do | Matematyka, zagadki logiczne, złożone debugowanie, rozumowanie wieloetapowe |
Model reasoner zwraca zarówno proces myślowy, jak i ostateczną odpowiedź:
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "Prove that the square root of 2 is irrational."}
]
)
# Łańcuch rozumowania
print(response.choices[0].message.reasoning_content)
# Ostateczna odpowiedź
print(response.choices[0].message.content)
Kiedy używać reasoner: Jeśli zadanie wymaga wieloetapowej logiki, dowodów matematycznych lub złożonego debugowania kodu, użyj deepseek-reasoner. Do wszystkiego innego deepseek-chat jest szybszy i tańszy.
Przykłady kodu
Python: Podstawowe 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: Streaming
W przypadku długich odpowiedzi, streaming zapewnia lepsze wrażenia użytkownika, zwracając tokens w miarę ich generowania:
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: Tryb Reasoner
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: Podstawowy Chat
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: 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);
}
}
Context Caching: 90% oszczędności przy powtarzających się prompts
Context caching w DeepSeek to jedna z jego najsilniejszych przewag konkurencyjnych, która wymaga zero zmian w kodzie z Twojej strony.
Jak to działa
Kiedy wysyłasz żądanie, DeepSeek sprawdza, czy początek Twojego promptu pasuje do wcześniej zapisanego w pamięci podręcznej prefiksu. Jeśli pierwsze N tokens jest identyczne z niedawnym żądaniem, te tokens są serwowane z cache po obniżonej stawce ($0.028/M vs $0.28/M).
Dzieje się to automatycznie. Nie musisz deklarować kluczy cache, ustawiać TTL ani w żaden sposób modyfikować wywołań API.
Kiedy aktywuje się cachowanie
Cachowanie uruchamia się, gdy:
- Ten sam system prompt w wielu żądaniach. Jeśli każde żądanie zaczyna się od "Jesteś doświadczonym programistą Python...", ten prefiks zostanie zapamiętany po pierwszym wywołaniu.
- Współdzielona historia konwersacji. W rozmowach wieloturowych, nagromadzona historia z wcześniejszych tur jest cachowana.
- Przetwarzanie wsadowe ze spójnymi szablonami. Uruchomienie tego samego promptu analitycznego na różnych danych wejściowych sprawia, że tylko zmienna część generuje pełny koszt.
Maksymalizacja Cache Hits
Aby w pełni wykorzystać cachowanie:
- Umieszczaj statyczną treść na początku. Ustrukturyzuj wiadomości tak, aby system prompt i wszelkie stałe instrukcje znajdowały się przed zmienną treścią.
- Utrzymuj identyczne system prompts. Nawet różnica jednego znaku przerywa dopasowanie w cache.
- Grupuj podobne żądania. Wysyłaj żądania ze wspólnymi prefiksami w krótkich odstępach czasu, aby cache pozostał aktywny.
- Śmiało używaj długich system prompts. 10,000-tokenowy system prompt nie kosztuje prawie nic po pierwszym zapytaniu, jeśli pozostaje w cache.
Migracja z OpenAI
Jeśli obecnie korzystasz z OpenAI API, przejście na DeepSeek to zmiana dwóch linii kodu. Format API jest identyczny.
Przed (OpenAI)
from openai import OpenAI
client = OpenAI(
api_key="sk-openai-key-here"
# base_url defaults to https://api.openai.com/v1
)
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello"}]
)
Po (DeepSeek)
from openai import OpenAI
client = OpenAI(
api_key="sk-deepseek-key-here",
base_url="https://api.deepseek.com" # <-- dodaj tę linię
)
response = client.chat.completions.create(
model="deepseek-chat", # <-- zmień nazwę modelu
messages=[{"role": "user", "content": "Hello"}]
)
To cała migracja. Zmieniły się dwie linie: base_url i model. Wszystko inne — format wiadomości, streaming, function calling, tryb JSON — działa tak samo.
Podejście ze zmiennymi środowiskowymi
Dla projektów, które muszą łatwo przełączać się między dostawcami:
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"]
)
Używanie DeepSeek z narzędziami Open Source
Ponieważ DeepSeek jest kompatybilny z OpenAI, współpracuje z rosnącym ekosystemem narzędzi open source do kodowania AI. Oto najpopularniejsze z nich.
OpenCode
OpenCode to terminalowy asystent kodowania AI typu open source. Skonfiguruj go do pracy z DeepSeek, ustawiając dostawcę w konfiguracji:
{
"provider": {
"name": "deepseek",
"apiKey": "sk-your-key",
"baseURL": "https://api.deepseek.com",
"model": "deepseek-chat"
}
}
Aider
Aider to działający w linii komend asystent programowania parowego AI. Skieruj go na DeepSeek za pomocą zmiennych środowiskowych:
export OPENAI_API_BASE="https://api.deepseek.com"
export OPENAI_API_KEY="sk-your-deepseek-key"
aider --model openai/deepseek-chat
Continue (Rozszerzenie VS Code)
Continue to otwartoźródłowy asystent kodu AI dla VS Code i JetBrains. Dodaj DeepSeek w swoim pliku ~/.continue/config.json:
{
"models": [
{
"title": "DeepSeek V4",
"provider": "openai",
"model": "deepseek-chat",
"apiBase": "https://api.deepseek.com",
"apiKey": "sk-your-key"
}
]
}
Wszystkie trzy narzędzia traktują DeepSeek jako bezpośredni zamiennik OpenAI. Nie są potrzebne żadne specjalne adaptery ani wtyczki.
Wykorzystanie okna kontekstowego 1M tokens
Okno kontekstowe 1 milion tokens w DeepSeek otwiera możliwości przepływów pracy, które wcześniej były niepraktyczne.
Analiza całej bazy kodu
Typowy średniej wielkości projekt (50,000 linii kodu) to około 500,000 tokens. Dzięki kontekstowi 1M w DeepSeek, możesz przesłać całą bazę kodu w jednym prompcie w celu:
- Przeglądu architektury. Poproś model o zidentyfikowanie cyklicznych zależności, brakujących abstrakcji lub niespójnych wzorców w całym projekcie.
- Refaktoryzacji międzyplikowej. Opisz pożądaną zmianę i pozwól modelowi wygenerować skoordynowane edycje w wielu plikach.
- Audytów bezpieczeństwa. Przeskanuj całą bazę kodu pod kątem SQL injection, XSS i innych podatności w jednym przebiegu.
Praktyczne porady dla dużych kontekstów
- Najpierw podaj drzewo plików. Rozpocznij prompt od struktury katalogów, aby model zrozumiał układ projektu przed czytaniem poszczególnych plików.
- Używaj wyraźnych ograniczników. Otocz każdy plik znacznikami takimi jak
--- FILE: src/auth.py ---, aby model mógł odwoływać się do konkretnych plików w swojej odpowiedzi. - Zadawaj konkretne pytania. Okno kontekstowe 1M nie oznacza, że powinieneś używać niejasnych prompts. Bądź precyzyjny w tym, co chcesz poddać analizie.
- Łącz z cachowaniem. Jeśli zadajesz wiele pytań dotyczących tej samej bazy kodu, część z kodem zostanie zacachowana po pierwszym żądaniu — kolejne pytania będą kosztować ułamek ceny początkowego wywołania.
Najlepsze praktyki optymalizacji kosztów
1. Strukturuj prompty dla maksymalnych Cache Hits
Umieść najdłuższą, najbardziej stabilną treść na początku tablicy komunikatów. System prompts, przykłady few-shot i dokumentacja referencyjna powinny znajdować się przed zmiennym zapytaniem użytkownika.
2. Domyślnie używaj deepseek-chat
Zarezerwuj deepseek-reasoner do zadań, które faktycznie wymagają wieloetapowego rozumowania. Do prostego generowania, podsumowywania i uzupełniania kodu deepseek-chat jest szybszy i zużywa mniej tokens.
3. Ustaw odpowiednie max_tokens
Nie ustawiaj max_tokens wyżej niż to konieczne. Jeśli spodziewasz się 200-tokenowej odpowiedzi, ustawienie max_tokens: 8192 nie zwiększy samo w sobie kosztów, ale uniemożliwi modelowi przerwanie pracy wcześniej, jeśli zacznie niepotrzebnie się rozpisywać.
4. Grupuj podobne żądania
Grupuj żądania korzystające z tego samego system prompt i wysyłaj je w krótkich odstępach czasu. Dzięki temu cache pozostanie "rozgrzany" i zapewni dopasowanie prefiksu w większości zapytań.
5. Monitoruj zużycie tokens
Sprawdzaj pole usage w odpowiedziach API, aby śledzić rzeczywiste zużycie:
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. Używaj streamingu dla długich odpowiedzi
Streaming nie oszczędza pieniędzy, ale poprawia odczuwalną latencję. Użytkownicy widzą pierwsze tokens w ciągu milisekund, zamiast czekać na wygenerowanie pełnej odpowiedzi.
Podsumowanie
API DeepSeek łączy w sobie agresywną politykę cenową, kompatybilność z OpenAI i okno kontekstowe 1M tokens w pakiet, który trudno zignorować. Ścieżka migracji z OpenAI jest trywialna — zmień dwie linie kodu, a Twoja istniejąca aplikacja będzie działać. Context caching zapewnia automatyczne oszczędności kosztów bez żadnych zmian w kodzie. A ekosystem narzędzi open source już wspiera DeepSeek jako dostawcę pierwszej kategorii.
Dla programistów budujących aplikacje wrażliwe na koszty, potoki przetwarzania o dużym natężeniu ruchu lub narzędzia do analizy całych baz kodu, DeepSeek V4 jest rozwiązaniem wartym poważnego rozważenia. Zacznij od 5 milionów darmowych tokens, porównaj wyniki z obecnym dostawcą i pozwól, aby liczby pokierowały Twoją decyzją.
