DEV Community: Emre Demir

DeepSeek V4 Kostenlos Nutzen: Anleitung & Tipps

Emre Demir — Fri, 24 Apr 2026 05:21:57 +0000

DeepSeek V4 wurde am 23. April 2026 veröffentlicht. Im Gegensatz zu vielen anderen Launches sind die kostenlosen Nutzungsmöglichkeiten tatsächlich nutzbar: Der offizielle Web-Chat läuft mit V4-Pro ohne Kreditkarte, die MIT-lizenzierten Gewichte sind heute verfügbar und Aggregatoren wie OpenRouter und Chutes bieten oft wenige Tage nach Release kostenlose Stufen an. So können Sie V4-Workloads ernsthaft testen, bevor Sie sich für ein kostenpflichtiges Modell entscheiden.

Testen Sie Apidog noch heute

In diesem Leitfaden finden Sie konkrete, geprüfte kostenlose Pfade, passende Anwendungsfälle und eine Schritt-für-Schritt-Anleitung, wie Sie eine produktionsreife Sammlung in Apidog einrichten. So bleibt Ihr Wechsel zur kostenpflichtigen Nutzung bei steigendem Bedarf reibungslos.

Eine Produktübersicht: Was ist DeepSeek V4. Komplette API-Anleitung: So verwenden Sie die DeepSeek V4 API.

Kurzfassung

chat.deepseek.com – Kostenloser Web-Chat mit V4-Pro, Think High-/Think Max-Modi. Keine Karte nötig, funktioniert sofort.
Hugging Face Gewichte + eigene GPU – MIT-Lizenz, V4-Flash läuft auf 2–4 H100s, V4-Pro benötigt einen Cluster.
OpenRouter und Chutes kostenlose Tarife – Drittanbieter-Gateways mit meist zeitnahen Freischaltungen für neue DeepSeek-Modelle.
Hugging Face Inference Provider – Ratenbegrenzter, geteilter Endpunkt für frühe Experimente.
Kaggle, Colab, RunPod Testguthaben – Einmalige kostenlose Rechenleistung zum Self-Hosting-Test.
Jeder kostenlose Pfad limitiert die Nutzung. Für produktiven Einsatz wechseln Sie rechtzeitig zu kostenpflichtigen APIs.

Pfad 1: chat.deepseek.com (der Standardweg)

Der schnellste Weg: Die offizielle Chat-Oberfläche. V4-Pro ist Standard, der Umschalter oben wechselt zwischen Non-Think, Think High und Think Max.

Einrichtung

Öffnen Sie chat.deepseek.com.
Anmeldung via E-Mail, Google oder WeChat.
Prüfen, dass das Modell V4-Pro aktiv ist.
Prompt schreiben und losschicken.

Was ist verfügbar

Komplettes 1M-Token-Kontextfenster
Dateiupload (PDF, Bilder, Codepakete)
Websuche on demand
Alle Denkmodi inklusive Think Max
Gesprächsverlauf und Ordnerstruktur

Begrenzungen

Es gibt keine feste Tageslimitierung; die Drosselung erfolgt dynamisch unter Last. Starke Nutzung kann zu Wartezeiten führen, jedoch selten zu Komplettsperren. Bei dauerhafter Ratenbegrenzung empfiehlt sich der Wechsel zur API.

Geeignet für: Schnelles Testen, Architektur-Reviews, Think Max gegen komplexe Dokumente

Nicht geeignet für: Automatisierung, reproduzierbare Workflows

Pfad 2: V4-Flash selbst hosten (eigene GPU)

V4-Flash ist MIT-lizenziert und realistisch selbst zu betreiben. 284B gesamt, 13B aktiv – läuft auf Multi-H100-Box (FP8) mit hohem Durchsatz, INT4-Quantisierung reicht für eine einzelne 80GB-Karte.

Kosten: Hardware, nicht Lizenz

Ideal: Bereits vorhandene GPU-Kapazitäten oder Compliance-Anforderungen

Gewichte herunterladen

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash

Erfordert ca. 500 GB bei FP8.

Deployment mit vLLM

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto \
  --port 8000

Stellen Sie OpenAI-kompatible Clients auf http://localhost:8000/v1 um. Apidog behandelt diesen Endpunkt wie jede andere Basis-URL, gespeicherte Collections bleiben nutzbar.

Hardware-Check

Variante	Min. Karten (FP8)	Min. Karten (INT4)	Realistischer Durchsatz
V4-Flash	2 × H100 80GB	1 × H100 80GB	50–150 Tok/s
V4-Pro	16 × H100 80GB	8 × H100 80GB	Cluster-abhängig

Wenn keine ungenutzten Karten vorhanden sind, ist die API in der Regel günstiger als GPU-Miete. Dieser Weg lohnt für bestehende Hardware oder strenge Compliance.

Pfad 3: OpenRouter kostenloser Tarif

OpenRouter aggregiert APIs für offene und geschlossene Modelle und stellt regelmäßig kostenlose Tarife für neue DeepSeek-Releases bereit.

Einrichtung

Registrierung bei openrouter.ai.
API-Schlüssel generieren.
Im Modellkatalog nach deepseek/deepseek-v4-pro oder deepseek/deepseek-v4-flash suchen, kostenlose Varianten sind mit :free gekennzeichnet.
Nutzung mit OpenAI-kompatiblem SDK.

from openai import OpenAI

client = OpenAI(
    api_key=OPENROUTER_KEY,
    base_url="https://openrouter.ai/api/v1",
)

response = client.chat_completions.create(
    model="deepseek/deepseek-v4-flash:free",
    messages=[{"role": "user", "content": "Write a Python CLI for semver bumping."}],
)

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

Begrenzungen

Kostenlose Tarife erlauben meist einige hundert Anfragen/Tag und Schlüssel, bei Last mit reduzierter Priorität. Für Prototyping geeignet, nicht für Produktion.

Pfad 4: Hugging Face Inference Provider

Hugging Face bietet gehostete Inferenz-Endpoints für neue DeepSeek-Modelle. Die Nutzung ist kostenlos, aber stark ratenbegrenzt.

from huggingface_hub import InferenceClient

client = InferenceClient(model="deepseek-ai/DeepSeek-V4-Flash")

response = client.chat_completion(
    messages=[{"role": "user", "content": "Summarize the V4 technical report in 5 bullets."}],
    max_tokens=512,
)

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

Für intensivere Nutzung empfiehlt sich ein Pro-Account – günstiger als die offizielle API.

Pfad 5: Testguthaben bei Colab, Kaggle, RunPod, Lambda

Viele GPU-Mietdienste bieten Testguthaben:

Google Colab: Kostenloser T4-Tarif reicht nicht, aber Colab Pro+ mit 500 Compute-Einheiten/Monat reicht für einige V4-Flash-Experimente (A100).
Kaggle: Wöchentliche kostenlose GPU-Stunden (T4, P100) – zu klein für V4-Pro, reicht manchmal für quantisierte V4-Flash-Tests.
RunPod: $10 Testguthaben – reicht für mehrere Stunden auf H100.
Lambda: Gelegentlich Gratis-Stunden auf H100/H200; aktuelle Aktionen bei Registrierung prüfen.

Alle diese Wege sind für einmalige Tests, nicht für langfristige Nutzung geeignet.

Anbieterunabhängige Apidog-Sammlung erstellen

Der Vorteil: Testen Sie denselben Prompt gleichzeitig auf allen kostenlosen Pfaden ohne Dopplung. Vorgehen:

