Keploy and Mockifyer: When to Use Which

Tested with Mockifyer: fetch and axios record/replay on Node 24.22.1 against a local test API, @sgedda/mockifyer-core 1.10.190, -fetch 1.8.106, -axios 1.10.35, axios 1.x, 2026-11-10. Keploy: keploy record then keploy test, 24 recorded and 24/24 passed on a small Node HTTP app, Linux, native OSS CLI v3.6.229, no account, no Docker, 2026-11-10; docs, README, pricing page and GitHub API also checked 2026-11-10 against v3.6.229. Repro: demos/keploy-mockifyer on GitHub

We ran keploy record and then keploy test on Linux with the open-source CLI v3.6.229 against a small Node HTTP app: 24 test cases were recorded and 24/24 passed. No account and no Docker were used. Other Keploy facts come from its docs, README and pricing page. On 2026-11-10 we re-tested Mockifyer fetch and axios record/replay on Node 24.22.1 against a local test API (core 1.10.190, fetch 1.8.106, axios 1.10.35): calls were recorded, the live response body was changed, and replay served the recording. That replay needed useGlobalFetch or useGlobalAxios, domainPathRulesMode: 'record_all', MOCKIFYER_RECORD_RESPONSES=true and MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API=false. React Native, client lanes, the dashboard and multi-service tracing were not part of that run; those details are from Mockifyer’s README and dashboard README, or from our October tests, and are marked “per docs” below. The apps and commands are in demos/keploy-mockifyer.

Keploy and Mockifyer aren’t really alternatives. They record traffic at different layers, and they overlap for a Node service’s outbound HTTP. Keploy wraps your backend service and turns the requests it receives, plus the database, queue and API calls it makes, into regression tests with mocks. Mockifyer is a JS/TS library for fetch and axios. It runs in Node.js — backends, tests, scripts and services that call other APIs — and in React Native/Expo, and it can log a request across several services (per the dashboard README). React Native and on-device work are a strength, not the only use. Both tools can record and replay outbound HTTP from a Node process. If you have a Node backend and a mobile app, you may want one of each.

Checked 2026-11-10 against Keploy’s docs, README, pricing page and GitHub, and Mockifyer’s README, React Native docs and npm packages.

TL;DR

• Testing a backend API (Go, Java, Node, Python and more) and its database and queue calls: use Keploy. It works at the network/eBPF layer with no SDK, also covers databases and queues, and generates API tests. It’s mature (repo since January 2022, about 19.6k GitHub stars) and it has a documented CI flow.
• Recording fetch or axios in JavaScript: use Mockifyer. It is an in-code library for Node.js (backends, tests, scripts, services calling other APIs) as well as React Native/Expo, with per-client lanes, a dashboard and multi-service logging (lanes, dashboard and tracing per docs). On-device React Native is a strength, not the only use. Keploy’s docs don’t cover React Native. Mockifyer is young and has sharp defaults, so read the caveats below first.
• Both: Keploy guards the backend’s API behaviour — and its database and queue calls — in CI. Mockifyer mocks fetch/axios in the Node service and/or in the app, including offline React Native scenarios (per docs). They overlap only on a Node process’s outbound HTTP.

Where each one sits

 Node.js or React Native / Expo         Backend service                 Dependencies
 ┌───────────────────────┐   HTTP    ┌─────────────────────┐        ┌──────────────────┐
 │ fetch / axios         │ ───────▶  │ your API (any lang) │ ─────▶ │ Postgres, MySQL, │
 │  ▲ Mockifyer patches  │           │  ▲ Keploy captures  │        │ Mongo, Kafka,    │
 │    outbound calls     │           │    in + out here    │        │ 3rd-party APIs   │
 └───────────────────────┘           └─────────────────────┘        └──────────────────┘

• Keploy captures at the socket level: with eBPF in the kernel on Linux, and in user space on macOS and Windows (per Keploy’s “How Keploy works” docs). It needs no code changes or SDK. It records incoming API requests as tests and outgoing dependency calls (HTTP, databases, queues) as mocks.
• Mockifyer is an npm library for fetch and axios. You call setupMockifyer in a Node.js process (a backend, test, script or service) or setupMockifyerForReactNative in an app, and it patches fetch or adds axios interceptors in that process. It does not mock databases or queues.

Quick decision table

Swipe the table to see all 3 columns →

Keploy: backend API regression testing

Keploy runs your server under keploy record, captures the requests it receives and the calls it makes, and saves them as YAML test cases and mocks. keploy test starts the app again, replays the recorded requests, serves the dependency calls from the mocks, and compares the responses.

From Keploy’s README and install docs:

# Install the CLI (Linux, macOS, WSL)
source /dev/stdin <<<"$(curl -fsSL https://keploy.io/install.sh || echo 'echo Keploy installer download failed >&2; return 1')"

