The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. Built by Neon, it is officially maintained and best for Database.
by Neon
About
The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.
Trust verdict
How grades are computed →Grade A (95/100, reliable) from 3 measured signals, based on live MCP handshakes.
What was measured
- Live MCP handshake85/100 · weight 30
Answered with an OAuth/Bearer challenge — the endpoint is alive and speaking MCP, it just requires credentials before it will list tools. (265 ms handshake)
- Measured uptime100/100 · weight 20
Answered 200 of 200 recorded checks (100%). A check counts as answered when the server completed the MCP handshake in any form, including an auth challenge.
- Tool-schema stability100/100 · weight 15
No tool-schema or protocol-version drift across 200 recorded checks. Tools an agent bound to last week are still the tools it will find today.
- Source verification100/100 · weight 25
The repository URL was confirmed to resolve against the live GitHub API and is not archived.
- Provenance90/100 · weight 10
Published and maintained by the vendor of the service it connects to, rather than by a third party.
- Listing ↔ repository match100/100 · weight 5
The listing name lines up with the linked repository neondatabase/mcp-server-neon.
What could not be measured
These contributed nothing to the score — not a penalty, not a zero. They are why the confidence reads the way it does.
- Repository maintenanceunknown
No repository-freshness reading has been collected for this server yet.
Installation
npx add-mcp https://mcp.neon.tech/mcpadd-mcp confirmed live on the npm registry — checked August 17, 2026.
The Neon server is remote-first — there is nothing to install, you point a client at https://mcp.neon.tech/mcp and authorize in a browser — and that makes the interesting configuration entirely a matter of what you put in the URL. Three query params (readonly, category, projectId) decide whether the agent can write, which tool categories exist at all, and whether it can see one project or your whole account. This matters more here than on most servers because the default surface is roughly thirty tools spanning project creation, deletion, migrations and auth provisioning, and because Neon says plainly in its own README that the server is "intended for local development and IDE integrations only" and that it does not recommend running it against production. The other thing worth knowing before you start: the migration tools are two-phase on purpose, and the branch they create is what makes "let the agent change my schema" a defensible idea rather than a reckless one.
Connecting the Neon MCP server
1.One command, if your editor is Cursor, VS Code or Claude Code
neon init authenticates over OAuth, mints an API key for you, and writes the MCP config plus Neon's agent skills and the VS Code extension. It is the fastest path and the one to use unless you need a specific scoped URL.
shellnpx neon@latest init2.Or register the hosted server everywhere at once
add-mcp detects the agents and editors in the workspace and adds the entry to each. It is project-scoped by default; add -g to write it to the global MCP server list instead. On first connect a browser window opens for the OAuth grant.
shellnpx add-mcp https://mcp.neon.tech/mcp3.Or write the config by hand
Streamable HTTP, so there is no command and no args. Any client that speaks it takes this verbatim.
json{ "mcpServers": { "Neon": { "type": "http", "url": "https://mcp.neon.tech/mcp" } } }4.Constrain it in the URL before you connect anything real
readonly=true removes the write tools and leaves run_sql available for read-only queries. projectId confines every operation to one project — and note that in project-scoped mode the docs-search tools search and fetch become unavailable. Config in the URL travels with each request and takes effect immediately, with no re-auth.
urlhttps://mcp.neon.tech/mcp?readonly=true&projectId=proj-1235.Cut the tool list with category=
category takes repeated params or a CSV, drawn from projects, branches, schema, querying, neon_auth, data_api, observability and docs. Dropping to two categories is the cheapest way to shrink both the risk and the tokens the tool list costs on every turn.
urlhttps://mcp.neon.tech/mcp?category=querying&category=schema6.Check what a URL actually exposes before you trust it
The server will tell you which tools a given configuration yields, without authenticating. Worth running once after you write a scoped URL, rather than assuming the params did what you meant.
shellcurl "https://mcp.neon.tech/api/list-tools?readonly=true&category=querying"7.API-key auth, where no browser exists
Create the key in the Neon Console and pass it as a bearer header. Use an organization key to confine access to that organization's projects. In this flow there is no OAuth scope exchange, so readonly=true in the URL is the only way to get read-only mode.
shellnpx add-mcp https://mcp.neon.tech/mcp \ --header "Authorization: Bearer <$NEON_API_KEY>"
Tool categories
Roughly thirty tools, grouped by the scope category used for filtering and for the OAuth consent screen.
projectslist_projects (first 10 unless you raise limit), list_shared_projects, describe_project, list_organizations, plus create_project and delete_project behind write access.
branchescreate_branch, delete_branch, describe_branch, list_branch_computes, compare_database_schema (diff against parent) and reset_from_parent, which auto-preserves a backup if the branch has children.
queryingrun_sql, run_sql_transaction, get_connection_string. run_sql stays available in read-only mode but only for read-only queries.
schemaget_database_tables and describe_table_schema, plus the two-phase prepare_database_migration and complete_database_migration.
observabilityquery_logs, list_log_fields, list_log_field_values, and the optimization set — inspect_database, list_slow_queries, explain_sql_statement, prepare_query_tuning, complete_query_tuning.
neon_auth / data_apiprovision_neon_auth, configure_neon_auth, get_neon_auth_config and provision_neon_data_api. All writes except reading the config; disable these unless you are actually provisioning.
docssearch, fetch, list_docs_resources, get_doc_resource — Neon's documentation, the only category with no access to your data. Note that search and fetch drop out under projectId.
What people use it for
Migrate on a branch, then decide
“Use prepare_database_migration to add a created_at timestamptz default now() to public.users, run my smoke queries against the temporary branch, show me compare_database_schema against the parent, and stop before completing.”
prepare creates a throwaway branch and applies the change there; complete is a separate call that merges it and cleans up. Stopping between the two is the whole point — you review a real applied schema, not a proposed diff.
Find the slow query and prove the fix
“Run list_slow_queries, take the worst one, use explain_sql_statement to show the plan, then run prepare_query_tuning and tell me what it changed and what the new plan costs.”
The tuning tools are two-phase like migrations, so the optimization is applied somewhere disposable first. This is the workflow that justifies giving an agent database access at all.
A read-only analyst on one project
“Using only the tables in this project, tell me which accounts signed up in the last 30 days and never returned, and show the SQL you ran.”
Point this at ?readonly=true&projectId=... and the agent physically cannot create, delete or migrate anything. It is the configuration to hand to anyone who is not the person on call.
Which one should you use?
Neon MCP vs a generic Postgres MCP server
Neon when you want the platform — branches, migrations on a throwaway branch, logs, connection strings. A Postgres server when you want SQL and index analysis against the database itself and would rather not expose project creation and deletion at all.
Neon MCP vs Supabase MCP
Whichever hosts your database; they are not interchangeable. The shapes rhyme, though — both are hosted, both are OAuth, both put read-only and project scoping in URL params, and both tell you not to point them at production.
Remote server vs running mcp-server-neon locally
Remote, in almost every case. Local exists for development on the server itself and needs Node 22+ with Corepack; it gains you nothing operationally and falls behind.
Every command, environment variable, and endpoint above was read from the project’s own documentation on 2026-08-12: neondatabase/mcp-server-neon on GitHub, Neon Docs — Neon MCP Server.
Categories
Frequently Asked Questions
Can I use the Neon MCP server in production?
Why does the MCP server not see my organization's projects?
How do I make the Neon MCP server read-only?
The connection fails and I have IP Allow enabled — what do I whitelist?
My client does not support Streamable HTTP — is there an SSE endpoint?
Do I need to run the server locally?
What is Neon MCP Server?
Who built Neon MCP Server?
Is Neon MCP Server free?
How do I install Neon MCP Server?
What does Neon MCP Server integrate with?
Related Guides
Best Database MCP Servers 2026: PostgreSQL, MySQL, SQLite & More
7 min read • Guides
Best MCP Servers for Supabase Developers in 2026
8 min read • Guides
Best MCP Servers for Next.js Developers in 2026
8 min read • Guides
Best MCP Servers for TypeScript Developers in 2026
7 min read • Guides
Best MCP Servers for SQL Developers in 2026
7 min read • Guides
Best MCP Servers for Vercel Developers in 2026
6 min read • Guides
Live Status
- Latency
- 265 ms
OAuth-gated (HTTP 401): SSE error: Non-200 status code (401)
Quick Info
- Install Type
- npm
- Author
- Neon
- Categories
- 2
- Integrations
- 5
Related Servers
AWS MCP Servers
AWS Labs maintains a monorepo of specialized, open-source MCP servers that bring AWS best practices directly into AI-assisted development workflows, spanning infrastructure, data, AI/ML, cost management, and healthcare/life-sciences domains. Rather than one monolithic server, the project ships dozens of focused servers you install individually depending on the task: the AWS Documentation MCP Server for real-time official docs and API references, dedicated servers for Terraform/CDK/CloudFormation infrastructure-as-code, container and serverless platforms (ECS, EKS, Lambda), SQL/NoSQL databases (DynamoDB, RDS, Aurora), search and analytics (OpenSearch), messaging (SQS/SNS), and cost/billing analysis. Most servers install via uvx with a package name like awslabs.aws-documentation-mcp-server, run locally over stdio, and use standard AWS credential chains (IAM roles, profiles, or access keys) rather than exposing raw account credentials to the model. AWS also now offers a managed, remote "AWS MCP Server" (in preview) that combines full API coverage with pre-built agent SOPs, syntactically validated API calls, and complete CloudTrail audit logging for teams that want centralized governance instead of running servers locally. The Getting Started with Kiro/Cursor/VS Code/Claude Code sections in the repo provide one-click install configs for each server, making it straightforward to wire up only the AWS services a given project actually touches.
Cloudflare MCP Server
Cloudflare ships two different things under this name. The mcp-server-cloudflare repo provides 16 remote, domain-specific MCP servers rather than one monolith — Documentation, Workers Bindings (storage/AI/compute primitives), Workers Builds, Observability (logs/analytics), Container sandboxes, Browser Rendering (fetch pages, convert to markdown, screenshots), Logpush health, AI Gateway (prompt/response search), AI Search, Audit Logs, DNS Analytics, Digital Experience Monitoring, Cloudflare One CASB, Radar, GraphQL analytics and the Agents SDK docs server, each on its own `*.mcp.cloudflare.com/mcp` hostname. Separately, the Cloudflare API MCP server at mcp.cloudflare.com/mcp (repo: cloudflare/mcp) exposes the whole 2,500+ endpoint Cloudflare API through just two tools, `search` and `execute`, using the Code Mode pattern — model-written JavaScript runs in an isolated Dynamic Worker, costing ~1,000 tokens of context against the ~1.17M an equivalent native-tool server would need. Pick a domain server when you want a readable, curated tool list for one product area; pick the API server for breadth or for endpoints nobody wrote a tool for. All endpoints are Streamable HTTP on `/mcp` and support the MCP 2026-07-28 spec; the historical `/sse` URLs remain as aliases for the same Streamable HTTP handler but no longer serve the deprecated HTTP+SSE transport, so clients pinned to SSE must switch. Auth is OAuth on connect, or a scoped Cloudflare API token as a bearer header for CI. Clients without native remote-MCP support bridge via `npx mcp-remote https://<subdomain>.mcp.cloudflare.com/mcp`.
MongoDB MCP Server
The official MongoDB MCP server, `mongodb-js/mongodb-mcp-server`, maintained by MongoDB. Searchers find it as the MongoDB MCP server or the Mongo MCP server; both names refer to this one project, and there is no separate short-form server. It is really two tool surfaces in one process. The database tools connect to any MongoDB deployment over a connection string in `MDB_MCP_CONNECTION_STRING` — `find`, `aggregate`, `explain`, `collection-schema`, `collection-indexes`, `create-index`, `count`, `export`, `mongodb-logs` and the write tools — or, if no connection string is set, the model calls the `connect` tool at runtime and passes the returned `connectionId` to later calls. The Atlas tools are a separate control plane: listing and creating clusters, database users, IP access-list entries, stream processing resources and the performance advisor. They authenticate with Atlas Service Account credentials (`MDB_MCP_API_CLIENT_ID` / `MDB_MCP_API_CLIENT_SECRET`), not with a connection string, and they simply do not register when those are unset — the usual cause of a 'the Atlas tools are missing' report. Two defaults are worth knowing before you point it at production. `readOnly` is false, so every write tool including `drop-database` is registered unless you pass `--readOnly`, which is why MongoDB's own README uses that flag in every example. And confirmation-required tools rely on MCP elicitation, so on a client that does not support elicitation they execute without prompting — `--readOnly` or `--disabledTools` is the actual boundary. Other guardrails: `indexCheck` rejects queries that would do a collection scan, server-side JavaScript (`$where`, `$function`, `$accumulator`) is disabled by default, results are capped at 100 documents and 16 MB per call, and `--dryRun` prints the resolved config and enabled tool list without starting the server. Requires Node 22.13.0 or later (Node 20 is deprecated); also published as the `mongodb/mongodb-mcp-server` Docker image. Runs over stdio by default, with an optional HTTP transport and a separate monitoring listener for `/health` and Prometheus `/metrics`.
PostgreSQL MCP Server
The PostgreSQL MCP server was the Model Context Protocol reference server for Postgres, and it is retired: the source now sits in modelcontextprotocol/servers-archived — a repository GitHub reports as archived, described as "Reference MCP servers that are no longer maintained" — and the npm package @modelcontextprotocol/server-postgres carries a deprecation notice reading "Package no longer supported." It still installs and still runs, which is why most third-party setup articles have not caught up. What it provides is deliberately small: a single tool, query, which executes read-only SQL inside a READ ONLY transaction, plus per-table schema information exposed as MCP resources at postgres://<host>/<table>/schema, with column names and data types discovered from database metadata. There is no index advice, no health check, no separate schema-listing tool, and no write mode. Install is npx @modelcontextprotocol/server-postgres with a postgres:// connection string as the argument. For active work against Postgres, the maintained alternative is Postgres MCP Pro (crystaldba/postgres-mcp), which exposes nine tools including index tuning against hypothetical indexes and a database health check, and has an explicit restricted access mode; if your database is hosted on Supabase or Neon, their platform servers add branching and logs that a raw Postgres connection cannot see. Reach for this archived server only when you want the smallest possible surface — one process, one read-only query tool, nothing else.
SQLite MCP Server
conversational read and write access to any SQLite database file, plus a running business-insights memo that accumulates what the analysis turns up. It is a Python server on PyPI, not a Node one, and the difference is the single most common reason setups fail here: `@modelcontextprotocol/server-sqlite` does not exist on npm, so every npx line for it 404s. The working invocation is `uvx mcp-server-sqlite --db-path /path/to/database.db` (PyPI package mcp-server-sqlite, v2025.4.25), or the equivalent `mcp/sqlite` Docker image with a volume mounted at /mcp. The --db-path argument is required and points at the .db file; the server will create it if it is not there yet. Six tools are exposed, deliberately split by risk: read_query for SELECT only, write_query for INSERT/UPDATE/DELETE, create_table for DDL, list_tables and describe-table for schema introspection, and append_insight, which writes into a memo://insights resource that updates live as findings accumulate — that resource, not the SQL tools, is what makes this server different from a generic database connector. It also ships an mcp-demo prompt that takes a business topic, generates a plausible schema and sample data, and walks through an analysis end to end, which is the fastest way to see the memo behaviour without wiring up real data. One caveat to weigh before adopting it: this is an Anthropic reference implementation that now lives in modelcontextprotocol/servers-archived, archived on 2025-05-28. The published package still installs and runs, but it is frozen — no new features, no dependency updates, and no security patches.
Sponsored
Better Stack
Free PlanGet alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.
Start monitoring free →