Apidog herunterladen.
Erstellen Sie eine Sammlung mit vier Umgebungen:
- chat (Platzhalter)
- deepseek (https://api.deepseek.com/v1)
- openrouter (https://openrouter.ai/api/v1)
- self-hosted (http://localhost:8000/v1)
Speichern Sie eine POST-Anfrage an {{BASE_URL}}/chat/completions.
Legen Sie Anbieter-Keys als geheime Variablen an, damit der Request-Body identisch bleibt.
Wechseln Sie die Umgebungen, um Prompts per A/B-Test über alle Backends zu schicken.

Nutzen Sie das gleiche Muster wie für die GPT-5.5 Free-Tier-Sammlung.

Welchen kostenlosen Pfad sollten Sie wählen?

In 5 Minuten testen: chat.deepseek.com
Prototyp bauen: OpenRouter kostenlos, dann DeepSeek-API laden
Eigene GPUs und Compliance: V4-Flash selbst hosten (vLLM)
Langfristig kostenlos nutzen: Gibt es nicht – kombinieren Sie chat.deepseek.com für Interaktion mit kleinen kostenpflichtigen Paketen für Automatisierung.

Wann den kostenlosen Tarif verlassen?

Wechseln Sie zu kostenpflichtigen APIs, wenn:

Ratenbegrenzung mehrmals täglich auftritt: Dann lohnt sich ein Budget.
SLAs benötigt werden: Nur die offizielle API bietet diese.
Protokollierung, Auditing, Compliance: Die kostenpflichtige API liefert klare Abrechnungsdaten.

Dann empfiehlt sich die offizielle API. Mindestaufladung: $2, Frontier-Tarif ist am günstigsten.

FAQ

Ist chat.deepseek.com wirklich kostenlos?

Ja, keine Kreditkarte, keine Testzeit. Es wird nur bei hoher Last sanft gedrosselt.

Brauche ich ein Hugging Face-Konto für die Gewichte?

Technisch nein, aber angemeldet sind die Downloads weniger eingeschränkt.

Welcher kostenlose Pfad bietet echtes V4-Pro?

chat.deepseek.com liefert immer V4-Pro. OpenRouter-free ist meist V4-Flash. V4-Pro-Ausgaben kostenlos gibt es zuverlässig nur im Web-Chat.

Kann ein kostenloser Tarif produktiv genutzt werden?

Nicht verantwortungsvoll — Tarife können limitiert oder abgestellt werden. Für Kundenanwendungen: kostenpflichtige API oder eigenes Hosting.

Ist Self-Hosting wirklich kostenlos?

Die Lizenz ist es, die Hardware nicht. Bei bestehenden GPUs sind die Zusatzkosten minimal. Miete lohnt meist nicht.

Wird es einen kostenlosen Apidog-Tarif geben?

Apidog ist für API-Design/-Testing kostenlos; Gebühren entstehen nur bei kostenpflichtigen API-Aufrufen. Sie können also mit chat.deepseek.com oder OpenRouter einen komplett kostenfreien Workflow aufsetzen.

DeepSeek V4 lokal ausführen: Eine Anleitung

Emre Demir — Fri, 24 Apr 2026 04:49:14 +0000

DeepSeek V4 wurde am 23. April 2026 mit MIT-lizenzierten Gewichten auf Hugging Face veröffentlicht. Diese einzelne Lizenzwahl ändert die Rechnung für jedes Team, das Spitzen-KI auf seiner eigenen Hardware betreiben möchte. V4-Flash (insgesamt 284 Mrd., 13 Mrd. aktiv) passt auf ein Paar H100s bei FP8. V4-Pro (insgesamt 1,6 Billionen, 49 Mrd. aktiv) benötigt einen Cluster, läuft aber bei Code und Reasoning wettbewerbsfähig mit GPT-5.5 und Claude Opus 4.6.

Teste Apidog noch heute

Dieser Leitfaden zeigt dir Schritt für Schritt, wie du DeepSeek V4 lokal bereitstellst. Es werden die Hardware-Anforderungen, Quantisierungsoptionen, Setups für vLLM und SGLang, die Konfiguration der Tool-Nutzung sowie ein Test-Workflow in Apidog behandelt – so validierst du deinen lokalen Server, bevor du Produktionsdaten darauf leitest.

Für eine Produktübersicht siehe was ist DeepSeek V4. Für den gehosteten API-Pfad siehe wie man die DeepSeek V4 API verwendet. Für den Kostenvergleich siehe DeepSeek V4 API-Preise.

TL;DR

V4-Flash läuft auf 2 × H100 80 GB mit FP8 oder 1 × H100 mit INT4. Die Gewichte betragen bei FP8 ~500 GB.
V4-Pro benötigt 16+ H100s mit FP8 für Produktionsdurchsatz; kein Laptop-Modell.
vLLM ist der schnellste Weg zu einem OpenAI-kompatiblen Server. vllm>=0.9.0 bringt V4-Unterstützung.
SGLang ist die Alternative für Teams, die bessere Funktionen für Tool-Nutzung und strukturierte Ausgabe benötigen.
Quantisierung auf AWQ INT4 oder GPTQ INT4 ermöglicht Betrieb von V4-Flash auf einer einzelnen 80-GB-Karte mit ~5 % Qualitätsverlust.
Nutze Apidog, um auf http://localhost:8000/v1 zu verweisen und dieselbe Sammlung wie für die gehostete API wiederzuverwenden.

Wer sollte selbst hosten

Das Selbst-Hosting von V4 ist sinnvoll für:

Compliance-pflichtige Teams: Gesundheitswesen, Finanzen, Recht, Verteidigung – überall, wo Daten das Netzwerk nicht verlassen dürfen. Die MIT-Lizenz eliminiert Nutzungsvereinbarungen und grenzüberschreitende Datenflüsse.
Große, stabile Workloads: Ab ca. 200 Milliarden Tokens pro Monat wird dedizierte Hardware günstiger als die V4-Pro API (1,74 $/Mio. Eingabe, 3,48 $/Mio. Ausgabe).
Feinabstimmung & Forschung: Basis-Checkpoints sind für weiteres Vortraining und Domänenanpassung ausgelegt; die MIT-Lizenz erlaubt kommerzielle Weiterverteilung.

Nicht selbst hosten sollten: Prototypenentwickler, Teams ohne GPU-Betriebserfahrung und alle mit Workloads unter 200 $/Monat im gehosteten API-Modell.

Hardware-Anforderungen

DeepSeek V4 nutzt nativ FP4 + FP8 gemischte Präzision. Die Speicherberechnung ist günstiger als es die reine Parameteranzahl vermuten lässt.

Variante	Gesamtparameter	Aktive Parameter	FP8 VRAM	INT4 VRAM	Minimale Karten
V4-Flash	284 Mrd.	13 Mrd.	~500 GB	~140 GB	2 × H100 80 GB (FP8) oder 1 × H100 (INT4)
V4-Pro	1,6 Billionen	49 Mrd.	~2,4 TB	~700 GB	16 × H100 80 GB (FP8) oder 8 × H100 (INT4)

Wichtige Hinweise:

MoE-Speicher ist Gesamt-, nicht Aktivspeicher. Der VRAM-Bedarf bezieht sich auf alle Experten, nicht nur die aktiven.
H200 & MI300X sind kompatible Alternativen; durch mehr VRAM pro Karte werden weniger Karten benötigt.
Consumer-GPUs ungeeignet. Selbst INT4 passt nicht auf 24-GB-RTX 5090.
Apple Silicon: M3/M4 Max (128 GB RAM) können V4-Flash mit starker Quantisierung langsam laufen lassen – nur als Entwicklungs-Spielwiese, nicht für Produktion.

Schritt 1: Gewichte herunterladen

Offizielle Modelle:

deepseek-ai/DeepSeek-V4-Flash
deepseek-ai/DeepSeek-V4-Pro
deepseek-ai/DeepSeek-V4-Flash-Base und DeepSeek-V4-Pro-Base für Feinabstimmung.

Download per CLI:

pip install -U "huggingface_hub[cli]"
huggingface-cli login

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

Reserviere ~500 GB Speicherplatz für V4-Flash, mehrere TB für V4-Pro. Modelscope.cn ist für China oft schneller.

Schritt 2: Serving-Engine auswählen

Zwei Hauptoptionen:

vLLM: Bester Durchsatz, OpenAI-kompatible Schnittstelle, große Community. Standard.
SGLang: Bessere Tool-Nutzung, strukturierte Ausgabe, Vorteile bei langem Kontext. Wähle dies, wenn Funktionsaufrufe zentral sind.

Beide unterstützen V4 ab aktuellen Versionen.

Schritt 3: V4-Flash mit vLLM bereitstellen

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --dtype auto \
  --enable-prefix-caching \
  --port 8000

Flags:

--tensor-parallel-size 2: Modell auf 2 H100s verteilen. Mehr Karten = höhere Zahl.
--max-model-len 1048576: Volles 1M-Token-Kontextfenster. Für weniger Kontext (und mehr VRAM) z.B. 131072.
--enable-prefix-caching: Lokale Cache-Hit-Preise wie bei der gehosteten API.
--dtype auto: Nutzt FP8-Mischpräzision.

Nach dem Start ist der Server OpenAI-kompatibel unter http://localhost:8000/v1.

Schritt 4: V4-Pro mit vLLM bereitstellen

Cluster erforderlich. Befehlsstruktur:

vllm serve deepseek-ai/DeepSeek-V4-Pro \
  --tensor-parallel-size 8 \
  --pipeline-parallel-size 2 \
  --max-model-len 524288 \
  --enable-prefix-caching \
  --port 8000

Hier ist der Kontext auf 512K reduziert, damit das Modell in eine 16-H100-Box passt. Pipeline- und Tensor-Parallelität ermöglichen knotenübergreifenden Betrieb.

Schritt 5: Mit SGLang bereitstellen (Alternative für Tool-Nutzung)

pip install "sglang[all]>=0.4.0"

python -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp 2 \
  --context-length 1048576 \
  --port 30000

SGLang stellt eine OpenAI-kompatible API unter http://localhost:30000/v1 bereit. Die lang-DSL bietet bessere Funktionsaufruf- und JSON-Ausgabe-Primitives als vLLM.

Schritt 6: Für eine Single-GPU-Box quantisieren

INT4-Quantisierung ermöglicht V4-Flash auf einer 80-GB-Karte mit geringem Qualitätsverlust.

AWQ (empfohlen)

pip install autoawq

python -c "
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = './models/deepseek-v4-flash'
out_path = './models/deepseek-v4-flash-awq'
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
model.quantize(tokenizer, quant_config={'w_bit': 4, 'q_group_size': 128})
model.save_quantized(out_path)
tokenizer.save_pretrained(out_path)
"

GPTQ

pip install auto-gptq
# Folge dem GPTQ-Quantisierungs-Recipe; ähnlich wie bei AWQ.

Starte den quantisierten Checkpoint mit vLLM via --quantization awq oder --quantization gptq.

Schritt 7: Mit Apidog testen

Schicke keinen Produktionsverkehr an einen neuen lokalen Server – validiere ihn zuerst.

Apidog herunterladen.
Neue Sammlung mit http://localhost:8000/v1/chat/completions als Ziel anlegen.
Den gleichen Test-Prompt wie bei der gehosteten API nutzen. Ergebnisse vergleichen.
Einen 500K-Token-Kontexttest durchführen, um den KV-Cache zu prüfen.
Einen Tool-Calling-Workflow komplett durchtesten, bevor weitere Systeme angebunden werden.

Die gleiche Sammlung, die du für die gehostete DeepSeek V4 API nutzt, funktioniert lokal durch simples Ändern der Basis-URL – OpenAI-Kompatibilität macht’s möglich.

Beobachtbarkeit und Überwachung

Diese vier Metriken solltest du von Anfang an tracken:

Tokens pro Sekunde: Prompt & Generierung (vLLM bietet /metrics im Prometheus-Format).
GPU-Auslastung: Mit nvidia-smi oder DCGM. < 70 % Auslastung deutet auf zu kleine Batch-Größe hin.
KV-Cache-Trefferrate: Mit --enable-prefix-caching sichtbar; sinkende Rate = weniger Durchsatz.
Anforderungslatenz p50/p95/p99: Mit Tracing; hoher p99 bei stabilem p50 = einzelne Requests blockieren die Queue.

Alle Metriken sollten an Grafana oder euren Observability-Stack weitergeleitet werden.

Feinabstimmung von V4 Basis-Checkpoints

Basis-Checkpoints sind für weiteres Vortraining und SFT gedacht. Standard-Pipeline:

pip install "torch>=2.6" transformers accelerate peft trl

# Standard SFT mit LoRA auf V4-Flash-Base
python -m trl sft \
  --model_name_or_path deepseek-ai/DeepSeek-V4-Flash-Base \
  --dataset_name your-org/your-sft-set \
  --output_dir ./models/v4-flash-custom \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 2e-5 \
  --bf16 true \
  --use_peft true \
  --lora_r 64 \
  --lora_alpha 128

Die vollständige Feinabstimmung von V4-Pro ist eine Großaufgabe. Für die meisten Teams sind LoRA-Adapter auf V4-Flash-Base der realistische Weg: viel Qualitätsgewinn, wenig Aufwand.

Häufige Fallstricke

OOM beim Start: Meist ist --max-model-len zu hoch oder --tensor-parallel-size zu niedrig. Kontext halbieren oder Parallelität erhöhen.
Langsamer erster Request: vLLM kompiliert Kernel lazy – erster Aufruf pro Form dauert immer. Mit Dummy-Request vorwärmen.
Fehler beim Parsen der Tool-Nutzung: DeepSeek-Kodierung unterscheidet sich leicht von OpenAI. Nutze ein SDK, das V4 explizit unterstützt.
FP8-Fehler auf älteren Karten: A100s unterstützen FP8 nicht. BF16 verwenden und mit doppeltem VRAM rechnen.

Wann sich das Selbst-Hosting lohnt

Break-Even-Berechnung (siehe Preise der gehosteten DeepSeek V4 API):

V4-Flash bei 200 Mrd. Eingabe + 20 Mrd. Ausgabe/Monat: ~33,6 Tsd. $ (gehostet) vs. ~20 Tsd. $/Monat (8 × H100 gemietet) → Selbst-Hosting spart ~40 %.
V4-Pro bei 500 Mrd. Eingabe + 50 Mrd. Ausgabe/Monat: ~1,04 Mio. $ (gehostet) vs. ~35 Tsd. $/Monat (16 × H100 Cluster) → Selbst-Hosting spart >95 %.

Break-Even für V4-Flash ab ca. 100 Mrd. Tokens/Monat. Darunter lohnt sich gehostet eher.

FAQ

Kann ich V4-Flash auf einer einzelnen A100 ausführen?

Mit starker Quantisierung und reduziertem Kontext – ja, aber langsam. INT4 auf 80-GB-A100: 5–15 Tokens/s. H100 ist optimal.

Unterstützt V4 LoRA-Feinabstimmung?

Ja. Nutze Basis-Checkpoints und Standard-TRL- oder Axolotl-Pipelines. MoE-Routing beeinflusst LoRA nicht.

Ist der lokale Server OpenAI-kompatibel?

Ja. vLLM & SGLang exposen /v1/chat/completions und /v1/completions nach OpenAI-Format. Der API-Leitfaden funktioniert auch mit localhost.

Wie aktiviere ich den Denkmodus lokal?

Im Request-Body thinking_mode: "thinking" oder "thinking_max" übergeben. vLLM und SGLang reichen das Flag ans Modell weiter.

Kann ich von einem lokalen V4-Server streamen?

Ja. Setze stream: true wie bei OpenAI oder gehosteter DeepSeek API.

Was ist der günstigste Weg zum Testen vor Hardware-Kauf?

Miete eine einzelne H100 bei RunPod oder Lambda, führe V4-Flash mit INT4 aus und miss den Durchsatz mit echten Prompts. Für 10–30 $ bekommst du echte Hardwaredaten – schneller als jede Planung.

DeepSeek V4 API: Anleitung zur Nutzung

Emre Demir — Fri, 24 Apr 2026 04:27:40 +0000

DeepSeek V4 ist ab Tag 1 per API verfügbar. Die Modell-IDs sind deepseek-v4-pro und deepseek-v4-flash, der Endpunkt ist OpenAI-kompatibel mit der Basis-URL https://api.deepseek.com. Sie können bestehende OpenAI-Clients direkt nutzen, indem Sie nur die Basis-URL ändern.

Teste Apidog noch heute

In diesem Leitfaden finden Sie konkrete Schritte zur Authentifizierung, zu Parametern, Python- und Node-Beispielen, Denkmodi, Tool-Calls, Streaming und einen Apidog-Workflow zur Kostenkontrolle.

Produktübersicht: Was ist DeepSeek V4. Kostenlos testen: Wie man DeepSeek V4 kostenlos nutzt.

TL;DR

DeepSeek V4 ist über den OpenAI-kompatiblen Endpunkt https://api.deepseek.com/v1/chat/completions oder den Anthropic-kompatiblen Endpunkt https://api.deepseek.com/anthropic erreichbar.
Modell-IDs: deepseek-v4-pro (1.6T gesamt, 49B aktiv), deepseek-v4-flash (284B gesamt, 13B aktiv)
Beide Varianten: 1M Token Kontext, Denkmodi: non-thinking, thinking, thinking_max
Setzen Sie temperature=1.0, top_p=1.0, wie von DeepSeek empfohlen.
Die IDs deepseek-chat und deepseek-reasoner werden am 24. Juli 2026 abgeschaltet – rechtzeitig migrieren.
Apidog herunterladen für reproduzierbare Anfragen, Denkmodus-Vergleiche und sicheren Umgang mit API-Schlüsseln.

Voraussetzungen

Vor dem ersten API-Call benötigen Sie:

Ein DeepSeek-Entwicklerkonto auf platform.deepseek.com mit mindestens $2 Guthaben. Ohne Guthaben: 402 Insufficient Balance.
Einen projektspezifischen API-Key. Nutzen Sie keine Kontoschlüssel für Produktion.
Ein SDK, das OpenAI-kompatible Basis-URLs erlaubt: z.B. Python openai>=1.30.0, Node openai@4.x.
Einen API-Client für wiederholbare Anfragen. Nach dem ersten curl-Aufruf empfiehlt sich Apidog.

Key exportieren:

export DEEPSEEK_API_KEY="sk-..."

Endpunkt und Authentifizierung

Zwei relevante Endpunkte:

POST https://api.deepseek.com/v1/chat/completions    # OpenAI-Format
POST https://api.deepseek.com/anthropic/v1/messages  # Anthropic-Format

Empfohlen: OpenAI-Format, sofern Sie nicht bereits Anthropic nutzen. Authentifizierung via Bearer-Token im Authorization-Header.

Minimalbeispiel:

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Explain MoE routing in two sentences."}
    ]
  }'

Antworten enthalten ein choices-Array, einen usage-Block (inkl. reasoning_tokens bei Denkmodus) und eine id. Fehler kommen im OpenAI-Fehlerformat.

Anfrageparameter

Alle Felder wirken auf Kosten und Verhalten:

Parameter	Typ	Werte	Hinweise
`model`	String	`deepseek-v4-pro`, `deepseek-v4-flash`	Erforderlich.
`messages`	Array	Rollen-/Inhaltspaare	Erforderlich. Gleiches Schema wie OpenAI.
`thinking_mode`	String	`non-thinking`, `thinking`, `thinking_max`	Standard ist `non-thinking`.
`temperature`	Float	0 bis 2	DeepSeek empfiehlt 1.0.
`top_p`	Float	0 bis 1	DeepSeek empfiehlt 1.0.
`max_tokens`	Integer	1 bis 131.072	Begrenzt die Ausgabelänge.
`stream`	Boolesch	true oder false	Aktiviert SSE-Streaming.
`tools`	Array	OpenAI Tool-Spezifikation	Für Funktionsaufrufe.
`tool_choice`	String oder Objekt	`auto`, `required`, `none` oder spezifisches Tool	Steuert die Tool-Nutzung.
`response_format`	Objekt	`{"type": "json_object"}`	JSON-Modus-Ausgabe.
`seed`	Integer	beliebige Integer-Zahl	Für Reproduzierbarkeit.
`presence_penalty`	Float	-2 bis 2	Bestraft wiederholte Themen.
`frequency_penalty`	Float	-2 bis 2	Bestraft wiederholte Tokens.

Wichtig: thinking_mode ist der größte Kostentreiber.

non-thinking = schnell & günstig, keine Argumentationsspur.
thinking = mehr Genauigkeit bei Code/Mathematik, zusätzliche Tokens.
thinking_max = teuer, maximales Kontextbudget (384K+), höchste Qualität.

Python-Client

Das offizielle openai-SDK funktioniert mit angepasster Basis-URL:

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Reply in code only."},
        {"role": "user", "content": "Write a Rust function that debounces events."},
    ],
    extra_body={"thinking_mode": "thinking"},
    temperature=1.0,
    top_p=1.0,
    max_tokens=2048,
)

choice = response.choices[0]
print("Content:", choice.message.content)
print("Reasoning tokens:", response.usage.reasoning_tokens)
print("Total tokens:", response.usage.total_tokens)

Mit extra_body können Sie DeepSeek-exklusive Parameter durchreichen.

Node-Client

Analog funktioniert das Node-SDK:

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [
    { role: "user", content: "Explain the Muon optimizer in plain English." },
  ],
  thinking_mode: "thinking",
  temperature: 1.0,
  top_p: 1.0,
});

console.log(response.choices[0].message.content);
console.log("Usage:", response.usage);

Unbekannte Felder wie thinking_mode werden direkt weitergereicht.

Streaming-Antworten

Für Streaming setzen Sie stream: true:

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Stream a 300-word essay on MoE."}],
    stream=True,
    extra_body={"thinking_mode": "non-thinking"},
)

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

Bei aktiviertem Denkmodus wird die Denkspur separat als delta.reasoning_content gestreamt.

Tool-Aufruf

V4 unterstützt OpenAI Tool-Call-Schema:

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Return the current weather for a city.",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"},
                "unit": {"type": "string", "enum": ["c", "f"]},
            },
            "required": ["city"],
        },
    },
}]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "Weather in Lagos in Celsius?"}],
    tools=tools,
    tool_choice="auto",
    extra_body={"thinking_mode": "thinking"},
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name, tool_call.function.arguments)

Nach dem Tool-Call: Funktion ausführen, Ergebnis als {"role": "tool"} anfügen und erneut an die API senden.

JSON-Modus

Für strukturierte JSON-Ausgaben:

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "Reply with a single JSON object."},
        {"role": "user", "content": "Summarize this release note as {title, date, bullets}: ..."},
    ],
    response_format={"type": "json_object"},
    extra_body={"thinking_mode": "non-thinking"},
)

Das Modell liefert gültiges JSON, aber keine Schemavalidierung – prüfen Sie ggf. clientseitig.

Sammlung in Apidog erstellen

Wiederholbare Requests und Kostenkontrolle mit Apidog:

Apidog herunterladen und Projekt anlegen.
Umgebung mit {{DEEPSEEK_API_KEY}} als Secret-Variable anlegen.
POST-Request an {{BASE_URL}}/chat/completions mit Header Authorization: Bearer {{DEEPSEEK_API_KEY}} speichern.
model und thinking_mode als Parameter einrichten – für schnelle A/B-Tests.
Im Antwort-Viewer usage.reasoning_tokens checken, um Denkmodus-Kosten zu kontrollieren.

Nutzen Sie bestehende GPT-5.5 API-Sammlungen als Vorlage – nur Basis-URL und Modell-ID tauschen.

Fehlerbehandlung

Antworten entsprechen OpenAI-Fehlern:

Code	Bedeutung	Behebung
400	Ungültige Anfrage	JSON-Schema prüfen, v. a. `messages` und `tools`.
401	Ungültiger Schlüssel	Key neu generieren auf platform.deepseek.com.
402	Ungenügendes Guthaben	Aufladen.
403	Modell nicht erlaubt	Scope und Schreibweise prüfen.
422	Parameter außerhalb des Bereichs	`max_tokens` oder `thinking_mode` prüfen.
429	Ratenbegrenzung	Mit exponentiellem Jitter erneut versuchen.
500	Serverfehler	Einmal wiederholen, sonst Statusseite prüfen.
503	Überlastet	Auf V4-Flash wechseln oder nach 30s erneut versuchen.

Implementieren Sie einen Retry-Helper mit exponentiellem Backoff für 429 und 5xx. 4xx-Fehler immer manuell prüfen.

Muster zur Kostenkontrolle

Standardmäßig V4-Flash nutzen. Nur auf V4-Pro wechseln, wenn die Qualität messbar besser ist.
thinking_max nur per Flag zulassen. Sehr teuer, nur wenn Korrektheit > Latenz.
max_tokens limitieren. 2.000 Output-Tokens reichen meist, 1M-Kontext ist für Input gedacht.
usage immer loggen. Tracken Sie Eingabe-, Ausgabe- und Reasoning-Tokens – Alarm bei Ausreißern.