# Record: run your app under Keploy and send it some traffic
keploy record -c "node server.js"

# Replay the recordings as tests, with dependencies mocked
keploy test -c "node server.js" --delay 10

Recordings land in a keploy/ folder that you commit (per Keploy’s docs):

keploy
└── test-set-0
    ├── mocks.yaml
    └── tests
        ├── test-1.yaml
        └── test-2.yaml

Keploy can also mock the dependencies of an existing test suite with keploy mock record -c "<your test command>" and keploy mock replay -c "<your test command>". Its docs mention pytest, go test and Jest. Your test runner’s exit code is passed through, so it works in CI.

Things to know before you start (all per Keploy’s docs):

• macOS needs Apple Silicon for the native CLI. Intel Macs use a Lima VM. On macOS and Windows, native mode understands HTTP/HTTPS, MySQL and MongoDB. PostgreSQL, Redis, Kafka and gRPC calls are “captured only as raw bytes and usually don’t replay”, so run those in Docker or on Linux/WSL. Linux needs kernel 5.10+.
• On macOS, start the app directly (node server.js, a built Go binary), not through a launcher such as npm start.
• The open-source Linux CLI v3.6.229 ran keploy record/keploy test locally with no account. In CI it signs in with a KEPLOY_API_KEY secret (per Keploy’s GitHub CI docs).
• Pricing: the open-source core is Apache-2.0 and self-hosted. The free Playground plan has 30 test-suite generations and 100 test runs a month. Pro is $19/user/month billed yearly or $24 billed monthly, plus usage. Enterprise is custom. The pricing comparison table lists Kubernetes recording from Pro (shared with Enterprise). The same page’s Enterprise card and FAQ, though, present “Record traffic inside Kubernetes” / “record-replay in Kubernetes clusters” as an Enterprise feature. The page disagrees with itself, so we can’t say which tier actually includes it; ask Keploy if this matters for you. Production traffic capture is consistently Enterprise only.

Where Keploy wins

• Language coverage. It works at the network layer, so it isn’t tied to JavaScript. The pricing table lists Node, Go, Java and Python for the free and Pro tiers, and “all languages” for Enterprise. The README shows badges for many more.
• Database and queue mocks. It records and replays Postgres, MySQL, MongoDB, Redis, Kafka and more, not just HTTP. One caveat: the pricing table’s open-source column lists MySQL as the only database and GraphQL as the only messaging protocol. Kafka appears from Playground up and RabbitMQ only on Enterprise, so check which tier covers your stack.
• No SDK. You don’t change any code to start recording.
• A mature CI flow. It has documented GitHub Actions, GitLab and Jenkins setups, test reports and a keploy/testgpt GitHub Action.
• Maturity and community. The repo started in January 2022 and has about 19.6k stars, about 2,450 forks and about 140 contributors. Several releases shipped on 9–10 Nov 2026 alone (v3.6.226 to v3.6.229). It’s in the CNCF Landscape, and there’s commercial support.

Mockifyer: record/replay for fetch and axios in Node.js and React Native

Mockifyer (MIT) is a JS/TS library that records fetch and axios responses as one JSON file per request in your repo, under mock-data/<scenario>/, and replays them. It runs in Node.js — backends, tests, scripts and services that call other APIs — and in React Native/Expo. In Node you call setupMockifyer from @sgedda/mockifyer-fetch or @sgedda/mockifyer-axios. In a React Native app, in development, its “Hybrid” provider writes mocks to the device and to the project’s mock-data/ folder through Metro endpoints, and release builds can load bundled mocks (per docs; we didn’t run it on a device for this page).

A Node setup looks like this. To store response bodies and then replay them, we also needed MOCKIFYER_RECORD_RESPONSES=true and MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API=false (without those, recordings were empty or replay called the live API):

import { setupMockifyer } from '@sgedda/mockifyer-fetch';

process.env.MOCKIFYER_RECORD_RESPONSES = 'true';
process.env.MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API = 'false';

setupMockifyer({
  mockDataPath: './mock-data',
  useGlobalFetch: true, // axios: useGlobalAxios: true
  recordMode: process.env.MOCKIFYER_RECORD === 'true',
  domainPathRulesMode: 'record_all',
});

You can run a small Node record-then-replay example in the browser. It uses the real @sgedda/mockifyer-fetch package against the shared demo API at https://demo.devxtools.dev, with the same non-default settings as the snippet above (useGlobalFetch, record_all, MOCKIFYER_RECORD_RESPONSES=true and MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API=false). The first request is recorded to a mock file; the second is served from that file. StackBlitz (a third-party service) runs this in a Node WebContainer, not as a rewritten simulation of the library. There is no equivalent in-browser run for Keploy here: it attaches to the kernel on Linux and is not a JS library we can run in StackBlitz. The commands we ran are in demos/keploy-mockifyer.

