כמה עולה ה-DeepSeek V4 API?

ה-pricing הנוכחי של DeepSeek הוא בערך $0.028 למיליון tokens עבור cache hits, כ-$0.28 למיליון עבור cache misses (input) ו-$0.42 למיליון עבור output tokens. המחירים עבור V4 עשויים להשתנות, אך DeepSeek שומרת היסטורית על תעריפים תחרותיים מאוד — בערך פי 50 זול יותר מ-Claude Opus.

האם ה-DeepSeek API תואם ל-OpenAI?

כן. DeepSeek API עוקב אחר הפורמט של OpenAI API. ניתן להשתמש ב-OpenAI Python SDK על ידי שינוי ה-base_url ל-'https://api.deepseek.com' ושימוש ב-DeepSeek API key שלכם. מרבית הכלים וה-frameworks התואמים ל-OpenAI עובדים עם DeepSeek out of the box.

איך ניתן לקבל DeepSeek API key?

הירשמו ב-platform.deepseek.com, עברו לקטגוריית API Keys וצרו key חדש. משתמשים חדשים מקבלים 5 מיליון tokens בחינם, ללא צורך בכרטיס אשראי.

מה זה DeepSeek context caching?

Context caching משתמש מחדש באופן אוטומטי בקידומות prompt משותפות בבקשות. אם ה-prompt שלכם מתחילים באותו אופן (למשל system prompts), תוכן שמור ב-cache עולה $0.028/M tokens לעומת $0.28/M עבור cache misses — חיסכון של 90%. זה קורה באופן אוטומטי ואינו דורש שינויים בקוד.

האם ניתן להשתמש ב-DeepSeek V4 עם LangChain או LlamaIndex?

כן. מכיוון ש-DeepSeek עוקב אחר הפורמט של OpenAI API, הוא עובד עם LangChain, LlamaIndex ומרבית ה-AI frameworks התומכים ב-endpoints תואמי OpenAI. פשוט הגדירו את ה-base URL וה-API key.

מה ההבדל בין deepseek-chat ל-deepseek-reasoner?

deepseek-chat הוא המצב הסטנדרטי למשימות כלליות עם 8K max output. ה-deepseek-reasoner כולל חשיבת Chain-of-Thought עם 64K max output, מה שמתאים באופן אידיאלי למשימות במתמטיקה, לוגיקה ותכנות מורכב. ה-Reasoner צורך יותר tokens, אך מספק איכות תוצאות גבוהה יותר למשימות קשות.

Viktiga slutsatser

OpenAI-kompatibelt API: DeepSeek följer OpenAI API-formatet -- byt genom att ändra base URL och API-nyckel. OpenAI Python SDK, LangChain och LlamaIndex fungerar direkt.
90 % besparingar med context caching: Delade prompt-prefix cachas automatiskt till $0.028/M tokens jämfört med $0.28/M vid cache misses -- inga kodändringar krävs.
5 miljoner fria tokens för att börja: Nya konton får 5M fria tokens utan att något kreditkort krävs, vilket räcker för omfattande experimenterande.
Två lägen: deepseek-chat för standarduppgifter (8K max output) och deepseek-reasoner för Chain-of-Thought-resonemang (64K max output) -- reasoner använder fler tokens men ger bättre resultat på svåra problem.

DeepSeek V4 API-guide: Prissättning, konfiguration och kodexempel

DeepSeek har blivit den ledande aktören gällande kostnad för LLM-API:er. Med en prissättning som ligger en storleksordning under OpenAI och Anthropic, och full OpenAI SDK-kompatibilitet, tar det ungefär fem minuter att byta till DeepSeek. Denna guide går igenom allt: kontoinställning, prisberäkning, kodexempel i Python och JavaScript, context caching och migrering från OpenAI.

Oavsett om du bygger en chatbot, en kodningsassistent eller bearbetar hela källkoder med ett kontextfönster på 1M tokens, så har den här guiden allt du behöver.

Snabbstart: Ditt första DeepSeek API-anrop

Att komma igång kräver tre steg.

1. Skapa ett konto

Gå till platform.deepseek.com och registrera dig. Nya konton får 5 miljoner fria tokens utan att något kreditkort krävs — tillräckligt för att experimentera omfattande innan du binder dig.

2. Generera en API-nyckel

Navigera till API Keys i instrumentpanelen. Klicka på Create new API key, ge den ett namn och kopiera nyckeln omedelbart. Du kommer inte att kunna se den igen.

Lagra nyckeln som en miljövariabel:

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

3. Gör din första begäran

Eftersom DeepSeek följer OpenAI API-formatet kan du använda det officiella OpenAI SDK. Installera det först:

pip install openai

Gör sedan ett enkelt chat completion-anrop:

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)

Det är allt. Om du har använt OpenAI API tidigare är de enda skillnaderna base_url och din API-nyckel.