Migration von älteren DeepSeek-Modellen

Die Modelle deepseek-chat und deepseek-reasoner werden am 24. Juli 2026 eingestellt. Migration: Modell-ID austauschen, Aufrufstruktur bleibt gleich.

-  model="deepseek-chat"
+  model="deepseek-v4-pro"

Vor Produktion: Side-by-Side A/B-Tests in Apidog fahren. Die Deadline erzwingt Migration ohnehin.

FAQ

Ist die DeepSeek V4 API produktionsreif?

Ja, seit 23. April 2026 produktiv. Die API ist stabil und basiert auf bewährter Infrastruktur.

Unterstützt V4 das Anthropic-Nachrichtenformat?

Ja, über https://api.deepseek.com/anthropic/v1/messages. Beide Formate greifen auf dasselbe Modell zu.

Was ist das Kontextfenster?

1 Million Tokens für V4-Pro und V4-Flash. thinking_max benötigt mindestens 384K Kontext.

Wie zähle ich Eingabe-Tokens vor dem Senden?

Für Näherungen: Standard-OpenAI-Tokenizer. Exakte Zahlen liefert der usage-Block jeder Antwort.

Kann ich Fine-Tuning via API machen?

Zum Start nicht. Fine-Tuning aktuell nur über selbst gehostete Modelle auf Hugging Face.

Gibt es einen kostenlosen API-Test?

Keine kostenlose Stufe, aber gelegentlich Startguthaben für neue Accounts.

DeepSeek V4 API Preise

Emre Demir — Fri, 24 Apr 2026 04:26:37 +0000

DeepSeek veröffentlichte die V4-Preise am selben Tag, an dem die Modelle erschienen (23. April 2026). Die Tarife setzen neue Maßstäbe: V4-Flash kostet $0,14 pro Million Eingabetokens und $0,28 pro Million Ausgabetokens, V4-Pro liegt bei $1,74 pro Eingabetokens und $3,48 pro Ausgabetokens. Beide Modelle unterstützen ein 1M-Token-Kontextfenster und bis zu 384K Ausgabetokens. Ein aggressiver Cache-Hit-Rabatt reduziert die Eingabekosten bei wiederholten Prompts um 80% bis 90%.

Probiere Apidog jetzt aus

In diesem Leitfaden findest du die vollständige Preisliste, eine technische Erklärung zum Kontext-Caching, einen direkten Kostenvergleich mit GPT-5.5 und Claude Opus sowie vier konkrete Maßnahmen, um die Ausgaben in Apidog effizient im Griff zu behalten.

Produktüberblick: Was ist DeepSeek V4.
Entwickleranleitung: Wie man die DeepSeek V4 API verwendet.
Kostenlos testen: Wie man DeepSeek V4 kostenlos nutzt.

TL;DR

V4-Flash: $0,14 / M Eingabe (Cache-Fehlzugriff), $0,028 / M Eingabe (Cache-Treffer), $0,28 / M Ausgabe.
V4-Pro: $1,74 / M Eingabe (Cache-Fehlzugriff), $0,145 / M Eingabe (Cache-Treffer), $3,48 / M Ausgabe.
Kontextfenster: 1M Tokens Eingabe, 384K Tokens Ausgabe.
Cache-Hit-Rabatt: ca. 80% Rabatt auf Flash, 92% Rabatt auf Pro bei wiederholten Präfixen.
deepseek-chat und deepseek-reasoner werden zum 24. Juli 2026 eingestellt; Abrechnung läuft über V4-Flash.
V4-Pro ist bei Cache-Fehlzugriffen etwa 2,9x günstiger als GPT-5.5 bei Eingabe und ~8,6x günstiger bei Ausgabe.

Die vollständige Preisliste

Modell	Eingabe (Cache-Fehlzugriff)	Eingabe (Cache-Treffer)	Ausgabe	Kontext
`deepseek-v4-flash`	$0,14 / M	$0,028 / M	$0,28 / M	1M / 384K
`deepseek-v4-pro`	$1,74 / M	$0,145 / M	$3,48 / M	1M / 384K
`deepseek-chat` (veraltet 24.07.2026)	entspricht V4-Flash Non-Thinking	—	—	—
`deepseek-reasoner` (veraltet 24.07.2026)	entspricht V4-Flash Thinking	—	—	—

Wichtige technische Details:

Preise sind identisch für Denk- und Nicht-Denkmodus. Die Modell-ID steuert den Tarif; der Reasoning-Modus beeinflusst nur die Token-Menge.
Cache-Hit-Preisgestaltung ist automatisch: Sobald ein Präfix (mind. 1.024 Tokens, bytegenau identisch) erneut verwendet wird, greift der Rabatt – keine Konfiguration nötig.
Die alten IDs (deepseek-chat und deepseek-reasoner) werden bereits als V4-Flash abgerechnet. Migration ist technisch nicht erforderlich, aber empfohlen.

Kontext-Caching: Technische Umsetzung

Caching ist der stärkste Kostenhebel bei DeepSeek V4. Alles, was in mehreren Anfragen identisch bleibt (System-Prompts, Tool-Schemata, RAG-Kontext), wird ab dem zweiten Aufruf zum Cache-Hit-Tarif berechnet.

Beispiel:

Agent mit 20.000 Token System-Prompt (unverändert)
100 Benutzerfragen à 200 Tokens

Ohne Caching:

Eingabe: 100 × 20.200 × $1,74 / M = $3,52
Ausgabe: 100 × 500 × $3,48 / M = $0,17
Gesamt: $3,69

Mit Caching (1 Miss, 99 Hits):

Erster Aufruf: 20.200 × $1,74 / M = $0,035
99 Cache-Hits: 99 × 20.000 × $0,145 / M = $0,287
99 Benutzerfragen: 99 × 200 × $1,74 / M = $0,034
Ausgabe: 100 × 500 × $3,48 / M = $0,174
Gesamt: $0,53

=> Rund 7x günstiger bei gleicher Nutzung. Bei V4-Flash fällt das Einsparpotenzial noch größer aus.

Vergleich mit GPT-5.5 und Claude Opus

Modell	Eingabe (Standard)	Eingabe (gecached)	Ausgabe	Kontext
DeepSeek V4-Flash	$0,14 / M	$0,028 / M	$0,28 / M	1M
DeepSeek V4-Pro	$1,74 / M	$0,145 / M	$3,48 / M	1M
GPT-5.5	$5 / M	$1,25 / M	$30 / M	1M
GPT-5.5 Pro	$30 / M	—	$180 / M	1M
Claude Opus 4.6	$15 / M	$1,50 / M	$75 / M	200K

Interpretation für die Praxis:

Ausgabetokens: V4-Pro ist ~8,6x günstiger als GPT-5.5 und ~21x günstiger als Claude Opus 4.6. Besonders relevant für agentenbasierte Workloads.
Gecachte Eingabe: V4-Pro liegt ~10x günstiger als gecachtes GPT-5.5 und Claude – relevant bei langen, gleichbleibenden Prompts.
Benchmarking: V4-Pro erreicht oder übertrifft GPT-5.5 bei LiveCodeBench und Codeforces zu einem Bruchteil der Kosten. Details: Benchmark-Tabelle.

Einschränkung: Claude bleibt stärker bei langen Kontextabfragen und Gemini 3.1 Pro bei MMLU-Pro. Bei "Needle-in-a-Haystack"-Abfragen kann Qualität wichtiger sein als Kostenvorteil.

Kostenmodellierung: Praxisbeispiele für Workloads

Vier typische Produktionsszenarien (jeweils V4-Pro, Cache-Miss-Baseline):

1. Agenten-Coding-Loop (50K Kontext, 2K Ausgabe, 20 Aufrufe/Aufgabe)

Eingabe: 50.000 × 20 × $1,74 / M = $1,74
Ausgabe: 2.000 × 20 × $3,48 / M = $0,14
Kosten pro Aufgabe: ~$1,88

(GPT-5.5: ~$6,20 pro Aufgabe)

2. Langdokument-Fragen & Antworten (500K Kontext, 1K Ausgabe)

Eingabe: 500.000 × $1,74 / M = $0,87
Ausgabe: 1.000 × $3,48 / M = $0,003
Kosten pro Aufruf: ~$0,87

(GPT-5.5: ~$2,53 pro Aufruf)

3. Hochvolumige Klassifizierung (2K Kontext, 200 Ausgabe, 10.000 Aufrufe)

Empfehlung: V4-Flash nutzen!

Eingabe: 2.000 × 10.000 × $0,14 / M = $2,80
Ausgabe: 200 × 10.000 × $0,28 / M = $0,56
Laufkosten: ~$3,36

(GPT-5.5: ~$110 pro Lauf)

4. Chatbot mit wiederholtem Prompt (10K System-Prompt, 500 User-Tokens, 1K Ausgabe, 1.000 Sitzungen)

Eingabe (erste Anfrage): 10.500 × $1,74 / M = $0,018
Cache-Hit-Eingabe: 999 × 10.000 × $0,145 / M = $1,45
Benutzerinteraktion: 999 × 500 × $1,74 / M = $0,87
Ausgabe: 1.000 × 1.000 × $3,48 / M = $3,48
Kosten pro Sitzungslauf: ~$5,82

(GPT-5.5 mit Caching: ~$26,35)

Versteckte Kosten: Die vier wichtigsten Stolpersteine

Token-Inflation im Denkmodus: thinking_max verbraucht 3-10x mehr Ausgabetokens als non-thinking. Schütze Think Max durch Feature-Flag.
Stilles Kontextwachstum: Agenten-Loops mit 1M-Kontext können schnell eskalieren. Kontext regelmäßig kürzen oder zusammenfassen.
Wiederholungsstürme: Endlosschleifen mit Retry auf 500er-Fehler verdoppeln die Kosten in kurzer Zeit. Exponentielles Backoff und Retry-Limit pro Anfrage implementieren.
Entwicklungsaufwand: Jeder Prompt-Test per Curl verursacht volle Kontextkosten. Mit Apidog kannst du Variablen substituieren und Prompts kostenfrei anpassen, ohne die gesamte Payload neu zu schicken.

Kosten-Tracking in Apidog

So behalten Entwickler die Kosten unter Kontrolle:

Apidog herunterladen und DEEPSEEK_API_KEY als geheime Umgebungsvariable speichern.
Eine einzelne POST-Anfrage an https://api.deepseek.com/v1/chat/completions anlegen.
Im Response-Bereich die Felder usage.prompt_tokens, usage.completion_tokens und usage.reasoning_tokens anpinnen. Die Kostenberechnung ist sofort sichtbar.
model und thinking_mode als Parameter definieren, um V4-Flash vs. V4-Pro und Non-Think vs. Think Max direkt im A/B-Vergleich zu testen.
Für GPT-5.5 eine identische Sammlung spiegeln (GPT-5.5 API-Leitfaden). Beide Anbieter, Kosten auf einen Blick.

Dieser Workflow deckt rund 80% aller Kostenüberraschungen vor Monatsende auf.

Vier Regeln für vorhersehbare Ausgaben

Standardmäßig V4-Flash nutzen. Nur auf V4-Pro wechseln, wenn ein echter Qualitätsvorteil nachgewiesen ist.
Non-Think als Default. Für schwierige Aufgaben auf Think High wechseln. Think Max nur bei kritischen Anforderungen aktivieren.
max_tokens restriktiv setzen. Die 384K-Grenze ist ein Sicherheitsnetz, kein Zielwert. In der Praxis reichen oft 2K.
Telemetry bei jeder Anfrage. Protokolliere prompt_tokens, completion_tokens und reasoning_tokens. Bei Reasoning-Spitzen Alarm auslösen – sie zeigen versehentliche Think-Max-Nutzung.

FAQ

Gibt es einen kostenlosen Tarif?

Es gibt keinen generell kostenlosen API-Tarif, gelegentlich bekommen neue Konten Testguthaben. Für kostenlose Möglichkeiten außerhalb der API siehe Wie man DeepSeek V4 kostenlos nutzt.

Wie funktioniert das Cache-Hit-Pricing?

Präfixe ≥1.024 Tokens werden bei Wiederholung automatisch zum Cache-Hit-Tarif abgerechnet (bytegenau, Account-gebunden). Die erste Anfrage zählt als Miss, danach greift der Rabatt.

Kosten Denkmodi mehr?

Der Preis pro Token bleibt gleich. Reasoning-Modi erzeugen aber mehr Output-Tokens. Tracke reasoning_tokens im usage-Objekt zur Kostenüberwachung.

Sind die Preise stabil?

DeepSeek ändert die Preise regelmäßig. V3.2 galt fast ganz 2025, V4 hat kein Enddatum. Aktuelle Preise immer unter Preisseite prüfen.

Gibt es gleiche Output-Tarife für V4-Pro und V4-Flash?

Nein. V4-Pro-Output kostet $3,48 / M, V4-Flash $0,28 / M – das 12,4-fache. Standardmäßig immer V4-Flash wählen.

Beeinflusst das Anthropic-Format die Preise?

Nein. Endpunkt https://api.deepseek.com/anthropic nutzt die gleichen Preise wie das OpenAI-Format. Das Request-Format hat keinen Einfluss auf die Abrechnung.

DeepSeek V4: Web Chat, API und Self-Hosting Nutzung

Emre Demir — Fri, 24 Apr 2026 04:17:53 +0000

DeepSeek V4 wurde am 23. April 2026 mit vier Checkpoints, einer Live-API und MIT-lizenzierten Gewichten auf Hugging Face veröffentlicht. Sie haben damit die Wahl zwischen sofortigem Zugriff per Web, Produktions-API oder On-Premise-Betrieb. Hier finden Sie einen praxisorientierten Leitfaden für alle drei Optionen, mit klaren Empfehlungen, Fallstricken und einem wiederverwendbaren Prompt-Workflow.

Probiere Apidog noch heute aus

Für einen Produktüberblick starten Sie mit was ist DeepSeek V4. Die reine API-Anleitung finden Sie im DeepSeek V4 API-Leitfaden. Für den kostenlosen Zugang, siehe wie man DeepSeek V4 kostenlos nutzt. Zum Testen von echten Anfragen holen Sie sich Apidog und erstellen Sie eine Sammlung.

TL;DR

Schnellster Weg: chat.deepseek.com. Kostenloser Web-Chat, V4-Pro als Standard, drei Denkmodi.
Produktionsweg: https://api.deepseek.com/v1/chat/completions mit deepseek-v4-pro oder deepseek-v4-flash als Modell-IDs.
Self-Hosted: Gewichte über Hugging Face laden und /inference-Skripte nutzen.
Nutzen Sie Non-Think für Routing/Klassifizierung, Think High für Code/Analyse, Think Max nur, wenn höchste Genauigkeit gefragt ist.
Empfohlene Sampling-Parameter: temperature=1.0, top_p=1.0.
Apidog als API-Client verwenden; OpenAI-Format ermöglicht einfaches Umschalten zwischen DeepSeek, OpenAI, Anthropic.

Wählen Sie den richtigen Pfad für Ihre Arbeitslast

Vier Wege, jeweils für unterschiedliche Anforderungen:

Pfad	Kosten	Einrichtungszeit	Am besten für
chat.deepseek.com	Kostenlos	30 Sekunden	Schnelle Tests, Ad-hoc-Arbeiten
DeepSeek API	Pro-Token-Abrechnung	5 Minuten	Produktion, Agenten, Batch-Jobs
Self-hosted V4-Flash	Nur Hardwarekosten	Einige Stunden	On-Premise-Compliance, Offline-Inferenz
Self-hosted V4-Pro	Nur Clusterkosten	Ein Tag	Forschung, kundenspezifische Fine-Tunes
OpenRouter / Aggregator	Pro-Token-Abrechnung	2 Minuten	Multi-Anbieter-Fallback

Pfad 1: V4 im Web-Chat nutzen

Gehen Sie zu chat.deepseek.com.
Melden Sie sich mit E-Mail, Google oder WeChat an.
V4-Pro ist Standard. Modus oben im Eingabefeld: Non-Think, Think High, Think Max.
Prompt eingeben, ausführen.

Web-Chat unterstützt Datei-Uploads, Websuche und 1M-Token-Kontext. Ratenlimits gelten pro Konto – hohe Nutzung kann Antworten verzögern, blockiert aber selten vollständig.

