DeepSeek V4 API für Programmierung: Routing von deepseek-v4-pro und deepseek-v4-flash

Jeden Schritt einer Coding-Sitzung an ein einziges Modell zu senden, ist die einfachste Routing-Strategie, aber meist auch die teuerste. Dieses Tutorial zeigt, wie man die DeepSeek V4 API für die Programmierung auf TokenLab nutzt, indem die Arbeit zwischen deepseek-v4-pro und deepseek-v4-flash aufgeteilt wird. Wir haben beide Modell-Datensätze am 03.10.2026 aus der Live-API ausgelesen; alle folgenden Informationen stammen aus diesen Datensätzen und der TokenLab-Dokumentation. Sie erhalten eine Vergleichstabelle, eine ausgearbeitete Kostenschätzung, eine Tool-Calling-Anfrage, Code für Wiederholungsversuche (Retries) und Fallbacks sowie eine Vorabprüfung (Preflight Check).

Wichtige Erkenntnisse

• Beide Modelle listen ein Eingabelimit von 1.000.000 Token, ein Ausgabelimit von 384.000 Token und dieselben drei Anfrageformate. Der Preis ist der Hauptunterschied zwischen ihnen.
• Zu Listenpreisen kostet deepseek-v4-pro pro Eingabe-Token das 4,4-Fache und pro Ausgabe-Token das 3,3-Fache von deepseek-v4-flash.
• In unserem Beispiel mit 20 Aufrufen kostet das Routing von 4 Aufrufen an Pro und 16 an Flash außerhalb der Spitzenzeiten etwa 0,18 $. Alle 20 Aufrufe an Pro zu senden, kostet etwa 0,46 $.
• Wiederholen Sie 429 nach Retry-After. Wiederholen Sie 500–504 nur, wenn retryable auf true steht. Wiederholen Sie niemals 400, 401, 402, 403, 404 oder 413 unverändert.
• Der Katalog führt deepseek-v4.1-flash als aktiv. Weder deepseek-v4-pro noch deepseek-v4-flash benennen ein Nachfolgemodell.
• Lesen Sie Limits, Formate und Preise über GET /v1/models/:model aus, bevor Sie das Routing festlegen. Hardcodieren Sie keine kopierte Tabelle.

Die DeepSeek V4 API für die Programmierung: Was der Katalog sagt

Wir haben beide Datensätze am 03.10.2026 abgerufen. Die folgende Tabelle vergleicht sie direkt miteinander. Die Preise sind in USD pro 1 Mio. Token angegeben, und die Katalogpreise wurden zuletzt am 02.10.2026 um 16:53:30.068Z aktualisiert.

Element	deepseek-v4-pro	deepseek-v4-flash	Quelle, beobachtet am 03.10.2026
Kontextlimit (max. Eingabe-Token)	1.000.000	1.000.000	pro, flash
Ausgabelimit (max. Ausgabe-Token)	384.000	384.000	pro, flash
Akzeptierte Anfrageformate	anthropic_messages, openai_chat_completions, openai_responses	anthropic_messages, openai_chat_completions, openai_responses	pro, flash
Fähigkeiten	json-mode, prompt-cache, tool-use	json-mode, prompt-cache, tool-use	pro, flash
Eingabe (außerhalb Spitzenzeit)	0,66 $	0,15 $	pro, flash
Ausgabe (außerhalb Spitzenzeit)	1,98 $	0,60 $	pro, flash
Cache-Lesen (außerhalb Spitzenzeit)	0,022 $	0,003 $	pro, flash
Cache-Schreiben (außerhalb Spitzenzeit)	0,66 $	nicht gelistet	pro, flash
Eingabe (Spitzenzeit)	1,32 $	0,30 $	pro, flash
Ausgabe (Spitzenzeit)	3,96 $	1,20 $	pro, flash
Cache-Lesen (Spitzenzeit)	0,044 $	0,006 $	pro, flash
Lebenszyklus-Phase	aktiv, veröffentlicht am 24.04.2026	aktiv, veröffentlicht am 24.04.2026	pro, flash

