Mockzilla

Overview

Mockzilla creates hosted mock APIs from OpenAPI specifications or plain JSON, with an offline CLI for local work and CI. It is a strong fit for developers who need contract-aware responses and controlled failure scenarios. Its breadth is useful, but the Free plan cannot access the API and retains request history for only two hours.

Key features

OpenAPI schemas can generate realistic responses and validate incoming requests, helping teams catch contract mismatches while building clients. Plain JSON gives developers a simpler input when there is no specification to work from. Per-service or per-endpoint latency and error injection makes retry and fallback behavior reproducible, rather than dependent on a live service failing at the right moment.

The proxy can forward requests to a real backend while supplying mocks for routes it does not serve. That is a practical bridge for partially implemented APIs; teams needing only fixed fixtures may not need this added flexibility. A GitHub Action creates a mock URL for each pull request, updates it on pushes and cleans it up when the branch is gone, making it well suited to review workflows built around GitHub.

Request history records status and timing, with replay for individual requests or groups. The two-hour Free retention window limits its value for later debugging. Mockzilla also describes payment simulations for declines, 3D Secure, lifecycle operations and idempotency, a focused capability for teams exercising payment flows. Its CLI is MIT-licensed, works offline on a laptop or in CI, and keeps hosted cloud features optional. The site also lists an MCP server for coding agents and CLI setup instructions for Claude and Gemini.

The privacy policy describes TLS in transit, encryption at rest and isolated simulations with scoped access. Those safeguards do not make Mockzilla a place for sensitive payloads: its terms prohibit uploading personally identifiable information, real financial data, health records, credentials or other sensitive data.

Pricing

The Free plan costs nothing and includes 1K requests/mo, 5 req/s, 1 simulation and 10 MB data transfer. It suits evaluation, but the absence of API access and the two-hour history window make it a poor choice for an ongoing hosted workflow.

Hobby costs $10 a month, with 100K requests/mo, 10 req/s, 2 simulations and 1 GB data transfer. It is aimed at side projects and is the lowest-cost paid route, though its quotas and two-simulation allowance constrain broader use. Starter is $20 a month for 200K requests/mo, 20 req/s, 5 simulations and 4 GB data transfer; its stated audience is solo developers and small teams needing more headroom.

Pro costs $50 a month and raises those limits to 400K requests/mo, 40 req/s, 10 simulations and 16 GB data transfer. It is the clearest fit for teams with CI pipelines and heavier usage. Enterprise has custom pricing, dedicated infrastructure, an own domain and capacity sized to traffic. Verified students can apply for a free tier without a card; approval is manual and usually takes 1–2 business days.

Platforms

Mockzilla supports API, web, Linux, macOS and Windows use, as well as self-hosting. HTTP is the supported protocol. The offline CLI makes local and CI use possible without opting into hosted cloud features.

Who it's for

Choose Mockzilla if your team builds against OpenAPI contracts, needs deliberate failure simulation, or wants a mock environment attached to each GitHub pull request. Its offline CLI also suits developers who want local or CI use without making hosted features central. It is a weaker fit for projects that require sensitive test data or for Free users who need API access and durable request history.

Pros and cons

• Pros: Schema-based responses and request validation keep mocks tied to an API contract.
• Pros: Fault injection, proxy fallback and replay cover failure testing as well as ordinary response mocking.
• Pros: Per-pull-request URLs and an offline MIT-licensed CLI support hosted review workflows and local or CI use.
• Cons: Free has no API access, only 1K requests/mo, and request history lasts two hours.
• Cons: Sensitive information is barred from uploads, limiting use with realistic personal, financial, health or credential data.
• Cons: The paid tiers impose request, rate, simulation and transfer quotas, so teams must match their workload to a plan.

Alternatives

API Mocking Tools is the broader category directory for comparing options. Choose Microcks instead if a fully open-source, community-driven CNCF Incubating project is the priority. MockServer is an alternative when a free, self-hosted option without a SaaS account fits better.

WireMock offers a free tier with 1,000 calls/month, one user, three mock APIs and 10 requests per second; consider it if those limits suit your workload. Mockfly is another freemium option, with a Starter plan at no cost. Knockout API offers a free plan for 30 images/month, making it the relevant alternative for that stated allowance.

MockAPI has a free plan limited to one project and two resources, or a paid monthly plan at $5 a month with 20 projects and 50 resources. moqapi.dev offers three projects with unlimited mock endpoints in Free Mode, and a Team plan at $29 a month for collaboration and project sharing. WireMock is also listed as a freemium alternative with a free tier and free trial.

Verdict

Mockzilla is a persuasive choice for developers and teams that want contract-aware mocks, reproducible failure testing and pull-request environments, with an offline CLI as a useful option. The main reason to choose it is the combination of those workflows; the main reasons to look elsewhere are the Free plan’s missing API access and short history retention, or any need to upload sensitive data.