Typische Use-Cases: Fehler-Traces analysieren, PDFs zusammenfassen, Benchmarks mit identischem Prompt wie GPT-5.5 oder Claude. Nicht geeignet für Automatisierung oder wiederholbare Workflows.

Pfad 2: Die DeepSeek API nutzen

Empfohlener Weg für Teams: OpenAI-kompatible API, stabile Modell-IDs.

API-Schlüssel generieren

Registrieren unter platform.deepseek.com.
Zahlungsmethode hinzufügen (min. 2 $).
API-Schlüssel unter API Keys erzeugen und sichern.

Schlüssel als Umgebungsvariable bereitstellen:

export DEEPSEEK_API_KEY="sk-..."

Minimalbeispiel (cURL)

curl https://api.deepseek.com/v1/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {"role": "user", "content": "Refactor this Python function to async. Reply with code only."}
    ],
    "thinking_mode": "thinking"
  }'

deepseek-v4-pro gegen deepseek-v4-flash tauschen, je nach Bedarf. thinking gegen non-thinking wechseln für schnellen Modus.

Python-Client

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a concise senior engineer."},
        {"role": "user", "content": "Explain the CSA+HCA hybrid attention stack."},
    ],
    extra_body={"thinking_mode": "thinking_max"},
    temperature=1.0,
    top_p=1.0,
)

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

Node-Client

import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [{ role: "user", content: "Write a fizzbuzz in Rust." }],
  temperature: 1.0,
  top_p: 1.0,
});

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

Weitere Details und Fehlerbehandlung im DeepSeek V4 API-Leitfaden.

Pfad 3: Mit Apidog iterieren

cURL reicht für einen Test, aber für produktive API-Workflows ist Apidog effizienter und wiederholbar.

Laden Sie Apidog für Mac, Windows oder Linux herunter.
Neues API-Projekt anlegen, POST-Request auf https://api.deepseek.com/v1/chat/completions.
Authorization: Bearer {{DEEPSEEK_API_KEY}} als Header, Schlüssel in Umgebungsvariablen speichern.
JSON-Body einfügen, speichern, per Klick wiederholen.
Antwort-Viewer nutzen, um Non-Think- und Think Max-Runs mit identischem Prompt zu vergleichen.

Sie können OpenAI GPT-5.5, Claude und DeepSeek V4 parallel in einer Sammlung testen. A/B-Tests über Anbieter hinweg und Abrechnung bleiben im Blick. Für bestehende Apidog-Workflows reicht oft eine Basis-URL-Änderung. Siehe GPT-5.5 API-Sammlung für Details.

Pfad 4: V4-Flash selbst hosten

Für Air-Gap/Compliance oder reine Kostenkontrolle: MIT-Lizenz erlaubt vollständige Eigenkontrolle.

Hardware-Anforderungen

V4-Flash (13B aktiv, 284B gesamt): 2–4 H100/H200/MI300X bei FP8. Mit INT4 auf eine 80GB-Karte, kleine Batches.
V4-Pro (49B aktiv, 1.6T gesamt): Cluster-Betrieb, 16–32 H100 für Produktion.

Gewichte laden

pip install -U "huggingface_hub[cli]"
huggingface-cli login
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir ./models/deepseek-v4-flash \
  --local-dir-use-symlinks False

V4-Flash ca. 500 GB (FP8), V4-Pro Multi-TB.

Inferenz starten

pip install "vllm>=0.9.0"

vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 4 \
  --max-model-len 1048576 \
  --dtype auto

OpenAI-kompatible Clients auf http://localhost:8000/v1 zeigen. Gleiches Apidog-Projekt, andere Basis-URL.

V4 effektiv prompten

Denkmodus explizit setzen: thinking_mode immer passend zur Aufgabe angeben.
System-Prompts für Persona, Aufgaben in User-Message: Für Aufgabenbeschreibung die User-Message nutzen, System für Ton/Persona.
Code-Aufgaben mit Test-Harness eingeben: Geben Sie Testfälle mit an, um bessere Ergebnisse zu erhalten.

Bei langem Kontext: Das wichtigste Material an den Anfang und das Ende der Eingabe setzen. V4 nutzt hybride Aufmerksamkeit, aber Reihenfolge bleibt relevant.

Kostenkontrolle

Standardmäßig V4-Flash nutzen. V4-Pro nur, wenn messbar besser.
Standardmäßig Non-Think. Think High/Max nur nach Bedarf.
max_tokens begrenzen. 1M ist das Maximum, meist reichen 2.000 Output-Tokens.

In Apidog Umgebungsvariablen für Schlüssel nutzen; so trennen Sie Test- und Produktionsabrechnung. Apidog zeigt die Token-Anzahl jeder Antwort an – ideal zur Erkennung von zu langen Prompts.

Migration von DeepSeek V3 oder anderen Modellen

Von deepseek-chat/deepseek-reasoner: Modell-ID auf deepseek-v4-pro oder deepseek-v4-flash ändern. Alte IDs laufen am 24. Juli 2026 aus.
Von OpenAI GPT-5.x: Basis-URL auf https://api.deepseek.com/v1, Modell-ID anpassen, sonst alles gleich. Siehe GPT-5.5 API-Leitfaden für Details.
Von Anthropic Claude: https://api.deepseek.com/anthropic verwenden oder Nachrichten ins OpenAI-Format übertragen.

FAQ

Benötige ich ein kostenpflichtiges Konto, um V4 zu nutzen? Web-Chat ist kostenlos. Für API sind mindestens 2 $ notwendig. Siehe kostenlos nutzen für Gratis-Wege.

Welche Variante sollte ich standardmäßig verwenden? Starten Sie mit V4-Flash im Non-Think-Modus. Messen, dann ggf. wechseln.

Kann ich V4 auf meinem MacBook ausführen? V4-Flash läuft auf M3/M4 Max mit 128 GB RAM (starke Quantisierung, langsam). V4-Pro nicht. Für Laptops: API oder Web-Chat nutzen.

Unterstützt V4 Tools/Funktionsaufrufe? Ja, OpenAI-kompatibler Endpunkt akzeptiert tools-Array; Antwort enthält tool_calls. Anthropic-Format nutzt natives Schema.

Wie streame ich Antworten? stream: true im Request-Body. Antwort kommt als OpenAI-kompatibler SSE-Stream, jede OpenAI-Bibliothek funktioniert direkt.

Gibt es Ratenlimits? Gehostete API: limits auf api-docs.deepseek.com. Self-Hosted: keine, außer Hardware.

DeepSeek V4: Was ist das?

Emre Demir — Fri, 24 Apr 2026 04:16:16 +0000

DeepSeek veröffentlichte V4 am 23. April 2026 – ein großes Upgrade mit vier neuen Checkpoints, darunter DeepSeek-V4-Pro (1,6 Billionen Parameter, MIT-Lizenz, 1M Token Kontextfenster) und DeepSeek-V4-Flash (284 Milliarden Parameter, gleiches Kontextfenster, offene Gewichte). Benchmarks zeigen, dass die Pro-Variante bei LiveCodeBench und Codeforces vor Claude Opus 4.6 liegt und auf MMLU-Pro GPT-5.4 xHigh erreicht.

Teste Apidog noch heute

Wenn du dich fragst, ob du Claude, GPT-5.5 oder Qwen gegen DeepSeek V4 austauschen solltest, findest du hier einen praxisorientierten Leitfaden: Was ist das Modell, was hat sich gegenüber V3.2 geändert, welche Architektur-Entscheidungen beeinflussen Benchmarks und wie setzt du es direkt ein.

Für die Implementierung findest du einen DeepSeek V4 API-Leitfaden, einen Guide für kostenlosen Zugriff sowie eine vollständige Anwendungsanleitung. Die Requests sind OpenAI-kompatibel und können in Apidog vorbereitet werden, bevor dein API-Key eintrifft.

TL;DR

DeepSeek V4 ist eine Mixture-of-Experts-Modellfamilie, am 23. April 2026 unter MIT-Lizenz veröffentlicht.
Vier Checkpoints: V4-Pro, V4-Pro-Base, V4-Flash, V4-Flash-Base.
V4-Pro: 1,6 Billionen Parameter (49B aktiv); V4-Flash: 284 Milliarden (13B aktiv).
Beide Varianten: 1M Token Kontextfenster, drei Schlussfolgerungsmodi (Non-Think, Think High, Think Max).
Benchmarks: LiveCodeBench 93.5, Codeforces 3206, MMLU-Pro 87.5 (Pro).
API unter api.deepseek.com mit Modell-IDs deepseek-v4-pro und deepseek-v4-flash; Gewichte bei Hugging Face und ModelScope.

Was DeepSeek V4 tatsächlich ist

DeepSeek V4 folgt auf V3 und V3.2 und bleibt bei der Mixture-of-Experts-Architektur, setzt aber auf neue Dimensionen. Bei V4-Pro werden pro Token nur 49B der 1,6T Parameter aktiviert – die Rechenkosten pro Token ähneln so eher einem 50B-Modell. Technische Details findest du im DeepSeek V4 Modellbericht.

Checkpoints:

DeepSeek-V4-Pro: Flaggschiff, 1,6T Parameter, 49B aktiv, 1M Kontext – Standard für API-Nutzung.
DeepSeek-V4-Pro-Base: Pretrained-Base, ideal für eigene Fine-Tunes.
DeepSeek-V4-Flash: Effizienzvariante, 284B Parameter, 13B aktiv, 1M Kontext – für lokale Deployments.
DeepSeek-V4-Flash-Base: Base-Checkpoint für Flash.

Alle vier sind MIT-lizenziert. Du kannst V4-Pro auf eigener Hardware ohne Lizenzkosten betreiben, anpassen und weitergeben.

Was sich gegenüber V3.2 geändert hat

V4 wurde grundlegend überarbeitet: Neuer Attention-Stack, optimierte Trainingspipeline für längere Kontexte und Effizienz.

Fähigkeit	V3.2	V4-Pro
Gesamtparameter	685B	1.6T
Aktive Parameter	37B	49B
Kontextfenster	128K	1M
Inferenz-FLOPs (1M Kontext)	baseline	27% von V3.2
KV-Cache (1M Kontext)	baseline	10% von V3.2
Präzision	FP8	FP4 + FP8 gemischt
Lizenz	DeepSeek-Lizenz	MIT
Schlussfolgerungsmodi	einzeln	drei

Drei Kernpunkte:

Hybrid-Attention-Stack: Kombiniert Compressed Sparse Attention mit Heavily Compressed Attention – daher 10% KV-Cache.
Manifold-Constrained Hyper-Connections: Stabilisiert tiefe Netze für bessere Skalierung.
Muon-Optimierer: Schnellere Konvergenz als AdamW.

Trainingsdaten umfassen 32T Tokens, Post-Training nutzt zweistufige Pipeline (Experten und On-Policy-Destillation).

Wichtige Benchmarks

V4-Pro liefert Top-Werte bei Coding und Wissen. Schwächen bestehen bei Langkontext-Retrieval.

V4-Flash (13B aktiv): MMLU-Pro 86.2, GPQA Diamond 88.1, LiveCodeBench 91.6, Codeforces 3052, SWE Verified 79.0. Ideal für eigene Hardware. Details auf der V4-Flash-Karte.

Fazit: V4-Pro ist bei Codierung und offener Faktensuche führend, Gemini 3.1 Pro bleibt bei allgemeinem Wissen vorne, Claude Opus bei 1M-Token-Retrieval.

Drei Schlussfolgerungsmodi

Jeder Checkpoint unterstützt drei Modi – wähle nach Kosten/Nutzen:

Non-Think: Schnell, ohne Ketten oder Zusatz-Tokens. Für Klassifikation, Routing, kurze Summaries.
Think High: Standard für anspruchsvolle Aufgaben – mit Schlussfolgerungs-Tokens, Toolplanungen, Output-Prüfung.
Think Max: Maximale Leistung, längere Reasoning-Chains, empfohlen ab 384K Kontext.

API-Parameter:

{
  "model": "deepseek-v4-pro",
  "thinking_mode": "think_high",
  "temperature": 1.0,
  "top_p": 1.0
}

Architektur kompakt erklärt

Drei zentrale Architekturentscheidungen:

Hybrid Attention: Compressed Sparse für relevante Tokens, Heavily Compressed für Effizienz. Führt zu 27% FLOPs und 10% KV-Cache von V3.2.
Manifold-Constrained Hyper-Connections: Residuals werden so stabilisiert, dass noch tiefere Netze möglich sind.
Muon-Optimierer: Ersetzt AdamW, skaliert besser mit MoE-Architekturen.

Keine Einzelinnovation, sondern die Kombination dieser Ansätze auf Billionen-Parameter-Skala.

Verfügbarkeit heute

Vier Checkpoints und API sind ab 24. April 2026 live:

Oberfläche	Zugang
chat.deepseek.com	Kostenloser Web-Chat, V4-Pro Standard, Anmeldung erforderlich
DeepSeek API	Live unter `api.deepseek.com`; Modell-IDs `deepseek-v4-pro`, `deepseek-v4-flash`
Hugging Face Gewichte	V4-Pro, V4-Flash, beide MIT
ModelScope	Gespiegelte Gewichte für Benutzer in China
OpenRouter und Aggregatoren	Innerhalb weniger Tage erwartet; typisches DeepSeek-Startmuster
`deepseek-chat` / `deepseek-reasoner`	Veraltet am 24. Juli 2026

Achtung: Die alten Modell-IDs werden am 24. Juli 2026 abgeschaltet. Migriere rechtzeitig auf die neuen IDs.

Vergleich mit GPT-5.5 und Claude

Kosten: V4-Pro und V4-Flash sind Open-Weights. Bei Self-Hosting unschlagbar in der Skalierung.
Coding: V4-Pro ist auf LiveCodeBench und Codeforces vor GPT-5.5 und Claude Opus.
Wissensbreite: Gemini 3.1 Pro liegt bei MMLU-Pro vorne, V4-Pro und GPT-5.5 gleichauf. Im SimpleQA schlägt V4 beide.
Langkontext: Claude Opus ist bei 1M-Token-Retrieval führend.
Lizenz: MIT – vollständige Produktintegration ohne Lizenzpflicht.

Anwendungsfälle für Entwickler

Setze V4 gezielt ein für:

Agentische Coding-Loops: Multi-Datei-Debugging, Refactoring, autonome Testkorrektur. Kombiniere mit einem API-Client wie Apidog.
Langdokument-Reasoning: 1M Kontextfenster reicht für Monorepos, Verträge, Forschungsdaten. Nutze Think High.
Self-Hosted KI-Produkte: V4-Flash liefert erstmals Frontier-Qualität als Open-Weights für On-Premise.
Forschung & Fine-Tuning: Base-Checkpoints für individuelles Training, kombiniere mit eigenen Daten für Spezialmodelle.

Nicht optimal für: Massenklassifikation, Embedding Retrieval, Kurzprompt-Chat – hier sind ältere oder kleinere Modelle günstiger.

Preisübersicht

Zum Redaktionszeitpunkt war die V4-API-Preisliste noch nicht final. V3.2 lag bei ca. $0,28 pro 1M Input-Tokens / $0,42 pro 1M Output-Tokens. Erwartung: V4-Flash ähnlich, V4-Pro etwas teurer. Konkurrenz liegt bei $5–15 pro 1M Input. Aktuelle Preise auf der DeepSeek Preisgestaltungsseite.

So testest du V4 heute

Wähle nach "Time to First Token":

Web-Chat:

Gehe zu chat.deepseek.com, melde dich an, stelle im UI den Modus auf Think High. Kostenlos, sofort nutzbar.
API:

Besorge dir einen API-Key, setze deinen Client auf https://api.deepseek.com, nutze "model": "deepseek-v4-pro". OpenAI-kompatibles Format. Schneller Einstieg mit dem DeepSeek V4 API-Leitfaden.
Lokale Gewichte:

Lade die Modelle von Hugging Face oder ModelScope. V4-Flash läuft auf 2–4 H100s, V4-Pro braucht einen Cluster. Inferenzcode im /inference-Ordner des Repos.

Für vollständige How-tos inkl. Prompt-Iteration mit Apidog siehe Anleitung und kostenlosen Zugang.

Apidog herunterladen und Requests vorab anlegen – das OpenAI-Format läuft API-übergreifend.

