Zum Hauptinhalt springen
ProAPI & Automation

Mock-Server

Die echte API ist noch nicht fertig, aber dein Frontend soll schon laufen? Mit dem Mock-Server definierst du eigene Endpunkte mit fester Antwort, Statuscode, Headern und einer künstlichen Verzögerung - und rufst sie sofort auf. Simuliere APIs, bevor sie existieren, und teste, wie sich dein Code bei jedem Statuscode verhält.

Ein Blick hinein - live

Live-Vorschau. Interaktiv wird es mit deinem Konto.

Was Mock-Server kann

In fast jedem Projekt hängt das Frontend am Backend, und das Backend ist selten pünktlich fertig. Statt untätig zu warten, mockst du die API einfach. Der Mock-Server macht genau das ohne eigenes Server-Setup: Du beschreibst einen Endpunkt - Pfad, Methode, Statuscode, Antwort-Header und Response-Body - und schon antwortet er so, wie du es festgelegt hast.

Ein Mock-Endpunkt besteht aus wenigen Angaben. Der Pfad legt die Adresse fest, die Methode (GET, POST, PUT, PATCH oder DELETE) das Verb, der Statuscode das Ergebnis - von 200 OK über 404 Not Found bis 500 Internal Server Error. Die Response-Header bestimmst du frei, etwa Content-Type oder eigene Felder, und im Response-Body hinterlegst du die Antwort, typischerweise als JSON.

Besonders nützlich ist die einstellbare Verzögerung. Reale APIs antworten nicht in null Millisekunden, und dein Ladezustand, deine Spinner und deine Timeouts wollen getestet werden. Mit einer künstlichen Delay simulierst du langsame Verbindungen und siehst, ob dein UI sauch dann sauber reagiert, wenn eine Antwort auf sich warten lässt.

Jeder definierte Endpunkt lässt sich direkt im Werkzeug testen. Du bekommst die simulierte Antwort mit Status, Headern, Body und der tatsächlichen Antwortzeit zurück - genauso, wie sie später bei deinem Code ankäme. Das Request-Logging zeigt dir, welche Aufrufe eingegangen sind, sodass du nachvollziehst, ob deine Integration den Endpunkt wirklich trifft.

Der typische Ablauf: Du modellierst die geplante API mit ein paar Mock-Endpunkten, verdrahtest dein Frontend dagegen und ersetzt die Mocks später durch die echte Schnittstelle, sobald sie steht. So entkoppelst du die Entwicklung von Frontend und Backend und blockierst dich nicht gegenseitig.

Der Mock-Server spielt gut mit dem API-Spielplatz zusammen: Dort rufst du deine Mock-Endpunkte auf und prüfst die Antwort im Detail, ganz so, als wäre es eine echte API. Zusammen bilden sie eine kleine, browserbasierte Werkbank für alles, was mit HTTP-Schnittstellen zu tun hat - ohne Docker, ohne lokalen Node-Prozess, ohne Installation.

Funktionen

Endpunkte frei definieren

Pfad, Methode, Statuscode, Header und Body - beschreibe einen Endpunkt in wenigen Feldern und er antwortet sofort.

Jeder Statuscode

Von 200 über 404 bis 500 - teste, wie sich dein Code bei Erfolg, Fehler und Sonderfällen verhält.

Freie Response-Header

Setze Content-Type oder beliebige eigene Header, um realistische Antworten nachzubilden.

Künstliche Verzögerung

Simuliere langsame Verbindungen mit einer einstellbaren Delay und prüfe deine Ladezustände und Timeouts.

Direkt testen

Ruf jeden Mock-Endpunkt im Werkzeug auf und sieh Status, Header, Body und Antwortzeit der Simulation.

Request-Logging

Sieh, welche Aufrufe eingegangen sind, und stell sicher, dass deine Integration den Endpunkt wirklich trifft.

So funktioniert es

  1. 1

    Endpunkt anlegen

    Gib Pfad und Methode ein, wähle den Statuscode und beschreibe die gewünschte Antwort.

  2. 2

    Antwort ausgestalten

    Trag Response-Header und Body ein, meist als JSON, und setze bei Bedarf eine Verzögerung.

  3. 3

    Speichern und testen

    Speichere den Endpunkt und ruf ihn direkt auf, um Status, Header und Body der Simulation zu sehen.

  4. 4

    Gegen die Mocks entwickeln

    Verdrahte dein Frontend gegen die Mock-Endpunkte und ersetze sie später durch die echte API.

Wer das braucht

Frontend-Entwickler, die vor dem fertigen Backend loslegen wollen.
Teams, die Frontend- und Backend-Entwicklung entkoppeln.
Tester, die Fehler- und Sonderfälle gezielt provozieren.
Entwickler, die Ladezustände und Timeouts unter langsamen Antworten prüfen.
Prototypen, die eine API vortäuschen müssen, bevor sie existiert.

Häufige Fragen

Wofür brauche ich einen Mock-Server?

Um zu entwickeln, bevor das echte Backend fertig ist. Du definierst die geplanten Endpunkte mit fester Antwort und baust dein Frontend schon dagegen. So blockieren sich Frontend- und Backend-Team nicht gegenseitig, und du kannst auch Fehlerfälle gezielt provozieren.

Kann ich Fehlerantworten simulieren?

Ja. Setz den Statuscode einfach auf 400, 401, 404, 500 oder was du testen willst und hinterlege den passenden Fehler-Body. So prüfst du, ob deine App auch mit Fehlern umgehen kann, nicht nur mit dem Happy Path.

Wie simuliere ich langsame Antworten?

Über die einstellbare Verzögerung. Trag einfach eine Delay in Millisekunden ein, und der Endpunkt antwortet entsprechend später. Ideal, um Spinner, Skeletons und Timeouts realistisch zu testen.

Welche Methoden werden unterstützt?

GET, POST, PUT, PATCH und DELETE. Damit deckst du die gängigen REST-Operationen ab und kannst ein realistisches API-Verhalten für Lesen, Anlegen, Ändern und Löschen nachbauen.

Wie rufe ich die Mock-Endpunkte auf?

Direkt im Werkzeug per Test-Button oder aus dem API-Spielplatz, wo du die Antwort im Detail prüfen kannst. Auch deine eigene Anwendung kann die Endpunkte während der Entwicklung ansprechen.

API-Spielplatz

Teste HTTP-Anfragen, verwalte Collections und Umgebungsvariablen.

REST API & DATEV Export

Greife auf deine Rechnungsdaten per REST API zu. DATEV-kompatible Exporte für deinen Steuerbe…

Skripte

Eigene JavaScript- und TypeScript-Skripte in sandboxed Umgebung ausführen. Tool-APIs steuern,…

JSON-Formatierer

Formatiere, validiere und minimiere JSON mit Syntaxhervorhebung und Fehlererkennung. Kostenlo…

Regex-Tester

Teste reguläre Ausdrücke mit Live-Highlighting und deutschen Muster-Vorlagen.

Bereit für Mock-Server?

Keine Installation. Zum Loslegen kein Konto nötig. Direkt im Browser öffnen.

Jetzt öffnen