Key takeaways
- Keep PostgREST if you are Postgres-only and already model access with database roles and row-level security. Most alternatives exist because a team needs something PostgREST deliberately doesn't do.
- Closest swaps on Postgres: pREST (self-hosted Go binary, now also MySQL 8) and the managed, PostgREST-compatible Data APIs from Supabase and Neon.
- Want GraphQL instead? PostGraphile keeps the Postgres-roles model; Hasura adds more data sources and a commercial cloud (DDN).
- Need MySQL, SQL Server or Oracle? pREST (MySQL 8), Data API builder (SQL Server, MySQL), Directus and Hasura cover several engines; Faucet adds Snowflake and SQLite in one MIT binary; DreamFactory covers them in paid editions.
- AI agents: pREST (read-only), Faucet, Data API builder, Directus and DreamFactory ship MCP servers that use their API's access rules. Supabase and Neon offer separate platform MCP servers, and Hasura has one for PromptQL. PostgREST has none. Read our analysis of a Postgres MCP read-only bypass before connecting one.
- Licenses: Directus has been source-available since v10 (BSL 1.1); v12 (2026) moved it to the Monospace Sustainable Core License, and each version converts to GPLv3 after four years.
PostgREST is still one of the best ways to put a REST API on Postgres. These are the nine tools to look at when you need a different database, GraphQL, a managed service, or an MCP server for AI agents.
What is the best PostgREST alternative?
There is no single best PostgREST alternative: pick by what PostgREST doesn’t do for you, and keep it if Postgres roles and RLS already work. For the same model without a server, use the Supabase Data API (full backend platform) or the Neon Data API (serverless Postgres). For a self-hosted Go binary, use pREST. For GraphQL, use PostGraphile (keeps RLS) or Hasura (many sources). For SQL Server and Azure, use Data API builder. For several SQL engines plus MCP, use Faucet, the open-source database-to-REST-API and MCP server. For an admin app, use Directus; for enterprise connectors, DreamFactory.
PostgREST alternatives compared at a glance
| Tool | Best for | Databases | API style | Where access control lives | MCP server | License / pricing model | Hosting | GitHub stars |
|---|---|---|---|---|---|---|---|---|
| PostgREST (baseline) | Postgres teams using DB roles + RLS | PostgreSQL | REST | Postgres roles, grants, RLS (JWT selects the role) | No | MIT, free | Self-hosted | 27.7k |
| pREST | Self-hosted Go binary | PostgreSQL 9.5+, MySQL 8.0.19+ | REST | API layer: JWT + config access rules | Yes, built in, read-only | MIT, free | Self-hosted | 4.6k |
| Supabase Data API | Managed Postgres platform | PostgreSQL (your Supabase project) | REST (PostgREST); GraphQL via pg_graphql (opt-in on new projects) | Postgres roles + RLS; new tables need explicit GRANTs | Platform MCP (SQL, read-only mode), separate from the API | Apache-2.0; free plan, then plan fee + usage | Managed, or self-hosted Docker stack | 111.7k |
| Neon Data API | Serverless Postgres | PostgreSQL (Neon) | REST (PostgREST-compatible) | Postgres grants + RLS; JWT from your auth provider | Platform MCP (SQL, read-only mode), separate from the API | Managed; on all Neon plans incl. Free, usage-based above | Managed only | n/a (managed service) |
| PostGraphile | GraphQL with RLS | PostgreSQL | GraphQL | Postgres roles + RLS | No | MIT, free (sponsor-supported) | Self-hosted (Node.js) | 12.9k |
| Hasura | Multi-source GraphQL | Postgres, SQL Server, BigQuery, MongoDB, ClickHouse, Snowflake, Oracle and more (some per edition) | GraphQL; REST via RESTified endpoints | API layer: role-based permissions in metadata | Separate PromptQL MCP, not the v2 engine | v2 engine Apache-2.0; DDN free tier, then per active model | Self-hosted, or DDN cloud | 32.1k |
| Faucet | One API across SQL engines | PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake, SQLite | REST + OpenAPI 3.1 | API layer: roles + API keys (table and verb); no RLS or column rules | Yes, built in | MIT, free | Self-hosted only (single binary) | 138 |
| Data API builder | SQL Server / Azure | SQL Server, Azure SQL, PostgreSQL, MySQL, Cosmos DB | REST + GraphQL | API layer: config roles, policies, field rules | Yes (SQL MCP Server, v1.7+) | MIT, free | Self-hosted (container) | 1.5k |
| Directus | Data studio + API | PostgreSQL, MySQL/MariaDB, SQL Server, Oracle, SQLite, CockroachDB | REST + GraphQL | API layer: Directus roles and policies | Yes, built in (v11.12+) | Source-available (MSCL); free under $5M revenue and 50 staff, free Core tier above, paid enterprise tiers | Self-hosted, or Directus Cloud add-on | 38.5k |
| DreamFactory | Enterprise connectors | Free edition: PostgreSQL per pricing page; paid: SQL Server, Oracle, Snowflake, DB2 and more | REST + OpenAPI | API layer: RBAC per table, endpoint and verb | Yes, built in | Apache-2.0 core; paid editions by annual subscription | Self-hosted | 1.8k |
As of 2026-10-16, from each project’s docs, repository and pricing page; not hands-on tested.
How we evaluated
We picked tools a PostgREST user would realistically switch to: tools that generate an API from an existing database without you writing endpoints. We left out API gateways (Kong, Tyk) and backend builders that only work with their own schema.
We judged each tool on five things: which databases it serves, REST versus GraphQL, where access control lives (in Postgres or in the API layer), whether it ships an MCP server for AI agents, and its license and pricing model.
Every competitor fact comes from that project’s own repository, documentation or pricing page, checked on 2026-10-16. Faucet facts come from its source code. We did not run a hands-on benchmark for this post, so nothing here is described as tested. Prices change often, so the table uses pricing models rather than numbers.
The order follows reader fit, not a score. The closest drop-in replacements come first, then the GraphQL options, then the multi-database tools.
Also considered: NocoDB (65.3k stars) adds REST APIs and an MCP server to a spreadsheet-style app, but it is source-available (Sustainable Use License) and closer to Directus than to PostgREST. NpgsqlRest (MIT) is a .NET Postgres-to-REST server with about 130 stars. Nhost (MIT) is a Hasura-based platform, covered by the Hasura and Supabase entries.
Why teams look beyond PostgREST
PostgREST deserves its reputation. It has been developed since 2014, has about 27.7k GitHub stars, shipped v16.4 on 2026-09-24 and is MIT-licensed. Its design is clean: a JWT picks a Postgres role, and the database’s own grants and row-level security decide what that role can see. Supabase’s REST API is PostgREST, and Neon’s Data API copies its protocol.
The reasons teams move are usually specific:
- The database isn’t Postgres. PostgREST serves “any existing PostgreSQL database” and nothing else.
- The people who own security are on the app team, not the DBA team. RLS policies on every table are powerful, but writing them is SQL work.
- They want GraphQL, or relationship-heavy queries with a different client model.
- They want an MCP server so AI agents can use the same governed API. PostgREST has none built in.
- They need OpenAPI 3. PostgREST’s generator is built on the Haskell
Data.Swaggerlibrary, which produces Swagger 2.0.
If none of these apply, staying on PostgREST is a reasonable answer. Our Faucet vs PostgREST comparison goes deeper on that one decision, and the alternatives hub collects our other head-to-head pages.
How should you choose?
Database coverage
Every tool here works on Postgres. Beyond it, coverage and edition rules differ a lot; see the engine list below.
REST vs GraphQL
Existing PostgREST clients want REST, so pREST, Supabase and Neon need the fewest client changes. PostGraphile and Hasura mean rewriting clients for GraphQL. Data API builder and Directus serve both, which helps if you’re migrating gradually.
Where auth lives
PostgREST, Supabase, Neon and PostGraphile let Postgres roles and RLS decide access, so the rules hold for every client of the database. pREST, Faucet, Data API builder, Hasura, Directus and DreamFactory enforce rules in the API layer, which is easier for app teams to manage but doesn’t protect direct SQL access.
AI agent access
Ask whether the MCP server goes through the same permissions as the API. pREST, Faucet, Data API builder, Directus and DreamFactory tie MCP tools to their API roles. Supabase’s and Neon’s MCP servers are platform tools that run SQL and manage projects, each with a read-only mode.
License
MIT and Apache-2.0 tools (pREST, PostGraphile, Faucet, Data API builder, Supabase, Hasura’s v2 engine, DreamFactory’s core) carry no usage thresholds. Directus’s MSCL is free below revenue and headcount limits. Neon’s Data API is a managed service, not software you run.
1. pREST — Best for a self-hosted, single-binary REST server on Postgres (and now MySQL 8)
Best for: teams that like PostgREST’s “point it at a database” model but want a Go binary, config-file access rules or MySQL.
pREST (pRESTd) is an MIT-licensed Go server that “delivers instant REST and Model Context Protocol (MCP) APIs” on an existing database. PostgreSQL 9.5+ is the default engine. v2.5.0 (2026-10-07) added a native MySQL 8.0.19+ engine, and v2.5.1 (2026-10-08) brought its MCP endpoint to MySQL. It has about 4.6k stars.
Strengths
- Ships as a single Go binary, installable with Docker, Homebrew or Go.
- Serves several databases from one process through a
[[databases]]registry inprest.toml. - JWT verification supports HMAC, RSA, ECDSA and EdDSA keys, plus JWKS and well-known URLs.
- Has a read-only MCP endpoint at
/_mcpon the same server, with per-table select tools that respect access rules. - Supports custom SQL routes through
/_QUERIESscripts.
Things to know
- MySQL support is new (October 2026). The docs list known differences: no
RETURNING, noFULLjoin, and no MariaDB support yet. - MCP is read-only by design and returns at most 100 rows per select.
- JWT enforcement is off by default in v2 (
jwt.default = false), so set up auth before you expose it. - Access rules live in pREST’s config, not in Postgres RLS, so they don’t apply to other clients of the same database.
Who should choose it
Postgres or MySQL 8 teams that want a lightweight self-hosted binary and an MCP endpoint agents can read from but not write to.
2. Supabase Data API — Best for managed PostgREST inside a full Postgres backend platform
Best for: teams that want PostgREST’s model without running it, plus auth, storage and realtime.
Supabase’s docs put it plainly: “Supabase provides a RESTful API using PostgREST,” running “behind an API gateway with key-auth enabled.” A GraphQL API is available through the pg_graphql extension. Supabase is Apache-2.0 and can be self-hosted with its Docker stack.
Strengths
- Uses the same query syntax and RLS model as PostgREST, so existing clients port easily.
- Can serve GraphQL from the same schema and permissions once you enable
pg_graphql. - Has an official MCP server at
https://mcp.supabase.com/mcpwith OAuth sign-in, aread_only=truemode andproject_refscoping. It runs SQL and manages projects; it doesn’t go through the Data API. - Offers a free plan, then a fixed plan fee plus usage-based charges (compute is billed hourly per project).
Things to know
- It is PostgreSQL only, and it serves the Postgres database in your Supabase project.
- New tables aren’t exposed to the Data API until you GRANT them. That is the default for new projects since May 30, 2026, and Supabase applies it to all existing projects on October 30, 2026.
pg_graphqlstopped being enabled by default on May 18, 2026, and from pg_graphql 1.6.0 (new projects from June 29, 2026) GraphQL introspection is off by default.- It is a whole platform, which is more than you need if you only want a REST layer.
- Supabase’s MCP docs advise scoping the server to one project, enabling read-only mode and reviewing the security risks before you connect a production project.
Who should choose it
New or growing apps that want Postgres, auth and a PostgREST API managed in one place. Faucet vs Supabase covers the self-hosted angle.
3. Neon Data API — Best for PostgREST-compatible REST on serverless, branchable Postgres
Best for: Neon users who want a REST endpoint without running PostgREST themselves.
Neon describes its Data API as “fully compatible with PostgREST.” It isn’t PostgREST itself but “a re-implementation of PostgREST in Rust built directly into Neon’s proxy fleet.” Neon’s 2026-09-18 changelog lists the Data API as one component of its generally available backend, and the pricing page says every plan includes it, Free included.
Strengths
- Existing PostgREST clients (
postgrest-jsand similar) work once you change the endpoint and auth config. - Each request is a stateless HTTP call rather than a long-lived connection, which fits edge and serverless functions.
- Validates JWTs from Neon’s Managed Better Auth or your own provider (Auth0, Clerk, Firebase and others).
Things to know
- In Neon’s words, “The Data API has no permission layer of its own.” Everything depends on your GRANTs and RLS policies.
- It doesn’t support projects that have IP Allow or Private Networking enabled.
- You enable it per branch for a single database, and you have to refresh the schema cache after schema changes.
- It is managed only, with no self-hosted version.
- Neon’s separate MCP server can run SQL (with a read-only mode via
?readonly=true) and manage projects, but it doesn’t go through the Data API’s JWT and RLS path.
Who should choose it
Teams already on Neon (or choosing it) that want PostgREST semantics with no server to run.
4. PostGraphile — Best for GraphQL on Postgres that keeps database roles and RLS in charge
Best for: Postgres teams that like PostgREST’s security model but want GraphQL.
PostGraphile analyzes your database and builds a GraphQL schema “informed by its tables, relations, functions, indexes, permissions, and your configuration,” as its README puts it. Version 5 (package [email protected], MIT) lives in the graphile/crystal monorepo, which has about 12.9k stars. It runs as Node.js middleware and is written in TypeScript.
Strengths
- Shares PostgREST’s philosophy: it exposes only what is granted and lets RLS decide which rows.
- Has a rich plugin and preset system, plus “smart tags” for renaming or hiding entities.
- Lets you extend the schema with your own types and fields that run SQL or Node.js code.
Things to know
- It is GraphQL only, with no REST endpoints and no OpenAPI. Moving to it means rewriting clients.
- Postgres is the core data source; other sources need your own schema extensions.
- It has no MCP server.
- Development is sponsor-supported through GitHub Sponsors.
Who should choose it
Postgres teams moving to GraphQL that want permissions to stay in the database.
5. Hasura — Best for GraphQL across many data sources, with a commercial cloud
Best for: organizations that want one GraphQL API over several databases and services.
Hasura’s v2 GraphQL Engine is Apache-2.0 and, per its README, “the current stable version.” The v3 engine powers Hasura DDN. The v2 docs list Postgres, SQL Server, BigQuery, Athena, Redshift, ClickHouse, MongoDB, Snowflake, MariaDB, MySQL (alpha) and Oracle.
Strengths
- It is a long-established project (about 32.1k stars; v2.50.3 shipped 2026-09-09).
- Role-based permissions are defined in Hasura metadata, separate from database roles.
- RESTified endpoints turn any GraphQL query or mutation into a REST endpoint.
- DDN’s pricing page lists self-hosting with the v3 engine on every tier, Free included.
Things to know
- It is GraphQL-first. REST exists only as RESTified wrappers around operations you write.
- Hasura v2 needs a Postgres metadata database to start.
- Some connectors depend on edition. Oracle, for example, is listed for Hasura Cloud and Self-Hosted Enterprise.
- DDN’s paid tiers are billed per active model per month, so model the cost before you scale.
- Hasura publishes a separate MCP server (
hasura/promptql-mcp) for PromptQL, tied to PromptQL and DDN rather than the v2 engine.
Who should choose it
Teams already committed to GraphQL that need federation across many sources. Faucet vs Hasura covers the REST-first trade-off.
6. Faucet — Best for one REST API and MCP server across several SQL engines
Best for: teams that run more than one database engine, or that want AI agents on the same governed API as their apps.
Faucet is a single MIT-licensed Go binary (we build it; v0.1.15 shipped 2026-10-09). It introspects PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, Snowflake or SQLite and serves REST endpoints, an OpenAPI 3.1 spec, an admin UI and an MCP server on one port.
Example setup (not benchmarked for this post):
brew install faucetdb/tap/faucet
faucet db add --name pagila --driver postgres --dsn "postgres://user:pass@localhost:5432/pagila"
faucet role create --name readonly --verbs GET
faucet key create --role readonly # prints the key once
export FAUCET_KEY=faucet_... # paste the key printed above
faucet serve
The same query in both tools:
# PostgREST
curl "http://localhost:3000/film?rental_rate=gt.2.99&length=gt.120&select=title,length&order=length.desc&limit=10"
# Faucet
curl -G "http://localhost:8080/api/v1/pagila/_table/film" \
-H "X-API-Key: $FAUCET_KEY" \
--data-urlencode "filter=rental_rate > 2.99 AND length > 120" \
--data-urlencode "fields=title,length" \
--data-urlencode "order=length DESC" \
--data-urlencode "limit=10"
The Faucet filter syntax reference documents the filter language.
Strengths
- Serves seven engines from one binary with pure-Go drivers, so Oracle needs no Instant Client.
- Roles and API keys live in Faucet, so access works the same on every engine. You can also mark a service read-only, which rejects every write with a 403 whatever the role allows. See the RBAC guide.
- Has a built-in MCP server at
/mcpwhose eight tools go through the same role checks as REST. Raw SQL is off by default. Setup for Claude, Cursor and VS Code is in the MCP server docs and our guide to connecting Claude to a database. - Adds REST extras: aggregates and
GROUP BYin query parameters, NDJSON streaming, batch modes with rollback, and schema-contract locking that refuses breakingALTERs sent through Faucet’s API and flags drift (X-Schema-Drift) when the database changes underneath it.
Things to know
- Access lives in Faucet, not in Postgres roles. Faucet connects as one database user, and rules apply per table and verb. If per-user RLS is your security model, PostgREST, Supabase, Neon or PostGraphile fit better.
- REST only. No GraphQL, and no equivalent of PostgREST’s resource embedding, so you query one table at a time.
- API keys. Apps and agents authenticate with API keys.
- Telemetry: release binaries send anonymous usage telemetry by default; opt out with
FAUCET_TELEMETRY=0. PostgREST sends none. - It’s a young project, with about 138 GitHub stars and no managed cloud.
Who should choose it
Teams with MySQL, SQL Server, Oracle or Snowflake alongside Postgres, and teams that want AI agents and apps behind one set of keys and roles. Start with the PostgreSQL REST API guide or the Postgres tutorial.
7. Microsoft Data API builder — Best for SQL Server and Azure shops wanting REST, GraphQL and MCP from one config
Best for: .NET and Azure teams, or anyone whose main database is SQL Server.
Data API builder (DAB) is Microsoft’s MIT-licensed “configuration-based engine that creates REST and GraphQL APIs” for SQL Server, Azure SQL, Cosmos DB, PostgreSQL and MySQL. Microsoft calls it “truly free, with no premium tier.” SQL MCP Server has been included since v1.7, and the latest release is v2.1.5 (2026-10-01).
Strengths
- Serves REST and GraphQL at the same time, with OpenAPI/Swagger for REST.
- Authenticates with Microsoft Entra ID, any JWT provider or App Service EasyAuth, and passes claims into the SQL session context.
- SQL MCP Server exposes seven DML tools under the same RBAC, over streamable HTTP or stdio. By design it does no NL2SQL and no DDL.
- Runs anywhere as a container, with OpenTelemetry and health checks built in.
Things to know
- You must declare everything you expose in
dab-config.json. That is safer than PostgREST’s automatic exposure, but it is more setup. - Its documented databases don’t include Oracle, Snowflake or SQLite.
- The default authentication provider is “Unauthenticated,” which assumes a trusted front end handles identity.
Who should choose it
SQL Server and Azure teams that want a Microsoft-supported, config-driven API with MCP included. Our SQL Server MCP server comparison, SQL Server REST API guide and analysis of DAB’s MCP server cover where Faucet differs.
8. Directus — Best for a data studio and admin app with REST and GraphQL on top
Best for: teams where non-developers need to browse and edit the data the API serves.
Directus connects to PostgreSQL, MySQL/MariaDB, SQL Server, Oracle, SQLite or CockroachDB. It gives you “a REST and GraphQL API” plus a full web app, auth, file management and automations. It has about 38.5k stars, and v12.5.0 shipped 2026-10-07.
Strengths
- Offers a full no-code admin app on top of the API, which none of the thinner API layers here do.
- Serves REST and GraphQL with granular roles and policies.
- Has a built-in MCP server (Directus v11.12+) that you enable in Settings and authenticate with an access token.
Things to know
- License: Directus has been source-available since v10 (BSL 1.1). v12 moved it to the Monospace Sustainable Core License. Organizations under $5M annual revenue and 50 employees get the full platform free; larger ones get a free Core tier, with paid tiers for enterprise features such as SCIM and offline mode. Each version becomes GPLv3 after four years.
- It stores its own settings in
directus_*system tables inside the connected database. - It’s a platform, not a thin API layer, so expect a Node.js service with more moving parts than PostgREST.
Who should choose it
Content- and operations-heavy teams that want an admin app and API together and can work within the MSCL terms.
9. DreamFactory — Best for enterprises needing many connectors and commercial support
Best for: larger organizations that need SQL, NoSQL, file and SOAP services behind one governed API, with a vendor to call.
DreamFactory is a PHP/Laravel platform with an Apache-2.0 core that generates REST APIs with OpenAPI/Swagger documentation for every endpoint. Access is governed by “role-based access control (RBAC)” per table, endpoint and HTTP verb. Release 7.7.1 shipped 2026-09-24.
Strengths
- Its paid editions list “all connectors including Oracle, Snowflake, and DB2,” plus NoSQL, file and SOAP services (per its pricing page, 2026-10-16).
- Has a built-in MCP server. AI clients authenticate with OAuth 2.0, and tools are filtered to the services a role allows.
- Offers commercial editions with support tiers, including a Federal edition that its pricing page says was “created to meet US Federal Government security standards.”
Things to know
- Per its pricing page, the free Essential (open-source) edition lists PostgreSQL as its database connector; the open-source build also includes SQLite. MySQL, SQL Server, Oracle, Snowflake and DB2 connectors are commercial.
- Paid editions are annual subscriptions (a flat monthly price on Linux, per-vCPU pricing on Docker and Kubernetes) priced for enterprise budgets.
- It’s heavier to run than a single binary, because it’s a full Laravel application.
Who should choose it
Enterprises that need broad connectivity, OAuth for AI clients and vendor support more than a minimal footprint.
PostgREST vs Hasura
PostgREST and Hasura solve different problems. PostgREST is a thin REST layer where Postgres decides everything through roles, grants and RLS. Hasura is a GraphQL engine with its own permission system in metadata and connectors to many sources.
Choose PostgREST for REST clients, Postgres-native security and minimal infrastructure. Choose Hasura when clients want GraphQL, you need to join data across sources, or you want a commercial cloud.
PostgREST vs pREST
Both are free, MIT-licensed and self-hosted, and both turn an existing Postgres database into REST. The differences are in philosophy and reach:
- Access control: PostgREST delegates to Postgres roles and RLS. pREST enforces JWT and its own config-file access rules.
- Databases: PostgREST is Postgres-only. pREST added MySQL 8.0.19+ in v2.5.0.
- AI agents: pREST ships a read-only MCP endpoint. PostgREST has none.
- Maturity: PostgREST has the larger community (about 27.7k stars versus 4.6k) and the longer track record.
If your RLS policies are your security model, stay on PostgREST. If you’d rather keep rules in a config file or you need MySQL, pREST is the closest swap.
Supabase Data API vs Neon Data API
Both give you PostgREST semantics without running PostgREST. Supabase runs PostgREST itself and adds optional GraphQL, auth and storage. Neon runs a Rust reimplementation in its proxy, which suits serverless and edge clients. Both rely entirely on Postgres grants and RLS, and both offer a platform MCP server with a read-only mode. Choose by platform: Supabase if you want a full backend, Neon if you want serverless Postgres with branching.
Which PostgREST alternative works with MySQL, SQL Server or Oracle?
- MySQL: pREST (8.0.19+), Faucet (MySQL and MariaDB), Data API builder, Directus, Hasura (alpha in v2) and DreamFactory (paid editions).
- SQL Server: Data API builder, Faucet, Directus, Hasura and DreamFactory (paid editions).
- Oracle: Faucet, Directus, Hasura (Cloud and Self-Hosted Enterprise) and DreamFactory (paid editions).
The bottom line
If PostgREST works for you, keep it; if you’re leaving, pick the tool that matches your reason, using the table above.
If your reason is several SQL engines, or agents and apps sharing one set of keys and roles, try Faucet. The getting-started guide has you serving REST and MCP in a few minutes, and our walkthrough on turning a database into a REST API and MCP server covers the full setup.
Frequently asked questions
Is there a PostgREST alternative for MySQL or SQL Server?
Yes. pREST added a native MySQL 8.0.19+ engine in v2.5.0. For SQL Server, Microsoft Data API builder, Faucet, Directus, Hasura and DreamFactory's paid editions all connect to it. Faucet also covers MariaDB, Oracle, Snowflake and SQLite from the same MIT-licensed binary. PostgREST, PostGraphile, Supabase and Neon remain PostgreSQL-only.
Is Supabase just PostgREST?
Supabase's REST Data API is PostgREST, run for you behind an API gateway with key auth. Supabase adds Auth, Storage, Realtime, a dashboard and an official MCP server, and a GraphQL API through pg_graphql, which new projects must enable since May 2026. If you only need the REST layer on your own Postgres, plain PostgREST or pREST is lighter.
Which PostgREST alternative works with AI agents over MCP?
Microsoft Data API builder (SQL MCP Server, v1.7+), Faucet (built-in MCP at /mcp), pREST (read-only /_mcp endpoint), Directus (v11.12+) and DreamFactory ship MCP servers tied to their API permissions. Supabase and Neon offer platform MCP servers that run SQL and manage projects, each with a read-only mode. Hasura publishes an MCP server for PromptQL.
Is Hasura a PostgREST alternative?
Partly. Hasura generates a GraphQL API, not a PostgREST-style REST API, though Hasura v2 can turn any GraphQL query or mutation into a RESTified endpoint. It suits teams that want GraphQL across several data sources. The v2 engine is Apache-2.0; Hasura DDN is priced per active model, and its free tier lists self-hosting with the v3 engine.
Which PostgREST alternatives are OSI open source today?
As of 2026-10-16: pREST (MIT), PostGraphile (MIT), Faucet (MIT), Microsoft Data API builder (MIT), Hasura's v2 engine (Apache-2.0), Supabase (Apache-2.0) and DreamFactory's core (Apache-2.0; its pricing page lists PostgreSQL as the free edition's connector). Directus is source-available (BSL since v10, MSCL since v12). Neon's Data API is a managed service.
Can I migrate from PostgREST without changing my schema?
Mostly. pREST, PostGraphile, Faucet and Data API builder read your existing schema and add nothing to it. Directus adds its own directus_* system tables, Hasura v2 needs a Postgres metadata database, and Supabase or Neon mean moving the database onto their platform. What changes for everyone is the client side (URL and query syntax) and, outside Supabase and Neon, where access rules live.
Sources
- PostgREST repository (README, MIT license, v16.4 release) (checked )
- PostgREST OpenAPI generator source (Data.Swagger) (checked )
- pREST repository README and v2.5.0/v2.5.1 release notes (checked )
- pREST docs: MCP over HTTP (checked )
- pREST docs: Configuring pREST (JWT, auth) (checked )
- Supabase docs: REST API (checked )
- Supabase docs: GraphQL (pg_graphql) (checked )
- Supabase changelog: tables not exposed to the Data and GraphQL API automatically (checked )
- Supabase changelog: pg_graphql 1.6.0 introspection disabled by default (checked )
- Supabase docs: MCP server (checked )
- Supabase pricing (checked )
- Neon docs: Data API overview (checked )
- Neon docs: Data API get started (limitations) (checked )
- Neon blog: A PostgREST-compatible Data API, now on Neon (checked )
- Neon changelog 2026-09-18 (backend GA) (checked )
- Neon docs: Neon MCP server (SQL tools, read-only mode) (checked )
- Neon pricing (checked )
- PostGraphile (graphile/crystal) repository and package.json (v5.1.5, MIT) (checked )
- PostGraphile README (schema description quote) (checked )
- PostGraphile V5 documentation (checked )
- Hasura graphql-engine repository (v2 Apache-2.0, v3 engine) (checked )
- Hasura pricing (DDN) (checked )
- Hasura v2 docs: supported databases (checked )
- Hasura v2 docs: Oracle availability (checked )
- Hasura v2 docs: RESTified endpoints (checked )
- Hasura v2 docs: server flags (metadata database URL) (checked )
- Hasura PromptQL MCP server repository (checked )
- Microsoft Learn: What is Data API builder? (checked )
- Microsoft Learn: SQL MCP Server overview (checked )
- Directus v12 license change (BSL to MSCL) (checked )
- Directus pricing (Core tier, Directus Cloud add-on) (checked )
- Directus docs: database configuration (DB_CLIENT) (checked )
- Directus docs: collections (directus_ system collections) (checked )
- Directus docs: MCP (checked )
- DreamFactory pricing (checked )
- DreamFactory repository README and composer.json (checked )
- DreamFactory df-sqldb services (PostgreSQL, SQLite, AlloyDB) (checked )
- DreamFactory docs: MCP server (checked )
- NocoDB repository (Sustainable Use License) (checked )
- NocoDB docs: MCP server (checked )
- NpgsqlRest repository (MIT) (checked )
- Nhost repository (MIT) (checked )
- Faucet repository (MIT, v0.1.15) (checked )
Last reviewed