Der Standard-Preisblock in jedem Datensatz entspricht dem Eintrag für Zeiten außerhalb der Spitzenlast. Die Zeiten für Spitzenlast unterscheiden sich je nach Datensatz. Für deepseek-v4-pro gelten Spitzenpreise von 09:00–12:00 und 14:00–18:00 Uhr Pekinger Zeit. Für deepseek-v4-flash besagt der Datensatz, dass Spitzenlast-Zeitfenster an Wochentagen gelten, ausgenommen chinesische Feiertage. Er gibt an, dass Zeiten außerhalb der Spitzenlast Wochenenden und diese Feiertage umfassen, nennt aber keine Uhrzeiten. Überprüfen Sie den Preis-Endpunkt, bevor Sie Ihr Budget auf das Flash-Zeitfenster ausrichten.

Lebenszyklus und neuere DeepSeek-Modelle

Beide Datensätze zeigen lifecycle stage active, wobei replacement model, deprecated_at und retired_at alle leer sind. Der Katalog plant also für keines der Modelle eine Entfernung und nennt für keines einen Nachfolger.

Der Katalog führt auch deepseek-v4.1-flash. Sein Datensatz, beobachtet am 03.10.2026, ist aktiv, ohne Veröffentlichungsdatum und ohne Nachfolger. Er hat dieselben Limits, Formate und Listenpreise wie deepseek-v4-flash. Er fügt reasoning und vision zur Liste der Fähigkeiten hinzu und zeigt einen Preis für Cache-Schreiben von 0,15 $ außerhalb der Spitzenzeit.

Da es sich um eine separate Modell-ID handelt, bleibt dieser Artikel bei seinem Thema. Wir würden deepseek-v4.1-flash bei Ihren eigenen Aufgaben testen, bevor Sie es austauschen. Der Katalog listet auch deepseek-v4-flash-vision-exp, aber wir haben dessen Datensatz nicht gelesen. Überprüfen Sie ihn auf der Modellseite, falls Sie ihn benötigen.

Routing von deepseek-v4-pro und deepseek-v4-flash nach Aufgaben

Stellen Sie sich eine Agenten-Sitzung vor, die eine Änderung über fünf Module hinweg plant, die Bearbeitungen schreibt und dann ein Dutzend Test-Stubs generiert. Der erste Schritt erfordert den meisten Kontext und Sorgfalt. Der letzte ist repetitiv und günstig neu zu erstellen. Der Katalog kann Ihnen nicht sagen, wo die Qualitätsgrenze liegt. Der TokenLab-Leitfaden zu Coding-Agent-Modellen, beobachtet am 03.10.2026, besagt, dass Leaderboard-Ergebnisse nicht vorhersagen, wie ein Modell Ihre eigenen Anweisungen und Tools befolgt.

Unsere anfängliche Heuristik geht davon aus, dass das teurere Modell seine Kosten bei dateiübergreifender Arbeit rechtfertigt. Betrachten Sie dies als eine zu testende Hypothese, nicht als feststehendes Ergebnis:

+-------------------------------------------------------------+
|                      Eingehende Aufgabe                     |
+-------------------------------------------------------------+
                               |
         [Beinhaltet die Aufgabe dateiübergreifenden Kontext,
          Abwärtskompatibilität oder Sicherheitsüberprüfung?]
                               |
               +---------------+---------------+
               |                               |
             [Ja]                            [Nein]
               |                               |
               v                               v
       deepseek-v4-pro                 deepseek-v4-flash

Kriterien, die einen Schritt an deepseek-v4-pro weiterleiten:

• Änderung der Logik über mehrere importierte Dateien hinweg.
• Sicherheits- oder Schwachstellenbewertungen.
• Strenge Abwärtskompatibilität bei öffentlichen Schnittstellen.
• Mehrstufige Arbeit, bei der Genauigkeit wichtiger ist als die Bearbeitungszeit.

Eigenständige Test-Gerüste, Schema-Formatierung, Docstrings und Syntax-Vervollständigung gehen an deepseek-v4-flash.

Um die Heuristik zu testen, folgen Sie demselben Leitfaden. Geben Sie jedem Modell denselben Repository-Status, dieselben Anweisungen, Tools und dasselbe Zeitlimit. Vergleichen Sie dann die Korrektheit, die bestandenen Tests, unnötige Änderungen, die Gesamtzahl der Token, die Gesamtkosten und wie oft ein Mensch eingreifen musste. Behalten Sie die Ergebnisse nach Aufgabentyp bei, da ein Modell möglicherweise gut prüft, aber schlecht implementiert.