Prisöversikt

DeepSeeks prismodell är enkel och dramatiskt billigare än konkurrenternas. Den viktigaste differentiatorn är context caching, vilket minskar input-kostnaderna med 90 % för upprepade prompt-prefix.

DeepSeek API Prissättning

Typ av token	Kostnad per 1M tokens
Input (cache hit)	$0.028
Input (cache miss)	$0.28
Output	$0.42

Jämförelse

Leverantör / Modell	Input (per 1M)	Output (per 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

Siffrorna talar för sig själva. Med cache hits är DeepSeek ungefär 90x billigare än OpenAI på input-tokens och 500x billigare än Claude Opus. Även utan caching är DeepSeeks cache-miss-pris på $0.28/M fortfarande 9x billigare än input-priset för GPT-5.4.

Kostnadsexempel

Bearbetning av 100 förfrågningar, var och en med en system-prompt på 2,000 tokens och en användarfråga på 500 tokens, vilket genererar svar på 1,000 tokens:

Med caching (99 cache hits): ~$0.05 totalt
Utan caching: ~$0.29 totalt
Samma arbetsbelastning på GPT-5.4: ~$3.75 totalt

För applikationer med stora volymer ackumuleras besparingarna snabbt.

API-lägen: deepseek-chat mot deepseek-reasoner

DeepSeek erbjuder två distinkta modell-lägen, var och en optimerad för olika uppgifter.

deepseek-chat

Standardläget för allmänna uppgifter. Snabbt, effektivt och lämpligt för de flesta applikationer.

Egenskap	Värde
Max input-tokens	1,000,000
Max output-tokens	8,192
Bäst för	Chat, sammanfattning, kodgenerering, allmänna frågor och svar

deepseek-reasoner

Möjliggör Chain-of-Thought (CoT)-resonemang. Modellen "tänker" steg för steg innan den producerar ett slutgiltigt svar, vilket dramatiskt förbättrar noggrannheten vid svåra problem.

Egenskap	Värde
Max input-tokens	1,000,000
Max output-tokens	64,000
Bäst för	Matematik, logiska pussel, komplex felsökning, flerstegsresonemang

Modellen returnerar både tankeprocessen och det slutgiltiga svaret:

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

# Resonemangskedjan
print(response.choices[0].message.reasoning_content)

# Det slutgiltiga svaret
print(response.choices[0].message.content)

När man ska använda reasoner: Om uppgiften kräver flerstegslogik, matematiska bevis eller komplex kodfelsökning, använd deepseek-reasoner. För allt annat är deepseek-chat snabbare och billigare.

Kodexempel

Python: Grundläggande 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

För långa svar ger streaming en bättre användarupplevelse genom att returnera tokens allt eftersom de genereras:

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-läge

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: Grundläggande 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 % besparingar på upprepade prompter

DeepSeeks context caching är en av dess starkaste konkurrensfördelar, och den kräver noll kodändringar från din sida.

Så fungerar det

När du skickar en förfrågan kontrollerar DeepSeek om början på din prompt matchar ett tidigare cachat prefix. Om de första N tokens är identiska med en nyligen gjord förfrågan, serveras dessa tokens från cachen till det reducerade priset ($0.028/M jämfört med $0.28/M).

Detta sker automatiskt. Du behöver inte deklarera cache-nycklar, ställa in TTL:er eller ändra dina API-anrop på något sätt.

När caching aktiveras

Caching kickar in när:

Samma system-prompt används i olika förfrågningar. Om varje förfrågan börjar med "You are a senior Python developer...", kommer det prefixet att cachas efter det första anropet.
Delad konversationshistorik. I konversationer med flera turer cachas den ackumulerade historiken från tidigare turer.
Batchbearbetning med konsekventa mallar. Genom att köra samma analys-prompt över olika indata innebär det att endast den variabla delen debiteras enligt fullt pris.

Maximera cache hits

För att få ut det mesta av caching:

Placera statiskt innehåll först. Strukturera dina meddelanden så att system-prompten och eventuella fasta instruktioner kommer före variabelt innehåll.
Håll system-prompter identiska. Till och med en skillnad på ett enda tecken gör att cache-matchningen bryts.
Batchkör liknande förfrågningar tillsammans. Skicka förfrågningar med delade prefix i snabb följd så att cachen hålls varm.
Använd långa system-prompter med självförtroende. En system-prompt på 10,000 tokens kostar nästan ingenting efter den första förfrågan om den förblir cachad.

Migrering från OpenAI

Om du för närvarande använder OpenAI API är bytet till DeepSeek en ändring på två rader. API-formatet är identiskt.

Före (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"}]
)

Efter (DeepSeek)

from openai import OpenAI

client = OpenAI(
    api_key="sk-deepseek-key-here",
    base_url="https://api.deepseek.com"  # <-- lägg till denna rad
)

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

Det är hela migreringen. Två rader ändrade: base_url och model. Allt annat — meddelandeformat, streaming, function calling, JSON-läge — fungerar på samma sätt.

Tillvägagångssätt med miljövariabler

För projekt som enkelt behöver kunna växla mellan leverantörer:

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"]
)

