# Faucet vs PostgREST: Multi-Database REST + MCP

> PostgREST serves PostgreSQL only. Faucet serves 7 databases as REST + MCP, with API keys, roles and an admin UI built in. Compare features and migration.

Source: https://faucetdb.ai/alternatives/faucet-vs-postgrest/

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.

Last reviewed October 9, 2026 · [Sources](https://faucetdb.ai/alternatives/faucet-vs-postgrest/#sources)

[Star on GitHub](https://github.com/faucetdb/faucet)

## 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.

Weighing more than these two? Our [PostgREST alternatives roundup](https://faucetdb.ai/blog/postgrest-alternatives/) compares nine REST, GraphQL and MCP options.

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: connect with plain fields and Test connection, schema browser, API explorer, roles and keys, copy-ready MCP configs | 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 at /mcp, scoped by API key (stdio for local use); configs for Claude, Cursor, VS Code and Windsurf | 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.14) | **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](https://github.com/faucetdb/faucet) [Quick start](https://wiki.faucetdb.ai/getting-started)

## 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 at `/mcp` on the same port as the REST API, so Claude Code, Claude Desktop (via mcp-remote), Cursor, VS Code, Windsurf and other MCP clients can query your database. Every call is limited by the API key's role.

### How do I migrate from PostgREST to Faucet?

Add the database with `faucet db add --name mydb --driver postgres --dsn "postgres://..."` (or in the admin UI), create a role and API key, run `faucet serve`, 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.

`npx @faucetdb/faucet serve`

or `brew install faucetdb/tap/faucet`

[Star on GitHub](https://github.com/faucetdb/faucet) [Quick start](https://wiki.faucetdb.ai/getting-started)

## Sources

Competitor facts were checked against these on October 9, 2026. Faucet facts come from the [Faucet source](https://github.com/faucetdb/faucet) and [docs](https://wiki.faucetdb.ai/).

- [PostgREST on GitHub](https://github.com/PostgREST/postgrest)
- [PostgREST license (MIT)](https://github.com/PostgREST/postgrest/blob/main/LICENSE)
- [PostgREST OpenAPI docs](https://docs.postgrest.org/en/stable/references/api/openapi.html)

PostgREST is a trademark of its respective owners. Based on public documentation, last reviewed October 2026. Spot something out of date? [Open an issue](https://github.com/faucetdb/faucet/issues).