Schätzung der Kosten einer Coding-Agent-Schleife

Agenten senden bei jedem Aufruf Anweisungen, Verlauf, Code und Tool-Ergebnisse erneut. Der Kostenleitfaden, beobachtet am 03.10.2026, merkt an, dass lange Sitzungen viel mehr kosten können als eine einzelne Chat-Anfrage. Wir haben die Arithmetik unten anhand der Listenpreise berechnet. Das Ergebnis ist eine Schätzung, keine gemessene Rechnung.

Annahmen (unsere, nicht gemessen): eine Schleife von 20 Modellaufrufen, jeder mit 30.000 Eingabe-Token und 1.500 Ausgabe-Token. Das ergibt insgesamt 600.000 Eingabe-Token und 30.000 Ausgabe-Token.

Die Formel lautet Eingabe-Token / 1 Mio. × Eingabepreis + Ausgabe-Token / 1 Mio. × Ausgabepreis. Die Preise stammen aus der obigen Tabelle.

Alle 20 Aufrufe an deepseek-v4-pro:

• Außerhalb Spitzenzeit: 0,6 × 0,66 $ = 0,396 $ Eingabe, plus 0,03 × 1,98 $ = 0,0594 $ Ausgabe, ergibt 0,4554 $.
• Spitzenzeit: 0,6 × 1,32 $ = 0,792 $, plus 0,03 × 3,96 $ = 0,1188 $, ergibt 0,9108 $.

Alle 20 Aufrufe an deepseek-v4-flash:

• Außerhalb Spitzenzeit: 0,6 × 0,15 $ = 0,09 $, plus 0,03 × 0,60 $ = 0,018 $, ergibt 0,108 $.
• Spitzenzeit: 0,6 × 0,30 $ = 0,18 $, plus 0,03 × 1,20 $ = 0,036 $, ergibt 0,216 $.

Gemischt: 4 Aufrufe an Pro, 16 an Flash. Pro verbraucht 120.000 Eingabe- und 6.000 Ausgabe-Token. Flash verbraucht 480.000 Eingabe- und 24.000 Ausgabe-Token.

• Außerhalb Spitzenzeit: Pro ist 0,12 × 0,66 $ + 0,006 × 1,98 $ = 0,0792 $ + 0,01188 $ = 0,09108 $. Flash ist 0,48 × 0,15 $ + 0,024 × 0,60 $ = 0,072 $ + 0,0144 $ = 0,0864 $. Die Summe beträgt 0,17748 $.
• Spitzenzeit: Pro ist 0,12 × 1,32 $ + 0,006 × 3,96 $ = 0,1584 $ + 0,02376 $ = 0,18216 $. Flash ist 0,48 × 0,30 $ + 0,024 × 1,20 $ = 0,144 $ + 0,0288 $ = 0,1728 $. Die Summe beträgt 0,35496 $.

Szenario	Schätzung außerhalb Spitzenzeit	Schätzung Spitzenzeit
20 Aufrufe auf deepseek-v4-pro	0,4554 $	0,9108 $
20 Aufrufe auf deepseek-v4-flash	0,1080 $	0,2160 $
4 Pro + 16 Flash	0,1775 $	0,3550 $

Schätzungen basierend auf Listenpreisen, beobachtet am 03.10.2026 (pro, flash).

Cache-Variante (außerhalb Spitzenzeit, Annahme: 80 % der Eingabe-Token sind Cache-Lesevorgänge). Das bedeutet 480.000 Cache-Lese-Token und 120.000 ungecachte Token pro Schleife.

• Pro: 0,48 × 0,022 $ = 0,01056 $, plus 0,12 × 0,66 $ = 0,0792 $, plus 0,0594 $ Ausgabe, ergibt 0,14916 $.
• Flash: 0,48 × 0,003 $ = 0,00144 $, plus 0,12 × 0,15 $ = 0,018 $, plus 0,018 $ Ausgabe, ergibt 0,03744 $.

Diese Variante berechnet ungecachte Token zum einfachen Eingabepreis und ignoriert Cache-Schreibgebühren bei Flash, die im Datensatz nicht aufgeführt sind. Bestätigen Sie die Anzahl der gecachten Token in der Antwort oder unter Nutzung, bevor Sie sich auf diesen Rabatt verlassen. Der Abrechnungsleitfaden warnt auch davor, dass der niedrigste Preis pro Token nicht immer die niedrigsten Kosten pro abgeschlossener Aufgabe bedeutet, da sich Wiederholungsversuche summieren.

