API Mocking, Testing & Automation Platform

Mock, test, and automate HTTP, gRPC, GraphQL, SOAP, WebSocket, SSE, MCP, Kafka, RabbitMQ, SMTP — with built-in AI agents, deployed on-premise on your own infrastructure

Request Demo Download Documentation
HTTP/REST gRPC gRPC GraphQL GraphQL SOAP WebSocket SSE MCP Kafka Kafka RabbitMQ RabbitMQ SMTP

Why Mockarty?

Modern development teams face real challenges that Mockarty solves

Frontend Blocked

Frontend teams wait for backend APIs to be ready, slowing down the entire development cycle

Hard to Test Edge Cases

Timeouts, errors, race conditions — hard to reproduce with real services

No Team Isolation

Shared test environments cause conflicts between teams and unreliable test results

Too Many Tools

Different mock tool per protocol leads to complex setups and inconsistent developer experience

8 Protocols. 2 Brokers. One Platform.

Every protocol and integration your team needs, unified under one API and one UI

HTTP / REST

Full REST API mocking with route parameters, query matching, header conditions, and dynamic response generation using 50+ faker functions.

  • Route parameters and pattern matching
  • Body, header, query param conditions
  • 50+ faker functions for realistic data
  • Global, Chain, and Mock stores for stateful workflows
Client
GET /api/users/:id
Mockarty
Route + Method
Conditions (body, query, headers)
Stores (gS / cS / mS)
Faker + JsonPath templates
Mockarty
200 JSON + Headers
Client

gRPC

Via Server Generator plugin

Upload .proto files and get fully functional gRPC mock servers with reflection support.

  • Proto-based mock generation
  • Unary and streaming support
  • gRPC reflection for tool compatibility
gRPC Client
protobuf RPC
gRPC Servergenerated
.proto upload
Service + Method
Unary / Stream
gRPC Server
POST /mock/findGrpc
Mockartymock resolution

GraphQL

Mock GraphQL queries and mutations with condition-based response matching.

  • Query and mutation detection
  • Field-level condition matching
Client
POST /graphql
Mockarty
GraphQL detection
query / mutation / subscription
Conditions on variables
Mockarty
{ data, errors }
Client

SOAP / WSDL

Import WSDL definitions and auto-generate SOAP mock services with proper XML envelope handling.

  • WSDL import and auto-generation
  • SOAPAction header matching
SOAP Client
XML Envelope + SOAPAction
Mockarty
WSDL import
Path + Action + Method
XML → JSON conditions
Mockarty
SOAP Response / Fault
SOAP Client

WebSocket

Via Server Generator plugin

Mock bidirectional WebSocket communication with event-based response patterns.

  • Event-based message matching
  • Bidirectional communication support
WS Client
events
WS Servergenerated
serverName
event + data
bidirectional
WS Server
POST /mock/findSocket
Mockartymock resolution

Server-Sent Events

Mock Server-Sent Events streams with configurable event types and intervals.

  • Configurable event streams
  • Custom event types and intervals