Run this Mockifyer record/replay example in your browser with StackBlitz (a third-party service).

From Mockifyer’s React Native docs (per docs; we didn’t run it on a device for this page):

import {
  setupMockifyerForReactNative,
  isMockifyerReactNativeActive,
} from '@sgedda/mockifyer-fetch';

export async function initializeMockifyer() {
  const recordMode = __DEV__ && process.env.MOCKIFYER_RECORD === 'true';
  if (recordMode) process.env.MOCKIFYER_RECORD_RESPONSES = 'true';

  const result = await setupMockifyerForReactNative({
    isDev: __DEV__,
    mockDataPath: 'mock-data',
    bundledDataPath: './assets/mock-data',
    recordMode,
    config: {
      logging: 'info',
    },
  });

  if (isMockifyerReactNativeActive(result)) {
    // result.instance.enableMockifyer() / disableMockifyer() / isMockifyerEnabled()
  }
}

MOCKIFYER_MODE controls when it activates. The modes are on (the default), manual (a runtime toggle), launch_client (only when a Detox/Maestro launch argument is present) and off (store builds) (per docs).

Where Mockifyer wins

• Node.js as well as React Native. In a Node process it patches fetch or axios so backends, tests, scripts and services can record and replay their outbound HTTP. On a React Native/Expo simulator or device it mocks the app’s own fetch calls, syncs recordings back to the repo through Metro, and selects scenarios at launch for Detox and Maestro (per docs; we didn’t run React Native for this page). Keploy’s docs don’t cover React Native. Keploy’s Chrome extension records a web app’s browser traffic to generate API tests, but it doesn’t serve mocks to the app.
• Per-client lanes. A client or lane ID, sent as X-Mockifyer-Client-Id, keeps each client, device, developer or CI run on its own scenario through the optional dashboard proxy (per docs).
• A dashboard, and traffic logging across services. @sgedda/mockifyer-dashboard is a local UI for browsing and editing mock data. In Node, setupMockifyer also assigns an X-Mockifyer-Request-Id per hop and can pass a parent id downstream; the dashboard can show that chain (per the dashboard README). Cross-service request IDs worked in our October tests.

Mockifyer caveats (re-tested 2026-11-10)

We re-ran our October checks on the latest npm releases: core 1.10.190, fetch 1.8.106 and axios 1.10.35, on Node 24.22.1. They’re still true, and one is new:

• The README’s basic setup records nothing. setupMockifyer({ mockDataPath, recordMode: true }) wrote no mock files.
• fetch and axios need the global flags in Node. Without useGlobalFetch: true, or useGlobalAxios: true for axios in ESM, nothing recorded.
• New: response bodies aren’t saved by default. With domainPathRulesMode: 'record_all', recordings stored the request with an empty response (responsePending) until we set MOCKIFYER_RECORD_RESPONSES=true.
• Replay calls the live API by default. New recordings get alwaysUseRealApi: true. Replay only served the recorded data once we also set MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API=false.
• Two packages named in the README aren’t on npm. @sgedda/mockifyer-mcp (you build it from the repo) and @sgedda/mockifyer-test-helper both return 404.
• It’s small. It has 2 GitHub stars, about 177 weekly downloads of @sgedda/mockifyer-core (3–9 Nov), essentially one maintainer, and the repo dates from March 2025. It only handles fetch and axios, with no database or queue mocks.

With all four settings in place (useGlobalFetch/useGlobalAxios, record_all, MOCKIFYER_RECORD_RESPONSES=true, MOCKIFYER_RECORD_DEFAULT_ALWAYS_USE_REAL_API=false), fetch and axios each recorded once and then replayed the recording after the API changed.

Use both: a Node backend plus a React Native app

Say you have an Expo app that talks to a Node API backed by Postgres and a payments API.

1. Backend API tests, with Keploy. Record the API with keploy record while you run through the app’s main flows against a dev backend. Do this on Linux or in Docker, since Postgres doesn’t replay natively on macOS. Commit keploy/, and run keploy test in CI on every backend PR. If someone changes a response shape the app depends on, the test fails before it ships. Postgres and the payments API are served from mocks.yaml, so CI needs neither. Keploy does this at the network layer, with no SDK.
2. The Node service’s outbound fetch/axios, with Mockifyer (optional). If that Node API itself calls other HTTP APIs, you can also install Mockifyer in the service: record those fetch or axios calls, use per-client lanes, and inspect hops in the dashboard (per docs). This overlaps with Keploy’s HTTP mocks. Prefer Keploy when you also need database and queue mocks or generated API tests with no code changes. Prefer Mockifyer when you want an in-code library, lanes or multi-service request logging in that Node process.
3. The React Native app, with Mockifyer. In dev builds, record the app’s fetch calls once against the same backend. Commit mock-data/ with named scenarios (happy, empty-cart, payment-declined). Developers work offline against those scenarios, and Maestro or Detox launches the E2E build with scenario: "payment-declined" (per docs).
4. Keep them in step. When a Keploy test fails because the API changed on purpose, re-record both: Keploy’s tests and Mockifyer’s Node and app scenarios. To check formally that the app’s mocks still match the API, add contract tests (see our Pact guide).