Eine Tool-Calling-Anfrage für einen Coding-Agenten

Beide Datensätze führen tool-use auf und beide akzeptieren openai_chat_completions. Die folgende Anfrage verwendet nur Felder aus dem Tool-Calling-Leitfaden (beobachtet am 03.10.2026): model, messages und tools mit type: "function". Wir haben max_tokens hinzugefügt, was der Abrechnungsleitfaden als Möglichkeit zur Begrenzung der Antwortlänge aufführt. Wir haben tool_choice weggelassen, da dieser Leitfaden es nur für das Responses-Format dokumentiert.

curl https://api.tokenlab.sh/v1/chat/completions \
  -H "Authorization: Bearer $TOKENLAB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "max_tokens": 2000,
    "messages": [
      {"role": "system", "content": "You are a software engineering assistant."},
      {"role": "user", "content": "The pagination test in tests/test_api.py fails. Find the cause."}
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "read_file",
          "description": "Read a file from the repository",
          "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
          }
        }
      },
      {
        "type": "function",
        "function": {
          "name": "run_tests",
          "description": "Run the test suite for one path",
          "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
          }
        }
      }
    ]
  }'

Das Modell gibt einen Funktionsnamen und Argumente in tool_calls zurück. Ihr Backend führt das Tool aus. Die Schleife läuft dann in fünf Schritten:

1. Senden von Nachrichten plus Tool-Definitionen.
2. Lesen der Antwort auf tool_calls.
3. Ausführen des Tools in Ihrem eigenen Backend.
4. Anhängen des Tool-Ergebnisses im selben API-Format.
5. Fortfahren, bis das Modell eine endgültige Antwort zurückgibt.

Der Leitfaden zeigt die Form der Tool-Ergebnis-Nachricht nicht inline. Entnehmen Sie diese der Referenz zu Create Chat Completion (/api-reference/chat/create-completion), anstatt zu raten.

Validieren Sie vor der Ausführung eines Aufrufs die Argumente und wenden Sie Ihre eigenen Berechtigungsprüfungen an. Gestalten Sie die Ausführung idempotent, da ein Client-Retry denselben Tool-Aufruf wiederholen kann. Behalten Sie für den gesamten Austausch ein API-Format bei, da die Formate den Tool-Status unterschiedlich darstellen.

Wiederholungsversuche, Backoff und Fallback zwischen den beiden Modellen

Der Fehlerleitfaden und der Leitfaden zu Ratenbegrenzungen, beide beobachtet am 03.10.2026, legen die Richtlinie fest. Verzweigen Sie basierend auf dem HTTP-Status und dem code, niemals basierend auf der message.

Status	Dieselbe Anfrage wiederholen?	Aktion
400, 401, 402, 403, 404, 413	Nein	Korrigieren Sie die Anfrage, den Schlüssel, das Guthaben, die Berechtigungen oder die Eingabe
429	Ja	Warten Sie auf Retry-After; falls nicht vorhanden, verwenden Sie exponentielles Backoff mit Jitter
500–504	Nur wenn retryable auf true steht	Respektieren Sie retry_after und begrenzen Sie die Versuche
Verbindung vor einer Antwort geschlossen	Manchmal	Wiederholen Sie mit Vorsicht, falls ein Tool-Aufruf einen Seiteneffekt wiederholen könnte
Stream nach Ankunft der Ausgabe unterbrochen	Nein	Behandeln Sie es als unvollständig; eine Wiederholung kann eine andere Ausgabe oder eine zweite Gebühr erzeugen

Zwei Fälle erfordern besondere Sorgfalt. Ein 503 all_channels_failed oder 503 delivery_tier_unavailable ist nicht immer vorübergehend. Wenn retryable auf false steht und retry_after fehlt, wiederholen Sie die Anfrage nicht. Überprüfen Sie GET /v1/models, bevor Sie ein anderes Modell auswählen. Außerdem wird context_length_exceeded nicht durch das Wechseln zwischen diesen beiden Modellen behoben, da beide dasselbe Eingabelimit von 1.000.000 Token auflisten.

