Faucet

Faucet: REST API and MCP server for any SQL database

Turn any SQL database into a secure REST API and MCP server. One binary. One command.

Faucet is an open-source (MIT) single Go binary that turns PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake or SQLite into a REST API and an MCP server for AI agents, with role-based access control (RBAC), OpenAPI 3.1 and a built-in admin UI.

Endpoints, OpenAPI specs and MCP tools are generated from your database schema at runtime. No code generation, no ORM, no boilerplate.

Website · Docs · Getting Started · Docker · MCP Server · Issues

What is Faucet?

Faucet is a database-to-REST-API gateway — a lightweight, self-hosted server that connects to your SQL databases, introspects the schema, and generates a full CRUD REST API with authentication, role-based access control (RBAC), and OpenAPI documentation. It also exposes an MCP server at /mcp so AI agents and AI app builders (Claude, ChatGPT, Cursor, VS Code, Windsurf, Base44, Replit) can query your data through the same roles and API keys.

Think of it as an open-source alternative to DreamFactory, PostgREST, or Hasura, with multi-database support, a built-in admin UI, and native AI agent integration, all in a single binary. See how it compares.

Use Cases

• Instant backend for apps — Skip writing CRUD APIs by hand. Point Faucet at your database and start building your frontend.
• AI agent data access — Give Claude, GPT, or any MCP-compatible agent governed, read/write access to your databases.
• Internal tools & dashboards — Generate APIs for internal databases without modifying existing infrastructure.
• Legacy database modernization — Put a REST API in front of SQL Server 2012, MySQL 5.7, or PostgreSQL 9.6 without code changes.
• Multi-database aggregation — Connect PostgreSQL, MySQL, SQL Server, Oracle, and more to a single Faucet instance and query them all through one API.
• Rapid prototyping — Go from empty database to working API in under 60 seconds.

How It Works

┌──────────────┐       ┌───────────────────────────────────────┐       ┌──────────────┐

│ PostgreSQL │ │ F A U C E T │ │ REST API │ │ MySQL │──────▶│ │──────▶│ /api/v1/* │ │ MariaDB │ SQL │ ┌─────────┐ ┌──────┐ ┌───────────┐ │ ├──────────────┤ │ SQL Server │◀──────│ │ Schema │ │ RBAC │ │ OpenAPI │ │──────▶│ OpenAPI 3.1 │ │ Oracle │ │ │ Intro- │ │ Auth │ │ Generator │ │ │ /openapi.json│ │ Snowflake │ │ │ spection│ │ │ │ │ │ ├──────────────┤ │ SQLite │ │ └─────────┘ └──────┘ └───────────┘ │──────▶│ MCP Server │ └──────────────┘ │ │ │ (AI Agents) │ │ ┌──────────────────────────────────┐ │ ├──────────────┤ │ │ Embedded Admin UI (Preact) │ │──────▶│ Admin UI │ │ └──────────────────────────────────┘ │ │ :8080/ │ └───────────────────────────────────────┘ └──────────────┘

Connect any SQL database → Faucet introspects the schema → Instantly generates REST endpoints, OpenAPI docs, MCP tools, and an Admin UI — all secured with API keys, JWT auth, and role-based permissions.

Screenshots

Connect a database with host, port, user and password. Faucet tests it before saving and tells you what to fix.

Browse tables, columns, keys and data, and lock your API contract against breaking schema changes.

Build requests with filters and pagination, then copy them as curl, JavaScript or Python.

Copy-ready MCP setup for Claude Code, Claude Desktop, Cursor, VS Code, Windsurf and ChatGPT.

See the Admin UI guide for a tour of every page.

Key Features

API Generation

• Full CRUD REST API — GET, POST, PUT, PATCH, DELETE with filtering, ordering, and pagination
• Schema introspection — Discovers tables, columns, types, and constraints at runtime
• Schema DDL — Create, alter, and drop tables via API
• Stored procedure calls — Execute stored procedures with typed parameters
• Human-readable query filters — (age > 21) AND (status = 'active')
• OpenAPI 3.1 spec — Auto-generated from live database schema at /openapi.json

Security & Access Control

• API key authentication — SHA-256 hashed keys with per-key role assignment
• JWT authentication — HMAC-SHA256 signed tokens for admin sessions
• Role-based access control (RBAC) — Per-table verb permissions (GET, POST, PUT, PATCH, DELETE)
• Row-level security filters — Filter expressions are stored per access rule and returned by the API; applying them to queries is planned and not enforced yet
• Schema contract locking — Lock your API contract against silent breaking schema changes with three modes (none, auto, strict), drift detection, and CLI management

AI Agent Integration (MCP)

• Built-in MCP server — 8 tools + 2 resources for Model Context Protocol, served at /mcp on the same port as the REST API
• Works with your AI tools — Copy-ready configs for Claude Code, Claude Desktop, Cursor, VS Code and Windsurf; ChatGPT via a Custom GPT Action on /openapi.json
• Streamable HTTP + stdio transport — API-key authenticated over the network, or stdio on your own machine
• Governed AI queries — AI agents respect the same RBAC rules as API clients

Developer Experience

• Single binary — Zero external dependencies, cross-platform (Linux, macOS, Windows)
• Embedded admin UI — connect databases with host, port, user and password (no connection strings), test before saving, browse schemas and data, build roles and keys, and copy ready-made MCP configs for Claude, Cursor, VS Code and more. Works offline; light and dark themes
• SQLite config store — All configuration stored locally, no external database required
• npm + Homebrew + Docker — Install in seconds on any platform (npx @faucetdb/faucet)
• Health endpoints — /healthz and /readyz for Kubernetes-style probes

Supported Databases

Connector details, SSL options and driver notes: Database connectors.

60-Second Quickstart

Install

npm (Node.js 18+):

npx @faucetdb/faucet serve

Homebrew (macOS / Linux):

brew install faucetdb/tap/faucet

Docker:

docker run -p 8080:8080 -v faucet-data:/data faucetdb/faucet

Go:

go install github.com/faucetdb/faucet/cmd/faucet@latest

Binary download: See GitHub Releases for pre-built binaries (Linux, macOS, Windows).

Run

faucet serve

Open http://localhost:8080. The setup wizard creates your admin account and connects your first database: pick the engine, enter host, port, username and password, click Test connection, and save. Every table gets REST endpoints at /api/v1/ /_table/ and MCP tools right away. Then create a role on the Roles page and an API key on the API keys page, which hands you a ready-to-run curl command and an MCP setup command that already contain the new key.

Prefer the terminal? The same steps with the CLI:

# Create an admin account and add a database (no connection string needed)

faucet admin create --email admin@example.com --password changeme123 faucet db add --name mydb --driver postgres \ --host localhost --user app --password 's3cret@!' --database mydb

Create a role that can read every database, then an API key bound to it

faucet role create --name default --verbs GET faucet key create --role default

Start the server (it loads databases on startup), then query your data

faucet serve curl -H "X-API-Key: faucet_YOUR_KEY_HERE" "http://localhost:8080/api/v1/mydb/_table/users?limit=10"

--dsn still works if you already have a connection string. A running server picks up databases added through the admin UI or API immediately; databases added with faucet db add are loaded the next time the server starts.

MCP Server for AI Agents

Faucet includes a built-in Model Context Protocol (MCP) serv