FAQ

Ist DeepSeek V4 wirklich Open Source?

Ja, alle Checkpoints unter MIT-Lizenz – kommerzielle Nutzung, Modifikation und Weiterverbreitung ohne Restriktionen.

Brauche ich einen GPU-Cluster für V4-Flash?

Für V4-Flash: 2–4 H100s/H200s (full precision), weniger bei Quantisierung. V4-Pro benötigt einen Cluster. Für einfache Tests: API oder chat.deepseek.com.

Wann ist V4 in der DeepSeek API live?

Seit 23. April 2026. Modell-IDs: deepseek-v4-pro, deepseek-v4-flash. Ältere IDs (deepseek-chat, deepseek-reasoner) werden am 24. Juli 2026 abgekündigt.

Wie schneidet V4 gegenüber Kimi und Qwen ab?

V4-Pro erzielt auf LiveCodeBench und Codeforces höhere Scores als Kimi K2 und Qwen 3 Max. Alle drei sind Open-Weights-MoE-Modelle – wähle nach passendem Benchmark.

Eigenes Fine-Tuning möglich?

Ja, Base-Checkpoints sind für Custom-Training vorgesehen. Kombiniere mit eigenen Daten, nutze Standard-SFT-Pipeline. MIT-Lizenz deckt kommerzielle Nutzung ab.

Funktioniert V4 mit OpenAI-kompatiblen Tools?

Ja. API nimmt OpenAI- und Anthropic-Nachrichtenformate (https://api.deepseek.com, https://api.deepseek.com/anthropic). Bestehende OpenAI-Clients laufen mit Austausch der Base-URL. Siehe GPT-5.5 API-Walkthrough für das Muster.

GPT-5.5 Preise: Detaillierte Kostenaufschlüsselung für API, Codex und ChatGPT (April 2026)

Emre Demir — Fri, 24 Apr 2026 02:32:11 +0000

OpenAI hat am 23. April 2026 mit der Einführung von GPT-5.5 die Token-Preise der GPT-5-Linie verdoppelt. Die Kosten für Input steigen von $2,50 auf $5,00 pro Million Tokens, Output von $15,00 auf $30,00 pro Million. Die Pro-Preise bleiben bei $30/$180. In diesem Artikel findest du einen technischen, praxisorientierten Überblick, wie du die neuen Preismodelle effizient für deine Projekte einsetzt und wie du Kosten vorab berechnest.

Probiere Apidog noch heute aus

Dieser Leitfaden behandelt alle Preismodelle: Standard-API, Batch, Flex, Priority, Pro-Tarife, Codex-Limits pro Plan und zeigt, wie du die Kosten deiner tatsächlichen Workloads berechnest, bevor du den Standardmodus wechselst.

Für einen Modellüberblick siehe Was ist GPT-5.5. Für eine Entwickleranleitung siehe Wie man die GPT-5.5 API benutzt.

TL;DR

Oberfläche	Input / M	Output / M
GPT-5.5 Standard-API	$5,00	$30,00
GPT-5.5 Pro-API	$30,00	$180,00
GPT-5.5 Batch (50 % Rabatt)	$2,50	$15,00
GPT-5.5 Flex (50 % Rabatt)	$2,50	$15,00
GPT-5.5 Priority (2,5×)	$12,50	$75,00
GPT-5.4 Standard-API	$2,50	$15,00
GPT-5.4-mini API	$0,25	$2,00

Fazit: GPT-5.5 ist pro Token 2× teurer als GPT-5.4. OpenAI gibt an, dass sich dies durch ca. 20% effizientere Token-Nutzung relativiert.

Die wichtigsten Zahlen

GPT-5.5: $5,00/M Input-Tokens, $30,00/M Output-Tokens
GPT-5.5 Pro: $30,00/M Input-Tokens, $180,00/M Output-Tokens
Kontextfenster: 1 Mio Tokens (Input + Output). Reasoning-Tokens werden auf das Kontextfenster und die Output-Abrechnung angerechnet.

OpenAI veröffentlicht Preise auf der API-Preisseite.

Batch, Flex und Priority

OpenAI bietet drei alternative Preisstufen für unterschiedliche Anforderungen:

Batch-API

Anfragen werden über den Batch-Endpunkt eingereicht und mit 50 % Rabatt bearbeitet.
Bearbeitung innerhalb von 24 Stunden.
Ideal für: nächtliche Auswertungen, historische Datenverarbeitung, Workflows mit Latenzbudget in Stunden.

Preis: $2,50 (Input) / $15,00 (Output) pro Million Tokens – entspricht GPT-5.4 Standard.

Flex-Verarbeitung

Ebenfalls 50 % Rabatt.
Latenz variiert von Sekunden bis Minuten.
Geeignet, wenn Latenz unkritisch ist, aber (fast) synchrone Antworten benötigt werden.

Priority-Verarbeitung

2,5× Standardtarif ($12,50 / $75,00 bei GPT-5.5).
Schneller Durchsatz, höhere Rate-Limits, kaum Warteschlange.
Nutze Priority für Live-Anwendungen, bei denen Endlatenz entscheidend ist.

Kostenberechnung für den Thinking-Modus

Mit GPT-5.5 kann der "reasoning.effort" Parameter gesetzt werden. Er verändert die Anzahl der verwendeten Tokens pro Anfrage, nicht den Preis pro Token. Die Multiplikatoren:

Aufwand	Output-Token-Multiplikator	Wann zu verwenden
`low` (Standard)	1×	Routineaufrufe
`medium`	1,3–2×	Mehrschrittige Codierung, strukturierte Generierung
`high`	2–4×	Tiefgehende Recherche, Korrektheitsprüfung
`xhigh`	3–8×	Agenten-Loops, dichte Planung

Praxis-Tipp: Ein einziger xhigh-Call mit langem Prompt kann >20.000 Reasoning-Tokens verbrauchen. Bei $30/M Output sind das $0,60 nur für Reasoning – Output-Kosten kommen dazu. Kalkuliere daher das Budget pro Arbeitslast, nicht pro Anfrage.

Codex-Preise

Der Zugang zu Codex hängt vom ChatGPT-Plan ab, nicht vom reinen Tokenverbrauch:

Plan	Codex-Zugang	GPT-5.5	Anmerkungen
Kostenlos	Ja (limitiert)	Ja	Strenge Wochenlimits
Go	Ja (limitiert)	Ja	2× kostenlose Limits
Plus ($20/Monat)	Ja	Ja	Standard-Limits
Pro ($200/Monat)	Ja	Ja + Thinking + Pro	Höchste Benutzerlimits
Business	Ja	Ja	Platzbasiert
Enterprise/Bildung	Ja	Ja	Vertragsbasiert

Praxis-Tipp: Wer viel im Coding-Terminal arbeitet, fährt mit Plus oder Pro günstiger als mit API-Einzelabrechnung – insbesondere ab einigen 100k Tokens/Tag. Der Leitfaden zum kostenlosen Einstieg zeigt, wie du loslegen kannst.

Vergleich: GPT-5.5 vs. andere Modelle

Wann lohnt sich GPT-5.5? Vergleiche Input-/Output-Kosten:

Modell	Input / M	Output / M	Kosten pro 1.000 Output-Tokens
GPT-5.4-mini	$0,25	$2,00	$0,0020
GPT-5.4	$2,50	$15,00	$0,0150
GPT-5.5	$5,00	$30,00	$0,0300
GPT-5.5 Pro	$30,00	$180,00	$0,1800

Entscheidungshilfe:

Viel Output, geringes Risiko (Klassifikation, Zusammenfassung, simpler Chat): GPT-5.4-mini
Produktion, 5.4 erfüllt Qualitätsanspruch: GPT-5.4
Anspruchsvolle Codierung, Agenten, Forschung: GPT-5.5
Kritischer Output, Fehlererkennung teuer: GPT-5.5 Pro

Beispiel: Kosten pro Aufgabe für einen Coding-Agenten

Eine typische API-Session mit GPT-5.5 und reasoning.effort: "medium":

Input-Tokens: ~15.000 (Repo-Kontext + Prompt)
Output-Tokens: ~3.000 (Code + Erklärung)
Reasoning-Tokens: ~6.000 (mittlerer Aufwand)

Kosten pro Aufgabe (Standardpreise):

Input:   15 K × $5,00 / M  = $0,075
Output: (3 K + 6 K) × $30,00 / M = $0,27
Gesamt: $0,345 pro Aufgabe

Auf GPT-5.4:

Input:   15 K × $2,50 / M  = $0,0375
Output:  9 K × $15,00 / M  = $0,135
Gesamt: $0,1725 pro Aufgabe

Fazit: GPT-5.5 kostet das Doppelte pro Aufgabe. Das Upgrade lohnt sich, wenn die höhere Genauigkeit teure Wiederholungen einspart.

Kostenkontrollen: Sofort umsetzbare Maßnahmen

Implementiere diese fünf Hebel direkt zum Start, um Kosten im Griff zu behalten:

Harte max_output_tokens-Limits – z.B. Standard 2.000, nur bei Bedarf mehr.
Strikte JSON-Schemas – Fehlerhafte Ausgaben verursachen teure Wiederholungen.
Nach Schwierigkeit routen – Einfache Aufgaben an 5.4-mini, Komplexes an 5.5 senden.
Batch für alles Offline nutzen – Auswertungen, Reports, Nachfüllungen = 50 % Rabatt.
usage.reasoning_tokens überwachen – Unerwartet hohe Reasoning-Kosten früh erkennen und alarmieren.

Monatliche Kostenübersicht pro Plan

Wähle den passenden ChatGPT-Plan für deinen Use-Case:

Plan	Monatlicher Preis	Am besten geeignet für
Kostenlos	$0	GPT-5.5 via Codex testen
Go	$4 / Monat	Studierende, Gelegenheitsnutzer (2× Limits)
Plus	$20 / Monat	Einzelentwickler, tägliche Nutzung
Pro	$200 / Monat	Power-User, Thinking und Pro in ChatGPT
Business	$25 / Sitzplatz / Monat	Teams, gemeinsame Workspaces
Enterprise / Bildung	Kundenspezifisch	Vertragsbasiert mit SLA

Praxis-Tipp: Wer >4 Mio Output-Tokens/Monat verarbeitet, spart mit ChatGPT Pro + Codex CLI gegenüber der API-Abrechnung – solange die Arbeitslast in das 400k Token Kontextfenster passt.

Preisänderungssignale: Darauf achten

Zwei wichtige Indikatoren für die Preisentwicklung:

Allgemeine Verfügbarkeit von GPT-5.5 – Preise könnten mit Konkurrenz (Claude, Gemini, Open-Weight-Modelle) sinken. Siehe Vellum-Leaderboard.
Demokratisierung des Pro-Modells – OpenAI hat Pro-Preise bisher oft 3–6 Monate nach Release gesenkt. Plane mit Spielraum.

FAQ

Reduziert Caching die Input-Kosten?

Ja, gecachte Input-Tokens werden günstiger abgerechnet. Details auf der OpenAI-Preisseite. Cache-Systemprompts, Tool-Schemas, Repo-Kontext.

Gibt es Mengenrabatt?

Kein offizieller. Individuelle Tarife sind für Großkunden möglich. Bei >$1 Mio/Jahr: Vertrieb kontaktieren.

Verursacht Thinking-Modus Zusatzkosten?

Nein, aber der höhere Tokenverbrauch erhöht die Kosten.

Wird Codex CLI separat abgerechnet?

Nur bei API-Key-Login. Bei ChatGPT-Login über die Plangebühr.

Günstigster Einstieg für GPT-5.5?

Kostenloser oder Go-Plan plus Codex CLI. Siehe Leitfaden zum kostenlosen Einstieg für Details.

GPT-5.5 Kostenlos Nutzen mit Codex: Anleitung

Emre Demir — Fri, 24 Apr 2026 02:30:10 +0000

OpenAI hat am 23. April 2026 GPT-5.5 veröffentlicht und Codex für alle ChatGPT-Pläne (inklusive Free und Go, zeitlich begrenzt) eingeführt. Das schnellste Setup für GPT-5.5 ohne API-Schlüssel oder Kreditkarte: Codex CLI installieren, mit ChatGPT-Konto anmelden und GPT-5.5 direkt im Terminal nutzen.

Probiere Apidog noch heute aus

In diesem Leitfaden findest du Schritt-für-Schritt-Anleitungen zur Installation, Authentifizierung, Modellwahl, Limits und Integration von Codex in echte Coding-Workflows. Die Modellübersicht gibt es hier, kostenlose Alternativen im GPT-5.5-Free-Guide.

TL;DR

Codex CLI bringt GPT-5.5 (400K Kontext) direkt ins lokale Repo.
ChatGPT Free, Go, Plus, Pro, Business, Enterprise, Edu erhalten Zugriff (Free/Go: limitiert).
Installation:

  npm install -g @openai/codex
  # oder
  brew install codex

Anmeldung via ChatGPT OAuth im Browser, alternativ Gerätecode für Headless-Server.
Modellwechsel live: /model gpt-5.5, Kontingent prüfen: /status
Kombiniere Codex mit Apidog für vorgefertigte, getestete API-Calls.

Warum Codex der einfachste Weg zu GPT-5.5 ist

Die OpenAI API ist kostenpflichtig (5 $/Mio Input-Token, 30 $/Mio Output-Token). Codex kapselt GPT-5.5 im CLI, authentifiziert via ChatGPT-Login statt API-Key. Der Plan bestimmt die Rate-Limits, aber das Modell ist identisch.

Codex CLI installieren

Zwei Wege:

# Plattformübergreifend mit npm
npm install -g @openai/codex

# Oder mit Homebrew (macOS / Linux)
brew install codex

Installation prüfen:

codex --version

Mindestens Version 0.28.0 erforderlich (ältere Versionen zeigen GPT-5.5 nicht an).

Mit ChatGPT-Konto authentifizieren

Erster Start: CLI fragt nach der Anmeldemethode.

Browser OAuth (lokale Maschinen)

codex

Browser öffnet sich – mit ChatGPT-Daten anmelden. Sitzung bleibt gespeichert.

Gerätecode (Headless/Remote)

codex login --device-auth

Im Terminal erscheint ein Code+URL. Auf beliebigem Gerät öffnen, Code eingeben, bestätigen. Headless-Server authentifiziert sich nach Bestätigung.

API-Key-Fallback

printenv OPENAI_API_KEY | codex login --with-api-key

Belastet das API-Abrechnungskonto statt ChatGPT. Sinnvoll für Team-Accounts oder wenn API-Key bevorzugt wird.

GPT-5.5 als Modell wählen

Standardmodell ist abhängig vom Plan. Bei Free/Go ggf. manuell wechseln.

Im laufenden CLI

/model gpt-5.5

CLI zeigt aktives Modell und Limits.

Direkt beim Start

codex --model gpt-5.5

Kontingent prüfen

/status

Zeigt Nachrichtenbudget, Kontextgröße, ggf. Ablaufzeit des Free/Go-Zugangs.

Erste Sitzung: Praxisbeispiel

Codex CLI arbeitet fullscreen im Terminal, hat Zugriff aufs Repo, kann Befehle ausführen, Dateien bearbeiten.

cd ~/Projects/my-app
codex --model gpt-5.5

Im CLI z.B.:

> Lese README.md, öffne dann scripts/deploy.sh und fasse zusammen, was es in fünf Stichpunkten tut.

Codex zeigt Zusammenfassung.

> Refaktorisiere deploy.sh so, dass es bei jedem fehlgeschlagenen Schritt beendet wird, und füge ein Dry-Run-Flag hinzu. Achte auf Abwärtskompatibilität.

CLI schlägt Diff vor, wartet auf Genehmigung und übernimmt bei OK.

> Führe die Deploy-Testsuite aus und zeige mir den fehlerhaften Fall.

Testergebnisse werden gestreamt. Fehler? Modell um Fix bitten, wiederholen bis „grün“.

Dieser Workflow ist der Sweetspot für GPT-5.5 (SWE-Bench-Score: 88,7 % lt. OpenAI).

Codex-CLI – Mehrwert gegenüber reinen API-Calls

Vorteile:

Repo-Kontext: Dateibaum-Indexierung, Modell erhält Handles statt reinen Dateiinhalten → riesiges Kontextfenster bleibt frei für Code.
Befehlsausführung mit Freigabe: Jeder vorgeschlagene Befehl wartet auf deine Bestätigung.
Diff-Vorschau: Jede Änderung als einheitlicher Diff, akzeptieren/ablehnen/editieren vor Anwendung.
Session-Persistenz: Verlauf pro Projekt, nahtloses Weitermachen.

Ohne Codex müsstest du diese Funktionen selbst via API bauen. Siehe diesen Guide für die Bare-Metal-Variante.

Ratenlimits pro Plan

Stand 23. April 2026:

Plan	GPT-5.5-Zugriff in Codex	Wöchentliche Obergrenze
Kostenlos	Ja (begrenzte Zeit)	Streng; Prototyp-Größe
Go	Ja (begrenzte Zeit), 2× Free-Limits	Klein
Plus	Ja	Mittel
Pro	Ja, höchste Obergrenzen für Einzelnutzer	Hoch
Business	Ja, sitzbasiert	Hoch pro Platz
Enterprise / Bildung	Ja, vertragsbasiert	Benutzerdefiniert

Bei Überschreitung liefert Codex einen klaren Fehler zurück. /status zeigt aktuelle Limits.

Editor- und IDE-Integration

Codex-Login gilt auch für VS Code Extension, JetBrains-Plugin, Codex-Cloud-App. Nach CLI-Login nutzt die IDE-Erweiterung dieselben Credentials.

Für Apidog-User:

Prototyping einer Anfrage im Codex CLI (führe GPT-5.5-Prompt für diese Datei aus)
Exportiere Prompt + Output in eine Apidog-Kollektion für Team-Sharing.
Ersetze Codex durch direkten API-Call, sobald das Contract stabil ist und du auf kostenpflichtigen Key wechselst.

Siehe Apidog in VS Code für Integration.

Sicherheit: Free & Go absichern

Zwei Empfehlungen:

Datei-Schreibvorgänge immer bestätigen: In ~/.codex/config.json:

  "autoApproveWrites": false

Bei Free ist das Default, bei manchen Go-Setups werden triviale Diffs sonst automatisch übernommen.

Arbeitsbereich eingrenzen: Starte codex nur im Projektverzeichnis – so bleibt der Lesebereich limitiert. Wer im Home-Verzeichnis startet, gibt Zugriff auf alle Dateien.

OpenAI hat GPT-5.5 durch Third-Party-Security-Audits geprüft (CNBC), aber CLI läuft lokal: Immer Diffs prüfen!

Wann solltest du upgraden?

„Für eine begrenzte Zeit“ heißt: Free/Go laufen aus. Upgrade, wenn:

Wöchentliche Limits zu knapp: Echte Arbeit = Upgrade auf Plus/Pro.
Du willst direkte API: CLI reicht nicht mehr; API-Guide zur Migration.
Team braucht sitzbasierte Abrechnung: Business/Enterprise via Preisübersicht.

Nur Abrechnungsmodell und Oberfläche ändern sich – das Modell bleibt identisch.

FAQ

Führt Codex auch GPT-5.5 Pro aus?

Pro ist aktuell nicht in Codex verfügbar. Das CLI nutzt GPT-5.5 Standardmodell, Pro bleibt Web/App/API vorbehalten.

Kann ich Codex ohne ChatGPT-Konto nutzen?

Nein, entweder ChatGPT-Login oder OpenAI API-Key ist Pflicht. Die Gratis-Variante setzt ChatGPT voraus.

Wie lange bleibt Free/Go-Zugang?

OpenAI spricht explizit von „begrenzter Zeit“. Kalkuliere mit einigen Wochen/Monaten und plane rechtzeitig dein Upgrade.

Läuft Codex offline?

Nein – jeder GPT-5.5-Call geht zu OpenAI.

Unterschied zur ChatGPT-Web-App?

Codex läuft im Terminal mit Zugriff auf dein Dateisystem, Shell, Repo-Kontext. Die Web-App bietet das nicht.

GPT-5.5 API Kostenlos Nutzen: Anleitung & Möglichkeiten

Emre Demir — Fri, 24 Apr 2026 02:17:29 +0000

GPT-5.5 wurde am 23. April 2026 veröffentlicht und ist auf den meisten Oberflächen hinter einer Paywall zugänglich: Plus, Pro, Business und Enterprise in ChatGPT sowie über kostenpflichtige API-Tokens für programmatische Aufrufe. Es gibt jedoch drei funktionierende kostenlose Wege, mit denen Sie sofort echte GPT-5.5-Aufrufe durchführen können – vorausgesetzt, Sie akzeptieren Ratenbegrenzungen und ein mögliches Ablaufdatum. Dieser Leitfaden zeigt Ihnen alle kostenlosen Optionen, für welchen Anwendungsfall sie geeignet sind und wie Sie eine produktionsreife Sammlung in Apidog vorbereiten, um bei steigendem Bedarf nahtlos auf kostenpflichtige Nutzung umzusteigen.

Teste Apidog noch heute

TL;DR

Codex CLI auf ChatGPT Free oder Go — Temporärer kostenloser Zugriff auf GPT-5.5 über das Befehlszeilentool Codex. Keine Kreditkarte erforderlich. Funktioniert sofort.
OpenAI Testguthaben für neue API-Konten — Startguthaben auf dem ersten API-Schlüssel, das echte GPT-5.5-Aufrufe erlaubt, sobald die API offen ist.
OpenRouter und Aggregator-Freikontingente — Drittanbieter-Gateways mit gelegentlichen Free-Tiers für Frontier-Modelle kurz nach Release.
Jeder Pfad ist limitiert. Für Produktion rechtzeitig auf kostenpflichtige Abrechnung umstellen, bevor das Testguthaben erlischt.

Pfad 1: Codex CLI (der praktischste kostenlose Weg)

OpenAI hat Codex zu jedem ChatGPT-Plan (auch Free und Go) hinzugefügt – befristet. Wichtig: Codex macht GPT-5.5 über ChatGPT-Login statt API-Key nutzbar. Sie loggen sich mit kostenlosem Konto ein, führen die CLI aus, und GPT-5.5 antwortet im 400K-Token-Fenster.

Installation

npm install -g @openai/codex
# oder
brew install codex

Überprüfen:

codex --version

Authentifizierung

Beim ersten Start von codex öffnet sich ein Browser-Login mit ChatGPT OAuth. Auf Headless-Servern:

codex login --device-auth

Sie erhalten einen Gerätecode zur Eingabe auf einer anderen Maschine. Kein API-Key nötig.

Modell auswählen

In aktiver Codex-Session:

/model gpt-5.5

Oder CLI direkt:

codex --model gpt-5.5

Kontingent prüfen mit /status. Free- und Go-Stufen sind limitiert, reichen aber für Prototypen.

Was ist möglich, was nicht

Sie erhalten echtes GPT-5.5 mit 400K Kontext, Dateizugriff, Terminalausführung und Repo-Editing in der CLI. Kein direkter API-Zugriff – das Modell ist ausschließlich über Codex nutzbar, solange Sie angemeldet sind. Details siehe unseren Codex-Leitfaden.

OpenAI gibt „begrenzte Zeit“ vor – der kostenlose Codex-Zugang endet. Halten Sie die Modell-ID konfigurierbar, um bei Ablauf nahtlos auf kostenpflichtige Nutzung oder API umzustellen.

Pfad 2: OpenAI Testguthaben für neue API-Konten

Neue OpenAI-Entwicklerkonten starten meist mit Testguthaben (z.B. $5 für 90 Tage, manchmal mehr für .edu-E-Mail). Sobald die GPT-5.5 API offen ist, können Sie mit diesem Guthaben gpt-5.5-Aufrufe tätigen.

So beanspruchen Sie das Guthaben

Neues Entwicklerkonto unter platform.openai.com anlegen. Verwenden Sie eine bisher nicht genutzte E-Mail; bei bestehender Abrechnung gibt es oft kein Guthaben.
Telefonnummer verifizieren – Testguthaben gibt es nur für verifizierte Nummern.
Projektbezogenen API-Key unter der Test-Organisation erstellen.
Im Nutzungs-Dashboard Betrag und Ablaufdatum prüfen.

Was bringt das für GPT-5.5?

Mit $5 Guthaben und Preisen von $5/M Input-Token bzw. $30/M Output-Token können Sie rund 1 Mio. Input-Tokens oder ca. 160K Output-Tokens von gpt-5.5 testen. Perfekt für Prototyping, Benchmarking und Validierung kleiner Agenten – nicht für Produktion.

Zwei Tipps zum Sparen:

Batch-Modus nutzen: Batch-API-Anfragen laufen zum halben Preis. Gut für asynchrone Workflows. Dokumentation siehe OpenAI API-Preise.
reasoning.effort auf low lassen: Hohe Denkintensität verbraucht Budget schnell. Für Routine genügt der Standardwert.

Der Haken

Testguthaben wird nicht erneuert. Nach Verbrauch oder Ablauf gibt die API 402 zurück. Es gibt keinen zweiten Testzugang.

Pfad 3: Kostenlose Aggregator-Kontingente

Drittanbieter wie OpenRouter, Together und Groq schalten teils kurzfristig Free-Tiers für neue Modelle frei. Verfügbarkeit schwankt – prüfen Sie das am Tag der Kontoerstellung.

Typischer Ablauf:

Konto erstellen, E-Mail verifizieren.
Aggregator-API-Key beziehen.
OpenAI-Basis-URL im SDK durch die Aggregator-URL ersetzen.
Modell-String auf den Aggregator-Alias ändern, z.B. openai/gpt-5.5.

Beispiel in Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-v1-...",
)

response = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[{"role": "user", "content": "Explain the Responses API in two paragraphs."}],
)

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

Achtung: Aggregatoren haben eigene Ratenlimits, das Free-Tier ist oft geteilt, und sobald das Kontingent erschöpft ist, erhalten Sie 402 oder 429. Eignet sich für schnelles Prototyping, nicht für produktive Nutzung.

Welchen kostenlosen Weg sollten Sie wählen?

Anwendungsfall	Bester kostenloser Weg
Terminalbasierter Coding-Assistent	Codex CLI (Pfad 1)
Schnelle Python- oder Node-Experimente	Testguthaben (Pfad 2)
Testen über eine gehostete App	Aggregator (Pfad 3)
Vergleich von GPT-5.5 mit GPT-5.4 bei echten Prompts	Testguthaben + Apidog-Sammlung
Einmalige „Kann das meine Frage beantworten“-Recherche	ChatGPT Plus (nicht kostenlos, aber am günstigsten pro Stunde)

Für alles über Prototyping hinaus sind die drei Wege schnell ausgeschöpft. Nutzen Sie sie, um die API-Struktur und Prompt-Optimierung zu lernen, bevor Sie kostenpflichtig skalieren.

Die Anforderungsstruktur in Apidog vorbereiten

Der schnellste Weg vom „Free-Tier-Test“ zur produktionsreifen Nutzung ist eine zentral gepflegte, versionierte Sammlung in Apidog.

In Apidog:

Neue Sammlung erstellen, POST https://api.openai.com/v1/responses anlegen.
Auth-Header aus Umgebungsvariable setzen, damit Sie Keys austauschen können ohne die Anfrage zu ändern.
Beispielantwort speichern, sodass andere Entwickler im Team mit Mock-Daten arbeiten können.
Für Aggregator-Pfad Sammlung klonen, baseUrl auf OpenRouter stellen und Modell-String anpassen.

Wenn das Testguthaben abläuft oder Sie upgraden, einfach die Umgebungsvariable tauschen – die Sammlung bleibt unverändert funktionsfähig. Mehr dazu in unserer VS Code-Anleitung für Apidog.

Einschränkungen der kostenlosen Wege

Ratenbegrenzungen variieren je nach Auslastung. Codex Free/Go sind bei hoher Nachfrage langsamer.
Testguthaben ist nicht stapelbar. Zweitkonten mit gleicher Karte, Nummer oder IP erhalten kein neues Guthaben.
GPT-5.5 Pro ist nie kostenlos. Die Pro-Stufe bleibt kostenpflichtig.
Denkmodus verbraucht Budget. Halten Sie reasoning.effort auf low, außer bei gezielten, komplexen Tests.
Kostenlose Zugänge sind zeitlich befristet. Codex Free/Go ist laut OpenAI-Ankündigung explizit „für eine begrenzte Zeit“ verfügbar.

Ein realistischer Free-Tier-Prototyp

So holen Sie das Maximum aus dem Free-Tier:

Wählen Sie eine reale Aufgabe aus Ihrem Teamalltag (Report, Code Review, Research).
Führen Sie 10 Beispiele mit GPT-5.4 auf Ihren Tools aus, dokumentieren Sie die Qualität.
Wiederholen Sie die 10 Beispiele mit GPT-5.5 (über Codex CLI oder Testguthaben).
Vergleichen Sie Output und Fehlerrate pro Token.
Entscheiden Sie, ob das Upgrade die Preissteigerung für Ihre Workload rechtfertigt.

Das ist ein Workflow für einen Nachmittag – und zahlt sich aus, sobald Sie produktiv werden.

FAQ

Ist Codex Free/Go dauerhaft verfügbar?

Nein. Laut OpenAI-Ankündigung nur „für eine begrenzte Zeit“. Rechnen Sie mit einem Auslaufen binnen Monaten.

Bekomme ich GPT-5.5 im Browser auf ChatGPT Free?

Nein. Der kostenlose ChatGPT-Plan bleibt bei GPT-5.3. GPT-5.5 im Chat-Interface setzt Plus oder höher voraus.

Kann ich GPT-5.5 kostenlos auf Hugging Face oder Ollama nutzen?

Nein. GPT-5.5 ist Closed-Weight und läuft nur bei OpenAI oder über Codex-Login.

Gibt es Studentenrabatte?

OpenAI hat in der Vergangenheit Vergünstigungen für .edu-Adressen und mehr Testguthaben geboten. Prüfen Sie die OpenAI-Bildungsseite.

Wie wechsle ich auf kostenpflichtige Nutzung, ohne Code zu ändern?

Nutzen Sie Umgebungsvariablen für Key und Base-URL (OPENAI_API_KEY, OPENAI_BASE_URL). Tauschen Sie diese Werte, wenn der Free-Tier endet – darum setzt unser GPT-5.5 API-Leitfaden auf projektbezogene Schlüssel.

GPT-5.5 API nutzen: Eine Anleitung

Emre Demir — Fri, 24 Apr 2026 02:14:06 +0000

GPT-5.5 wurde am 23. April 2026 eingeführt. OpenAI hat das Modell am selben Tag in ChatGPT und Codex integriert und plant die Freigabe der Responses- und Chat Completions-APIs in Kürze. In diesem Leitfaden findest du alle praktischen Schritte für die API-Integration: Endpunkte, Authentifizierung, Python- und Node-Beispiele, Parametertabelle, Preisberechnung für den Denkmodus, Fehlerbehandlung und einen effizienten Test-Workflow in Apidog, um Iterationskosten zu minimieren.

Probiere Apidog jetzt aus

Für eine Produktübersicht siehe Was ist GPT-5.5. Einen kostenlosen Einstieg beschreibt Wie man die GPT-5.5 API kostenlos nutzt.

TL;DR

Endpunkte: responses und chat/completions mit Modell-ID gpt-5.5 oder gpt-5.5-pro.
Preise: 5 $ / Mio. Input, 30 $ / Mio. Output. Pro: 30 $ / Mio. Input, 180 $ / Mio. Output.
Kontextfenster: 1 Mio. Token (API), 400 K (Codex CLI).
Vorab-Nutzung: Über Codex und ChatGPT-Login möglich.
Tipp: Mit Apidog Sammlungen aufsetzen, da die Anforderungsstruktur größtenteils identisch zu GPT-5.4 ist (nur Modell-ID und reasoning-Block anpassen).

Voraussetzungen

Vor dem ersten API-Call brauchst du:

OpenAI-Entwicklerkonto mit Abrechnungsstufe (UI- und API-Abos sind getrennt).
API-Schlüssel mit GPT-5-Zugang (projektspezifisch empfohlen).
Aktuelles SDK: Python openai>=2.1.0, Node openai@5.1.0 oder neuer.
API-Client mit Wiederholungsfunktion (z.B. Apidog, nach erstem Test mit curl).

