Faucet vs Hasura
Both turn databases into APIs. Hasura leads with GraphQL. Faucet gives you REST + MCP for seven databases from one MIT-licensed binary, so your apps and AI agents can use your data without a platform to run.
TL;DR
Pick Hasura if your frontend speaks GraphQL, you need GraphQL subscriptions, or you want row- and column-level permission rules. It has a polished console and a large ecosystem.
Pick Faucet if you want REST (with an OpenAPI 3.1 spec), need more than PostgreSQL (MySQL, MariaDB, SQL Server, Oracle, SQLite, Snowflake), want one binary you can run anywhere without Docker, or want AI agents to reach your data over MCP. Everything is MIT-licensed, with no feature gates.
Key differences
The design choices that set the two apart.
REST vs GraphQL
Hasura generates a GraphQL API, with optional REST wrappers you define. Faucet generates REST endpoints for every table, plus an OpenAPI 3.1 spec that tools like Postman, SDK generators and Custom GPT Actions can import.
How you run it
Hasura usually runs as a Docker container, with its own metadata database, or on Hasura Cloud. Faucet is a single static binary: start it with npx @faucetdb/faucet serve and you're done. Docker is optional.
License
Hasura's v2 engine is Apache 2.0, and some features are in its enterprise edition. Faucet is MIT-licensed: every feature ships in the open-source binary, with no open-core split.
Database support
Hasura is PostgreSQL-first, with other databases via Hasura data connectors. Faucet has seven built-in drivers: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, and Snowflake. Connect several to one instance.
AI agents
Faucet includes an MCP server with 8 tools, over stdio (faucet mcp) or Streamable HTTP at /mcp. Claude Desktop, Claude Code, Cursor and any MCP client can connect, scoped by the same roles as your REST API.
Footprint
Faucet runs as one process with an embedded SQLite config store. You don't need a container runtime, a separate metadata database, or anything else to install.
Try it on your own database
npx @faucetdb/faucet serve Feature-by-feature comparison
Including where Hasura is ahead.
| Feature | Faucet | Hasura |
|---|---|---|
| API type | REST with OpenAPI 3.1, plus MCP | GraphQL (REST via RESTified endpoints) |
| Databases | 7: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, Snowflake | PostgreSQL-first; other databases via Hasura data connectors |
| Deployment | Single static binary (Linux, macOS, Windows); Docker optional | Docker container or Hasura Cloud |
| License | MIT, no feature gates | Apache 2.0 (v2 engine); some features enterprise-only |
| MCP server | Built in: 8 tools, stdio + Streamable HTTP (/mcp) | Not built into the open-source v2 engine |
| Access control | Built in: roles with per-service / per-table verb permissions; API keys bound to roles; fail-closed | Role-based permission rules, including row- and column-level |
| Row / column rules | No. Permissions are per service and per table; use database views for finer slices | Yes |
| Authentication | API keys (SHA-256 hashed) bound to roles; admin JWT for the UI and admin API | JWT or auth webhook; admin secret |
| Real-time | No subscriptions; large reads can stream as NDJSON | GraphQL subscriptions over WebSocket |
| Schema | Introspected live; schema contract locking with drift detection | Metadata-driven, with a migrations system |
| API docs | OpenAPI 3.1, generated per service and combined at /openapi.json | GraphQL introspection |
| Admin UI | Embedded in the binary | Hasura Console |
| Written in | Go (no CGO) | Haskell (v2); Rust (v3) |
When to use each
When to use Hasura
Hasura is a mature tool with a big ecosystem. It's the right call when:
- Your frontend is built around GraphQL (Apollo, Relay, urql)
- You need GraphQL subscriptions for live dashboards or collaborative apps
- You want row- and column-level permission rules in the API layer
- Your data is in PostgreSQL and you're happy running Docker or Hasura Cloud
- You want a large community with lots of guides and integrations
When to use Faucet
Faucet is for developers who want an API on their data now, with nothing extra to run:
- You want REST + OpenAPI 3.1 for backends, mobile apps, webhooks and app builders
- Your data is in MySQL, MariaDB, SQL Server, Oracle, SQLite or Snowflake, or several at once
- You want one binary: no Docker, no metadata database, no orchestration
- You want AI agents (Claude, Cursor, any MCP client) to query your data with read-only keys
- You want MIT software with every feature included
Frequently asked questions
What is the main difference between Faucet and Hasura?
Faucet gives you a REST API and an MCP server; Hasura gives you a GraphQL API. Faucet is a single MIT-licensed binary that serves seven databases: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite, and Snowflake. Hasura is PostgreSQL-first, reaches other databases through Hasura data connectors, and usually runs as a Docker container or on Hasura Cloud.
Does Faucet support GraphQL?
No. Faucet is REST + MCP. Every table gets REST endpoints described by an OpenAPI 3.1 spec, and AI agents get a built-in MCP server. If your frontend is built around GraphQL, Hasura is the better fit.
Can Hasura generate REST APIs?
Partly. Hasura can expose RESTified endpoints, which wrap GraphQL queries you write yourself. Faucet generates REST endpoints for every table automatically, with filtering, pagination, batch writes and an OpenAPI 3.1 spec at /openapi.json.
Is Faucet really free?
Yes. Faucet is MIT-licensed and every feature ships in the open-source binary: all seven database connectors, role-based access, the MCP server and the admin UI. A hosted Faucet Cloud is planned; self-hosting stays free.
How do AI agents connect to Faucet?
Through MCP. Faucet ships an MCP server with 8 tools (list services, list tables, describe table, query, insert, update, delete and raw SQL). Run faucet mcp for stdio, or point any MCP client at http://localhost:8080/mcp with an API key. Claude Desktop, Claude Code and Cursor connect directly.
Can I run Faucet without Docker?
Yes. Faucet is a single static binary for Linux, macOS and Windows with no CGO and no external dependencies. Install it with npx, Homebrew, Go or the install script, or use the faucetdb/faucet Docker image if you prefer containers.
Turn on your data in 60 seconds
Free, MIT-licensed, no account needed.
# 1. Start Faucet (or: brew install faucetdb/tap/faucet && faucet serve)
npx @faucetdb/faucet serve
# 2. Connect a database
npx @faucetdb/faucet db add --name mydb --driver postgres --dsn "postgres://user:pass@localhost:5432/mydb?sslmode=disable"
# 3. Create a read-only role and an API key
npx @faucetdb/faucet role create --name reader --verbs GET
npx @faucetdb/faucet key create --role reader
# 4. Query it
curl -H "X-API-Key: faucet_YOUR_KEY" "http://localhost:8080/api/v1/mydb/_table/users?limit=10"Hasura is a trademark of its respective owner. Based on public documentation as of October 2026. Spot something out of date? Open an issue.