Does Keploy replace Jest for TypeScript?

No. Keploy replaces the integration layer, where typed factories and interceptors are costly to maintain. Keep Jest for unit tests of individual modules — Keploy generates the API-level regression suite from real traffic alongside it.

Do I need ts-jest to use Keploy?

No. Keploy records the compiled process rather than your source, so there is no transform, loader, or tsconfig-tracking configuration involved. Build as you already do and hand the output to Keploy.

Can Keploy catch bugs my types cannot?

Yes, and that is the point of the pairing. The compiler checks that a mock has the right shape; it never sees the value the dependency actually sends. Keploy records that value, so a structurally valid but wrong response fails.

Does Keploy work with Prisma and Drizzle?

Yes, and identically. Capture happens at the database wire protocol beneath the client, so Prisma, Drizzle, node-postgres, and mysql2 all replay with the exact rows they received.

Is Keploy free for TypeScript projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any service with no seat limits. It is not an npm package, so it never appears in package.json or your lockfile.

Keploy as a TypeScript testing framework

Keploy tests TypeScript services by recording the compiled process at the network layer, then replaying real requests and dependency responses as assertions. Because nothing inside the process is substituted, there are no typed mock factories to maintain and no casts to satisfy a partial double.

Generate TypeScript tests free

keploy record -c "node dist/server.js"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a TypeScript team

Any TypeScript service, unchanged

Keploy records the compiled process, so the type system is invisible to capture. Express, Fastify, NestJS, Hono, and tRPC all record identically, whether you build with tsc, esbuild, or tsx.

TypeScript 4.5 and above
tsc, esbuild, swc, or tsx
CommonJS and ESM output
Decorators and strict mode alike

Try Keploy for free Explore the docs

The problem

Why TypeScript integration tests slow teams down

The friction is rarely the assertions. It is everything around them — spinning up dependencies, keeping mocks honest, and repairing tests after every refactor.

Book a call Explore the docs

Three ways to do it

Testing TypeScript: by hand, with Jest + typed mocks, or with Keploy

A typed mock is checked for shape and never for content, so a structurally valid wrong response passes. Keploy records what the dependency actually sent, which is the half the compiler cannot see.

By hand

Jest + typed mocks

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for TypeScript vs what Keploy records

All three produce the same assertion. Only the third still passes after the next refactor without anyone editing it.

By hand2–4 hours

orders.service.test.ts

hand-written

// Hand-written: a typed double that must satisfy the interface.

import type { OrderRepo, Payments } from '../src/ports';

const repo: OrderRepo = {

byId: async (id) => ({ id, amountMinor: 4200, state: 'NEW' }),

save: async (o) => o,

// Added to OrderRepo last sprint. Forgotten here.

countByState: async () => 0,

};

const payments = { authorize: async () => ({ status: 'AUTHORIZED' }) } as Payments;

it('confirms an authorized order', async () => {

const result = await confirmOrder(repo, payments, 'ord_1', 'tok_123');

expect(result.state).toBe('CONFIRMED');

});

The cast on payments is the tell: the double does not fully implement the interface, so the type safety that justified the interface is switched off exactly where it mattered.

Jest + typed mocks1–2 hours

orders.route.test.ts

tool-assisted

// Jest + typed factories + nock.

import nock from 'nock';

import request from 'supertest';

import { makeOrderRepo } from './factories';

it('confirms an authorized order', async () => {

// Structurally valid. Says nothing about what Stripe sends.

nock('https://api.payments.example.com')

.post('/v1/payment_intents/tok_123/confirm')

.reply(200, { status: 'AUTHORIZED' });

const app = buildApp({ repo: makeOrderRepo({ amountMinor: 4200 }) });

const res = await request(app)

.post('/orders/ord_1/confirm')

.send({ paymentToken: 'tok_123' });

expect(res.status).toBe(200);

});

The factory keeps the compiler happy and the Stripe body is still a literal — typed against your own interface, not against Stripe's contract.

With Keploy~5 minutes

test-1.yaml

auto-generated

# Recorded with: keploy record -c 'node dist/server.js'

# No factories, no casts, no transform config.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

body: '{"paymentToken":"tok_123"}'

resp:

status_code: 200

body:

id: "ord_1"

state: "CONFIRMED"

amountMinor: 4200

noise:

- body.confirmedAt

mocks:

- kind: Postgres

operation: "SELECT id, amount_minor, state FROM orders WHERE id = $1"

- kind: Http

url: https://api.payments.example.com/v1/payment_intents/tok_123/confirm

The recorded body is Stripe's actual response, so a field your types do not model yet is still captured — and appears the day your code starts reading it.

Times are estimates for authoring one endpoint’s coverage from scratch, not measurements.

Explore the docs Request a trial

Keploy vs the alternatives

TypeScript testing tools, compared

The options a team on Node.js actually reaches for, and where each one genuinely wins. Select a row for the full comparison.

Keploy

Jest + supertest

nock

Mocha + Sinon

Mock Service Worker

Postman

SmartBear ReadyAPI

Best in classStrongPartialNot covered

Assessments reflect each tool’s documented behaviour, not benchmark measurements.

Request a trial Book a call

How it works

Record your TypeScript app once, replay it forever

Keploy sits below your TypeScript process at the network layer. It watches the calls your app already makes, then serves them back on replay so tests run with no dependencies attached.

Your TypeScript appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres frontend/backend protocol

MySQLMySQL wire protocol

MongoDBMongoDB wire protocol

RedisRESP over TCP

+3 more TypeScript dependencies

An example shape of a captured call. Your own endpoints and dependencies come from your real traffic, so nothing here has to be written by hand.

Try Keploy for free Request a trial

Mock coverage

What Keploy mocks for TypeScript, with zero config

7 of the 7 dependencies a typical TypeScript service talks to are stubbed from the recording itself — no mock classes, no fixture files, no containers in CI.

Auto-mocked
PostgreSQLView page
Postgres frontend/backend protocol
Auto-mocked
MySQLView page
MySQL wire protocol
Auto-mocked
MongoDBView page
MongoDB wire protocol
Auto-mocked
RedisView page
RESP over TCP
Auto-mocked
Apache KafkaView page
Kafka producer and consumer protocol
Auto-mocked
gRPCView page
HTTP/2 framed gRPC calls
Outbound HTTP
Auto-mocked
Outbound HTTP
Any HTTP client call the service makes

Explore the docs Book a call

Quick start

Your first TypeScript test suite in under five minutes

Every command below runs against your existing TypeScript service. Nothing in your source tree changes.

1
1Install the Keploy CLI
A single binary. It needs a Linux kernel with eBPF support, or Docker on macOS and Windows — and it adds nothing to your project's dependencies.
curl -sSL https://keploy.io/install.sh | bash
2
2Record your service
Pass the command you already use to start the app. Keploy runs it and watches every socket it opens.
keploy record -c "node dist/server.js"
3
3Exercise the paths you care about
Build as normal, then drive the compiled process. Every request becomes a test case with its database and HTTP calls captured alongside.
npm run build
curl -X POST localhost:3000/orders/ord_1/confirm -H 'Content-Type: application/json' -d '{"paymentToken":"tok_123"}'
4
4Replay in CI
Replay serves the recorded dependency responses, so the job needs no service containers and no Docker daemon.
keploy test -c "node dist/server.js" --delay 8