Schlüssel im Terminal bereitstellen:

export OPENAI_API_KEY="sk-proj-..."

Endpunkt und Authentifizierung

GPT-5.5 nutzt zwei bekannte Endpunkte:

POST https://api.openai.com/v1/responses
POST https://api.openai.com/v1/chat/completions

Die Authentifizierung läuft über Bearer-Token. Beispielaufruf:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Summarize the last 10 releases of the openai/codex repo in three bullets.",
    "reasoning": { "effort": "medium" }
  }'

Die Antwort enthält das output-Array und einen usage-Block (Input-, Output- und Reasoning-Token). Fehler werden als JSON mit code und message zurückgegeben.

Anfrageparameter

Jeder Body-Parameter beeinflusst Kosten oder Verhalten. Die wichtigsten Felder für gpt-5.5:

Parameter	Typ	Werte	Anmerkungen
`model`	string	`gpt-5.5`, `gpt-5.5-pro`	Pflichtfeld. Pro kostet 6× mehr.
`input` / `messages`	string/array	Prompt oder Chat-Array	Pflichtfeld. `input` für Responses, `messages` für Chat Completions.
`reasoning.effort`	string	`none`, `low`, `medium`, `high`, `xhigh`	Default: `low`. Höhere Stufen erhöhen die Denkmodus-Tiefe und die Kosten.
`max_output_tokens`	integer	1 – 128000	Output-Limit (ohne Reasoning-Token).
`tools`	array	Function, web_search, file_search, computer_use, code_interpreter	Modell wählt und verknüpft Tools automatisch.
`tool_choice`	string/object	`auto`, `none`, oder Tool-Name	Tool explizit auswählen.
`response_format`	object	`{ "type": "json_schema", ... }`	Strukturiertes Output; Standard: striktes JSON.
`stream`	boolean	true / false	Server-Sent Events, Reasoning-Token als separate Events.
`user`	string	Freitext	Für Missbrauchserkennung; gehashte User-ID empfohlen.
`metadata`	object	Bis zu 16 Schlüssel-Wert-Paare	Sichtbar im Dashboard und Logs.
`seed`	integer	Beliebige int32	Schwacher Determinismus.
`temperature`	number	0 – 2	Ignoriert ab `reasoning.effort >= medium`.

Am kostenrelevantesten: reasoning.effort, max_output_tokens, tools. Denkmodus (high, xhigh) kann 3–8× mehr Output-Token erzeugen.

Python-Beispiel

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    input=[
        {
            "role": "system",
            "content": "You are a senior Go engineer. Answer in terse, runnable code.",
        },
        {
            "role": "user",
            "content": (
                "Write a worker pool with bounded concurrency and a context "
                "cancellation path. No third-party deps."
            ),
        },
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=4000,
)

print(response.output_text)
print(response.usage.model_dump())

Beachte:

response.output_text liefert den kompakten Text. Für Tool-Ereignisse, Reasoning-Traces, Zitate: direkt auf response.output zugreifen.
usage enthält jetzt separate Zähler für Input-, Output- und Reasoning-Tokens – alle sind abrechnungsrelevant.

Node-Beispiel

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.5",
  input: [
    { role: "system", content: "You are a careful reviewer." },
    {
      role: "user",
      content:
        "Review this migration and flag any operation that would lock a write-heavy table for more than 200 ms.",
    },
  ],
  reasoning: { effort: "high" },
  tools: [{ type: "file_search" }],
  max_output_tokens: 6000,
});

console.log(response.output_text);
console.log(response.usage);

Setze reasoning.effort auf high für Review-Aufgaben, bei denen Korrektheit wichtiger ist als Kosten.

Denkmodus

Denkmodus wird über reasoning.effort (high oder xhigh) aktiviert. Nutze als Standard medium (ausreichend für Multi-Agenten, Debugging, Doku-Generierung), high/xhigh für Forschung, kritische Prüfungen oder komplexe Tool-Ketten. Plane 3–8× mehr Token und längere Antwortzeiten ein.

Denkmodus ist besonders relevant für computer_use oder lange Websuche, da Halluzinationen nachweislich seltener auftreten (OpenAI Launch-Post).

Strukturierte Ausgabe

Striktes JSON ist Standard. Übergebe ein Schema, damit die Ausgabe immer valide ist:

response = client.responses.create(
    model="gpt-5.5",
    input="Extract the title, speaker, and start time from this transcript chunk.",
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "session_extract",
            "strict": True,
            "schema": {
                "type": "object",
                "required": ["title", "speaker", "start_time"],
                "properties": {
                    "title": {"type": "string"},
                    "speaker": {"type": "string"},
                    "start_time": {"type": "string", "format": "date-time"},
                },
            },
        },
    },
)

Für jede Pipeline, die Daten weiterverarbeitet, ist ein Schema Pflicht – kein Overhead, aber deutlich weniger Fehler.

Tool-Nutzung und Agenten

Die Responses API unterstützt:

web_search – Live-Suche mit Quellenangabe
file_search – Vektorsuche in hochgeladenen Dateien
code_interpreter – Python Sandbox
computer_use – Browser/Maus/Tastatur-Emulation
function – Eigene Callbacks

GPT-5.5 kann Tools autonom und mehrstufig verketten – laut The Decoder ca. 11 % häufiger als GPT-5.4.

Fehlerbehandlung und Wiederholungsversuche

Behandle diese Fehler gezielt:

Code	Bedeutung	Wiederholen?
`429 rate_limit_exceeded`	Rate-Limit (Min/Tag) erreicht	Ja, exponentieller Backoff + Jitter
`400 context_length_exceeded`	Kontext (Input+Output+Reasoning > 1 Mio. Token)	Nein, Input kürzen
`500 server_error`	OpenAI-Serverfehler	Ja, bis zu 3 Versuche
`403 policy_violation`	Sicherheitsverletzung	Nein, Prompt anpassen

Reasoning-Token zählen zum Kontext. Ein Call mit reasoning.effort: "xhigh" bei 900 K Input-Token führt schnell zum Überlauf.

Test-Workflow mit Apidog

Kosten sparen durch effiziente Tests:

Anfrage in Apidog anlegen, als Sammlung speichern, Umgebung zuweisen.
Mock-Server nutzen, um Downstream-Code gegen gespeicherte Antwort zu entwickeln.
Erst auf Live-Schlüssel umstellen, wenn das Schema steht.

Apidog integriert sich mit Claude Code und Cursor. Siehe VS Code-Anleitung und Postman-Vergleich.

GPT-5.5 aufrufen, bevor die API allgemein verfügbar ist

Vor GA der Responses API kannst du GPT-5.5 via Codex testen. Der Codex-Leitfaden erklärt Installation, Authentifizierung und Modellauswahl.

FAQ

Gibt es ein gpt-5.5-mini?

Nicht zum Start. Es bleibt bei gpt-5.4-mini als günstige Variante.

Was ist das Kontextfenster?

1 Mio. Token (API), 400 K (Codex CLI), Reasoning-Token inklusive.

Muss ich meinen GPT-5.4-Code anpassen?

Nein – Modell-ID tauschen, ggf. max_output_tokens und reasoning.effort justieren.

Wie senke ich die Kosten?

Batch (50 % Rabatt), Flex (50 % Rabatt, langsamere Queue), strikte Schemata gegen Wiederholungsschleifen. Details: GPT-5.5 Preisübersicht.

Wo kommt die GA-Ankündigung?

Checke die OpenAI Developer Community und die OpenAI API Pricing Page.

GPT-5.5: OpenAI's Neuester Durchbruch Erklärt

Emre Demir — Fri, 24 Apr 2026 01:51:51 +0000

OpenAI hat am 23. April 2026 GPT-5.5 veröffentlicht – nur sechs Wochen nach GPT-5.4. Das Modell richtet sich gezielt an Entwickler und Teams, die mehrstufige Codierung, produktive Computernutzung und tiefgehende Forschung automatisieren wollen. GPT-5.5 läuft bereits in ChatGPT und Codex, die API folgt in Kürze.

Teste Apidog noch heute

Wenn du abwägst, ob sich ein Umstieg auf GPT-5.5 lohnt, bietet dieser Leitfaden einen praxisorientierten Überblick: Was bringt das Modell gegenüber 5.4, welche Benchmarks sind relevant, wie kannst du es jetzt direkt einsetzen und welche Stolperfallen solltest du kennen?

Für die direkte Implementierung findest du hier Entwickler-Walkthroughs: GPT-5.5 API-Leitfaden, Anleitung für kostenlosen Zugriff, kostenloser Codex-Workflow und eine Preisübersicht. Wer direkt loslegen will, kann mit Apidog bereits eine Sammlung anlegen und auf die API warten.

TL;DR

GPT-5.5 ist das aktuelle Topmodell von OpenAI für Coding & logisches Denken (Release: 23.04.2026).
Benchmarks: 88,7 % auf SWE-bench, 92,4 % auf MMLU, 60 % weniger Halluzinationen ggü. GPT-5.4.
Drei Varianten: Standard, Thinking (erweitertes Denken), Pro (höchste Präzision).
Live in ChatGPT Plus, Pro, Business, Enterprise, Edu und Codex (alle Pläne), inkl. zeitlich begrenztem Free-/Go-Zugang.
API ist gestaffelt: Zugriff aktuell über Codex-Anmeldepfad, API Responses/Completions folgen.
API-Preise: 5 $ / Mio. Input-Tokens, 30 $ / Mio. Output-Tokens (doppelt so teuer wie 5.4, aber effizientere Token-Nutzung).

Was GPT-5.5 tatsächlich ist

GPT-5.5 ist das Flaggschiff der GPT-5-Reihe (über 5.4 und 5.4-mini, älter als die 5.3-Familie). Der Codename „Spud“ taucht in OpenAIs Teaser auf, offiziell heißt das Modell GPT-5.5.

Zum Launch gibt es drei Varianten:

GPT-5.5 – Standard: Schneller, präziser, optimiert für möglichst wenig Tokens je Aufgabe.
GPT-5.5 Thinking – wie Standard, aber mit erweitertem Budget fürs logische Denken. Ideal für komplexe Tabellen, dichte Forschungsberichte, Multi-Datei-Debugging. Begrenzung: 3.000 Nachrichten/Woche in ChatGPT.
GPT-5.5 Pro – höchste Präzision, speziell für Aufgaben mit kritischer Korrektheit. Verfügbar für Pro, Business, Enterprise.

Das Modell kann planen, Tools auswählen und die eigene Ausgabe prüfen, bevor es Ergebnisse zurückgibt. In der Praxis heißt das: Weniger Nachfragen nötig, weniger Fehler in Tabellen, häufiger Rückfragen statt Halluzinationen.

Was ist neu gegenüber GPT-5.4?

In nur sechs Wochen gab es gezielte Upgrades. Die wichtigsten Unterschiede:

Fähigkeit	GPT-5.4	GPT-5.5
SWE-bench	~74 %	88,7 %
MMLU	91,1 %	92,4 %
Halluzinationsrate	Baseline	−60 %
Kontextfenster (API)	1,05 Mio.	1 Mio. (Codex: 400 Tsd.)
API-Eingabepreis	2,50 $ / Mio.	5,00 $ / Mio.
API-Ausgabepreis	15,00 $ / Mio.	30,00 $ / Mio.
Computernutzung	Wird verbessert	Produktionsreif
Mehrstufige Werkzeugketten	Einzelschuss bevorzugt	Vollständige autonome Schleifen

Besonders der SWE-bench-Sprung ist entscheidend: 88,7 % auf SWE-bench Verified bedeutet, dass GPT-5.5 echte GitHub-Issues auf dem Level erfahrener Entwickler löst. In der Praxis solltest du aber vor Produktionsumstellungen eigene Tests auf deiner Codebasis durchführen.

Die Preisverdopplung relativiert sich durch effizientere Token-Nutzung. Unabhängige Analysen (z.B. The Decoder) rechnen mit ca. 20 % Mehrkosten pro Aufgabe im Durchschnitt. Bei kurzen Prompts ist der Unterschied minimal.

Wofür eignet sich GPT-5.5?

OpenAI zielt mit GPT-5.5 auf diese vier Kern-Usecases:

Agentisches Codieren: Automatisiertes Lesen von Repos, Öffnen von Dateien, Testausführung, iterative Verbesserungen. (SWE-bench-Score!)
Computernutzung: Browser/Shell steuern, Formulare ausfüllen, Daten scrapen, Fehler abfangen.
Tiefgehende Forschung: Lange Argumentationsketten, Websuche, Zusammenfassung widersprüchlicher Quellen (insb. im Thinking-Modus).
Dokumenten- & Tabellenkalkulationserstellung: Weniger Layout-/Formelfehler, klarere Struktur. Standard in ChatGPT Plus/Business.

Wofür nicht? Für Massenzusammenfassungen, Embedding-Queries, günstige Klassifizierungen ist 5.4-mini oder 5.3 weiterhin effizienter. GPT-5.5 lohnt sich, wenn sonst ein erfahrener Entwickler/Researcher prüfen müsste.

Verfügbarkeit heute

Der Zugang ist gestaffelt, hier der Stand (23.04.2026):

Oberfläche	Plan	Zugriff
ChatGPT	Free	GPT-5.3 Standard, kein GPT-5.5
ChatGPT	Go	GPT-5.3 Standard, kein GPT-5.5
ChatGPT	Plus	GPT-5.5 Standard + Thinking (3.000/Woche)
ChatGPT	Pro	Standard + Thinking + Pro
ChatGPT	Business	Standard + Thinking + Pro
ChatGPT	Enterprise / Edu	Standard + Thinking + Pro
Codex	Alle Pläne (Free, Go, Plus, Pro, Business, Enterprise, Edu)	GPT-5.5 mit 400 Tsd. Kontext; Free und Go zeitlich begrenzt
API	Responses / Chat Completions	„Sehr bald“; nicht GA zum Start

Wichtig für Entwickler: Über Codex ist GPT-5.5 bereits produktiv nutzbar, z.B. per CLI – auch ohne eigene API-Schlüssel.

API-Preise und Kostenstruktur

GPT-5.5 API: 5 $ / Mio. Input-Tokens, 30 $ / Mio. Output-Tokens
GPT-5.5 Pro API: 30 $ / Mio. Input, 180 $ / Mio. Output (wie 5.4 Pro)
Batch/Flex: 50 % des Standardtarifs
Priorität: 2,5x Standardtarif
Codex CLI: kostenlos für Plus, Pro, Business, Enterprise, Edu, Go und befristet Free (jeweils mit Wochenlimits)

Alle Details und Kostenschätzungen pro Usecase findest du in dieser Preisübersicht.

Schnellstart: So nutzt du GPT-5.5 direkt

ChatGPT öffnen (Plus/Pro/Business/Enterprise/EDU): GPT-5.5 im Modellauswahlmenü wählen. Sofort loslegen.
Codex CLI installieren:
```
npm install -g @openai/codex
  brew install codex
  
```
Dann codex starten, mit ChatGPT-Konto anmelden. Mit /model gpt-5.5 auf das neue Modell wechseln. Free/Go-Pläne haben temporären Zugang. Komplette Codex-Anleitung
Auf API-Rollout vorbereiten: Die API wird in Kürze freigeschaltet. Lege jetzt eine Anfragessammlung in Apidog an, damit du direkt nach Live-Schaltung loslegen kannst. API-Leitfaden mit Endpunktstruktur

Sicherheit & Red-Teaming

GPT-5.5 wurde vor Launch von Dritten auf Cyber- und Biogefahren getestet. Besonders relevant für Entwickler: Strengere Ablehnungsregeln für Dual-Use-Code, restriktivere API-Freigabe. Wenn du Agenten mit Browserzugriff/deployst, plane restriktivere Policies als bisher bei 5.4 ein.

Solltest du umsteigen?

Coding-Agenten? Ja, sofort upgraden. SWE-bench-Sprung zahlt sich in Loops schnell aus; Codex-Zugang ist aktiv.
High-Volume-Inferenz? 5.4-mini als Standard behalten, GPT-5.5 gezielt für komplexe Aufgaben nutzen.
Kundenfokus? Auf API-Rollout warten, dann A/B-Test fahren. Preissteigerung ist nur dann relevant, falls Halluzinationen problematisch waren.

