How is this different from the mock server I already have?

Mimic puts response editing, ordered journeys, and the live request log in one Mac window. Write the responses in the order they should happen, or save a sequence from traffic your app already sent. The same project can be driven from a script.

Does it work with my test framework?

Mimic is an HTTP server on localhost:8080, so anything that can make a request can use it. There is no plugin and no adapter to install. Between cases your tests run mimic reset, which returns every journey to its first step and clears the log.

Can I use it without opening the app?

Yes. Run Mimic headlessly and use the CLI or local HTTP interface to set up endpoints, switch responses, run a journey, and read back the requests. HAR and OpenAPI import review happens in the Mac window; a Mimic project export can be imported from the CLI.

Nothing. There is no account and no trial period, so there is nothing to cancel either. Download the installer and use it.

It is an early release, numbered below 1.0. The app is still changing, and the features described here are in the release linked by the download button.

Can I run it on an older macOS?

No. macOS 26.0 is the minimum and the installer will not run on anything earlier. It works on both Apple silicon and Intel Macs.

Where does my data go?

Projects and captured requests are stored locally on your Mac. If you enable pass-through with an upstream, Mimic forwards unmatched calls to that address. The control interface is bound to 127.0.0.1 behind a token that changes every time Mimic starts.

Can I forward calls to a real backend?

Yes. Run several named local listeners if your app uses multiple APIs. Give each listener its own upstream URL and enable pass-through. Mimic serves matching mocks, forwards other calls, and logs both. Save a supported text reply as a local mock, or opt in to automatic capture for the next matching request.

What if my API is GraphQL, or I already have an OpenAPI document?

GraphQL is matched on the operation rather than the path, because GraphQL sends everything to one URL. An OpenAPI or Swagger document, or a HAR file saved from your browser, imports as endpoints you can review and edit before keeping them.

01 / Native mock API server for macOS

Mock APIs.
Test flows.

Run multiple local API servers from one Mac project. Mock the routes you need, forward the rest to real backends, and save supported text responses for replay. Test failure and recovery while you inspect every request.

Download for Mac See a journey

Free · No account · macOS 26.0 or later · Apple silicon and Intel

Open source · MIT licensedExplore the code on GitHub

An API response, in motionLive response changes · request log

APP WALKTHROUGH 01 / 04Choose a failure

Set GET /account-summary to return 500 while the local server keeps running.

01Define the responseStatus, headers, body, and delay.

02Run the journeyFailures and retries in the order you choose.

03Forward, record, replayKeep other calls live, then save real replies as mocks.

02The modelChapter 02 of 08

Endpoint: A method and a path your app calls. Mimic matches each request to one of these, and lists the ones it could not match so you can see what is still missing.
Response: What goes back: a status code, headers, a body. One endpoint can hold several, and you switch between them while your app keeps running.
Journey: Those responses in order, so the same endpoint answers 500 on the first call and 200 on the retry. 9 journeys are included.

03JourneysChapter 03 of 08

A journey serves responses in order. Script a payment failure, an expired session, or a dropped connection, then replay the same flow every time you test. Try the live example below: send the next request four times and watch the same URL answer differently.

Acme Storefrontlocalhost:8080

Nothing has arrived yet. Send a request below.

Send

Press the request marked next four times. GET /account-summary is step 2 and step 4, so it answers 500 and then 200.

01 / Script

Choose the sequence

Set a status, headers, body, and delay for each step. A step can repeat or simulate a dropped connection or timeout.

02 / Run

Follow real requests

Matching requests move through the journey. Calls outside it still use your normal endpoints.

03 / Repeat

Reset between tests

Rewind to step one and clear the log from the window or with one command.

Built from real traffic

Turn a session into a journey

Run your app against Mimic, pick requests from the log, and save them as an ordered journey. Repeated polls become a single step with a repeat count. Nine included journeys give you a starting point for common flows.

Retry after failure · Payment retry · Session expiry · MFA challenge · Offline to online

ACME STOREFRONTCAPTURE A FLOW

REQUEST LOG4 selected

GET/job/status202

GET/job/status200

SAVED JOURNEY2 steps

01GET/job/status202 × 3

02GET/job/status200

Three polls, then the completed result.

04CLI & agentsChapter 04 of 08

The mimic command gives test suites and coding agents control over projects, local listeners, upstreams, endpoints, scenarios, journeys, and the request log. It returns JSON and useful exit codes, so they can check the result themselves.

A repeatable test setupmimic CLI

# keep test data out of your own projects
export MIMIC_DATABASE_PATH="$PWD/.mimic-ci/store.sqlite"

mimic daemon start                      # no window
mimic project import fixtures/api.json
mimic journey activate "Session expiry"
mimic reset --scope all                 # back to step 1

# … run your tests here …

mimic journey status | jq -e '.journeyStatus.isComplete'

Start headlessly

Run the installed Mac app without a window and use an isolated project store for CI.

Control the scenario

Load a project, set up local backends, change responses, activate a journey, and reset it between cases.

Assert on what happened

Read requests, responses, and journey progress as JSON. The same controls are available through a token protected interface on 127.0.0.1.

HAR and OpenAPI review happens in the Mac app. The CLI imports and exports Mimic project files.

05WorkflowChapter 05 of 08

Run several named local servers from one native Mac workspace. Give each its own routes and optional upstream, then turn real responses into repeatable local mocks.

Set up the API you need

Create endpoints by hand, or import a HAR capture or an OpenAPI or Swagger document in the app. Review what Mimic found before you keep it. Group routes so a larger project stays readable.

GET /orders/:id · POST /checkout

Choose what comes back