Använd DeepSeek med open source-verktyg

Eftersom DeepSeek är OpenAI-kompatibelt fungerar det med det växande ekosystemet av open source-verktyg för AI-kodning. Här är de mest populära.

OpenCode

OpenCode är en open source terminal-baserad AI-kodningsassistent. Konfigurera den för att använda DeepSeek genom att ställa in leverantören i din konfiguration:

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

Aider

Aider är en AI-parprogrammerare för kommandoraden. Peka den mot DeepSeek med miljövariabler:

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

Continue (VS Code-tillägg)

Continue är en open source AI-kodassistent för VS Code och JetBrains. Lägg till DeepSeek i din ~/.continue/config.json:

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

Alla tre verktyg behandlar DeepSeek som en direkt ersättning för OpenAI. Inga speciella adaptrar eller insticksmoduler behövs.

Utnyttja 1M token-kontextfönstret

DeepSeeks kontextfönster på 1 miljon tokens möjliggör arbetsflöden som tidigare var ogenomförbara.

Analys av hela källkoden

Ett typiskt medelstort projekt (50,000 rader kod) är ungefär 500,000 tokens. Med DeepSeeks 1M-kontext kan du mata in en hel källkod i en enda prompt för:

Arkitekturgranskningar. Be modellen identifiera cirkulära beroenden, saknade abstraktioner eller inkonsekventa mönster i hela projektet.
Refaktorering över flera filer. Beskriv den önskade ändringen och låt modellen generera samordnade redigeringar i flera filer.
Säkerhetsgranskningar. Skanna hela källkoden efter SQL-injektioner, XSS och andra sårbarheter i en enda genomgång.

Praktiska tips för stora kontexter

Tillhandahåll ett filträd först. Börja din prompt med katalogstrukturen så att modellen förstår projektets layout innan den läser enskilda filer.
Använd tydliga avgränsare. Omslut varje fil med markörer som --- FILE: src/auth.py --- så att modellen kan referera till specifika filer i sitt svar.
Ställ fokuserade frågor. Ett kontextfönster på 1M betyder inte att du behöver använda vaga prompter. Var specifik med vad du vill ha analyserat.
Kombinera med caching. Om du gör flera förfrågningar mot samma källkod kommer källkodsdelen att cachas efter den första förfrågan — efterföljande frågor kostar en bråkdel av det inledande anropet.

Best practices för kostnadsoptimering

1. Strukturera prompter för maximala cache hits

Placera ditt längsta och mest stabila innehåll i början av meddelandearrayen. System-prompter, few-shot-exempel och referensdokumentation bör komma före den variabla användarfrågan.

2. Använd deepseek-chat som standard

Reservera deepseek-reasoner för uppgifter som verkligen kräver resonemang i flera steg. För okomplicerad generering, sammanfattning och kodkomplettering är deepseek-chat snabbare och använder färre tokens.

3. Ställ in lämplig max_tokens

Ställ inte in max_tokens högre än du behöver. Om du förväntar dig ett svar på 200 tokens kommer inställningen max_tokens: 8192 inte i sig att kosta mer, men det förhindrar modellen från att fortsätta i onödan om den blir mångordig.

4. Batchkör liknande förfrågningar

Gruppera förfrågningar som delar samma system-prompt och skicka dem i snabb följd. Detta håller cachen varm och säkerställer att de flesta förfrågningar träffar det cachade prefixet.

5. Övervaka token-användning

Kontrollera fältet usage i API-svaren för att spåra din faktiska konsumtion:

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. Använd streaming för långa outputs

Streaming sparar inte pengar, men det förbättrar den upplevda latenstiden. Användare ser de första tokens inom millisekunder istället för att vänta på att hela svaret ska genereras.

Sammanfattning

DeepSeeks API kombinerar aggressiv prissättning, OpenAI-kompatibilitet och ett 1M token-kontextfönster i ett paket som är svårt att ignorera. Migreringsvägen från OpenAI är trivial — ändra två rader kod och din befintliga applikation fungerar. Context caching ger automatiska kostnadsbesparingar utan några kodändringar. Och ekosystemet för open source-verktyg stöder redan DeepSeek som en förstklassig leverantör.

För utvecklare som bygger kostnadskänsliga applikationer, pipeline-processer för stora volymer eller verktyg för analys av hela källkoder är DeepSeek V4 värt att seriöst överväga. Börja med de 5 miljoner fria tokensen, gör prestandatester mot din nuvarande leverantör och låt siffrorna styra ditt beslut.

מדריך ל-DeepSeek V4 API: Pricing, Setup & Code Examples (2026)