verifo

Verifo

250+ service emulators on local Docker — Stripe, Postgres, Slack, S3, OpenAI and more, speaking real wire protocols.

A verification layer for AI coding agents (and a "mock everything locally" tool for everyone else).

SERVICES="postgres,redis,stripe,openai,slack" docker compose up

That's it. Five real services are now listening on localhost — Postgres on 5432, Redis on 6379, Stripe on 4757, and so on. Point your app at them with unmodified real drivers and run your code. No accounts, no API keys, no cost, no side effects.

Why

Code that talks to databases, payment APIs, queues and SaaS needs testing. Today you either:

• Mock everything — fast, but mocks lie and miss real bugs.
• Use the real services — accurate, but slow, costs money, needs secrets, and has side effects (real charges, real emails).

Verifo is the third option: real wire protocols, in-memory, instant, free. The Postgres emulator speaks the actual Postgres protocol — psycopg/pg connect unmodified. The Stripe emulator speaks the real Stripe REST API — stripe-node works as-is. Your code is identical to production; only the endpoint changes.

This is especially useful for AI coding agents: an agent can spin up exactly the services its code touches, run it, assert, and tear down — all locally, all free, with zero risk to production.

Quick start

With the CLI (zero install):

npx verifo up postgres redis stripe   # start (foreground)
npx verifo up stripe -d               # or detached
npx verifo status                     # what's running
npx verifo ls payments                # browse the catalog by category
npx verifo reset                      # wipe all state between tests
npx verifo down                       # stop the detached fleet

See docs/cli.md for every command.

With Docker (collision-safe):

git clone https://github.com/dksingh1997/verifo && cd verifo
npm install   # one-time, for the launcher

# start just what you need
SERVICES="postgres,redis,stripe" npm run up

# or everything
SERVICES=all npm run up

npm run up publishes only the ports for the services you ask for, and if a port is already taken on your machine (a local Postgres on 5432, say) it remaps that one service to a free port and tells you which one:

parlel: 1 host port(s) were busy — remapped to free ports:
  • postgres: connect on localhost:15000 (container 5432)

Plain docker compose up also works if you'd rather — see docker-compose.yml.

With plain docker run:

docker build -t verifo .
docker run -p 5432:5432 -p 4757:4757 -e SERVICES="postgres,stripe" verifo

Without Docker (pure Node, no install needed):

SERVICES="postgres,redis,stripe" node src/launch.mjs

Then use the services with your normal drivers:

import psycopg, redis, stripe

db    = psycopg.connect("postgres://parlel:parlel@localhost:5432/parlel")
cache = redis.Redis(host="localhost", port=6379)
stripe.api_base = "http://localhost:4757"
stripe.api_key  = "sk_test_parlel"

import pg from "pg";
import Stripe from "stripe";

const db = new pg.Client("postgres://parlel:parlel@localhost:5432/parlel");
const stripe = new Stripe("sk_test_parlel", { host: "localhost", port: 4757, protocol: "http" });

See examples/ for a runnable end-to-end flow, and .env.example for every service's port + seeded test credentials.

What's included

250+ services across these categories:

TCP services (real wire protocols, reached with native drivers): Postgres, Redis, MySQL, MongoDB, Kafka, RabbitMQ, Cassandra. Everything else is HTTP.

See .env.example for all 250 services with their ports and seeded credentials, and docs/ for a per-service API reference.

Real protocols, not stubs

Each emulator implements the actual wire protocol or REST contract, verified against the real client libraries. The test suite connects with pg, redis, mysql2, mongodb, kafkajs, amqplib, cassandra-driver, the AWS SDK, Stripe, and more — and asserts real round-trips.

npm install      # dev deps: the real driver libraries + vitest
npm test         # per-service fidelity tests
npm run probe    # boot a set and health-check every service

Configuration

• SERVICES — comma-separated slugs, or all. Defaults to postgres,redis.
• Ports — each service uses its canonical port (see .env.example).
• Credentials — seeded test values (e.g. sk_test_parlel); any non-empty value is accepted, so you rarely need to change them.

Control plane

Alongside the emulators, Verifo runs an additive admin server on localhost:4600. Open it in a browser for a live dashboard — every running service, its connection string, the request log, a state inspector, and reset buttons, auto-refreshing every 2 seconds.

You can also drive it programmatically. List what's running, inspect state, and — most usefully — reset every service to a clean slate between tests without restarting anything:

beforeEach(() => fetch("http://127.0.0.1:4600/reset", { method: "POST" }));

GET /services returns each service's port and a ready-to-use connection string. You can also inspect the request log (GET /services/:slug/requests — "did my code call the API the way I think it did?") and preload fixtures (POST /services/:slug/seed, or a parlel.fixtures.json loaded on boot). See docs/control-plane.md. Disable with PARLEL_CONTROL=0.

How it works

your app / agent  ──▶  localhost:<port>  ──▶  in-memory emulator (real protocol)
   (unchanged)         (no bridge, no proxy)      (ephemeral, zero side effects)

Each emulator is dependency-free Node holding state in memory. State is ephemeral — restart for a clean slate. No data ever leaves your machine.

Everything runs locally, so the official client libraries connect directly — psycopg/pg to localhost:5432, kafkajs to localhost:9092, redis to localhost:6379, and so on. There is no proxy, no bridge, and no shim: the TCP services (Postgres, MySQL, MongoDB, Kafka, RabbitMQ, Cassandra, Redis) speak their real wire protocols straight to the port. (Kafka advertises localhost:9092 in its metadata, so kafkajs reconnects land on the emulator.)

Add a service

Adding an emulator is a manifest + a server.js + a test. See CONTRIBUTING.md — it takes about five minutes.

For AI agents

Verifo ships an MCP server so agents can drive the emulators by tool call — start services, run code against them, then read the request log to verify what the code actually did:

npx verifo-mcp

See AGENTS.md for the agent workflow and docs/mcp.md for client setup (Claude Desktop, Cursor, …).

Roadmap

• MCP server so agents can drive services by tool call. ✅ Shipped — see docs/mcp.md.
• Record / replay against real upstreams.
• More services (open an issue to request one).

License

MIT.