Projects / Developer Tools · API Simulation · AI
MockForge
Open-source API and event simulation platform for teams that need realistic backend behavior across HTTP, gRPC, GraphQL, WebSockets, and more.
Overview
MockForge is an open-source API and event simulation platform for developers who need mocks that behave more like real backend systems.
It is built for the practical problems that slow product teams down when APIs, services, and integrations are still moving:
- Frontend teams are blocked waiting for backend endpoints.
- QA needs repeatable scenarios, not random demo data.
- Integration tests break because mocks drift from real APIs.
- Teams need to test error paths, auth flows, and production-like behavior before everything is deployed.
- Modern systems use more than REST, but most mocking tools still feel HTTP-only.
Website: mockforge.dev
GitHub: github.com/SaaSy-Solutions/mockforge
Status: Active development
License: Apache 2.0 / MIT
Key Features
Realistic Backend Simulation
MockForge is designed around a simple idea: useful mocks should simulate real backend behavior, not just return static API responses.
That means richer scenarios, more realistic data, configurable failure modes, and mocks that help teams test how software behaves when the backend is incomplete, unstable, or changing.
Multi-Protocol Support
Modern applications do not run on one protocol.
MockForge supports HTTP/HTTPS, gRPC, GraphQL, WebSockets, and TCP so teams can model more of their real integration surface with one tool instead of stitching together separate mock servers.
AI-Powered Mock Generation
MockForge uses LLMs to generate realistic, context-aware mock data from OpenAPI specs and schema information.
The goal is not novelty. The goal is to remove the manual work of writing believable test data while still keeping outputs useful, repeatable, and cost-conscious through caching, deterministic seeding, and batching.
Intelligent API Sync
Mocks get less useful when they drift away from the real API.
MockForge includes upstream polling, change detection, deep response comparison, optional fixture updates, and observability for sync status so teams can see when their mock layer is no longer telling the truth.
Client Generation
MockForge can generate type-safe clients for modern frontend frameworks, including React, Vue, Angular, and Svelte.
Generated clients can include request and response validation, interceptors, and OAuth2/PKCE authentication so teams spend less time hand-rolling integration code.
Production-Ready Security
Some test scenarios require more than a local HTTP server.
MockForge includes TLS/HTTPS, mutual TLS, tunneling, enterprise error handling, CSRF protection, and secure token handling for teams that need production-like testing without deploying every dependency first.
Technical Architecture
MockForge is built in Rust for performance, reliability, and a small operational footprint.
The architecture uses async Tokio services, protocol abstraction layers, template-based code generation with Handlebars, LLM integration for intelligent data generation, and observability through Prometheus metrics and OpenTelemetry tracing.
That combination lets MockForge keep the core fast and predictable while still supporting higher-level AI-assisted workflows.
Why I Built It
Most mocking tools are good at returning a response. Fewer tools help teams simulate how a real backend behaves while the system is still being built.
That gap shows up everywhere: frontend teams waiting on APIs, QA teams creating brittle fixtures, integration tests passing against stale mocks, and developers discovering production edge cases too late.
MockForge is my answer to that problem: a practical simulation layer for modern software teams that need realistic backend behavior, multi-protocol coverage, and AI-assisted test data without giving up control, repeatability, or developer trust.
Impact
- Developer Experience: Reduces the manual work of setting up useful mocks and integration fixtures.
- Realism: Helps teams test behavior, edge cases, auth flows, and failure modes earlier.
- Reliability: API sync and change detection help prevent stale mocks from giving teams false confidence.
- Cost Efficiency: Caching, deterministic seeding, and batching keep AI-generated data practical.
- Security: TLS, mTLS, tunneling, and secure token handling support production-like testing scenarios.
Related Content
More projects