Faucet vs PostgREST

Q: How do I migrate from PostgREST to Faucet?

Run faucet serve, then faucet db add --name mydb --driver postgres --dsn "postgres://...", create a role and API key, and your tables and stored procedures are served at /api/v1/mydb/_table/... and /_proc/.... Your database doesn't change. The filter syntax does: Faucet uses filter=status = 'active' where PostgREST uses status=eq.active.

Both turn a SQL database into a REST API. PostgREST is a mature, PostgreSQL-native server. Faucet does it for seven databases and adds API keys, roles, an admin UI and a built-in MCP server for AI agents.

See the comparison Star on GitHub

TL;DR

PostgREST is the original database-to-REST server: PostgreSQL only, 10+ years in production, and the engine behind Supabase's REST API. If you're all-in on Postgres and manage access with roles and RLS, it's excellent.

Faucet is for when you need more: seven databases (PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, Snowflake), API keys and roles that live outside the database, an embedded admin UI, OpenAPI 3.1, and an MCP server so AI agents can use your data.

Feature by feature

Detailed comparison

Including where PostgREST is ahead.

Feature comparison of Faucet and PostgREST
Feature	Faucet	PostgREST
Databases	7: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, Snowflake	PostgreSQL only
Deployment	Single static binary (Linux, macOS, Windows), Docker, npm, Homebrew	Single binary, Docker
Written in	Go (no CGO)	Haskell
License	MIT	MIT
Admin UI	Embedded in the binary	None
Authentication	API keys (SHA-256 hashed) bound to roles; admin JWT for the UI	External JWT mapped to PostgreSQL roles
Access control	Built in: roles with per-service / per-table verb permissions; API keys bound to roles; fail-closed	PostgreSQL roles and row-level security
MCP server	Built in: 8 tools, stdio + Streamable HTTP (/mcp)	No
OpenAPI	OpenAPI 3.1, per service and combined at /openapi.json	OpenAPI 2.0 (Swagger)
Stored procedures	PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake via /_proc (SQLite has none)	PostgreSQL functions via /rpc
DDL via API	Create, alter and drop tables via /_schema	No (use migrations)
Schema	Introspected live; schema contract locking with drift detection	Schema cache, reloaded on demand
Maturity	Young and moving fast (v0.1.13)	10+ years in production

Credit where due

When to use PostgREST

PostgREST is a great tool. It's the better pick when:

You only use PostgreSQL

If everything runs on Postgres and always will, PostgREST's deep integration is a real advantage. It uses roles, RLS and functions directly, with no abstraction layer in between.

You want a decade of track record

PostgREST has been in production for over ten years and powers Supabase's REST API. If a long track record and a big community matter most, it delivers.

You rely on row-level security

PostgREST's authorization is PostgreSQL's own roles and RLS. If you've invested in RLS policies, PostgREST reuses that work with no separate auth layer.

You want the thinnest possible layer

PostgREST hands almost everything to the database engine, so there's very little between your HTTP request and Postgres.

Why Faucet

When to use Faucet

Faucet is the better fit when you need more than one database, or more than a bare API.

More than one database

Connect PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, and Snowflake to one Faucet instance. One binary, one REST API, one MCP server.

Auth without SQL grants

Roles and API keys live in Faucet, not in database grants. Give each app or agent its own key with exactly the tables and verbs it needs. Anything not granted is denied.

AI agents over MCP

The built-in MCP server lets Claude Desktop, Claude Code, Cursor and other MCP clients list tables, describe schemas and run queries. Hand agents a read-only key and they can look but not touch.

An admin UI in the box

Connect databases, manage roles and keys, and browse data from a web UI built into the binary. No pgAdmin, no SQL grants, no custom dashboard.

OpenAPI 3.1 out of the box

Every connected database gets an OpenAPI 3.1 spec. Import it into Postman, generate client SDKs, or hand /openapi.json to an app builder or a Custom GPT Action.

Schema changes via the API

Create, alter and drop tables via /_schema, then lock the schema contract so Faucet flags drift before it breaks your clients.

Migration

Switching from PostgREST to Faucet

Your PostgreSQL database stays exactly as it is. Four steps, a couple of minutes.

1
Point Faucet at your Postgres
```
faucet db add --name mydb --driver postgres --dsn "postgres://user:pass@localhost:5432/mydb"
faucet serve
```
Install with brew install faucetdb/tap/faucet, or prefix each command with npx @faucetdb/faucet. Faucet introspects your schema; nothing in the database changes.
2
Create a role and an API key
```
faucet role create --name readonly --verbs GET
faucet key create --role readonly
```
Auth is always on. There's nothing to enable. Keys without a matching role rule are denied.
3
Add another database (optional)
```
faucet db add --name app --driver mysql --dsn "user:pass@tcp(localhost:3306)/app"
faucet stop && faucet serve
```
Now PostgreSQL and MySQL sit behind one REST API and one MCP server. PostgREST can’t do that.
4
Query it
```
curl -H "X-API-Key: faucet_YOUR_KEY" "http://localhost:8080/api/v1/mydb/_table/users?limit=10"
```
Filters use filter=status = 'active' (DreamFactory-compatible), plus order, limit, offset and fields.

Try it on your own database

npx @faucetdb/faucet serve

Star on GitHub Quick start

Frequently asked questions

What is the main difference between Faucet and PostgREST?

PostgREST serves PostgreSQL only and relies on Postgres roles and row-level security for access control. Faucet serves seven databases (PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, and Snowflake) and adds built-in roles and API keys, an embedded admin UI, and an MCP server for AI agents.

Can Faucet replace PostgREST?

For most REST use cases, yes. Faucet covers table CRUD, filtering, pagination, batch writes and stored procedure calls, and adds more databases, built-in auth, an admin UI and MCP. Two differences to plan for: the filter syntax is different, and Faucet's permissions are set per service and per table rather than through Postgres row-level security.

Is PostgREST better than Faucet for PostgreSQL-only projects?

It can be. PostgREST has a decade of production use and builds directly on PostgreSQL roles and row-level security. If you're all-in on Postgres and already manage access in the database, it's a great choice. Pick Faucet if you need other databases, API keys and roles without SQL grants, an admin UI, or MCP for AI agents.

Does PostgREST have an admin UI?

No. PostgREST is a headless API server. Faucet ships an admin UI inside the binary where you connect databases, manage roles and keys, and browse data.

Does PostgREST support MCP for AI agents?

Not natively. Faucet has a built-in MCP server with 8 tools, served over stdio (faucet mcp) or Streamable HTTP at /mcp, so Claude Desktop, Claude Code, Cursor and other MCP clients can query your database. Over HTTP, every call is limited by the API key's role.

How do I migrate from PostgREST to Faucet?

Run faucet serve, then faucet db add --name mydb --driver postgres --dsn "postgres://...", create a role and API key, and your tables and stored procedures are served at /api/v1/mydb/_table/... and /_proc/.... Your database doesn't change. The filter syntax does: Faucet uses filter=status = 'active' where PostgREST uses status=eq.active.

Turn on your data in 60 seconds

Free, MIT-licensed, no account needed.