Der folgende Code wendet diese Richtlinie an. Er setzt max_retries=0, damit das SDK nicht in Ihrem Rücken wiederholt. Jedes Modell erhält vier Versuche, und der Fallback läuft erst, nachdem das erste Modell alle wiederholbaren Fehler ausgeschöpft hat.

import os
import random
import time
from openai import OpenAI, APIStatusError, APIConnectionError

client = OpenAI(
    api_key=os.environ["TOKENLAB_API_KEY"],
    base_url="https://api.tokenlab.sh/v1",
    timeout=30.0,
    max_retries=0,
)

FALLBACK = {
    "deepseek-v4-pro": "deepseek-v4-flash",
    "deepseek-v4-flash": "deepseek-v4-pro",
}

def error_fields(exc):
    body = getattr(exc, "body", None)
    if isinstance(body, dict):
        return body.get("error", body)
    return {}

def backoff(attempt):
    return min(30, 2 ** attempt + random.random())

def retry_delay(exc, attempt):
    """Sekunden warten, oder None, wenn die Anfrage nicht wiederholt werden darf."""
    if isinstance(exc, APIConnectionError):
        return backoff(attempt)
    fields = error_fields(exc)
    header = exc.response.headers.get("Retry-After")
    if exc.status_code == 429:
        return float(header) if header else backoff(attempt)
    if exc.status_code >= 500 and fields.get("retryable") is True:
        wait = fields.get("retry_after") or header
        return float(wait) if wait else backoff(attempt)
    return None

def chat_with_fallback(model, messages, tools=None, attempts=4):
    last_exc = None
    for candidate in (model, FALLBACK[model]):
        kwargs = {"model": candidate, "messages": messages}
        if tools:
            kwargs["tools"] = tools
        for attempt in range(attempts):
            try:
                return candidate, client.chat.completions.create(**kwargs)
            except (APIStatusError, APIConnectionError) as exc:
                delay = retry_delay(exc, attempt)
                if delay is None:
                    raise  # 4xx oder nicht wiederholbare 5xx: nicht wiederholen oder Fallback
                last_exc = exc
                if attempt < attempts - 1:
                    time.sleep(delay)
        print(f"{candidate} hat Wiederholungsversuche ausgeschöpft, versuche {FALLBACK[candidate]}")
    raise last_exc

def pick_model(is_complex):
    return "deepseek-v4-pro" if is_complex else "deepseek-v4-flash"

used, response = chat_with_fallback(
    pick_model(is_complex=False),
    [{"role": "user", "content": "Write a pytest case: an empty list returns 0 for sum_items()."}],
)
print(used, response.choices[0].message.content)

Protokollieren Sie immer, welches Modell geantwortet hat. Der Coding-Agent-Leitfaden warnt, dass ein Fallback Preis, Kontextlimit, Tool-Format oder Ausgabestil ändern kann, informieren Sie also den Benutzer, wenn sich das Modell ändert. Ein Fallback von Flash auf Pro vervierfacht die Eingabekosten zu Listenpreisen ungefähr, seien Sie also wachsam. Speichern Sie die Request-ID aus den Antwort-Headern bei jedem Aufruf, damit der Support einen Fehler nachverfolgen kann.

Limits, Formate und Preis vor dem Routing lesen

Die Referenz Get a Model, beobachtet am 03.10.2026, beschreibt GET /v1/models/:model. Die Antwort enthält ein tokenlab-Objekt mit capabilities, pricing, max_input_tokens, max_output_tokens, accepted_request_formats und lifecycle. Ein unbekanntes Modell gibt 404 model_not_found zurück. Der Abrechnungsleitfaden verweist auch auf GET /v1/models/:model/pricing für den aktuellen Preis.

import json
import urllib.request

def read_model(model_id):
    url = f"https://api.tokenlab.sh/v1/models/{model_id}"
    with urllib.request.urlopen(url, timeout=10) as resp:
        meta = json.load(resp)["tokenlab"]
    return {
        "max_input_tokens": meta.get("max_input_tokens"),
        "max_output_tokens": meta.get("max_output_tokens"),
        "formats": meta.get("accepted_request_formats"),
        "capabilities": meta.get("capabilities"),
        "lifecycle": meta.get("lifecycle"),
        "pricing": meta.get("pricing"),
    }

