Mock-LLM-API-Leitfaden
Erstellen Sie kostenlose LLM-Streaming-Endpoints, die OpenAI, Claude und andere KI-Anbieter nachbilden. Bauen und testen Sie KI-Funktionen, ohne Tausende für API-Aufrufe auszugeben.
Erste Schritte
Das Erstellen eines Mock-LLM-Streaming-Endpoints dauert weniger als 30 Sekunden. Folgen Sie diesen einfachen Schritten:
- 1
LLM-Mock-Seite besuchen
Gehen Sie zu mockapi.dog/llm-mock. Ein eindeutiger 6-stelliger Code wird automatisch für Ihren Endpoint generiert.
- 2
LLM-Anbieter-Profil wählen
Wählen Sie das Antwortformat, das emuliert werden soll:
- • OpenAI - Format der Chat-Completions- oder Responses-API, je nachdem, welchen Pfad Ihr SDK aufruft
- • Anthropic Claude - Streaming-Format der Messages-API
- • Generic Stream - Anbieterunabhängiger Token-Stream
- • Generic JSON - Einfache JSON-Antwort (kein Streaming)
- 3
Inhaltsmodus auswählen
Legen Sie fest, wie die Antwortinhalte erzeugt werden:
- • Generated - LLM-ähnlichen Text automatisch generieren (Stil: Chat, Technical oder Markdown)
- • Static - Den von Ihnen angegebenen Text exakt verwenden
- • Hybrid - Ihr Text gefolgt von einer generierten Fortsetzung
- 4
Token-Generierung konfigurieren (optional)
Legen Sie für die Modi Generated oder Hybrid eine Mindest- und Höchstzahl an Tokens fest (10–2000, Standard: 100–300). Die Länge des generierten Textes liegt zufällig zwischen diesen Werten. Für Static nicht erforderlich.
- 5
Verifizierung abschließen und speichern
Schließen Sie die Turnstile-Verifizierung ab und klicken Sie auf "Mock-Endpoint speichern". Die Endpoint-URL wird automatisch kopiert!
https://abc123.mockapi.dog/v1/chat/completions
Fertig! Sofort streamen
Ihr Endpoint ist einsatzbereit. Ersetzen Sie die baseURL für OpenAI/Claude durch Ihren Mock-Endpoint und beginnen Sie mit dem Testen. Keine Authentifizierung oder API-Schlüssel erforderlich.
Das Kostenproblem
Echte LLM-APIs sind teuer. Während Entwicklung, Tests und Prototyping können die Kosten schnell außer Kontrolle geraten. So viel würden echte Anbieter kosten:
OpenAI GPT-4
TeuerBeispiel: Ein Chatbot-Test mit 1.000 Konversationen (durchschnittlich 500 Tokens pro Konversation) = 20+ USD
Anthropic Claude
KostspieligCI/CD-Pipeline: 100 Test-Läufe pro Tag = 300+ USD/Monat
Mit MockAPI Dog: 0 USD
Kostenlose Streaming-Antworten für Entwicklung und Tests. Sparen Sie Tausende in der Entwicklungsphase. Wechseln Sie erst dann zu echten APIs, wenn Sie produktionsreif sind.
Warum eine Mock-LLM-API nutzen?
Geld sparen
Vermeiden Sie es, in der Entwicklung Tausende auszugeben. Testen Sie UI, Streaming-Logik und Fehlerbehandlung, ohne API-Guthaben zu verbrauchen.
- Keine API-Schlüssel oder Abrechnung erforderlich
- Kostenlose Anfragen während der Entwicklung
- Ideal für Indie-Entwickler und Start-ups
Sofort testen
Testen Sie Streaming-Antworten, UI-Animationen und Fehlerzustände sofort – ohne auf echte Modelllatenz zu warten oder an Rate Limits der Anbieter zu stoßen.
- Konfigurierbare Antwortgeschwindigkeit und Tokens
- Edge Cases und Fehlerszenarien testen
- Anfragen Ihrer App live einsehen
Mehrere Anbieter
Testen Sie Ihre App mit verschiedenen LLM-Anbietern, ohne mehrere API-Schlüssel zu verwalten. Wechseln Sie mühelos zwischen OpenAI, Claude und generischen Formaten.
- OpenAI-kompatible Endpoints
- Unterstützung für Anthropic-Claude-Format
- Generisches SSE-Streaming-Format
CI/CD-Integration
Lassen Sie automatisierte Tests in Ihrer CI/CD-Pipeline laufen, ohne sich um API-Kosten oder Rate Limits zu sorgen. Testen Sie Ihre KI-Funktionen bei jedem Commit.
- Keine Authentifizierung erforderlich
- Konsistente, vorhersagbare Antworten
- Schnelle Ausführung für schnelles Feedback
Unterstützte Anbieter
MockAPI Dog unterstützt Streaming-Formate gängiger LLM-Anbieter. Setzen Sie einfach Ihren Endpoint als baseURL in Ihrem bevorzugten SDK.
OpenAI-Format
Kompatibel mit dem offiziellen OpenAI-SDK. Ein Endpoint beantwortet sowohl Chat Completions als auch die Responses-API, mit oder ohne Streaming. Antworten melden gpt-5.4 als Modell; bei Chat Completions fügt stream_options.include_usage einen abschließenden Usage-Chunk hinzu.
Anthropic-Format
Kompatibel mit dem offiziellen Anthropic-SDK. Emuliert die Messages-API, mit oder ohne Streaming und in genau der Ereignisfolge, die das SDK erwartet. Antworten melden claude-sonnet-5 als Modell.
Generisches SSE-Format
Standardkonforme Server-Sent Events (SSE). Jedes Ereignis enthält {"token": "..."}, und der Stream endet mit {"done": true}. Verwenden Sie es mit jedem Streaming-Client oder bauen Sie Ihre eigene Integration.
- Eigene LLM-Integrationen
- EventSource-Implementierungen testen
- Streaming-Protokolle lernen
So erreichen Anfragen Ihren Endpoint
SDKs hängen ihren eigenen Pfad an die baseURL an. MockAPI Dog entfernt diese Suffixe vor dem Abgleich. Setzen Sie die baseURL daher exakt auf die gespeicherte URL.
POST https://xyz789.mockapi.dog/llm/chat/completions → /llm- Generische Profile gleichen den gespeicherten Pfad exakt ab. Rufen Sie diese URL daher direkt auf.
- LLM-Endpoints werden als POST gespeichert – die Methode, die alle SDKs verwenden.
Streaming oder JSON?
Eine Antwort wird gestreamt, wenn der Request-Body "stream": true enthält. Hat der Body kein stream-Feld, wird gestreamt, wenn der Accept-Header text/event-stream enthält. Andernfalls erhalten Sie eine einzelne JSON-Antwort.
Inhaltsmodi
Wählen Sie, wie Ihr Mock-LLM-Endpoint die Antwortinhalte erzeugt. Jeder Modus bietet eine andere Kontrolle über den gestreamten Text.
Generated
Erzeugen Sie automatisch LLM-ähnlichen Text in unterschiedlichen Stilen. Wählen Sie zwischen Chat (umgangssprachlich), Technical (programmierlastig) oder Markdown (formatiert mit Listen und Code-Blöcken).
Static
Verwenden Sie Ihren genauen Text als Antwort. Der Text wird unverändert gestreamt – ohne Generierung oder Anpassung.
Hybrid
Kombiniert Ihren Text mit einer automatisch generierten Fortsetzung. Ihr Text wird zuerst gestreamt, gefolgt von generiertem LLM-ähnlichem Inhalt.
Textstile für generierte Inhalte
Bei den Modi Generated oder Hybrid können Sie zwischen den Stilen Chat (umgangssprachlich), Technical (programmierlastig) und Markdown (mit Formatierung, Listen, Code-Blöcken) wählen.
Einstellungen zur Token-Generierung
Stimmen Sie genau ab, wie Ihr Mock-LLM-Endpoint Tokens generiert und streamt – passend zu Ihren Tests.
Token-Anzahl
Legen Sie fest, wie viele Tokens generiert werden (geschätzt etwa 4 Zeichen pro Token). Praktisch zum Testen unterschiedlicher Antwortlängen.
Streaming-Geschwindigkeit
Text wird in Chunks von 5–20 Zeichen gestreamt. Legen Sie eine minimale und maximale Verzögerung zwischen den Chunks fest (10–500 ms); jede Verzögerung wird zufällig aus diesem Bereich gewählt. Ohne Angabe gelten standardmäßig 30–120 ms.
Profi-Tipp
Testen Sie mit verschiedenen Geschwindigkeiten, damit Ihre UI sowohl schnelles als auch langsames Streaming sauber verarbeitet. Echte LLM-APIs schwanken erheblich in der Antwortzeit.
Code-Beispiele
So nutzen Sie Ihren Mock-LLM-Endpoint mit gängigen SDKs und Bibliotheken.
OpenAI-SDK
Ersetzen Sie die baseURL durch Ihren Mock-Endpoint. Kein API-Schlüssel erforderlich!
import OpenAI from 'openai'; const openai = new OpenAI({baseURL: 'https://xyz789.mockapi.dog/llm',apiKey: 'dummy-api-key', // Mock endpoint doesn't check API keys }); async function main() { const stream = await openai.chat.completions.create({ model: 'gpt-5.4', messages: [{ role: 'user', content: 'Hello!' }], stream: true, }); for await (const chunk of stream) { const content = chunk.choices[0]?.delta?.content || ''; process.stdout.write(content); } } main();
OpenAI-SDK (Responses-API)
Derselbe Endpoint beantwortet auch die Responses-API. Lesen Sie den Text aus den Ereignissen vom Typ response.output_text.delta.
import OpenAI from 'openai'; const openai = new OpenAI({baseURL: 'https://xyz789.mockapi.dog/llm',apiKey: 'dummy-api-key', // Mock endpoint doesn't check API keys }); async function main() { const stream = await openai.responses.create({ model: 'gpt-5.4', input: 'Hello!', stream: true, }); for await (const event of stream) { if (event.type === 'response.output_text.delta') { process.stdout.write(event.delta); } } } main();
Anthropic-SDK
Verwenden Sie das Anthropic-SDK, indem Sie eine eigene baseURL setzen.
import Anthropic from '@anthropic-ai/sdk'; const anthropic = new Anthropic({baseURL: 'https://xyz789.mockapi.dog/claude',apiKey: 'dummy-api-key', // Mock endpoint doesn't check API keys }); async function main() { const stream = await anthropic.messages.stream({ model: 'claude-sonnet-5', max_tokens: 1024, messages: [{ role: 'user', content: 'Hello!' }], }); for await (const chunk of stream) { if (chunk.type === 'content_block_delta' && chunk.delta.type === 'text_delta') { process.stdout.write(chunk.delta.text); } } } main();
Generischer Fetch (SSE)
Verwenden Sie reines JavaScript/TypeScript für maximale Flexibilität.
async function streamResponse() {const response = await fetch('https://xyz789.mockapi.dog/llm/stream', {method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ prompt: 'Hello, world!', stream: true, // without this (or Accept: text/event-stream) you get plain JSON }), }); const reader = response.body?.getReader(); const decoder = new TextDecoder(); while (true) { const { done, value } = await reader.read(); if (done) break; const chunk = decoder.decode(value); const lines = chunk.split('\n'); for (const line of lines) { if (line.startsWith('data: ')) { try { const json = JSON.parse(line.slice(6)); if (json.done) return; console.log(json.token); } catch (e) { // Skip invalid JSON } } } } } streamResponse();
So einfach ist das!
Ersetzen Sie einfach die baseURL und schon kann es losgehen. Ihr bestehender Code funktioniert ohne Anpassungen.
Reale Anwendungsfälle
Chatbot-Entwicklung
Bauen und testen Sie Chatbot-UIs ohne Ausgaben für API-Aufrufe. Testen Sie Nachrichten-Threads, Streaming-Animationen und Fehlerbehandlung.
- Streaming-Animationen für Nachrichten testen
- Konversations-Threading verifizieren
- UI-Edge-Cases debuggen
Tests und QA
Führen Sie automatisierte Tests und manuelle QA ohne API-Kosten durch. Testen Sie verschiedene Antwortszenarien und Edge Cases konsistent.
- Automatisierte E2E-Tests in CI/CD
- Konsistente Testdaten
- Schnelle Testausführung
Lernen und Tutorials
Lernen Sie KI-Integration ohne Geldausgaben. Ideal für Tutorials, Kurse und Lerninhalte.
- Kein API-Schlüssel-Setup für Lernende
- Kostenloses Üben
- Sichere Lernumgebung
MVPs und Demos
Bauen Sie Proofs of Concept und Demos ohne Vorabkosten. Zeigen Sie Investoren und Stakeholdern Ihre Vision, bevor Sie in Produktions-APIs investieren.
- Schnelles Prototyping
- Investoren-Demos
- Ideen günstig validieren
Erweiterte Funktionen
Request Inspector
Aktivieren Sie das Logging, um die Prompts, Header und Parameter, die Ihre App sendet, live zu verfolgen. Authorization- und Cookie-Header werden geschwärzt, andere Header wie x-api-key jedoch unverändert gespeichert. Verwenden Sie daher einen Dummy-API-Schlüssel.
Konfigurierbare Verzögerungen
Fügen Sie vor Beginn der Antwort eine feste Verzögerung hinzu und passen Sie die Streaming-Geschwindigkeit an, um Ladezustände und Timeout-Verhalten zu testen.
Fehlersimulation
Lassen Sie einen Prozentsatz der Anfragen fehlschlagen oder lösen Sie per Request-Header gezielt einen Fehler aus, mit Statuscodes wie 401, 429 oder 503. Fehler werden als JSON gesendet, bevor das Streaming beginnt, sodass Ihr SDK sie als API-Fehler wirft.
Keine Authentifizierung
Mock-Endpoints benötigen weder API-Schlüssel noch Authentifizierung. Ideal für CI/CD-Pipelines und öffentliche Demos.
Fehlerbehebung
Streaming funktioniert nicht
Eine Antwort wird nur gestreamt, wenn der Request-Body "stream": true setzt oder wenn kein stream-Feld vorhanden ist und der Accept-Header text/event-stream enthält. Andernfalls gibt der Endpoint eine einzelne JSON-Antwort zurück. Prüfen Sie außerdem, ob Ihr Client die Antwort als Stream liest.
// Make sure to set stream: true
const stream = await openai.chat.completions.create({
stream: true, // This is required!
// ...
});Antwort zu schnell/langsam
Öffnen Sie die "Einstellungen für Verzögerungen, Streaming-Geschwindigkeit und Fehlersimulation" und ändern Sie im Tab "Streaming-Geschwindigkeit" die minimale und maximale Verzögerung. Prüfen Sie außerdem im Tab "Verzögerungen", ob eine feste Verzögerung vor der Antwort eingestellt ist.
SDK-Kompatibilitätsprobleme
Stellen Sie sicher, dass das Anbieterprofil des Endpoints zu Ihrem SDK passt (das OpenAI-SDK benötigt das OpenAI-Profil, das Anthropic-SDK das Anthropic-Profil). Setzen Sie die baseURL auf die gespeicherte URL und lassen Sie das SDK seinen eigenen Pfad anhängen.
CORS-Fehler im Browser
Mock-Endpoints sind mit großzügigen CORS-Headern konfiguriert. Sollten dennoch CORS-Fehler auftreten, prüfen Sie Ihre Request-Header und stellen Sie sicher, dass Sie keine eingeschränkten Header senden.
SDK erhält 404 Not Found
LLM-Endpoints beantworten nur POST-Anfragen an den gespeicherten Pfad plus das SDK-eigene Suffix. Der 404-Body zeigt Code, Ressource und Methode, die der Server empfangen hat. Vergleichen Sie diese mit Ihrem gespeicherten Endpoint.
Anfragen geben 429 Too Many Requests zurück
Jeder Endpoint hat ein tägliches Aufruflimit. Ist es erreicht, geben Aufrufe 429 zurück, mit dem Limit und einem resetAt-Zeitpunkt (Mitternacht Serverzeit) im Body. Zusätzlich ist jede IP-Adresse dienstweit auf 100 Anfragen pro Minute begrenzt.
Tipps und Best Practices
Mit verschiedenen Geschwindigkeiten testen
Echte LLM-APIs unterscheiden sich in der Geschwindigkeit. Testen Sie Ihre UI sowohl mit schnellem als auch mit langsamem Streaming, um eine gute Nutzererfahrung unter allen Bedingungen sicherzustellen.
Umgebungsvariablen verwenden
Speichern Sie Ihre baseURL in einer Umgebungsvariable. Wechseln Sie zwischen Mock- und Produktions-API über eine einzige Variable.
// .env.development
OPENAI_BASE_URL=https://xyz789.mockapi.dog/llm
// .env.production
OPENAI_BASE_URL=https://api.openai.com/v1Fehlerszenarien testen
Testen Sie nicht nur den Happy Path. Nutzen Sie die Fehlersimulation, um Rate Limits (429), Authentifizierungsfehler (401) und Ausfälle (503) zu testen, und eine feste Verzögerung für Timeouts.
LLM-Entwicklungs-Workflow
Folgen Sie diesem Workflow für effiziente KI-Entwicklung:
- UI und Streaming-Logik mit Mock-Endpoints bauen
- Gründlich mit verschiedenen Inhaltsmodi und Geschwindigkeiten testen
- Automatisierte Tests in CI/CD mit Mock-Endpoints ausführen
- Erst für die finalen Integrationstests auf die echte API umsteigen
- Mit Produktions-API-Schlüsseln deployen
Vor der Produktion validieren
Bevor Sie auf Produktions-APIs umsteigen, validieren Sie Ihre Implementierung in einer Staging-Umgebung mit der echten Anbieter-API, um Verhaltensunterschiede aufzudecken.
Glossar
LLM (Large Language Model)
KI-Modelle wie GPT-4 und Claude, die menschenähnliche Textantworten erzeugen. Beispiele: OpenAIs GPT-Reihe, Anthropics Claude, Googles Gemini.
Streaming-API
Eine API, die Daten in Chunks sendet, statt auf die vollständige Antwort zu warten. Ermöglicht die Echtzeit-Anzeige KI-generierter Texte während ihrer Erstellung.
Token
Die Grundeinheit eines Texts in LLMs. Entspricht ungefähr einem Wort oder Wortteil. LLM-Preise basieren in der Regel auf der Token-Anzahl.
SSE (Server-Sent Events)
Eine Technologie, mit der Server Daten in Echtzeit an Clients senden. Wird von LLM-APIs zum Streamen von Antworten verwendet.
baseURL
Die Basisadresse für API-Anfragen. Ersetzen Sie sie durch Ihre Mock-Endpoint-URL, um Anfragen statt an den echten Anbieter an MockAPI Dog zu leiten.
Anbieter
Unternehmen, die LLM-APIs anbieten, etwa OpenAI (GPT), Anthropic (Claude), Google (Gemini) usw.
Bereit, loszubauen?
Erstellen Sie Ihren ersten Mock-LLM-Streaming-Endpoint in Sekunden. Keine Anmeldung, keine Kreditkarte, kein Aufwand. Starten Sie mit dem Bau von KI-Funktionen, ohne Tausende für API-Aufrufe auszugeben.