For a mock server for prototyping APIs from a spec, the strongest matches are stoplightio/prism (Prism generates mock servers directly from OpenAPI specs, providing), postcatlab/postcat (Postcat is an integrated API development platform that includes) and mock-server/mockserver (Mockserver is a self-hostable multi-protocol mock server that generates). ymfe/yapi and mockoon/mockoon round out the shortlist. Each is ranked by relevance to your query, popularity and recent activity.
Open-source utilities for simulating API endpoints and prototyping backend services based on interface specifications.
Prism is a set of tools for generating mock servers and validation proxies based on OpenAPI specifications or Postman collection files. It serves as an API contract testing tool to verify that API implementations adhere to formal contracts. The project provides an OpenAPI mock server that simulates API responses and a validation proxy that checks live HTTP traffic against an OpenAPI specification to identify implementation discrepancies. It also includes a mock server capable of mimicking API behavior based on exported Postman Collection files. The tool covers API behavior simulation and tra
Prism generates mock servers directly from OpenAPI specs, providing simulated endpoints with realistic responses and dynamic route matching, which matches your need for frontend prototyping and testing.
Postcat is an integrated platform for API design and documentation, serving as a REST API client and a mock server. It provides a workspace to define technical requirements and data schemas, allowing development teams to align on interface behavior. The platform features a plugin architecture that enables the integration of third-party tools and custom capabilities. It decouples frontend and backend development cycles by generating simulated server responses based on predefined data structures. The toolset includes an environment management system for switching between development, staging,
Postcat is an integrated API development platform that includes a mock server capable of generating simulated responses from data schemas, making it a viable tool for frontend prototyping, though its broader feature set and limited explicit OpenAPI/Swagger spec support mean it is a narrower fit than a dedicated spec-driven mock server.
Mockserver is a multi-protocol mock server and API verification proxy used to simulate HTTP, gRPC, and WebSocket endpoints. It functions as a tool for testing client applications without relying on live backend services, providing a system to simulate chat completions and streaming responses for large language model integrations. The project automates behavior by generating request expectations and response behaviors from OpenAPI and Swagger specification files. It differentiates itself through a network traffic simulator that introduces latency, dropped connections, and failures to verify ho
Mockserver is a self-hostable multi-protocol mock server that generates endpoints from OpenAPI/Swagger specs with realistic response simulation, latency injection, and scripting support, making it a comprehensive fit for frontend prototyping and testing.
yapi is an API management platform designed to coordinate the development of RESTful APIs between frontend, backend, and quality assurance teams. It functions as a centralized system for documenting interface specifications, simulating server responses, and validating requests through a built-in testing client. The platform features an API code generator that transforms interface specifications into typed request functions and data models across multiple programming languages. It also includes a mock server capable of generating synthetic responses using schema-based generators and rule-based
YAPI is a full API management platform that includes a schema-driven mock server, letting you simulate endpoints from imported API specifications—exactly what you need for frontend prototyping and testing, though its broader set of features and lack of explicit delay/scripting configurability keep it from being a pure, streamlined mock server.
Mockoon is an HTTP API simulation platform and design tool used to create fake API endpoints that simulate server responses without a backend. It functions as an OpenAPI mock server tool and a JSON API mocking utility, allowing for the rapid iteration of API contracts and the generation of response templates. The project distinguishes itself through a combination of stateful mocking, using a local JSON database to simulate CRUD operations, and the ability to run as a headless API mock server via a command line interface. It supports real-time collaborative editing and AI-assisted prototyping
Mockoon is a self-hostable desktop and CLI tool that creates mock API servers from OpenAPI/Swagger specs with realistic response generation and dynamic route matching, which squarely fits the query, though it lacks explicit support for configurable response delays and custom scripting.
Easy Mock is a tool for API mocking and simulation that allows for the creation of fake server responses using schemas. It enables the generation of mock API data and the implementation of OpenAPI specifications to align development with technical contracts. The project supports collaborative API design through a shared workspace where team members can synchronize and manage mock endpoints. It also features specification-driven bootstrapping, which automatically constructs mock environments by importing standard API definition files. The system provides API development proxying to forward re
Easy Mock creates mock API servers by importing OpenAPI/Swagger specification files and generating fake responses from schemas, with collaborative workspaces and specification-driven bootstrapping — exactly the kind of tool for prototyping and testing, though it may lack configurable delays and scripting.
Insomnia is a cross-platform API development environment that integrates a request debugger, schema design tools, a mocking server, and a test automation framework. It provides a unified workspace for sending requests and analyzing responses across REST, GraphQL, gRPC, and WebSocket protocols. The platform enables the design and preview of API specifications through a visual editor and allows for the simulation of backend behavior using mocking tools. It supports organizing and synchronizing API collections via local storage, cloud synchronization, or Git. The suite includes a command-line i
Insomnia includes a mocking server that can generate endpoints from OpenAPI specs, making it a valid choice for prototyping, though it is embedded in a broader API development environment rather than a standalone mock server.
api-blueprint is a markdown-based API design language and specification standard used to define the structure, behavior, and data schemas of HTTP web services. It provides a formal method for mapping HTTP methods to resources and defining payload validation rules through a machine-readable syntax. The project functions as a blueprint for creating interactive technical documentation and functional mock servers. These tools transform design specifications into human-readable guides and simulated backend environments to enable integration testing before implementation. The language covers API m
The api-blueprint repository defines the API Blueprint specification language, not a tool that creates a mock server from a spec file; while it enables mock server generation through separate tools, this repository itself is a specification standard rather than an executable mock server generator.
Slim is a PHP micro-framework designed for building web applications and APIs by routing incoming network requests to specific callback functions. It provides a lightweight foundation that emphasizes low memory overhead, allowing developers to construct backend systems by integrating only the necessary components. The framework distinguishes itself through a middleware-based request pipeline and full support for standardized HTTP message interfaces. By utilizing these standard interfaces, the system enables modular application logic and ensures interoperability with a wide range of third-part
Slim is a PHP micro-framework for building real APIs, not a tool that generates a mock server from an OpenAPI/Swagger specification file, so it would require custom coding to simulate endpoints rather than working from a spec.
Lumen is a PHP micro-framework and REST API framework designed for building high-performance web applications and lightweight services. It provides a streamlined environment for developing independent, small-scale web services that handle specific business logic. The framework is focused on microservices development and the creation of stateless web endpoints. It provides a minimal architecture to reduce operational overhead when constructing high-performance backend services and rapid web API prototypes. The system incorporates request dispatching and filtering through middleware, utilizing
Lumen is a PHP micro-framework for building real REST APIs, not a tool that automatically creates a mock server from an OpenAPI spec; while you could manually build a mock with it, it lacks the spec-driven mock generation and response simulation features this search targets.
Django is a full-stack web framework designed for rapid backend development. It provides an integrated environment for building data-driven applications by combining an object-relational mapping layer for database management with a modular request-response pipeline for handling HTTP traffic. The framework emphasizes security and maintainability, offering a suite of tools to protect against common web vulnerabilities while decoupling site structure from implementation through a centralized URL routing system. A defining characteristic of the framework is its ability to generate production-read
Django is a full‑stack web framework for building production applications, not a tool that generates a mock API server directly from an OpenAPI or Swagger specification.
Express is a minimalist web server framework that provides a foundational runtime environment for building backend web APIs and applications. It operates through a central application object that orchestrates the entire request-response lifecycle, allowing developers to define routes, manage server settings, and process incoming HTTP traffic. The framework is defined by its middleware-based routing engine, which sequences request handlers and logic blocks to process traffic based on path patterns and HTTP methods. This architecture supports a highly modular approach, enabling the creation of
Express is a minimalist web server framework for building custom APIs, not a tool that generates mock endpoints directly from OpenAPI/Swagger specification files, so it only helps if you build the mock manually rather than automating it from a spec.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| stoplightio/prism | 5K | TypeScript | Apache-2.0 | |
| postcatlab/postcat | 5.5K | JavaScript | Apache-2.0 | |
| mock-server/mockserver | 4.9K | Java | Apache-2.0 | |
| ymfe/yapi | 27.7K | JavaScript | Apache-2.0 | |
| mockoon/mockoon | 8.1K | TypeScript | mit | |
| easy-mock/easy-mock | 9K | JavaScript | gpl-3.0 | |
| getinsomnia/insomnia | 38.5K | TypeScript | Apache-2.0 | |
| apiaryio/api-blueprint | 8.6K | — | MIT | |
| slimphp/slim | 12.2K | PHP | mit | |
| laravel/lumen | 7.6K | PHP | — |