Neither tool replaces the other here. Keploy can’t patch fetch inside the React Native app, and Mockifyer can’t mock the backend’s Postgres calls. On the Node service’s outbound HTTP, pick the one that matches the job, or use both for different purposes.

FAQ

Is Mockifyer a Keploy alternative?

Not really, except for one overlap. Keploy tests a backend service by recording its incoming requests and outgoing dependency calls (HTTP, databases, queues) at the network layer, with no SDK, and it generates API tests. Mockifyer is an in-code library that records and replays fetch and axios — in Node.js and in React Native. Both can record and replay outbound HTTP from a Node service. For that case Keploy needs no code changes, while Mockifyer needs setup code, and adds per-client lanes, a dashboard and multi-service logging (per docs). Mockifyer does not mock databases or queues, and Keploy does not patch fetch inside a React Native app.

Does Keploy work with React Native?

Keploy’s docs don’t cover React Native, and it doesn’t patch fetch inside a mobile app. You can still use it on the backend your app calls. For in-app mocking, see our React Native mocking guide.

Is Keploy free?

The core is open source (Apache-2.0). The hosted Playground plan is free, with monthly limits. Pro costs $19/user/month billed yearly ($24 billed monthly) plus usage. The open-source CLI (v3.6.229) recorded and replayed tests locally with no account. Keploy’s docs say the keploy.io installer and CI/cloud features need a free account.

Which databases can Keploy mock?

Keploy’s README lists Postgres, MySQL and MongoDB, plus Kafka and RabbitMQ for messaging. Its pricing table limits some of these by plan, and on native macOS or Windows only HTTP/HTTPS, MySQL and MongoDB replay reliably. Use Docker or Linux for the rest.

Related

• Keploy · Mockifyer · MSW · Nock · WireMock
• How to Mock APIs in React Native · Polly.js alternatives · MSW vs Nock vs Polly.js · Pact contract testing
• Record/replay and mocking tools in the catalog · Mocking & test data · Testing

Sources

All accessed 2026-11-10.

• Keploy README (eBPF, no SDK, databases and queues, quick start): https://github.com/keploy/keploy/blob/main/README.md
• Keploy GitHub repo and releases (Apache-2.0, stars, forks, v3.6.226–v3.6.229): https://github.com/keploy/keploy and https://github.com/keploy/keploy/releases
• How Keploy works (eBPF on Linux, user space on macOS/Windows, YAML): https://keploy.io/docs/keploy-explained/how-keploy-works/
• Installing Keploy (Apple Silicon only on macOS, kernel 5.10+, native protocol limits, launcher caveat): https://keploy.io/docs/server/installation/
• Keploy test and mock layout (keploy/test-set-0/…): https://keploy.io/docs/server/sdk-installation/
• Mock your own tests (keploy mock record/replay, platforms): https://keploy.io/docs/running-keploy/mock-your-tests/
• Keploy GitHub CI (account and KEPLOY_API_KEY, keploy/testgpt action): https://keploy.io/docs/ci-cd/github/
• Keploy API Test Recorder (Chrome extension): https://keploy.io/docs/running-keploy/api-testing-chrome-extension/
• Keploy pricing (plans, $19/$24, tier table, Enterprise features): https://keploy.io/pricing
• Mockifyer README (packages, Node and React Native entry points, env vars, client lanes, domain-path rules): https://github.com/sgedda/mockifyer
• Mockifyer React Native docs (setupMockifyerForReactNative, MOCKIFYER_MODE, Hybrid provider): https://github.com/sgedda/mockifyer/blob/main/REACT_NATIVE.md
• Mockifyer dashboard README (@sgedda/mockifyer-dashboard 1.5.93: hops, network request trace, X-Mockifyer-Request-Id): https://github.com/sgedda/mockifyer/blob/main/packages/mockifyer-dashboard/README.md
• npm registry: @sgedda/mockifyer-core 1.10.190, -fetch 1.8.106, -axios 1.10.35 (MIT); -mcp and -test-helper 404: https://registry.npmjs.org/@sgedda/mockifyer-core
• npm weekly downloads, @sgedda/mockifyer-core (2026-11-03 to 2026-11-09): https://api.npmjs.org/downloads/point/last-week/@sgedda/mockifyer-core