Is Keploy an alternative to Mox?

For integration tests, yes. Mox needs a behaviour defined in production code and an expectation written per call. Keploy captures outside the process, so neither exists — and the recorded response comes from the dependency rather than from a developer.

Do I still need the Ecto sandbox with Keploy?

Not for replay. Keploy records the SQL Ecto emitted and the rows it received, so replay opens no connection and needs no transaction. Keep the sandbox for tests that must exercise real database behaviour.

Is Keploy a Bypass alternative?

Yes. Bypass runs a Plug you write, so it cannot notice upstream drift. Keploy records the real Finch or Tesla response at the socket layer and replays it, so re-recording refreshes every mock at once.

Does Keploy work with Phoenix?

Yes. Capture happens at the socket rather than inside the Plug pipeline, so router matching, plugs, and controller actions all execute on every recorded request and are exercised again on replay.

Is Keploy free for Elixir projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any Elixir service with no seat limits. It is not a Hex package, so it never appears in mix.exs.

Keploy as a Elixir testing framework

Keploy tests Elixir services by recording real HTTP and Ecto traffic from a running BEAM process, then replaying it as assertions. There are no Mox behaviours to define, no Bypass server to start, and no Ecto sandbox transaction per test.

Generate Elixir tests free

keploy record -c "mix phx.server"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Elixir team

Any Elixir service, unchanged

Keploy runs the app through mix or a release. Phoenix, Plug, and bare Cowboy services record the same way, because capture is at the socket rather than inside the Plug pipeline.

Elixir 1.14 and above
mix phx.server or a release
Phoenix, Plug, and Cowboy
Umbrella apps included

Try Keploy for free Explore the docs

The problem

Why Elixir 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 Elixir: by hand, with ExUnit + Mox, or with Keploy

Mox needs a behaviour to define against and Bypass needs a Plug you write. Keploy captures outside the process, so neither the behaviour nor the stub server has to exist.

By hand

ExUnit + Mox

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Elixir 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

order_service_test.exs

hand-written

# Hand-written: a stub module matching a behaviour.

defmodule Acme.StubRepo do

@behaviour Acme.OrderRepo

@impl true

def get(id), do: {:ok, %Acme.Order{id: id, amount_minor: 4200, state: "NEW"}}

end

defmodule Acme.OrderServiceTest do

use ExUnit.Case, async: true

test "confirms an authorized order" do

assert {:ok, order} =

Acme.OrderService.confirm(Acme.StubRepo, "ord_1", "tok_123")

assert order.state == "CONFIRMED"

end

The behaviour exists so this stub can satisfy it. Nothing checks that its return shape still matches what Postgres and Stripe actually send.

ExUnit + Mox1–2 hours

order_controller_test.exs

tool-assisted

# ExUnit + Mox + Bypass + the Ecto sandbox.

defmodule AcmeWeb.OrderControllerTest do

use AcmeWeb.ConnCase, async: true

import Mox

setup :verify_on_exit!

test "confirms an authorized order", %{conn: conn} do

insert(:order, id: "ord_1", amount_minor: 4200)

# A literal that will not change when Stripe does.

expect(Acme.PaymentsMock, :authorize, fn "tok_123" ->

{:ok, %{"status" => "AUTHORIZED"}}

end)

conn = post(conn, ~p"/orders/ord_1/confirm", payment_token: "tok_123")

assert json_response(conn, 200)["state"] == "CONFIRMED"

end

Idiomatic and concurrency-safe — and it needs a behaviour, a mock module, a migrated database, and a Stripe body typed out by hand.

With Keploy~5 minutes

test-1.yaml

auto-generated

# Recorded with: keploy record -c 'mix phx.server'

# Nobody wrote this file. Keploy captured it from a real request.

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 SQL Ecto emitted and Stripe's real response are both recorded, so no behaviour had to be introduced and no sandbox transaction was needed.

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

Explore the docs Request a trial

Keploy vs the alternatives

Elixir testing tools, compared

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

Keploy

ExUnit + Mox

Bypass

Ecto SQL Sandbox

ExVCR

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 Elixir app once, replay it forever

Keploy sits below your Elixir 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 Elixir appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres frontend/backend protocol

MySQLMySQL wire protocol

RedisRESP over TCP

Apache KafkaKafka producer and consumer protocol

Outbound HTTPAny HTTP client call the service makes

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 Elixir, with zero config

5 of the 5 dependencies a typical Elixir 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
RedisView page
RESP over TCP
Auto-mocked
Apache KafkaView page
Kafka producer and consumer protocol
Outbound HTTP
Auto-mocked
Outbound HTTP
Any HTTP client call the service makes

Explore the docs Book a call

Quick start

Your first Elixir test suite in under five minutes

Every command below runs against your existing Elixir 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 "mix phx.server"
3
3Exercise the paths you care about
Drive the running server. Every request becomes a test case with its Ecto queries and HTTP calls captured alongside.
curl -X POST localhost:4000/orders/ord_1/confirm -H 'Content-Type: application/json' -d '{"payment_token":"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 "mix phx.server" --delay 12