Edit status, response headers, body, and delay. Keep several scenarios on an endpoint and switch the active one while your app runs. The next request uses the change immediately.

Default 200 / Server error 500

Run multiple servers in one project

Give each local listener a name and port. Scope endpoints and journey steps to the right server, then run them together. Each listener can connect to a different real backend.

Catalog :8080 · Accounts :8081

Pass through, record, and replay

Enable pass-through on a listener to forward requests without a matching mock. The real reply appears in the log. Save a supported text response as a local mock, or opt in to automatic capture so the next matching call can use it.

unmatched → upstream → saved mock

Find the requests you missed

The live log records both sides of every exchange. Filter to Unmatched calls, inspect formatted headers and bodies, then create an endpoint from a request or add it to a journey.

GET /profile/avatar → Unmatched

06FeaturesChapter 06 of 08

Build a local API, reproduce a client flow, connect to a real backend, inspect the traffic, and run it again from a script.

Build the API

Start with the routes your client actually calls.

Local projects: Create, duplicate, rename, autosave, and move projects as JSON files.
HTTP endpoints: GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS, with path parameters and the most specific route match.
Response scenarios: Keep several statuses, headers, bodies, and delays per endpoint. Change the active one while serving.
Spec and traffic import: Review routes from HAR captures or OpenAPI and Swagger JSON in the Mac app before adding them.
GraphQL operations: Give separate responses to operations sharing one GraphQL path, including unnamed queries.

Reproduce the hard cases

Run the same client behavior again and again.

Ordered journeys: Make a route fail, recover, or change later in a flow. Start from nine included examples.
Real network failures: Drop a connection or hold it until the client times out, in addition to HTTP error responses.
Timing controls: Add project wide, endpoint, or journey step latency; repeat a step to model polling and retries.
Flow control: Choose forgiving or strict request order, hold a step, advance it manually, restart, or loop.
Journey groups: Organize saved flows by group and jump back to the active run from the navigator.

Multiple servers and live backends

Give each part of your app its own local API and optional real upstream.

Multi-server projects: Run several named local ports together, with endpoints and journey steps scoped to each listener.
Pass-through routing: Give each listener its own real backend URL. Matching mocks answer locally; other calls are forwarded and logged.
Record real responses: Save a supported upstream text reply from the log, or enable automatic capture, and replay it as a local mock.
Server status: See which ports are listening and which configuration changes need a restart.

See what happened

Turn observed traffic into the next useful mock.

Live request log: Read each request, response, status, and outcome while the server runs.
Unmatched requests: Filter the calls Mimic could not answer, then create an endpoint from one.
Request inspector: Search and format request and response headers and bodies without leaving the log.
Traffic to journey: Save selected calls as an ordered flow; repeated identical polls become one repeating step.

Automate and maintain

Use the same project from a Mac window or a test runner.

Headless app and CLI: Start Mimic without a window, configure a test case, reset it, and read JSON results and exit codes.
Local control API: Drive projects, endpoints, scenarios, journeys, and logs through a token protected loopback interface.
Portable files: Export and import Mimic projects and individual journeys for repeatable test fixtures.
Safe updates: Check for updates in the app or CLI. The Mac app verifies the installer and backs up projects before installation.

07QuestionsChapter 07 of 08

How is this different from the mock server I already have?
Mimic puts response editing, ordered journeys, and the live request log in one Mac window. Write the responses in the order they should happen, or save a sequence from traffic your app already sent. The same project can be driven from a script.
Does it work with my test framework?
Mimic is an HTTP server on localhost:8080, so anything that can make a request can use it. There is no plugin and no adapter to install. Between cases your tests run mimic reset, which returns every journey to its first step and clears the log.
Can I use it without opening the app?
Yes. Run Mimic headlessly and use the CLI or local HTTP interface to set up endpoints, switch responses, run a journey, and read back the requests. HAR and OpenAPI import review happens in the Mac window; a Mimic project export can be imported from the CLI.
What does it cost?
Nothing. There is no account and no trial period, so there is nothing to cancel either. Download the installer and use it.
How finished is it?
It is an early release, numbered below 1.0. The app is still changing, and the features described here are in the release linked by the download button.
Can I run it on an older macOS?
No. macOS 26.0 is the minimum and the installer will not run on anything earlier. It works on both Apple silicon and Intel Macs.
Where does my data go?
Projects and captured requests are stored locally on your Mac. If you enable pass-through with an upstream, Mimic forwards unmatched calls to that address. The control interface is bound to 127.0.0.1 behind a token that changes every time Mimic starts.
Can I forward calls to a real backend?
Yes. Run several named local listeners if your app uses multiple APIs. Give each listener its own upstream URL and enable pass-through. Mimic serves matching mocks, forwards other calls, and logs both. Save a supported text reply as a local mock, or opt in to automatic capture for the next matching request.
What if my API is GraphQL, or I already have an OpenAPI document?
GraphQL is matched on the operation rather than the path, because GraphQL sends everything to one URL. An OpenAPI or Swagger document, or a HAR file saved from your browser, imports as endpoints you can review and edit before keeping them.

08DownloadChapter 08 of 08

One installer adds the Mac app and the mimic command. Create a project, start the server, and point your app at localhost:8080.

Mimic for macOSabout 61 MB · Apple silicon and Intel · macOS 26.0 or later

Download the installer

01 / Install

Open the signed and notarised package. It puts Mimic in Applications and the command in /usr/local/bin.

02 / Use it locally

Projects stay on your Mac. The server and its token protected control interface listen locally.

03 / Know the release

Free with no account or trial period. Mimic is an early release below 1.0 and is still changing.