Client
GET /events/* Accept: text/event-stream
Mockarty
Path + Event name
Event chain
Loop + Heartbeat + Delay
Mockarty
data: {...}
Client

MCP (Model Context Protocol)

Generate MCP servers for AI coding tools like Cursor, Claude Desktop, and Windsurf. Manage mocks from your IDE.

  • Tool, resource, and prompt support
  • Works with Cursor, Claude, Windsurf
  • Generate standalone MCP servers
AI AgentCursor / Claude / Windsurf
JSON-RPC 2.0
MockartyMCP :5772
tools/call
resources/read
prompts/get
Mockarty
{ result } / { error }
AI Agent

Apache Kafka

Server adapter (plugin)

Drive a real Apache Kafka cluster from your tests — publish, consume, and resolve mock payloads through Mockarty. Requires a running broker (docker-compose, dev cluster, or testcontainers).

  • Publish and consume against a real cluster
  • Mock payloads resolved via Mockarty
KafkaKafkaorders.created
consume messages
Adapterplugin
Adapter sends message to resolver
Conditions (topic, body, headers)
Action: response + output config
Adapter
find mock
Mockartyadmin node
Publish to different topic / cluster
Webhook (optional)

RabbitMQ

Server adapter (plugin)

Drive a real RabbitMQ instance — publish to exchanges, consume from queues, and resolve mock payloads through Mockarty. Requires a running RabbitMQ (docker-compose, dev instance, or testcontainers).

  • Publish and consume against a real broker
  • Mock payloads resolved via Mockarty
RabbitMQRabbitMQnotifications
consume messages
Adapterplugin
Adapter sends message to resolver
Conditions (queue, exchange, body)
Action: response + output config
Adapter
find mock
Mockartyadmin node
Publish to different queue / exchange
Webhook (optional)

SMTP

Server adapter (plugin)

Mock SMTP servers for testing emails, notifications and bounce handling. The generated server accepts real SMTP connections with STARTTLS support.

  • 5 condition types: sender, recipient, subject, body, headers
  • Configurable SMTP response codes (250, 550, 421, etc.)
Applicationsends email
SMTP :2525
SMTP Serverplugin
Parse email (from, to, subject, body)
Conditions (sender, recipient, subject)
Action: accept / reject / delay
SMTP Server
find mock
Mockartyadmin node
Web mailbox interface
STARTTLS with auto-certificates

Accelerate with API-First

Import your API specifications and start developing immediately

OpenAPI / Swagger

Import OpenAPI/Swagger specs to auto-generate all REST mocks in seconds

.proto / gRPC

Upload .proto files to generate fully functional gRPC mock servers

WSDL / SOAP

Import WSDL definitions to auto-generate SOAP mock services

GraphQL Schema

Define GraphQL schemas with queries and mutations — generate mock resolvers instantly

MCP Schema

Describe MCP tools and resources in JSON — generate standalone MCP servers for AI agents

HAR (Traffic Recording)

Record real traffic with HAR files and convert to mocks in one click

Server Generator

Generate production-ready servers from API specs. Generated servers run autonomously with their own cache and resolve mocks through Mockarty.

OpenAPI
.proto
WSDL
GraphQL
MCP
Server Generator CLI
gRPCgRPC
WebSocket
KafkaKafka
RabbitMQRabbitMQ
SSE
SOAP
MCP
Mockarty Central storage for mocks, conditions, and stores
Local Cache Each server caches mocks for speed and load testing

AI-Native Platform

11 built-in AI agents, 50+ tools, MCP marketplace, and agent-to-agent protocol — AI at the core of every feature

Agent Development Kit

11 specialized sub-agents for mock building, API testing, fuzzing, performance analysis, database queries, web crawling, and notifications. Auto-routing, tool calling, and multi-step delegation.

mock_builderapi_testerfuzzeranalyzerdb_specialist+6

MCP Tool Marketplace

Connect any tool source — MCP servers, OpenAPI specs, gRPC services, WSDL, RAG knowledge bases. Admin controls tool access, users select per feature.

MCPOpenAPIgRPCWSDLRAGA2A

AI in Every Feature

AI-powered test generation, security fuzzing triage, performance diagnostics, API diff detection, log anomaly analysis, and smart collection building.

Test GenFuzzingPerfDiagnosticsLogs

IDE & Agent Interop

Built-in MCP server for Cursor, Claude Desktop, Windsurf. A2A protocol for external AI agents to discover and delegate tasks.

CursorClaudeWindsurfA2A
Any LLM Provider:
OpenAIClaudeGeminiMistralGroqOllamaOpenRouter
Agent System — Live
Agent RouterRouting... → mock_builder
mock_builderCreating endpoints
create_mock POST /api/payments 201
create_mock GET /api/payments/:id 200
create_mock POST /api/payments/:id/refund 200
Delegationmock_builder → notifier
notifier
send_slack #payments-alerts OK
Complete3 mocks + Slack webhook configured

What Sets Us Apart

Powerful features beyond standard mocking tools

Stateful Mocking

Global, Chain, and Mock stores for complex workflows like order processing and auth flows

50+ Faker Functions

Generate realistic names, emails, UUIDs, dates, addresses, and more

Advanced Conditions

JsonPath, regex, body/header/query matching with AND logic

Proxy Mode

Forward to real services, inject delays, replace headers, test timeouts

OneOf Responses

Return different responses randomly or in order — simulate flaky services

Code Generators

Generate standalone servers for MCP, gRPC, GraphQL, SOAP, SSE, WebSocket, Kafka, RabbitMQ

Built-in API Tester

Postman-like tool with collections, environments, variables, and test scripts

Performance Testing

Import Postman collections and run load tests with APDEX scoring to quickly find bottlenecks

Request Recorder

Capture real traffic with toxicity rules (delay, jitter, error injection, throttling) and convert to mocks

Templates Library

Reusable mock templates for common API patterns

Callbacks & Webhooks

Async HTTP/Kafka/RabbitMQ webhooks with retries, exponential backoff, and templating

Postman Compatible

Import Postman collections, environments, and scripts — run them as load tests with APDEX scoring

CORS & Preflight

Automatic OPTIONS preflight handling for all mock routes — no extra configuration needed

OpenTelemetry

Distributed tracing and metrics out of the box

Chaos Engineering for Kubernetes beta

Inject controlled failures into your K8s cluster. Kill pods, simulate network partitions, and verify resilience — all from Mockarty.

Kubernetes Cluster Node 1 Pod A Pod B Svc X Node 2 Pod C Pod D Svc Y Node 3 Pod E Pod F Svc Z

Pod Termination

Selectively kill pods to test self-healing and failover behavior

Network Chaos

Network partitions, DNS spoofing, and service isolation via NetworkPolicy

Presets & Scheduling

6 ready-made chaos scenarios (Chaos Monkey, Scale to Zero, etc.), run on cron schedule or from CLI

Observability

Cluster topology dashboard, real-time experiment logs, and recovery metrics

Contract Testing beta

Public API registry, mock drift detection, and pact violation tracking — ensure your mocks always match reality.

Public API Registry

Centralized registry of API contracts. Publish, discover, and subscribe to contract changes across teams.

OpenAPIgRPCGraphQLAsyncAPIWSDL

Mock Drift Detection

Automatically detect when mocks diverge from real API schemas. Get alerts before bugs reach production.

Mock
Real API
14% drift

Pact Violation Tracking

Consumer-driven contract testing. Track pact violations across services and teams with detailed reports.

auth-service → user-api
payment-svc → billing-api
order-svc → inventory-api
gateway → analytics-api

Your Data. Your Control.

Self-hosted, air-gapped, enterprise-ready

Self-Hosted

Runs entirely on your infrastructure. No third-party dependencies.

Air-Gapped Support

Works in fully offline environments. No internet required.

No Cloud Dependency

Your data never leaves your perimeter. Full data sovereignty.

Enterprise Deployment

Docker Compose, Kubernetes (Helm), Ansible, or bare metal.

Built to Scale

Distributed architecture designed for enterprise workloads

Clients & CI/CD
Load Balancer
Mockarty
Configuration, UI, API, user management
Resolver Node
Mock resolution, request matching
N
Runner Agent
Load tests, API tests, performance
N
PostgreSQL
Redis Cache

Horizontal Scaling

Add resolver nodes and runner agents on demand. Each component scales independently.

High Availability

No single point of failure. Automatic failover with health checks and readiness probes.

Performance

Sub-millisecond mock resolution. Redis caching for hot paths. Connection pooling.

For Developers

  • 5x development speed — work without waiting for backend
  • Full independence — each team gets its own namespace
  • Test edge cases easily — timeouts, errors, flaky services
  • API-first workflow — import OpenAPI spec, start coding immediately
  • MCP integration — manage mocks from your IDE (Cursor, Claude)

For Managers

  • Cost savings vs SaaS solutions — no per-seat pricing
  • Transparency — dashboards, audit logs, usage metrics
  • Security — RBAC, namespace isolation, audit trail
  • Scalability — horizontal scaling with Kubernetes
  • Compliance — SOX, GDPR, ISO 27001 ready

How We Compare

Ready to Simplify API Testing in Your Company?

Request a demo or deploy Mockarty on-premise on your own infrastructure — first mocks in minutes

Download Read Docs