def preflight(model_id, input_tokens):
    info = read_model(model_id)
    problems = []
    if "openai_chat_completions" not in (info["formats"] or []):
        problems.append("chat completions not accepted")
    if "tool-use" not in (info["capabilities"] or []):
        problems.append("no tool-use capability")
    if info["max_input_tokens"] and input_tokens > info["max_input_tokens"]:
        problems.append("input exceeds max_input_tokens")
    return info, problems

for model_id in ("deepseek-v4-pro", "deepseek-v4-flash"):
    info, problems = preflight(model_id, input_tokens=30_000)
    print(model_id, json.dumps(info, indent=2), problems)

Wir geben lifecycle und pricing roh aus, da die Belege in diesem Artikel nicht das exakte JSON-Layout innerhalb dieser Antwort zeigen. Überprüfen Sie die Ausgabe einmal und parsen Sie dann die Felder, die Sie benötigen. Die Dokumentation rät davon ab, kopierte Preistabellen zu hardcodieren, führen Sie die Prüfung also beim Start oder nach einem Zeitplan durch. Öffentliche Discovery-Endpunkte wie GET /v1/models haben ihre eigenen Ratenbegrenzungen, cachen Sie das Ergebnis also, anstatt es pro Anfrage aufzurufen.

Für Ratenbegrenzungen erlaubt die Standard-Benutzerebene 1.000 Anfragen pro Minute pro API-Schlüssel, beobachtet am 03.10.2026. Der Leitfaden sagt, dass die aktive Konfiguration abweichen kann. Vertrauen Sie bei einem 429 den zurückgegebenen X-RateLimit-Limit- und Retry-After-Werten mehr als jeder kopierten Zahl.

FAQ

Kann ich deepseek-v4-pro über das Anthropic Messages-Format aufrufen?

Ja. Beide Datensätze führen anthropic_messages unter den akzeptierten Formaten auf, beobachtet am 03.10.2026. Der Coding-Agent-Leitfaden gibt die Basis-URL für Anthropic Messages als https://api.tokenlab.sh an, ohne das /v1-Suffix, das Chat Completions verwendet. Tool-Schemata unterscheiden sich je nach Format, behalten Sie also ein Format für das gesamte Gespräch bei.

Sollte ich einen 503 von deepseek-v4-pro oder deepseek-v4-flash wiederholen?

Nur wenn der Fehlerkörper besagt, dass retryable auf true steht, und warten Sie dann auf retry_after. Ein 503 all_channels_failed mit retryable: false bedeutet, dass die Anfrage im ausgewählten Delivery-Tier nicht verfügbar ist. Eine Wiederholung hilft nicht. Überprüfen Sie GET /v1/models, bevor Sie ein anderes Modell auswählen, wie im Fehlerleitfaden beschrieben.

Ersetzt deepseek-v4.1-flash das deepseek-v4-flash?

Der Katalog sagt das nicht. Am 03.10.2026 zeigte der Datensatz für deepseek-v4-flash kein Nachfolgemodell, und deepseek-v4.1-flash zeigte den Status aktiv. Beide teilen sich Limits und Listenpreise, und das neuere Modell fügt reasoning- und vision-Fähigkeiten hinzu. Testen Sie es bei Ihren Aufgaben und wechseln Sie bewusst nach Modell-ID.

Machen gecachte Token deepseek-v4-flash in einer Agenten-Schleife günstiger?

Das können sie. Der Datensatz listet einen Preis für Cache-Lesen außerhalb der Spitzenzeit von 0,003 $ pro 1 Mio. Token gegenüber 0,15 $ für einfache Eingabe. Der Kostenleitfaden empfiehlt, die Nutzung gecachter Token in der Antwort oder unter Nutzung zu bestätigen, bevor Sie sich auf einen Rabatt verlassen. Cache-Verhalten und Preise unterscheiden sich je nach Modell.

Erhöht das Routing an deepseek-v4-flash mein Ratenlimit?

Nein. Der Leitfaden zu Ratenbegrenzungen besagt, dass ein schnelleres Modell das Anfrage-Limit Ihres Kontos nicht erhöht. Modellgeschwindigkeit, Token-Limits und Konto-Ratenbegrenzungen sind separate Einschränkungen, und Limits gelten pro API-Schlüssel.

Überprüfen Sie die aktuellen Einträge für deepseek-v4-pro und deepseek-v4-flash auf der TokenLab-Modellseite, bevor Sie Ihren Router verdrahten.