Den vollständigen Entscheidungsablauf findest du in der Preisübersicht.

FAQ

Ist GPT-5.5 schon über die API verfügbar? Direkt per Schlüssel: noch nicht (Stand 23.04.2026). OpenAI: „sehr bald“. Über Codex nach ChatGPT-Login aber jetzt schon ansteuerbar.

Wie groß ist das Kontextfenster? 1 Mio. Tokens in ChatGPT & API (bald). Codex CLI: 400 Tsd. Tokens/Plan.

Thinking vs. Pro? Thinking = erweitertes Denkbudget im Standardmodell; Pro = separate, hochpräzise Variante für Korrektheits-kritische Tasks. Pro nur in Pro/Business/Enterprise.

Kostenlos? In ChatGPT: nur mit kostenpflichtigen Plänen. In Codex: temporär auch für Free/Go (mit Limits). Kostenlose Wege im Überblick.

Kann ich GPT-5.4 weiter nutzen? Ja – günstiger (2,50 $ / 15 $ pro Mio. Tokens), bleibt Standard für kostenoptimierte Workflows.

Hy3 Preview API Kostenlos Nutzen: So geht's

Emre Demir — Thu, 23 Apr 2026 10:46:56 +0000

Tencent hat Hy3 Preview am 22. April 2026 quelloffen gemacht, und innerhalb eines Tages listete OpenRouter es als vollständig kostenlosen Endpunkt. Keine Kreditkarte, keine Token-Abrechnung, kein Testzeitraum. Sie können dasselbe 295B-Parameter Mixture-of-Experts-Modell, das Tencents Yuanbao-App und den CodeBuddy-Assistenten antreibt, heute aus Ihrem eigenen Code heraus für null Euro aufrufen.

Testen Sie Apidog noch heute

Dieser Leitfaden zeigt, wie Sie die Hy3 Preview API kostenlos über OpenRouter, den Hugging Face Space und das ursprüngliche Hy3-Repository nutzen können. Er behandelt auch die Denkmodi, die Hy3 von den meisten offenen Modellen von 2026 unterscheiden, und wie Sie die API innerhalb von Apidog testen können, ohne Wegwerf-Skripte schreiben zu müssen.

Wenn Sie den schnellsten Weg zu Ihrer ersten Antwort wünschen, springen Sie zu „Schritt-für-Schritt: Hy3 Preview kostenlos über OpenRouter aufrufen“.

Kurz gesagt (TL;DR)

Hy3 Preview ist kostenlos auf OpenRouter unter der Modell-ID tencent/hy3-preview:free mit 0 $ Eingabe- und 0 $ Ausgabepreisen.
Es ist ein Mixture-of-Experts-Modell: insgesamt 295B Parameter, 21B aktiv, 192 Experten mit Top-8-Routing und ein 256K-Token-Kontextfenster.
Drei Denkmodi sind eingebaut: no_think für schnelle Antworten, low und high für tiefgreifende Chain-of-Thought bei Agenten- und Programmieraufgaben.
Die Benchmarks sind für ein Open-Weights-Modell stark: SWE-bench Verified 74.4, Terminal-Bench 2.0 54.4, GPQA Diamond 87.2, MMLU 87.42.
Sie können es auf drei kostenlosen Wegen ausführen: den kostenlosen OpenRouter-Tarif, den Hugging Face Hy3-preview Space oder die lokale Inferenz mit vLLM und den offenen Gewichten.
Apidog passt gut zum OpenRouter-Endpunkt, da Hy3 das OpenAI Chat Completions-Schema verwendet; richten Sie eine Anfrage an OpenRouter und legen Sie los.

Was ist Hy3 Preview?

Hy3 Preview ist die erste Flaggschiff-Veröffentlichung des neu strukturierten Hunyuan-Basismodellteams von Tencent, das jetzt von Yao Shunyu geleitet wird, einem ehemaligen OpenAI-Forscher, den das Unternehmen eingestellt hat, um seinen Reasoning Stack voranzutreiben. Es kann als Tencents bisher leistungsfähigstes Modell und eine direkte Antwort auf die wichtigsten chinesischen Open-Weights-Veröffentlichungen von DeepSeek, Alibaba und Zhipu verstanden werden.

Das technische Profil der offiziellen Modellkarte ist agentenorientiert:

Architektur: Mixture-of-Experts, 80 Schichten plus eine MTP-Schicht, 64 Attention-Heads mit gruppierter Query-Attention.
Parameter: insgesamt 295B, 21B aktiv pro Vorwärtsdurchlauf.
Experten: 192 Spezialisten mit Top-8-Routing pro Token.
Kontext: 256K Token (262.144 auf OpenRouters Liste).
Tokenizer: 120.832-Einträge-Vokabular mit BF16-Präzision.
Lizenz: Tencent Hy Community License, kommerzielle Nutzung im Rahmen der Lizenzbedingungen erlaubt.

Was es von einem generischen MoE im 200B-Bereich unterscheidet, ist das agentische Training. Tencent hat seine RL-Infrastruktur für den Multi-Turn-Werkzeuggebrauch neu aufgebaut, und die veröffentlichten Ergebnisse auf SWE-bench Verified, Terminal-Bench 2.0 und der internen WildClawBench-Suite bringen es in die Nähe der besten geschlossenen Modelle bei Code- und Shell-Aufgaben.

Drei kostenlose Wege zur Nutzung von Hy3 Preview

Sie haben drei Möglichkeiten, je nachdem, ob Sie eine Chat-Benutzeroberfläche, eine API oder lokale Gewichte wünschen.

Weg	Was es ist	Kostenlos?	Gut für
OpenRouter `tencent/hy3-preview:free`	Gehostete OpenAI-kompatible API	Ja, 0 $ Input/Output	Entwicklung von Agenten, Skripten und Backend-Funktionen
Hugging Face Space	Browser-Chat-Demo	Ja	Schnelle Prompts, Ausprobieren, Smoke-Tests
Selbst gehostete Gewichte (vLLM/SGLang)	Führen Sie die offenen Gewichte auf eigenen GPUs aus	Kostenlose Software, Hardwarekosten fallen an	Datenschutzsensible Arbeitslasten, hohes Volumen

Die meisten Entwickler werden den OpenRouter-Weg bevorzugen. Es ist der kürzeste Weg von der Anmeldung bis zu einem funktionierenden API-Aufruf, und die Ratenbegrenzungen im kostenlosen Tarif sind für Prototypen ausreichend großzügig.

Schritt-für-Schritt: Hy3 Preview kostenlos über OpenRouter aufrufen

Hier ist der minimale Weg von null zu einer funktionierenden tencent/hy3-preview:free-Antwort.

OpenRouter-Konto erstellen. Gehen Sie auf openrouter.ai und melden Sie sich mit E-Mail an. Für Free-Tier-Modelle ist keine Zahlungsmethode erforderlich.
API-Schlüssel generieren. Im OpenRouter-Dashboard unter „Keys“ neuen Schlüssel erstellen. In eine Umgebungsvariable speichern, etwa export OPENROUTER_API_KEY=sk-or-....
Modellseite öffnen. Gehen Sie zur kostenlosen Hy3 Preview-Liste und prüfen Sie den „Free“-Statusbanner. Dort sehen Sie auch Nutzungsstatistiken.

Erste Anfrage senden: OpenRouter unterstützt das OpenAI Chat Completions-Schema, jedes OpenAI SDK funktioniert. Beispiel mit cURL:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tencent/hy3-preview:free",
    "messages": [
      {"role": "user", "content": "Explain the MoE routing decision inside a top-8 of 192 setup in 3 sentences."}
    ],
    "temperature": 0.9,
    "top_p": 1.0
  }'

Reasoning aktivieren: Hy3 akzeptiert einen reasoning-Parameter mit effort auf low oder high. OpenRouter gibt die Denkspur in einem separaten reasoning_details-Array zurück.

{
  "model": "tencent/hy3-preview:free",
  "messages": [
    {"role": "user", "content": "Plan, then write a Bash script that rotates daily log files older than 30 days into a dated archive folder."}
  ],
  "reasoning": {"effort": "high"}
}

Iterieren: Halten Sie die Sitzung im selben Thread, um Kontext zu bewahren. Hy3s 256K-Fenster kann komplette Codebasen verarbeiten.

Das war's. Das Modell hinter OpenRouter ist identisch mit dem Hugging Face-Modell; die Qualität ist gleich, egal ob kostenfrei oder kostenpflichtig.

Kostenlos, Plus und selbst gehostet: Wo sie sich unterscheiden

Fähigkeit	OpenRouter Kostenlos	OpenRouter Kostenpflichtig	Selbst gehostet (vLLM/SGLang)
Kosten pro Token	0 $	Pro Anbieter	Strom plus GPU-Amortisation
Denkmodi	`no_think`, `low`, `high`	Gleich	Gleich
Kontextlänge	256K	256K	256K (sofern Speicher ausreicht)
Durchsatz unter Last	Geteilter Pool, ggf. depriorisiert	Dediziert	Was Ihr Cluster liefert
Ratenbegrenzungen	OpenRouter Free-Tier-Grenze	Anbieterspezifisch	Keine
Datenaufbewahrung	OpenRouter Protokollierung	Anbieterspezifisch	Bleibt auf Ihrer Hardware
Sichtbarkeit von Reasoning-Token	Ja, über `reasoning_details`	Ja	Ja

Kostenlos eignet sich für Prototypen, Nebenprojekte, Benchmarks und Agenten mit geringem Traffic. Wählen Sie kostenpflichtig oder selbst gehostet, wenn Latenz oder Skalierung entscheidend sind.

Prompt- und Parameter-Tipps, um mehr aus Hy3 herauszuholen

Temperatur anpassen: Standard ist temperature=0.9, top_p=1.0. Für strukturierte Ausgabe auf 0.3 reduzieren, für kreative Aufgaben bei 0.9 bleiben.
no_think für Chat: Für einfachen Chat reicht der Standardmodus. low oder high für Planung, Code, Mathematik nutzen.
Tools im System-Prompt benennen: Beschreiben Sie Werkzeuge explizit, nicht nur als Schema. Das verbessert Tool-Aufrufe.
Code direkt einfügen: Nutzen Sie das 256K-Fenster, um vollständige Dateien einzufügen.
Mehrere Dateien stapeln: Senden Sie zusammengehörige Dateien in einer Nachricht, nicht einzeln.
Zuerst nach einem Plan fragen: Für komplexe Aufgaben erst „Plane“, dann „Führe aus“ abfragen.

Grenzen, die man vor dem Einsatz kennen sollte

Ratenbegrenzungen je nach Last: Der OpenRouter Free-Pool kann bei Peaks 429er-Fehler liefern. Exponentielles Backoff einplanen.
Reasoning-Token zählen als Output: Im Free-Tier kostenlos, bei kostenpflichtigen Endpunkten kostenpflichtig.
Lizenz prüfen: Die Tencent Hy Community License ist keine Apache 2.0. Kommerzielle Nutzung erfordert Einhaltung der Bedingungen. Lizenz im GitHub-Repo lesen.
Tool-Parser beachten: Beim Self-Hosting vLLM/SGLang mit --tool-call-parser hy_v3 bzw. hunyuan starten.
Sprache: Englisch und Chinesisch sind am stärksten, andere Sprachen schwächer.
Benchmark-Vergleich: Bei einigen Reasoning-Suiten hinter den US-Flaggschiffen.

Der schnelle Entwicklerweg: Hy3 Preview plus Apidog

Die Arbeit mit cURL ist für erste Tests geeignet, aber für schnelle Iteration ist ein visueller API-Client wie Apidog effizienter.

Apidog öffnen und ein neues Projekt anlegen. Importieren Sie die OpenAI Chat Completions OpenAPI-Spezifikation.
Basis-URL setzen auf https://openrouter.ai/api/v1 und eine Umgebungsvariable für OPENROUTER_API_KEY hinterlegen.
Anfrage anlegen auf /chat/completions mit Modell tencent/hy3-preview:free.
Anfrage duplizieren und Denkmodi (no_think, low, high) vergleichen. So messen Sie Latenz und Output direkt nebeneinander.
Prompt-Vorlagen speichern: Nutzen Sie Apidogs Variablen- und Umgebungsfeatures, um System-Prompts, Tool-Schemata und User-Turns zu verwalten.

Wenn Sie von Postman wechseln, finden Sie im API-Testing ohne Postman im Jahr 2026 Leitfaden die wichtigsten Schritte. Alternativ können Sie Apidog in VS Code nutzen, um API-Tests direkt im Editor auszuführen.

Kostenlose Alternativen, wenn Sie an die Grenze stoßen

Sollten Sie beim kostenlosen OpenRouter auf Limits stoßen, probieren Sie diese Wege:

Hugging Face Space: Die Hy3-preview Space bietet eine Chat-Demo im Browser – ideal für schnelle Tests.
Weitere chinesische Open-Weights-Modelle:
- Alibabas Qwen 3.5 Omni mit kostenlosem Tarif für multimodale Ausgabe. Siehe Qwen 3.5 Omni-Ankündigung und How-To.
- Zhipu GLM 5V Turbo mit großzügigem Free-Tier. Anleitung im GLM 5V Turbo API-Leitfaden.

Für produktive Entwicklung empfiehlt sich, Apidog herunterzuladen und pro Modell eine Sammlung zu erstellen. Benchmarks mit eigenen Prompts sind oft aussagekräftiger als Leaderboards.

Hy3 Preview selbst hosten mit vLLM

Mit passender Hardware können Sie Hy3 lokal ausführen. Die Modellkarte empfiehlt vLLM mit Tensorparallelität und Multi-Token-Vorhersage:

vllm serve tencent/Hy3-preview \
  --tensor-parallel-size 8 \
  --speculative-config.method mtp \
  --speculative-config.num_speculative_tokens 1 \
  --tool-call-parser hy_v3 \
  --reasoning-parser hy_v3 \
  --enable-auto-tool-choice \
  --served-model-name hy3-preview

Für SGLang verwenden Sie --tool-call-parser hunyuan und --reasoning-parser hunyuan. Sobald der Server unter http://localhost:8000/v1 läuft, zeigen Sie Ihr OpenAI-kompatibles SDK einfach auf die lokale URL, wie bei OpenRouter.

Rechnen Sie mit acht H100-ähnlichen GPUs bei BF16 für das volle Modell. Quantisierte Community-Builds werden folgen.

FAQ

Ist Hy3 Preview kostenlos?

Ja. OpenRouter listet tencent/hy3-preview:free mit 0 $ pro Million Input/Output-Token. Reasoning-Token sind im Free-Tier ebenfalls gratis, zählen aber für die Limits. Status auf der OpenRouter-Modellseite prüfen.

Wie schneidet Hy3 Preview im Vergleich zu DeepSeek V3 und Qwen 3 ab?

SWE-bench Verified 74.4 und Terminal-Bench 2.0 54.4 platzieren es auf Augenhöhe mit den Top-Chinesischen Open-Modellen, mit Fokus auf Agenten- und Tool-Nutzung. Für reinen Chat sind Qwen 3 und DeepSeek V3 ebenfalls stark; bei Agenten-Workflows ist Hy3s RL-Training der Unterschied.

Was sind Hy3s Denkmodi?

Drei: no_think (Standard), low, high. Übergeben Sie den Modus mit dem reasoning-Parameter auf OpenRouter oder per chat_template_kwargs={"reasoning_effort": "high"} beim direkten Modellaufruf. high für Planung, mehrschrittigen Code und Mathematik; für normalen Chat deaktiviert lassen.

Kann ich Hy3 Preview kommerziell nutzen?

Ja, unter der Tencent Hy Community License. Kommerzielle Nutzung mit Quellenangabe und Einhaltung der Nutzungsrichtlinien erlaubt. Lizenzbedingungen hier.

Welche Kontextlänge unterstützt der kostenlose Tarif?

256K Token. OpenRouter listet 262.144 Token, wie die Modellkarte. Damit können Sie komplette mittelgroße Codebasen einfügen.

Wie teste ich Hy3 Preview ohne Code zu schreiben?

Nutzen Sie den Hugging Face Space für Chat im Browser oder richten Sie Apidog auf den OpenRouter-Endpunkt ein. Apidog importiert die OpenAI OpenAPI-Spezifikation; Anfrage-Setup: Basis-URL, API-Key, Modellname.