Summary: Updates and changes to Neon's features, functionality, and performance, with a history of modifications and improvements.

Reset from parent now rolls back a branch's Object Storage along with its Postgres data. When you reset a branch, its buckets and objects return to the parent's current state, so any object storage uploads, overwrites, and deletes you made on the branch are also reverted.

You can reset a branch from the Neon Console, CLI, or API. See Reset from parent for the steps.

Resetting Object Storage is available now in AWS US East (Ohio) (aws-us-east-2) and AWS Europe (Frankfurt) (aws-eu-central-1), with support for additional regions rolling out soon.

The Lakebase Search extensions are updated: lakebase_vector to 1.1.1 and lakebase_text to 0.1.3, with performance improvements and fixes. If you have them installed, upgrade when convenient with ALTER EXTENSION <name> UPDATE; see Upgrade the extension and indexes.

Note:

Building search with an AI coding assistant? The neon-postgres agent skill now includes Lakebase Search guidance for vector, full-text, and hybrid queries. Install it with:

neon skills -s neon-postgres

Last week we announced that the Neon backend is generally available, with Functions running next to your database. This week, a new guide shows how to use Neon Functions to automate workloads with Function Triggers: run a Function on a UTC cron schedule or when a file lands in an Object Storage bucket.

Learn how to declare a function in code using a neon.ts file and apply it with neon deploy.

// neon.ts
functions: {
  reports: { name: 'Reports', source: './functions/reports.ts' },
},
triggers: {
  nightly: {
    type: 'schedule',
    function: 'reports',
    cron: '0 6 * * *',
  },
},

Realtime sync is coming to Neon. The team behind Electric, the Postgres sync engine, joined Neon at Databricks and is building native realtime and end-to-end reactivity into the platform, designed to work with branching and scale to zero. Read our Q&A with Electric co-founder James Arthur.

Neon started as serverless Postgres. Now you get the whole backend, and all of it branches. Every branch is a full copy, so a PR, preview, or agent session gets your entire backend, not just the database. Evolve your schema, storage, auth, and functions together on a preview branch, isolated from production.

▶️ Watch the walkthrough to see how it all fits together.

• Lakebase Postgres: 100% Postgres on the Lakebase architecture: autoscaling, scale to zero, and a branch for every PR, preview, or agent session.
• Object Storage: S3-compatible object storage that branches with your data, so files and rows stay in sync across branches.
• Auth: Managed Better Auth: users and sessions live in your neon_auth schema, queryable with SQL and protected by RLS.
• Functions: Long-running Node.js compute next to your database, now with triggers and custom domains.
• AI Gateway: One credential for frontier and open-weight models at provider prices with no markup. Buy prepaid credits to use it.
• Data API: An instant REST endpoint over your Postgres tables, no backend server required.

How to get started

Building with a coding agent? neon skills installs the Neon agent skills into your assistant (Cursor, Claude Code, Codex, and more), so it knows how to provision and wire the whole backend.

neon skills

However you build, your whole backend is declared in one neon.ts file and applied with neon deploy, whether your agent writes it or you do:

// neon.ts
import { defineConfig } from '@neon/config/v1';

export default defineConfig({
  auth: true, // managed authentication
  buckets: { uploads: {} }, // S3-compatible object storage
  functions: { api: { source: './functions/api.ts' } }, // serverless compute
  aiGateway: true, // one API for many LLMs
});

Get started with How a Neon backend fits together or the full-stack quickstart, or scaffold a working example with neon bootstrap. Read the launch blog post for the full story.

Turn an upload into a pipeline or run a job on a schedule, without standing up a queue or a cron server. A Function Trigger invokes a deployed Function on a schedule or an event, and fires even when the compute is scaled to zero. Two trigger types are available now, with more on the way:

• Schedule: a UTC cron expression, for recurring work like a nightly rollup or a health check.
• Object created: fires when a file lands in an Object Storage bucket (optionally under a key prefix), so an upload can kick off processing like generating a thumbnail.

Declare a trigger in neon.ts, or use the Console, CLI, or API:

// neon.ts
functions: {
  reports: { name: 'Reports', source: './functions/reports.ts' },
},
triggers: {
  nightly: {
    type: 'schedule',
    function: 'reports',
    cron: '0 6 * * *',
  },
},

See Function Triggers.

Ship your public API or webhook on a domain you own, like api.example.com, instead of the native Neon URL. Point a CNAME at the target Neon gives you, and Neon provisions the TLS certificate automatically. Declare it in neon.ts:

// neon.ts
functions: {
  api: {
    source: './functions/api.ts',
    customDomains: ['api.example.com'],
  },
},

Domains are branch-scoped, so a preview branch can serve from its own hostname while production keeps yours. See Custom domains.

You can now buy prepaid credits for the AI Gateway from the Console. Credits draw down as you send inference requests, at provider list prices with no markup. See AI Gateway prepaid credits.

Object Storage, Functions, and AI Gateway now run in four AWS regions: US East (Ohio), US East (N. Virginia), Europe (Frankfurt), and Asia Pacific (Singapore), with more coming.

Adopting the backend now starts at project creation. You can now enable Object Storage, Functions, AI Gateway, and Auth alongside Postgres when you first create your project, so it comes up with your whole stack already wired. You will only see services that are supported in your selected region.

The project Settings page has a cleaner, tabbed layout (General, Postgres, Networking, Credentials, Auth, Functions, HIPAA compliance, and Sharing) that groups related controls and labels project-wide settings as Applies to all branches. Setting your default branch on the General tab is now project-scoped: use Change default branch to pick any branch.

Switching and creating organizations, organization management, account settings, theme, Neon status, and help now live in one profile menu in the top-right corner of the Console.

Claimable Neon is for developers building with agents. When your agent is mid-build, the signup, email verification, or API key it needs to provision a database brings everything to a halt. Claimable Neon solves this problem. It lets your agent provision a temporary project with scoped credentials, without an account or payment details, and keep building. If you like the result, you can sign in later and claim the project.

# Agent: provision a claimable project (writes DATABASE_URL to .env)
neon claim create --env-pull

# Human: sign in and take ownership
neon claim accept

Today you can provision Lakebase Postgres, the Data API, and Managed Better Auth this way, with support for Object Storage, Functions, and AI Gateway coming soon.

For how it works, see the Claimable Neon docs and the launch blog post.

If you're building an AI agent or app that manages Neon itself, such as one that spins up a project or a branch, @neon/tools gives it typed, function-calling tools instead of hand-written API wrappers. It turns the @neon/sdk client into tools you hand to a model. Pick the Neon operations you want to expose, and they stay in sync with Neon's API. It also ships adapters for MCP, Mastra, and Eve.

import { createNeonTools } from '@neon/tools';

const tools = createNeonTools({
  apiKey: process.env.NEON_API_KEY,
  tools: ['projects.list', 'projects.createAndConnect', 'branches.createAndConnect'],
});

// createAndConnect provisions a project, attaches compute, and returns a connection string
const created = await tools['projects.createAndConnect'].execute({
  name: 'agent-project',
  region_id: 'aws-us-east-1',
});

The same @neon/tools catalog now powers the hosted Neon MCP server for coding assistants like Cursor and Claude, adding over 70 new tools. Read more in Give your agent Neon tools.

Lakebase Postgres now puts much more of a large compute's memory to work as cache. On fixed-size computes of 18 CU and above, shared buffers expand to use up to 75% of available memory, backed by huge pages, so more of your working set stays resident and fewer reads fall through to storage. Cache-heavy workloads can see up to 2x throughput, with no configuration change or restart required.

On an affected compute you can confirm the larger cache with SHOW shared_buffers and SHOW huge_pages.

For the engineering deep dive, see Improving Lakebase Postgres compute cache on Neon, Part 1.

The Neon backend is now available in AWS Europe (Frankfurt) (aws-eu-central-1), alongside AWS US East (Ohio) (aws-us-east-2). If you build in Europe, you can now run these services closer to your users and data.

The AI Gateway catalog also gains new models, callable through the same API and key as the rest of the catalog:

• Fable 5.1
• GLM 5.3 Flash
• Grok 4.6
• OpenAI GPT-6 Astra (landing soon)

Try the Neon backend, free during the beta

Object Storage, Functions, and AI Gateway are in beta in AWS US East (Ohio) and AWS Europe (Frankfurt), and branch with your Postgres database, so your whole stack forks together.

Get started

Neon is now available as a plugin in Grok Bot. Connect your Neon account once, then ask a Grok bot to work with your database:

• Create a project and get a connection string for your app
• Spin up an isolated branch before testing a migration
• List projects and spot databases you no longer need
• Run SQL against your database
• Set up routines that summarize database usage

The plugin pairs Neon agent skills with the Neon MCP server, so Grok Bot has both the context and the authenticated tools to act on your account.

To install, open the Neon plugin in Grok Bot and authorize Neon in the browser. You can also open Grok Bot's Plugins directory and search for Neon, or ask Grok to connect the Neon plugin. Read more in the blog post.

Two updates to the Neon CLI for setting up and connecting your projects:

• A leaner neon init: it now does one focused job based on where you run it: in an empty directory it scaffolds a template and installs agent tooling (like neon bootstrap); in an existing app it installs a plugin (or skills and MCP), links your project, and writes a neon.ts config. Run it with npx, and pass -y and --agent for unattended runs:

  npx neon@latest init

• neon env pull writes Neon Function invocation URLs: each function's public URL is written to your local .env as NEON_FUNCTION_<SLUG>_BASE_URL, so your local app or frontend can call your deployed functions. See Environment variables.

  neon env pull

Three new Neon CLI commands set up Neon in coding agents like Cursor and Claude Code, without manual config steps. Each runs an interactive walkthrough, or takes flags so you can script it.

Installs the Neon MCP Server into your agents by writing their MCP config for you. It points each agent at the hosted server, sets up authentication, and can limit which tools the agent sees. By default, it mints a Neon API key and writes it into the config. Alternativevly, pass --oauth to skip API-key creation and have the agent sign in to Neon on first use instead.

For example, install into Cursor and Claude Code with read-only tools:

neon mcp --agent cursor --agent claude-code --read-only

Installs Neon's agent skills so tools like Cursor and Claude Code know how to work with Neon's Postgres, AI Gateway, Object Storage, and Functions. Skills install into the current directory by default, so they travel with the repository, and neon skills update refreshes them to their latest versions later.

For example, install the core Postgres and AI Gateway skills into Cursor:

neon skills -s neon -s neon-ai-gateway --agent cursor

Installs the neon-postgres plugin into agents that support plugin marketplaces, such as Claude Code, Cursor, and Codex. The plugin bundles Neon's agent skills and MCP access in one package, so a single install gives the agent both.

For example, install into Claude Code without prompts:

neon plugins --agent claude-code -y

The Neon CLI has seen many new additions over the past several weeks. For a tour of other recent additions, from the branch-first workflow to built-in Postgres diagnostics, see Just landed in the Neon CLI.

Note: Have an idea for the CLI or agent tools?

We'd love to hear it. Let us know via the Feedback form in the Neon Console or our feedback channel on Discord.

Our Postgres version support policy docs now include a rollout history for recent minor releases. For each release, you can see the date PostgreSQL published it, the versions it included, when it became available on Neon, and how long that took. For example:

Each version in the table links to its PostgreSQL release notes, so you can see exactly which bug fixes and CVE patches that minor release contains.

Info: Run SELECT version(); to see which version you're on. Minor version updates are rolled out the next time your compute restarts. To update now, restart your compute yourself, or wait for your compute's next scheduled update. See Updates for details.

Two new guides show what you can build with the Neon backend, where Object Storage, Functions, and the AI Gateway sit next to your database:

• Build an image processing API with Neon Functions, Sharp, and Neon AI Gateway: resize, crop, optimize, analyze, and AI-caption images on Neon Functions, then store the results in your branch's Object Storage bucket.
• Clean up orphaned S3 objects with Neon Object Storage branching: run a real storage-cleanup job on a branch first, where buckets branch with your database, then promote it to production once you've verified it.

Try the Neon backend, free during the beta

Object Storage, Functions, and AI Gateway are in beta in AWS US East (Ohio) and branch with your Postgres database, so your whole stack forks together.

Get started

fx is a small, fast coding agent and CLI from Vercel Labs, built to embed in larger systems. You can now connect it to Neon's remote MCP server, using either OAuth or a Neon API key, so the agent can work with your Neon projects directly.

For example, add the server with OAuth:

npx add-mcp https://mcp.neon.tech/mcp -a fx

Then authorize from the fx shell:

/mcp auth neon --open

For the API key option and more detail, see Connect MCP clients to Neon.

Lakebase Search is now easier to install. You can install both Lakebase Search extensions (lakebase_vector and lakebase_text) directly with the following CREATE EXTENSION statements from your SQL client or the Neon SQL Editor:

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;
CREATE EXTENSION IF NOT EXISTS lakebase_text CASCADE;

Previously, you had to run an SQL statement first to load the supporting libraries.

We also updated both extensions to newer versions (lakebase_vector 1.0.1 and lakebase_text 0.1.1). If you already have them installed, see Update an extension to get the latest version.

Note: Get started with Lakebase Search

Lakebase Search is a pgvector-compatible alternative for vector, keyword, and hybrid search that scales past a billion vectors, builds indexes 50–100x faster than HNSW, and stays ready after a scale-to-zero cold start. Follow the getting started guide to enable the extensions, load sample data, and run your first vector and keyword searches.

We updated supported Postgres versions to 14.24, 15.19, 16.15, 17.11, and 18.6. Minor releases bring you the latest upstream Postgres fixes and security patches.

When a new minor version is available, Neon applies it the next time your compute restarts. For more about how we handle PostgreSQL minor version updates, refer to our Postgres version support policy.

Store credentials in your OS keyring. You can now keep a profile's credential in your operating system's keyring instead of a file. Pass --keyring to neon auth or neon profile create:

neon auth --keyring

The secret is stored in the macOS Keychain, Windows Credential Manager, or Linux Secret Service.

Inspect every database at once. neon inspect db now inspects every database on the branch when you omit the database name, adding a database column to the output. Pass the database name to inspect a single database, which also scopes locks and long-running-queries so their names resolve correctly.

Note: This change is also available in the Neon MCP server's inspect_database tool.

The Neon MCP server is now listed in Claude's connectors. You can manage Neon from Claude: create projects and branches, run SQL, change schemas, and diagnose a slow query.

In Claude.ai or Claude Desktop, go to Settings > Connectors, click Browse connectors, add Neon, and authorize access to your Neon account.

You can now install Neon Agent Skills with Pi, straight from the repository:

pi install git:github.com/neondatabase/agent-skills

Pi reads the skills directly, so there's no separate sync step. This joins the existing install channels, including npx skills, the Cursor, Claude Code, Codex, and Kimi Code plugins, and neon init.

Two new guides show what you can build on Neon Functions, which run alongside your database as part of the Neon backend:

• Automate Neon Functions deployments with GitHub Actions: set up CI/CD to deploy to production on merge and create preview functions for pull requests.
• Monitor Neon Functions with Sentry: add error tracking, structured logs, and request tracing.

Try the Neon backend

Object Storage, Functions, and AI Gateway branch with your Postgres database, so your whole stack forks together.

Get started

Electric, the team behind the Electric sync engine and PGlite, is joining Neon. The sync engine keeps data continuously synchronized between a central Postgres database and connected clients such as browser tabs, mobile apps, and agents, so you can build real-time, collaborative, and agentic apps without hand-rolling websockets, caching, and a sync layer.

Real-time sync is hard to get right on your own: conflict resolution, partial replication, and reconnection logic are difficult to build from scratch. Electric turns it into a reusable primitive that handles the hard parts, so agents can add live, collaborative features by default instead of wiring up sync themselves.

Electric is coming to the Neon platform alongside Neon's other backend services (Lakebase Postgres, Auth, Storage, Functions, and the AI Gateway), with deeper integration already underway. To get familiar now, our guide to Electric on Neon walks through real-time sync with Shapes and a React app.

Read the full announcement: Electric is joining team Neon at Databricks.

The Neon AI Gateway gives you one API and one credential for 42+ frontier and open-source models (OpenAI, Anthropic, Google, and more), built into your Neon branch. It's now a community provider for the Vercel AI SDK: point the SDK at your branch and swap models without per-provider SDKs or keys.

import { neon } from '@neon/ai-sdk-provider';
import { generateText } from 'ai';

const { text } = await generateText({
  model: neon('gpt-5-mini'),
  prompt: 'What is serverless Postgres?',
});

Set NEON_AI_GATEWAY_BASE_URL and NEON_AI_GATEWAY_TOKEN from your branch, or pull them with neon env pull.

Info: Free AI Gateway credits on paid plans

While in beta, Neon paid-plan users get free AI Gateway credits. To try it out, see Get started with Neon AI Gateway.

Neon's agent skills and MCP server now ship as an Agent Plugins package, an open standard for extending agents with skills and MCP. Point any conforming client, such as Cursor, Codex, GitHub Copilot, Kiro, or VS Code, at the repo to load them straight from source.

All existing native plugins remain available:

• Claude Code: /plugin marketplace add neondatabase/agent-skills, then /plugin install neon-postgres@neon
• Cursor: /add-plugin neon-postgres
• Kimi Code: /plugins install https://github.com/neondatabase/agent-skills

The CLI keeps growing. Recent additions include a branch-first workflow (neon link, neon checkout, neon psql, neon data-api) and commands for the new backend services (neon functions, neon buckets); see the CLI reference for the full set. Two of the latest:

neon env pull gained a --service flag to pull credentials for only the services you name, repeatable for more than one:

neon env pull --service ai-gateway --service postgres

neon open (neonctl 3.2.0) opens your linked project's dashboard in the Neon Console, straight from the terminal:

neon open

We first shipped these diagnostics as the neon inspect db CLI command. The same checks are now built into the Neon MCP server as the inspect_database tool. It runs the same 14 read-only diagnostics: table and index sizes, unused indexes, sequential scans, long-running queries and locks, heavy and frequent statements, cache hit rate and working set, autovacuum and bloat, and replication state. Ask your assistant why a branch is slow or large without writing catalog SQL by hand.

Don't have the MCP server set up yet? Install it with neon init:

npx neon@latest init

Neon for Herdr puts a live Neon pane in your Herdr terminal workspace. Browse projects, create and reset branches, start or suspend compute, and copy connection strings without leaving your editor.

herdr plugin install neon-solutions/neon-herdr
herdr plugin action invoke neon.herdr.dashboard

Read the post: Neon for Herdr: a Neon pane in your Herdr workspace.

The Console sidebar has a new shape. Every branch-level Neon backend service now sits at the same level.

• Postgres database is everything that was in the sidebar before: Tables, SQL Editor, Backup & Restore, Computes, Data API, Roles, and Databases, now under one collapsible item.
• Auth, Object storage, Functions, and AI Gateway backend services sit alongside it as siblings.

Above that section, the sidebar separates what belongs to project (Dashboard, Branches, Integrations, Settings) from what belongs to the branch (Overview, Credentials, Monitoring, Child branches). The branch picker sits between them, so it's clear which branch you're looking at when you open a service.

Overview is now a summary of the branch you have selected. It lists each backend service with its status, so you can see what the branch actually has enabled without opening each one:

Each service shows whether it's enabled on the branch, so the page doubles as a list of what you can still add.

Important: More regions for backend services coming soon

Object Storage, Functions, and the AI Gateway services are available only in AWS US East (Ohio) (aws-us-east-2). More regions are coming soon.

Update: region availability has since expanded. See Regions for current coverage.

We've expanded the models available through the Neon AI Gateway, including Kimi K3, GLM-5.2, Inkling, and new additions to the Gemini and GPT families.

The catalog now spans frontier and open-weight models from OpenAI, Anthropic, Google, Meta, Moonshot AI, Alibaba, Zhipu AI, and Thinking Machines. One credential and one base URL reach all of them, so trying a different model means changing a string rather than signing up with another provider:

curl -X POST "$NEON_AI_GATEWAY_BASE_URL/v1/chat/completions" \
  -H "Authorization: Bearer $NEON_AI_GATEWAY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"model": "kimi-k3", "messages": [{"role": "user", "content": "What is Neon?"}]}'

Browse the full catalog in the model reference, where you can filter by provider or open weights and open any model for a copy-paste quickstart. To see what your own project can reach right now, call GET /v1/models.

Note: Set up the Neon backend with your AI agent

To build with the beta services including AI Gateway, install the Neon agent skills so your assistant knows how to provision and wire them up:

npx neon@latest init

Then ask your assistant to get started with Neon. See the backend beta guide for access and setup, or How a Neon backend fits together for a tour of all five capabilities.

Last week we introduced project-level permissions to newly created organizations. Existing organizations are now supported, so every team on Neon has the four organization roles (Admin, Editor, Viewer, and Collaborator) and per-project permissions.

See Neon now has per-project permissions for the announcement, and User permissions for the complete documentation.

Tip: Get started with project permissions

Go from everyone-sees-everything to scoped access in about five minutes. Read the guide.

There are two new additions to the Neon CLI that go together: api-keys mints credentials, and profile stores them and switches between them. Together they let you give an agent a credential that reaches exactly one project, or work across a personal account and a work organization without juggling config directories.

Note: New to the Neon CLI?

Install it with npm install -g neon, then authenticate with neon auth. See the install guide and CLI quickstart to get going.

Minting a key used to mean opening the Console or hand-rolling a neon api request. neon api-keys now covers listing, creating, and revoking keys at every scope:

neon api-keys create --name ci                                        # account key
neon api-keys create --name ci --org-id org-example-12345678          # organization key
neon api-keys create --name agent --project-id green-breeze-12345678  # one project only

Project-scoped keys are the reason this matters. A key created with --project-id can't create projects, can't mint more keys, and can't see any other project, which makes it safe to hand to an agent or a CI job instead of sharing your account.

See the neon api-keys reference and Manage API keys for key types and permissions.

The CLI could only hold one account at a time, so anyone working across two built their own workaround out of --config-dir and shell aliases. A profile is a name pointing at a credentials file, selected per invocation with --profile or NEON_PROFILE:

neon auth --profile work                                            # create or re-authenticate
neon deploy --profile work                                          # use it
neon profile create ci --mint --project-id green-breeze-12345678    # or hold a scoped key, no browser

A profile can hold a browser sign-in or an API key, which is where it meets the scoped keys above. --mint signs in once, keeps only the minted key, and signs the session back out, so afterwards nothing about the profile can open a browser.

The CLI also now stores its configuration in $XDG_CONFIG_HOME/neon, or ~/.config/neon if that isn't set. A pre-existing neonctl directory is still read in place, so there's no migration step.

See the neon profile reference for the full command set and for how --profile resolves against NEON_API_KEY.

We've expanded infrastructure capacity in the AWS Europe (Frankfurt) region (eu-central-1) with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in eu-central-1, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

A feature you've been asking for is finally here. Until now, a person's access applied across your entire organization. We're excited to bring project-level permissions to Neon, so you can now grant people and agents access on individual projects, giving them only what they need where they need it. On any project, you can make someone a Viewer to see its resources, an Editor to change them, or an Admin to manage access and the project itself.

Note: Availability

The new model is available now for newly created organizations and will roll out to existing organizations soon.

Access works in two layers. When both apply, a user keeps the higher level of access:

• Organization roles set a baseline across every project. There are now four: Admin (full control), Editor (work in every project, but can't delete or transfer them), Viewer (read-only), and Collaborator (no access until granted specific projects).
• Per-project permissions raise that baseline on specific projects. Grant a member Viewer (read-only), Editor (connect, query, and edit resources), or Admin (manage access, settings, and the project lifecycle) on any project from Settings → Project permissions.

For example, give a contractor the Collaborator role, which grants nothing by default, then Editor on just the two projects they work on. Or give a teammate Viewer across the organization and Admin on the one project they own.

You can manage the same access through the Neon API, so an orchestrator can provision a project and grant a worker agent scoped access to it:

curl --request PUT \
     --url 'https://console.neon.tech/api/v2/projects/{project_id}/members/{member_id}/role' \
     --header 'authorization: Bearer $ORG_API_KEY' \
     --header 'content-type: application/json' \
     --data '{"role": "editor"}'

The CLI doesn't have a dedicated command yet, but you can call the same route with the neon api passthrough.

When your organization is migrated, it moves to the new model automatically, and everyone keeps the access they have today. No action is required:

• Admins stay Admins.
• Members become Editors, with the same access under the new name.
• Project creators become Admin on the projects they created.
• People with project-share access become Editor on the projects shared with them.

The older project collaboration feature is being replaced by the new Collaborator role plus per-project permissions.

See User permissions for roles, per-project levels, and how the two layers combine.

Two new guides show how to combine the Neon backend services, from long-running compute to LLM access, all in a single project that branches with your data:

• Build durable background workflows with Inngest and Neon Functions: run a multi-step lead-enrichment pipeline on Neon Functions, with each step checkpointed so a failure retries just that step, and an executive summary generated through the Neon AI Gateway.
• Build an LLM proxy with Neon Functions, Neon AI Gateway, and Managed Better Auth: host a secure proxy on Neon Functions that keeps your LLM keys off the browser, authenticates users with Managed Better Auth, enforces per-user rate limits in Postgres, and streams responses from the AI Gateway.

Note: Set up the Neon backend with your AI agent

The backend services (Object Storage, Functions, and AI Gateway) are in beta in AWS us-east-2. To build with them, install the Neon agent skills so your assistant knows how to provision and wire them up:

npx neon@latest init

Then ask your assistant to get started with Neon. See the backend beta guide for access and setup.

Lakebase Search adds scalable vector, keyword, and hybrid search to Postgres through the lakebase_vector and lakebase_text extensions. This week, two new resources show it in action:

• Case study: CommSync runs text, vector, and hybrid search on Postgres with Lakebase Search. See how a unified business inbox powers its main inbox (BM25 text search), AI assistant (semantic search), and command palette (hybrid search with Reciprocal Rank Fusion) from a single database, cutting query latency from 19.5 seconds to 18.6 milliseconds.
• Guide: Build image search over CLIP embeddings with Lakebase Search. Search a Flickr30k corpus by text, by image, and by caption from one vector(512) column, using the lakebase_ann index (IVF + RaBitQ) that builds 50 to 100 times faster than HNSW.

To get started, load the Lakebase Search preload libraries, then create the extensions:

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;
CREATE EXTENSION IF NOT EXISTS lakebase_text CASCADE;

You can now run read-only Postgres diagnostics straight from the Neon CLI with neon inspect db. Each subcommand runs a single, known-good query against Postgres' own statistics and catalog views, then prints a clean table (or JSON/YAML for scripting). There's no connection string to assemble and no catalog view to recall: the CLI resolves the endpoint, role, password, and database through the same Neon API the SDK uses, so you name a diagnostic and go.

Note: New to the Neon CLI?

Install it with npm install -g neon, then authenticate with neon auth. See the install guide and CLI quickstart to get going.

Fourteen subcommands cover the questions you actually ask when something is slow, grouped by what you're chasing:

• Size and storage: table-sizes, index-sizes, bloat
• Indexes and scans: unused-indexes, seq-scans
• Live activity and contention: long-running-queries, locks
• Query workload: outliers, calls (from pg_stat_statements)
• Maintenance: vacuum-stats
• Replication: replication-slots, subscriptions
• Neon cache debugging: lfc-hit-rate, working-set

Every command is read-only, scoped to the columns that answer the question, and capped where results can get large. That makes it as safe to hand to an agent as it is to run yourself. Point it at a linked project, or at any Postgres database with --db-url:

neon link                 # or: neon set-context --project-id <project-id>
neon inspect db bloat

neon inspect db outliers --db-url postgres://<user>:<password>@<host>:5432/<dbname>

See the neon inspect reference for the full command reference, and read the deep dive on our blog.

The Neon CLI now has a first-class neon snapshots command group. Snapshots are point-in-time backups of a branch, and they were previously only available in the Console and REST API. You can manage the full lifecycle from your terminal:

• neon snapshots list and neon snapshots get to see your snapshots.
• neon snapshots create to snapshot a branch, optionally at a point in time with --timestamp or --lsn.
• neon snapshots update and neon snapshots delete to rename, re-expire, or remove a snapshot.
• neon snapshots restore to restore a snapshot into a branch, with a preview step so you can inspect the result before running neon snapshots finalize to commit it.

For example, snapshot a branch before a risky migration, then restore it into a new branch if you need to roll back:

neon snapshots create --branch main --name pre-migration
neon snapshots list
neon snapshots restore pre-migration --name recovered

You can also view and set a branch's automatic backup schedule with neon snapshots schedule get and neon snapshots schedule set. Automated backup schedules are available on paid plans, except for the Agent plan. See the neon snapshots reference for the full list of subcommands.

neon projects create now accepts flags to configure a project up front: choose the PostgreSQL version, create protected branches, and enable logical replication.

neon projects create --name my-app --pg-version 17
neon branches create --project-id <project-id> --name production --protected
neon projects update <project-id> --enable-logical-replication --yes

See the neon projects reference for the full list of flags.

Functions and Object Storage are core pieces of the Neon backend: serverless functions and S3-compatible storage that branch with your database in the same project. You can now query logs from both services directly through the Neon MCP server, so your AI assistant can investigate a failure without leaving your editor. Three new read-only tools make up the observability category:

• query_logs: filter logs by source, service, severity, or a text match over a time window (or drop down to raw LogQL for full control).
• list_log_fields: discover the fields you can filter on.
• list_log_field_values: list the values a field takes, to ground your filters.

Once the MCP server is connected, ask your assistant in plain language:

Why did my function error in the last hour? Check the logs.

The same logs are documented under Neon Functions logs and object storage logs.

Two new guides show how to build on the Neon backend, from declaring your services to shipping a real app:

• Manage Neon projects with neon.ts: use Neon's native TypeScript configuration to provision Postgres, Managed Better Auth, and the Data API, manage branch compute, and generate type-safe environment variables, all from one file that branches with your data.
• Build a Discord bot with Neon Functions and Neon AI Gateway: put Functions and the AI Gateway to work in a single project, with AI chat and image generation hosted next to your database.

Note: Set up the Neon backend with your AI agent

The backend services (Object Storage, Functions, and AI Gateway) are in beta in AWS us-east-2. To build with them, install the Neon agent skills so your assistant knows how to provision and wire them up:

npx neon@latest init

Then ask your assistant to get started with Neon. See the backend beta guide for access and setup.

Neon Object Storage, Functions, and AI Gateway have graduated from private preview to beta. Everyone can start building a complete backend on new or existing projects in AWS US East (Ohio) today.

Declare your whole backend in one neon.ts file, and it branches with your data. Fork a branch and you get an isolated copy of your database, files, functions, and gateway.

• Object Storage: S3-compatible object storage that branches with your database.
• Functions: Long-running serverless functions that run alongside your database.
• AI Gateway: One API for frontier and open-source models, built into your project.

New to the Neon backend? Start with the beta guide, see how the pieces fit together, or build one end to end with the full backend quickstart. For the vision behind the platform, read the announcement blog post.

Note: One-shot your backend with an AI agent

Install the beta agent skills:

npx neon@latest init --preview

Then build your backend from a single prompt:

Set up a Neon backend for my app with Postgres, object storage, functions, and AI gateway

Your agent provisions the services, declares them in neon.ts, and wires them into your app.

We're introducing @neon/sdk 1.1, the best way to work with the Neon API from TypeScript. It's fetch-based, zero-dependency, and generated from our OpenAPI spec, with an ergonomic layer on top. It covers the whole Neon Platform API: projects, branches, databases, and our new backend services (Object Storage, Functions, and AI Gateway). It replaces @neondatabase/api-client as the recommended client, though the legacy package still works.

The ergonomic layer matters most for the multi-step provisioning workflows that might take you or your agent a few attempts to get right (for example, create a project, wait for it to be ready, then create a branch and hand back a connection string). createNeonClient({ apiKey }) gives you namespaced methods (neon.projects, neon.storage, neon.functions, neon.aiGateway, and more), typed { data, error } results, and workflow helpers like createAndConnect. Any method takes { waitForReadiness: true } to block until provisioning finishes, and a raw layer exposes every endpoint.

npm install @neon/sdk

import { createNeonClient } from "@neon/sdk";

const neon = createNeonClient({ apiKey: process.env.NEON_API_KEY! });

// Workflow helper: create, poll until ready, return a connection string
const { data, error } = await neon.projects.createAndConnect({ name: "my-app" });
if (error) throw error;
const { project, connectionString } = data;

// Or wait on any mutation with waitForReadiness
const { data: branch, error: branchError } = await neon.branches.create(
  project.id,
  { name: "preview" },
  { waitForReadiness: true }
);
if (branchError) throw branchError;

// The new backend services are namespaced too
await neon.storage.buckets.create(project.id, branch.id, { name: "uploads" });

Read the announcement blog post for the full story, or see the TypeScript SDK documentation and migration guide for setup, API reference, and moving from @neondatabase/api-client.

You can now sign in to Neon with a passkey instead of a 2FA code. Add a passkey from Account settings and use your device's built-in biometrics, like Touch ID or Windows Hello, or a security key to verify it's you. Passkeys satisfy organization-level 2FA requirements, so admins can let members enroll in either 2FA or a passkey to comply. See Manage your Neon account for setup steps.

We've added a top-level diff command to the Neon CLI, letting you (and your agents) quickly see schema changes between your current branch and any other branch you specify. It fits into a branch-first development workflow alongside neon link, neon checkout, neon status, and neon deploy.

1. neon link: link to a Neon project
2. neon checkout dev-1: create/checkout a dev branch
3. Do the dev work
4. neon diff main: sanity check the schema changes made against main

CREATE TABLE public.orders (    id integer NOT NULL,    customer_id integer NOT NULL,    status text NOT NULL    status text NOT NULL,    discount_code character varying(20));CREATE INDEX orders_discount_code_idx ON public.orders USING btree (discount_code);

Want your agents to use neon diff? Install the Neon agent skills so your assistant has current knowledge of the CLI and reaches for the command on its own:

npx neon@latest init

neon.ts is the TypeScript config file that declares your Neon backend: which services are on (Postgres, Auth, Data API, Object Storage, Functions) and your branch settings (compute size, TTL, protected). The config commands reconcile that file with what's actually live: neon config plan previews the changes, neon config apply makes them, and neon deploy applies and provisions in one step.

These commands now report their changes as a git diff instead of tables so you can see exactly what will change before you confirm:

Planned changes
  + Neon Auth
  + bucket uploads
  ~ main
      computeSettings.autoscalingLimitMaxCu  → 4
      ttl                                    → 2026-07-24T09:49:44.092Z

If apply finds a setting that already differs on the branch, it shows the current value too and stops without changing anything until you re-run with --update-existing.

We've expanded infrastructure capacity in the AWS US East (Ohio) (us-east-2), Europe (London) (eu-west-2), and Asia Pacific (Singapore) (ap-southeast-1) regions with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in these regions, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

The Neon CLI now ships an api command: call any Neon Platform API route from the terminal using your existing CLI login, without hand-building curl requests or giving agents raw API keys.

Dedicated CLI commands cover common workflows, but the Platform API moves faster. With the neon api command, you get full API reach the moment an endpoint exists. Run neon api --list to browse every route from the OpenAPI spec.

Read the announcement for why we built this for agent workflows.

List projects for your organization:

neon orgs list
neon api /projects -Q org_id=org-cool-darkness-12345678

Create a dev branch on an existing project:

neon api /projects/late-frost-12345678/branches -X POST -F branch.name=dev

The -F branch.name=dev flag builds the JSON body { "branch": { "name": "dev" } } automatically. See the api command reference for query parameters, file bodies (-d @file), and output formats.

You can now press Cmd+K (Mac) or Ctrl+K (Windows/Linux) from anywhere in the Neon Console to open a searchable command bar with actions scoped to your current branch and project: navigate to branches, open the SQL editor, create a snapshot, go to settings, and more.

The Neon MCP Server create_branch tool now accepts an optional expiresAt parameter (ISO 8601) to set automatic branch deletion when creating a branch, matching the Neon API and console Auto-delete behavior. See branch expiration.

Connect the MCP Server in your editor:

npx add-mcp https://mcp.neon.tech/mcp

For full setup (API key auth, agent skills, and more), run npx neon@latest init. See Connect MCP clients to Neon.

We've expanded infrastructure capacity in the AWS US East (Ohio) (us-east-2), Europe (London) (eu-west-2), and Asia Pacific (Singapore) (ap-southeast-1) regions with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in these regions, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

Postgres turned 30 on July 8. See our post on X.

Neon is a long-term bet on Postgres. We support Postgres 14 through 18 today, with Postgres 19 support on the way. Our team includes Postgres hackers who contribute upstream and support the wider ecosystem through our Open Source Program. We run standard Postgres, not a fork: Neon is Postgres, with serverless branching and autoscaling built around the database millions of developers already rely on.

Happy birthday, Postgres. 🎂🐘

We're continually improving the Neon CLI and the developer experience around it. Recent additions include branch-first dev loop (neon link, neon checkout, and neon env pull) commands and neon.ts. This week brings a shorter name plus two additional commands.

• The CLI is now just neon

  You can now install the Neon CLI from npm as neon instead of neonctl: npm i -g neon (or run it with npx neon@latest). All commands are now documented as neon rather than neonctl. If you already use neonctl, nothing changes: it's the same CLI, neonctl still works as a command, and no migration or re-authentication is needed. See the Neon CLI install guide.

  The latest CLI now requires Node.js 20.19.0 or higher (previously 18). An existing installation keeps working on your current Node.js version; if you're on an older version, upgrade Node.js before updating the CLI.

• Set up declarative branch management in one step

  The new neon config init command scaffolds a starter neon.ts config file and installs the @neon/config and @neon/env packages, so you can define how each branch is set up (compute size, scale-to-zero, TTL, and which services it uses) declaratively, without any manual setup. It runs entirely locally, and neon link now offers to run it as its final step.

  neon config init

• Check your current branch instantly, with no network call

  The new neon status command is a top-level alias for neon config status. Add --current-branch to print just the branch pinned in your local .neon file:

  neon status --current-branch

  Because it makes no network call, it's fast enough to run on every shell prompt. For example, add your current Neon branch to a starship prompt by appending this [custom.neon] module to ~/.config/starship.toml:

  # ~/.config/starship.toml
  [custom.neon]
  description = "Current Neon branch"
  command = "neon status --current-branch"   # prints the branch pinned in .neon (no network)
  when = "neon status --current-branch"       # exits non-zero when no branch -> segment is hidden
  symbol = "🌿 "
  style = "bold green"
  format = "[$symbol$output]($style) "

  See the config command reference for more.

Neon Object Storage now has a first-class adapter in the Files SDK, the open-source library that gives you one upload, download, and presigned-URL API across S3, R2, GCS, and more. The neon adapter is wired up from the AWS_* variables Neon injects, so pointing your object storage backend at Neon is a one-line config change:

import { Files } from 'files-sdk';
import { neon } from 'files-sdk/neon';

const files = new Files({ adapter: neon({ bucket: 'assets' }) });

// Upload a file, then get a presigned URL to view it
await files.upload('logos/neon-logo.png', body, { contentType: 'image/png' });
const url = await files.url('logos/neon-logo.png', { expiresIn: 3600 });

See the with-files-sdk example for a minimal script that uploads files to a branch-scoped bucket.

Neon Object Storage is part of Neon's new backend services, currently in private preview. If you haven't signed up yet, you can sign up and learn more.

We recently opened Lakebase Search to all Neon users, adding scalable vector, keyword, and hybrid search to Postgres through the lakebase_vector and lakebase_text extensions. This week, our engineering team goes under the hood.

Read Lakebase Search: vector and BM25 on Neon blog post to learn why the usual pgvector + GIN setup breaks down at scale, and how lakebase_ann (IVF + RaBitQ) and lakebase_bm25 (Block-Max WAND) keep indexes on object storage so they stay ready across scale-to-zero and branching.

You can now update a snapshot's expiration with the Update snapshot endpoint. Set expires_at to a future timestamp to change the retention deadline, or send null to remove it so the snapshot never expires. Previously, expiration could only be set when the snapshot was created.

curl --request PATCH \
  --url 'https://console.neon.tech/api/v2/projects/{project_id}/snapshots/{snapshot_id}' \
  --header 'authorization: Bearer $NEON_API_KEY' \
  --header 'content-type: application/json' \
  --data '{
    "snapshot": {
      "expires_at": "2026-12-31T00:00:00Z"
    }
  }'

So that we can ship Neon improvements and fixes faster, the advance notice period for planned updates on the Scale and Enterprise plans is changing from 7 days to 3 days, effective July 10, 2026. Updates take only a few seconds, and Neon prewarms your cache so performance isn't affected.

You can check for update notifications in your project's settings (Settings > Updates). On the Scale and Enterprise plans, you also receive an email notification in advance, in addition to the in-console notice. To learn more, see Updates.

This week, we're spotlighting contributions and integrations from the Neon community and ecosystem.

Neon Testing, the community-built integration testing library by Mikael Lirbank, shipped v3.0.0 with support for Bun Test alongside Vitest. Each test runs against its own isolated Neon branch, with DATABASE_URL set up and torn down automatically, so your tests hit the same schema and constraints as production without mocks or a shared local database.

npm install --save-dev neon-testing

View the package on npm and read the v3.0.0 release notes on GitHub.

Gamut, an AI agent hosting platform with native support for remote MCP servers, now connects to Neon through the Neon MCP server. Setup uses OAuth, matching the existing client flow. To get started, add Neon to your Gamut agent.

Our docs and Postgres tutorials get better thanks to fixes and improvements from the community. A quick thank you to contributors.

@AayushGoswami @AhmedYasinKUL @Arul-1911 @bcw117 @camro @chibx @codenim34 @crebelskydico @da-vaibhav @DorianDragaj @duffuniverse @fcdm @flow145 @harry-whorlow @houssaineamzil @ifeoluwak @Jaskaranrehal @jayhyp @karlhorky @keugenek @michaelgomeh @noo-dev @rahulrao0209 @Ranzeplay @realihorrud @rhutch117 @sanaeft @sdarnadeem @SefterM-zade @slotix @solisoares @this-fifo @VIM4L-M @webwurst

Neon Agent Skills are instruction files that teach AI coding assistants how to work with Neon. The collection now includes skills for Neon Functions, Object Storage, and AI Gateway, the backend services currently in private preview.

To install all Neon agent skills:

npx skills add neondatabase/agent-skills

For the complete list of skills and other install options, see the Agent Skills documentation.

Lakebase Search is now available to all Neon users on Postgres 16+. Two extensions, lakebase_vector and lakebase_text, bring vector, keyword, and hybrid search into Postgres, so you can run semantic RAG, exact-term lookups, and combined rankings without a separate search stack.

First, enable the shared preload libraries and restart your compute. Then install the extensions and query with the same operators you already know from pgvector and full-text search:

CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;
CREATE EXTENSION IF NOT EXISTS lakebase_text CASCADE;

-- Semantic: nearest neighbors by embedding
SELECT title FROM documents ORDER BY embedding <=> $query_vector LIMIT 5;

-- Keyword: BM25 relevance with top-K pushdown
SELECT title FROM documents
ORDER BY body_tsv <@> to_bm25query(to_tsvector('english', 'vector search'), 'documents_bm25')
LIMIT 5;

For production search, combine both with Reciprocal Rank Fusion (RRF): merge top vector and BM25 candidates into one score. The get started guide includes a full hybrid example in TypeScript.

Why Lakebase Search on Neon:

• lakebase_ann: drop-in pgvector compatibility; scales to 1B+ vectors; index builds 50-100× faster than HNSW
• lakebase_bm25: standard tsvector types; BM25 ranking GIN can't do natively
• Scale-to-zero: indexes live in storage, so they're ready immediately after a cold start; branches copy indexes without rebuilds

See the Lakebase Search overview to get started.

We updated supported Postgres versions to 14.23, 15.18, 16.14, 17.10, and 18.4, respectively.

When a new minor version is available on Neon, it is applied the next time your compute restarts. For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.

In June, Vercel introduced Eve, an open-source, filesystem-first framework for durable agents. Sessions checkpoint as they run, can last for days, and pause for human approval before resuming. Eve includes a sandbox, evals, and built-in channels.

We published a guide that pairs Eve with Neon branching. The integration is a small hook in agent/hooks/provision-branch.ts: create a branch when a session starts, delete it when the session ends. Agent tools read the branch connection URI and work against an isolated copy of your production schema.

export default defineHook({
  events: {
    async "session.started"(_event, ctx) {
      const branch = await createBranch(`eve-${ctx.session.id.slice(0, 12)}`);
      dbBranch.update(() => ({ connectionUri: branch.connectionUri }));
    },
  },
});

Read the guide: Running Vercel Eve agents and evals on disposable Neon branches

We're piloting a referral program. Send a friend your referral link, and when they sign up for Neon and spend $5, you get $5 in credits.

This is an early pilot, so we're still shaping it. Tell us what would make a referral program most useful to you, whether that's different rewards, how you share your link, or something else, in our Discord feedback channel.

Neon Object Storage, Functions, and AI Gateway are now in private preview.

• Functions: long-running Node.js compute next to your database. WebSocket servers, SSE streams, AI agents.
• Object Storage: S3-compatible object storage that branches with your data.
• AI Gateway: one API for frontier and open-source models from Anthropic, OpenAI, Google, and more.

neon.ts is a TypeScript config file you commit to your repo. Use it as branch policy infrastructure as code (for example, TTL, compute sizing, and scale-to-zero settings), and to declare which Neon services your project uses:

import { defineConfig } from "@neon/config/v1";

export default defineConfig({
  auth: true,
  dataApi: true,
  branch: (branch) => {
    if (!branch.exists) {
      return {
        ttl: "7d",
        postgres: {
          computeSettings: {
            autoscalingLimitMinCu: 0.25,
            autoscalingLimitMaxCu: 1,
            suspendTimeout: "5m",
          },
        },
      };
    }
    return {};
  },
  preview: {
    functions: { /* ... */ },
    buckets: { /* ... */ },
    aiGateway: true,
  },
});

Apply it with neonctl deploy, preview changes first with neonctl config plan. The @neon/env package gives you type-safe access to the environment variables each declared service injects, so missing or misconfigured variables surface at build time rather than runtime.

If you've signed up for the Neon backend for apps and agents private preview, the preview block enables Functions, object storage buckets, and AI Gateway in the same config. Fork a branch and you get an isolated copy of your database, files, object storage, functions, and AI gateway.

See the neon.ts reference for the full config schema, or read the blog post for a full walkthrough.

This new guide shows how to export your Postgres logs and metrics to SigNoz using the Neon OpenTelemetry integration. Once set up, your database telemetry lands alongside your application data in SigNoz, making it easier to spot and investigate performance issues across your stack.

Send Postgres logs and metrics from Neon to SigNoz

Three new services are now available in beta on Neon.

• Object Storage: S3-compatible object storage that branches with your database
• Functions: Long-running serverless functions that run alongside Postgres
• AI Gateway: One API for frontier and open-source models from Anthropic, OpenAI, Google, and more, built into your Neon project

Lakebase Search brings scalable vector and BM25 full-text search to Neon through two new Postgres extensions, so you can handle semantic and keyword search in a single database without running separate search infrastructure.

• lakebase_vector adds the lakebase_ann index type for approximate nearest-neighbor vector search. Drop-in compatible with pgvector: same types, operators, and query syntax. A single index scales to over 1 billion vectors, with builds 50–100x faster than HNSW.

  CREATE INDEX ON items USING lakebase_ann (embedding vector_l2_ops);
  SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;

• lakebase_text adds the lakebase_bm25 index type for BM25 full-text search. Works with standard tsvector types and operators, adding BM25 ranking and top-K pushdown that PostgreSQL's native GIN index doesn't support.

  CREATE INDEX docs_bm25 ON documents USING lakebase_bm25 (vector bm25_ops);
  SELECT id, vector <&> to_bm25query(to_tsvector('english', 'search'), 'docs_bm25') AS score
  FROM documents ORDER BY score LIMIT 5;

Both indexes live in storage rather than compute memory, so they're available immediately after a cold start. Because Neon branches are copy-on-write, your search indexes are available on every branch without reindexing.

Lakebase Search is in private preview. Request access to try it, or see the Lakebase Search overview to learn more. To see both in action, Build a dual-mode search app with lakebase_vector and lakebase_text walks through building a Next.js knowledge base with semantic and keyword search.

The neonctl psql command now gives you access to psql, the standard PostgreSQL command-line client, without requiring it to be installed. When no native binary is found in your $PATH, neonctl falls back to a built-in implementation automatically. If psql is already on your system, nothing changes.

neonctl psql --project-id <project-id>

You can now manage Neon Auth end-to-end from the CLI:

• Provision, check, and remove Neon Auth on a branch:

  neonctl neon-auth enable
  neonctl neon-auth status
  neonctl neon-auth disable

• Configure Google, GitHub, and Vercel OAuth providers:

  neonctl neon-auth oauth-provider add --provider-id google

• Manage trusted redirect domains:

  neonctl neon-auth domain add https://myapp.com

• Configure email auth, SMTP, organization settings, and webhooks:

  neonctl neon-auth config email-password update --enabled true
  neonctl neon-auth config webhook update --enabled true --url https://myapp.com/webhook

• Manage auth users from the terminal:

  neonctl neon-auth user create --email alex@example.com
  neonctl neon-auth user set-role <user-id> --roles admin

Both are in neonctl v2.23.0. For the full command reference, see neonctl neon-auth. To upgrade, see Neon CLI install.

With neonctl v2.24.0, the branch-first dev loop is complete. neon link and neon checkout shipped last week; this week adds neonctl env pull, which makes every branch switch also update your local credentials.

neonctl link                          # once per project
neonctl checkout my-feature           # create a branch; env pull runs automatically
neonctl env pull                      # or run directly anytime to refresh or use --file

In neonctl v2.24.1, link and checkout run env pull automatically after pinning a branch, so your DATABASE_URL and any Auth or Data API URLs land in .env without a separate step. Use --no-env-pull to opt out, for example when injecting env at runtime via neonctl dev.

If you'd rather not write secrets to disk, the @neon/env package injects branch-scoped variables at runtime:

npm i @neon/env
neon-env run -- npm run dev

For the full walkthrough, see our blog post.

As announced last week, three new services are coming to Neon.

• Object Storage: S3-compatible object storage that branches with your database. Every branch gets its own isolated storage state, so files and data stay in sync across dev, staging, and production.
• Functions: Long-running serverless functions that run alongside your Postgres database. Deploy code, trigger jobs asynchronously, and manage everything through the same CLI and API you already use.
• AI Gateway: One API for frontier and open-source models from Anthropic, OpenAI, Google, and more, built into your Neon project. Streaming responses and per-request logging included. No extra infrastructure required.

Sign up for early access to be among the first to try them when they ship.

Postgres 18 is now the default for newly created Neon projects. Neon continues to support Postgres 14, 15, 16, and 17, if you prefer to stick with those. For a rundown of what's new in Postgres 18, see our Postgres 18 blog post. For Neon's Postgres version support policy, see Postgres Version Support.

We've increased the public network transfer (egress) allowance on all paid plans from 100 GB to 500 GB per project per month. The new allowance takes effect automatically with no changes required on your end, and it will be reflected on your June invoice. To learn more about how network transfer is measured and billed, see Network transfer. For background on why we made this change, see our blog post.

Text-to-SQL suggestions in the Neon SQL Editor are now significantly faster. You'll notice quicker responses when asking the AI to generate queries from natural language, so there's less waiting and more querying. For an overview of the SQL Editor's AI features, see SQL Editor AI features.

Neon CLI v2.22.2 is a major CLI update that brings Vercel-style project linking, branch checkout, a top-level psql command, and full Data API management to the terminal. If you use the Neon CLI, upgrade to access these commands. We're actively evolving the CLI as a first-class tool for both developers and AI agents, and you'll see more improvements in this direction going forward.

New commands

• neon link: Bind the current directory to a Neon project. Writes a .neon context file with your orgId, projectId, and branchId. Supports interactive prompts, non-interactive flags, and --agent JSON mode for AI coding assistants.

  neon link

• neon checkout: Pin a branch in .neon so subsequent commands target it without passing --branch on every command.

  neon checkout <branch>

• neon psql: Connect to a database via psql as a dedicated top-level command. Pass arguments after -- directly to psql.

  neon psql production -- -c "SELECT version()"

• neon data-api: Provision and manage the Neon Data API with create, get, update, refresh-schema, and delete subcommands.

  neon data-api create --database neondb --auth-provider neon_auth

• neon set-context improvements:

  • --branch-id: Set which branch your commands target, the same way you set --project-id and --org-id.

    neon set-context --branch-id br-steep-math-aiu3vve7

  • Find your project from subfolders: Run CLI commands from any subdirectory. The CLI walks up parent folders looking for a .neon file to load your linked project.

    cd my-app/src/components
    neon psql

  • Auto-add .neon to .gitignore: The first time a .neon file is created, the CLI adds it to .gitignore in that folder so local project settings are not committed by accident.

For command reference and options, see the Neon CLI overview or get set up quickly with the CLI Quickstart.

These commands require neonctl 2.22.2 or later. For upgrade instructions including CI/CD usage, see Neon CLI upgrade.

Organization admins and personal account owners can now pay an outstanding invoice immediately from the Neon Console. This is useful as a recovery option when an auto-debit fails.

To pay an invoice manually, go to Billing and open the View/Pay invoices drawer. Select the invoice and follow the link to its hosted payment page. For more, see Manage billing.

We've expanded infrastructure capacity in the AWS Europe (Frankfurt) region (eu-central-1) with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in eu-central-1, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

We're excited to announce that Neon is building a complete backend for apps and agents. Three new services are joining the platform, each built around the same instant, branchable, serverless model as Postgres:

• Postgres — ✅ Available
• Neon Auth — ✅ Available
• Data API — ✅ Available
• Object Storage — 🔜 Coming Soon
• Functions — 🔜 Coming Soon
• AI Gateway — 🔜 Coming Soon

Object Storage is an S3-compatible object storage service that branches with your database, keeping data and files in sync across every branch. Functions are long-running serverless functions deployed alongside your database. The AI Gateway is one API for frontier and open-source models, built on the same infrastructure that handles 125 trillion tokens per month on Databricks.

Read the full announcement and sign up for early access to be among the first to try each service as it becomes available.

The schema line limit for branch comparisons has been raised from 8,000 to 20,000 lines, unblocking diffs on larger production schemas that were previously hitting the ceiling.

If you're not familiar with schema diff: Neon lets you compare the SQL schemas of any two branches side by side. It's useful for reviewing migrations before merging, auditing schema drift between environments, or checking what changed before a branch restore. You can run comparisons from the Neon Console, the CLI (neon branches schema-diff), or the API. There's also a Schema Diff GitHub Action that posts a schema comparison comment on every pull request automatically.

You can now retrieve consumption metrics broken down by branch using GET /consumption_history/v2/branches. It returns the same six usage-based metrics as the project consumption endpoint, but at the branch level:

• compute_unit_seconds
• root_branch_bytes_month
• child_branch_bytes_month
• instant_restore_bytes_month
• public_network_transfer_bytes
• private_network_transfer_bytes

When to use it: The project consumption endpoint (GET /consumption_history/v2/projects) tells you how much each project consumed. The branch endpoint tells you which branches within those projects consumed it. That matters when you're running CI pipelines, parallel development environments, or any workflow that creates many branches. You can attribute usage to individual branches instead of rolling it up to the project.

curl --request GET \
  --url 'https://console.neon.tech/api/v2/consumption_history/v2/branches?project_ids=$PROJECT_ID&org_id=$ORG_ID&from=2026-05-01T00:00:00Z&to=2026-05-29T00:00:00Z&granularity=daily&metrics=compute_unit_seconds,root_branch_bytes_month,child_branch_bytes_month' \
  --header 'Authorization: Bearer $NEON_API_KEY' \
  --header 'Accept: application/json' | jq

The response groups metrics by branch, using the same time-bucketed structure as the project endpoint:

{
  "branches": [
    {
      "branch_id": "br-young-sky-a1b2c3d4",
      "project_id": "calm-night-03860858",
      "periods": [
        {
          "period_id": "7f3a1c2d-4e5f-6a7b-8c9d-0e1f2a3b4c5d",
          "period_plan": "launch",
          "period_start": "2026-05-01T00:00:00Z",
          "consumption": [
            {
              "timeframe_start": "2026-05-01T00:00:00Z",
              "timeframe_end": "2026-05-02T00:00:00Z",
              "metrics": [
                { "metric_name": "compute_unit_seconds", "value": 1440 },
                { "metric_name": "root_branch_bytes_month", "value": 875309056 },
                { "metric_name": "child_branch_bytes_month", "value": 0 }
              ]
            }
          ]
        }
      ]
    }
  ],
  "pagination": {
    "cursor": "br-young-sky-a1b2c3d4"
  }
}

You can filter to specific branches using branch_ids, and paginate through large result sets with the cursor parameter (up to 1,000 branches per page).

Available on paid usage-based plans (Launch, Scale, Agent, Enterprise). See the API reference.

When an agent mutates a database and something goes wrong, you can't just retry the prompt. The data has already changed.

Pairing a Neon snapshot with a serialized copy of your agent's execution state creates a checkpoint you can restore and replay from. Because Neon preserves the connection string after a restore, no app restarts or reconfiguration are needed. Use it to pause before destructive calls, debug by replaying historical runs on an isolated branch, or link every agent trace to a snapshot ID for auditability.

The new guide covers a complete implementation using the OpenAI Agents SDK: Build replayable AI agents with Neon snapshots.

Paid plans now include 100 manual snapshots per project, up from 10. Snapshots created by backup schedules do not count toward this limit.

Manual snapshots are restore points you create on demand. Use them when you want a named snapshot before a specific change, such as a migration, schema update, or release. They are separate from backup schedules, which capture automated snapshots on a regular cadence.

To create a manual snapshot, see Backup & restore.

Snapshots capture your database at a point in time. You can restore a branch from a snapshot when you need to recover data or roll back to an earlier state.

• In the Console: Backup & restore covers snapshots, backup schedules, limits, and restore workflows.
• Via the API: The Neon API supports create, list, update, delete, restore, and schedule management for scripts and agent workflows.

If you're building a platform that provisions databases on behalf of your users or agents, the Neon Agent Plan is built for you. It's a usage-based plan for high-volume, programmatic database provisioning: think codegen tools, multi-tenant SaaS, and AI platforms that spin up a Neon project per user or per agent run.

There's now a companion skill to help you get set up: neon-for-agent-platforms. It gives your AI coding assistant runnable TypeScript samples and workflow guidance for the key Agent Plan patterns: dual-org fleet setup (free-tier vs. paid customer pools), per-tenant project provisioning, project transfer between orgs, and querying the Consumption API.

npx skills add neondatabase/neon-for-agent-platforms -s neon-postgres-agent-platforms

For the full integration guide, see AI agent integration. For more on building agent platforms with Neon and how this skill helps, see the blog post from Neon developer advocate Savannah Longoria.

The Neon MCP create_branch tool now accepts an optional parentId so you can fork any existing branch, not only the project default. If you omit parentId, behavior is unchanged.

Why it helps

If you or an agent is already working on a dev or staging branch, you often want a disposable copy of that branch before a risky migration or experiment, not a fresh fork of the default branch. Passing parentId (the source branch ID, for example br-...) uses that branch as the parent. The Neon API already supported parent_id on Create branch; this MCP update exposes it for agent workflows.

Example prompt

Create a branch named migration-test from my staging branch br-calm-credit-akyk05ll in project young-glade-00225221.

Your agent can call create_branch with parentId set to that branch ID. See the supported MCP tools list for parameters.

Don't have the Neon MCP Server yet?

From your project root:

npx neonctl@latest init

This configures the Neon MCP Server for supported editors and installs Agent Skills. Restart your editor after setup. For OAuth, API keys, and other clients, see Connect MCP clients to Neon.

Neon branching uses copy-on-write, which means creating a branch doesn't copy any data and takes only milliseconds no matter how large your database is. No other Postgres provider does this.

@ant_giuliano from Neon DevRel put together a video that shows you how it works: what branches are, how to create them, and how to use them in your developer and agent workflows.

Watch on YouTube

Neon continues to cover more of the backend stack, and auth is central to that. Four new Neon Auth features:

Magic Link sign-in: The Magic Link plugin lets users sign in via a link sent to their email, no password required. If you're using Neon Auth UI components, enable it with a single prop:

<NeonAuthUIProvider
  authClient={authClient}
  magicLink
>

Enable the plugin from the Console or via the API. See Magic Link plugin.

Phone number sign-in: Existing users can sign in with an OTP delivered by SMS. You bring your own SMS provider, connected via a send.otp webhook. The sign-in flow is a two-step SDK call:

// Step 1: send the OTP
await authClient.phoneNumber.sendOtp({ phoneNumber });

// Step 2: verify the code and sign in
await authClient.phoneNumber.verify({ phoneNumber, code });

Enable the plugin from the Console or via the API. See Phone number plugin.

Wildcard trusted domains: Add a wildcard trusted domain like https://*.my-app-preview.vercel.app to cover all preview deployments under that pattern, instead of adding each hostname individually.

Custom application name: Set a custom name that appears in user-facing auth messages like verification emails. Configurable per branch, so development and production can use different names. See Update auth configuration.

Tip: Getting ready for production? The Auth production checklist covers trusted domains, email provider setup, OAuth credentials, and more.

Two new Neon Auth management tools are now available in the Neon MCP server:

• configure_neon_auth: Configure your Neon Auth setup, including OAuth providers, email providers, and authentication methods.
• get_neon_auth_config: Retrieve your current Neon Auth configuration, including integration metadata.

If you haven't set up the Neon MCP server yet, run npx neonctl@latest init. Once connected, you can configure Neon Auth using natural language in your AI editor. For example:

Set up Neon Auth for my project. Enable Google OAuth and email/password sign-in,
and set the application name to "My App".

See Neon MCP server for full setup details.

Neon works with Stripe Projects, Stripe's platform for AI-native development. With the Stripe Projects CLI installed, your AI agent can provision a Neon Postgres database in a single command:

stripe projects add neon/postgres

Stripe Projects handles authentication and writes credentials directly to your .env file. No dashboards, no copy-pasting connection strings. See the Neon with Stripe Projects guide for a complete example.

Azure regions (azure-eastus2, azure-westus3, or azure-gwc) are deprecated, and you can no longer create new projects in them. Existing Azure projects continue to be supported until further notice. See Azure regions deprecation for details and migration options.

Neon now delivers significantly faster writes across all projects. For write-heavy workloads, this optimization delivers up to a 5x performance improvement in our testing.

This performance enhancement comes from reducing extra write overhead in Postgres and moving more of that work to Neon's storage layer, while preserving durability.

For a technical deep dive, see the blog post: Everyone gets faster writes: Turning off FPW on Neon.

Snapshot storage pricing took effect on May 1, 2026. Snapshots are now billed at $0.09/GB-month. This applies to both manual snapshots and snapshots created by automated backup schedules.

To review snapshot billing, visit the Billing page in the Neon Console. To view snapshot storage, see the Backup & Restore page.

For more about snapshots, see Backup & restore.

Organization admins can now require two-factor authentication for everyone in the organization. You can only enable this if your own account already uses 2FA, so you don't lock yourself out while rolling out the policy. Turn this feature on in Organization → Settings.

For details, see Require 2FA for organization members.

Postgres 18 is now generally available on Neon. The preview limitations have been lifted, and Postgres 18 is fully supported for production workloads. To get started, create a new project and select 18 as the Postgres version.

To learn more about the new features and improvements in Postgres 18:

• Read our blog post: Postgres 18 Is Out: Try it on Neon
• Review the official Postgres 18 release notes

For Neon's Postgres version support policy, see Postgres version support.

Last week we introduced organization spending limits in the Neon Console. From the Billing page, org admins can set a monthly cap, and Neon emails admins when spend reaches 80% and 100% of that limit.

This week the same functionality is available through the Neon API so you can manage your spend limit programmatically.

• View monthly spend limit

  curl "https://console.neon.tech/api/v2/organizations/${ORG_ID}/billing/spending_limit" \
    -H "Authorization: Bearer ${NEON_API_KEY}" \
    -H "Accept: application/json"

• Set monthly spend limit

  curl -X PUT "https://console.neon.tech/api/v2/organizations/${ORG_ID}/billing/spending_limit" \
    -H "Authorization: Bearer ${NEON_API_KEY}" \
    -H "Content-Type: application/json" \
    -d '{"spending_limit_cents":10000}'

• Delete monthly spend limit

  curl -X DELETE "https://console.neon.tech/api/v2/organizations/${ORG_ID}/billing/spending_limit" \
    -H "Authorization: Bearer ${NEON_API_KEY}" \
    -H "Accept: application/json"

For details, see Spending limits and the April 24 changelog.

We've expanded infrastructure capacity in the AWS US East (N. Virginia) region (us-east-1) with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in us-east-1, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

Neon branching gives you an isolated copy of your database with production-like data and separate compute, so you can run Grafana k6 against your application without hammering production or relying on an undersized staging database. Create a branch from your production branch, point your app at the branch connection string, exercise realistic concurrency with k6, then tune queries and indexes on the branch and validate improvements before you ship changes.

The guide Simulate production load using Neon branching and k6 walks through the full flow. It uses a branch named load-test-branch in the examples; with the Neon CLI, a minimal create from your real data branch looks like this:

neon branches create \
  --name load-test-branch \
  --parent main \
  --project-id "$NEON_PROJECT_ID"

Use the new branch's connection URI in DATABASE_URL, then run your app and k6 against that database.

The guide's load-test.js centers on options: stages ramp virtual users up and down, and thresholds fail the run if latency or errors cross the line. A tiny export default is still required so k6 knows what each virtual user does. The full guide adds category mix, check, and sleep for realism:

const http = require('k6/http');

export const options = {
  stages: [
    { duration: '10s', target: 20 },
    { duration: '30s', target: 50 },
    { duration: '10s', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<50'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  http.get('http://localhost:3000/api/products?category=Electronics');
}

You can now set a monthly spending limit for your organization from the Billing page in the Neon Console. When spend reaches 80% and 100% of that limit, Neon sends email alerts to organization admins. Spend is evaluated about every 15 minutes, and reminder emails continue weekly until you raise the limit or the billing cycle resets.

When you enable a limit, you enter a dollar amount and choose threshold behavior. Email alerts are available now. In a future release, you'll be able to suspend computes automatically when the limit is reached.

To get started, see Spending limits.

Building on the recent snapshot size fields added to snapshot API responses, the Retrieve project consumption metrics endpoint now supports a snapshot_storage_bytes_month metrics parameter. Use it to track monthly snapshot storage in your project-level consumption reporting.

Example response body (excerpt):

{
  "timeframe_start": "2026-02-05T00:00:00Z",
  "timeframe_end": "2026-02-06T00:00:00Z",
  "metrics": [
    { "metric_name": "root_branch_bytes_month", "value": 758611968 },
    { "metric_name": "instant_restore_bytes_month", "value": 983488 },
    { "metric_name": "snapshot_storage_bytes_month", "value": 0 }
  ]
}

Note: Snapshot billing

Snapshot storage is billed at $0.09/GB-month as of May 1, 2026. See Backup & restore and Plans for pricing details.

For the full list of metrics, see Querying consumption metrics.

The Neon MCP Server now supports an Add to Kiro badge for one-click MCP setup. Thanks to Anil Maktala for the contribution.

https://kiro.dev/launch/mcp/add?name=Neon&config=%7B%22url%22%3A%20%22https%3A//mcp.neon.tech/mcp%22%7D

Tip: Did you know?

Neon is also a Kiro Power. See Neon Is Now a Kiro Power for details.

Multi-step agents depend on LLMs and tools that can time out, rate limit, or fail mid-run. A practical pattern is durable execution: checkpoint progress in Postgres so a workflow can resume after a crash or retry without redoing expensive steps from scratch. DBOS provides that durable execution layer, Pydantic AI structures agent logic and tool orchestration, and Neon backs the database so checkpoint state lives in serverless Postgres that scales with your workload.

For a full walkthrough with a working example, see Building Durable AI Agents with Pydantic AI, DBOS, and Neon.

We've been optimizing our docs for AI agents. The post Agents grew up, so did our docs covers what worked, what didn't, and what we're still figuring out. It includes findings from a scan of 250+ doc sites, plus details like our MDX-to-Markdown pipeline, content negotiation (serving Markdown to agents or by appending .md to any doc URL), agent-aware 404 handling, and a restructured llms.txt index.

The Neon Postgres plugin is officially available in the OpenAI Codex plugin directory. It adds the Neon MCP Server and Neon-focused Agent Skills to Codex, so you can create and manage Neon projects, branches, and databases from chat, run SQL and migrations, and get guided help on connections, branching, autoscaling, Neon Auth, and more.

Codex CLI: If you do not have the CLI yet, install it and start codex:

npm

npm install -g @openai/codex
codex

Homebrew

brew install --cask codex
codex

Then in Codex run /plugins, find Neon Postgres, and choose Install plugin. Complete any Neon sign-in or connection prompts.

For Codex app instructions, more detail on what's bundled, and example prompts, see Codex plugin for Neon. For an overview, see the Neon blog.

The snapshot object in the Neon API now supports full_size and diff_size fields for monitoring snapshot storage.

• Manual snapshots expose full_size: the full logical size at the time of the snapshot.
• Scheduled snapshots: the first scheduled snapshot reports the full logical size via full_size. Subsequent snapshots report a diff_size value, which is the storage since the previous scheduled snapshot.

{  "snapshots": [    {      "id": "snap-twilight-boat-an3a2yx2",      "name": "production at 2026-04-17 09:57:07 UTC (manual)",      "source_branch_id": "br-gentle-leaf-anax5tl3",      "created_at": "2026-04-17T09:57:09Z",      "manual": true,      "full_size": 30965760    }  ]}

The fields are supported on snapshot objects in responses from:

• Create snapshot
• List snapshots
• Update snapshot

For more on these fields (when each is present, omitted, or zero, and how that relates to charging and incremental billing), see Snapshot size fields in API responses in Backup & restore.

Note: Snapshot billing reminder

Snapshot storage billing starts May 1, 2026. For more information, see Backup & restore.

We've expanded infrastructure capacity in the AWS Asia Pacific (Singapore) region (ap-southeast-1) with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in ap-southeast-1, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

The Neon Auth page now includes a Plugins tab. Organization plugin settings (limits, creator role, invitation email) moved here from Configuration, so plugin-related options stay in one place.

See Organization plugin for what each setting does and how it maps to your app.

Info: New to Neon Auth?

Neon Auth is Neon's managed authentication: users, sessions, and organizations live in your Neon database next to your app data. For overviews, quick starts, plugins, and SDKs, see the Neon Auth documentation.

skills.sh is a registry of reusable Agent Skills for compatible coding assistants. Add the Neon skill from neon-postgres on skills.sh so your assistant gets structured guidance for Neon Postgres: connections, branching, Neon Auth, APIs, CLI, and MCP.

Watch the demo below to learn more.

Watch on YouTube

Other ways to install (including Cursor, Claude Code, npx skills, and neonctl init) are covered in Agent Skills.

Diagnosing and fixing production errors with Sentry and Neon MCP shows how to connect an AI agent (such as Cursor) to the Sentry and Neon MCP servers. You pull stack traces and the failing query from Sentry, then use Neon branching to create an isolated database copy, apply and validate fixes (for example with EXPLAIN ANALYZE), and ship the change to production when you are ready.

Copy page in the header opens a menu on every Neon Docs page: copy the page as Markdown, or open it in ChatGPT or Claude to ask questions with the page in context.

Set up Neon with AI appears in the right-hand sidebar. Choose it to open a modal where you can copy npx neonctl@latest init (npm or Homebrew tabs).

The init command gives your assistant Neon context and configures the Neon MCP Server. For the full flow and supported tools, see Connect MCP clients to Neon.

The neon extension is now version 1.14, up from 1.9. The neon extension can be used to monitor Local File Cache usage (how often pages are served from cache versus database storage) through the neon_stat_file_cache view and EXPLAIN ANALYZE. See The neon extension for details.

Neon support for the pg_search extension is deprecated. As of March 19, 2026, it is not available for new Neon projects.

If you already use pg_search: you will continue to have access to the extension on your existing projects. Our team will contact you to discuss alternative options and deprecation timelines. You do not need to take action before we reach out. See The pg_search extension for alternatives you may want to explore.

As of April 7, 2026, all Neon Azure regions (azure-eastus2, azure-westus3, and azure-gwc) are deprecated.

If your project already runs in an Azure region: your databases keep running as they do today.

If your organization actively uses Azure regions: you can continue to create new projects in Azure regions to maintain your current operations. Otherwise, new Azure project creation is no longer available.

We will contact you directly to discuss migration options and timelines. You do not need to migrate on your own before we reach out. See Region migration if you want to start planning a move.

Tip: How to check if you are on an Azure region

Open your organization's Projects page. Your project's region is shown in the Projects table.

Building stateful AI Agents with Mastra and Neon Postgres shows how to use Mastra's Memory module with Neon so agents keep context across threads and sessions instead of starting from scratch every time.

Build a Data-Driven AI Assistant on Slack with Vercel AI SDK and Neon Read Replicas walks through a Slack bot that answers data questions with the Vercel AI SDK. Queries run against a Neon read replica so production stays protected.

Neon is now part of Stripe Projects. Stripe Projects is a Stripe CLI workflow for hooking an app up to backends. You pick services from a catalog (databases, hosting, auth, and more), provision them into your provider accounts, and get connection strings and keys in your environment so your agent can run against a live backend.

Example Stripe CLI flow (after you install the Stripe CLI):

stripe projects init my-app   # set up your project
stripe projects catalog        # browse available services
stripe projects add neon/postgres       # provision a Neon database

Learn more in Neon works with Stripe Projects for agentic provisioning.

To apply updates to your Neon compute (Postgres upgrades, security patches, and the like), we restart the compute where Postgres runs during your update window. The restart itself typically takes only a few seconds, but in-memory caches are left cold, which can impact query performance until they warm up again.

To protect performance, we now prewarm your compute's cache during the update process without affecting restart times. There are no additional compute or storage costs associated with this enhancement.

For the technical details, see our blog post: Zero-Downtime Patching Part 1: Prewarming.

Snapshots are billed at $0.09/GB-month as of May 1, 2026.

We announced support for Neon Auth webhooks a couple of weeks ago. With webhooks, your app receives auth events over HTTP so you can send OTPs and other auth messages through your own email, SMS, or WhatsApp providers, validate signups, or sync to other systems.

This week we have a new guide, Customizing Neon Auth with Webhooks, that walks you through setting up a Next.js app that handles webhooks, sends OTP email with Resend, tests locally with ngrok, and uses a blocking handler to reject signups you don't want. You can reference this guide alongside our Webhooks docs when you are ready to implement.

Neon's instant database branching and AI coding agents work well together. Branching gives each run an isolated Postgres database in seconds, so agents can perform schema migrations, run tests, and try risky changes safely. The new guides below demonstrate this workflow with Codex and Claude Code.

• Safe AI-powered schema refactoring with OpenAI Codex and Neon: Use OpenAI Codex CLI with the Neon MCP Server so Codex can create an isolated branch, run Drizzle migrations, and validate schema refactors safely. In your project, wiring Codex to Neon is a small MCP configuration:

  [mcp_servers.neon]
  url = "https://mcp.neon.tech/mcp"
  bearer_token_env_var = "NEON_API_KEY"

• Isolated Subagents: Running Claude Code in parallel with Neon Database Branching: Use a post-checkout hook to give each Claude Code subagent its own Git worktree and Neon branch, so parallel agents can run without code or database collisions.

The npx neonctl@latest init command, which sets up Neon and configures the Neon MCP Server for you, now supports more AI assistants including VS Code, Claude Code, Cursor, Claude Desktop, Codex, OpenCode, Antigravity, Cline, Cline CLI, Gemini CLI, GitHub Copilot CLI, Goose, MCPorter, and Zed.

Run it from the root directory of your project:

npx neonctl@latest init

The init command uses add-mcp to configure the Neon MCP Server for your AI assistant. See Supported agents (add-mcp) for the full list of supported agents.

Paid plans can open Request billing support on the Billing page. The form lets you choose an invoice and describe your issue.

• neon-auth-orgs-example in neondatabase/neon-js: A small multi-tenant todo app that demonstrates Neon Auth's Organization plugin end to end. Learn more about the Organization plugin. For other Neon Auth samples, browse examples/ in that repo.

• Build your own Full-Stack Cloud Agents with Cloudflare Sandboxes and Neon Database Branching: Run a Cloudflare Sandbox worker that creates a Neon branch per task, runs an agent such as Claude Code with a branch-specific DATABASE_URL, then commits and opens a pull request.

• Triaging pull requests with OpenCode and Neon Database Branching: Use GitHub Actions with OpenCode and Neon's create-branch-action, so each issue-triggered run gets its own Postgres branch for schema changes, migrations, and validation before the PR.

You can now add unlimited members to each organization on the Free plan. Collaborate with teammates, invite others to your org, or keep separate workspaces for personal projects, side projects, and collaborations.

Info: What are orgs and members?

An organization is a workspace that owns Neon projects and where you manage projects and collaborate. Members are people you invite to your organization. Learn more.

With unlimited members, listing them efficiently matters. The API for listing organization members now supports pagination and sorting, and the Console members page supports sorting and pagination. Member objects also include an optional has_mfa field, and the Console shows a 2FA indicator, following the recent introduction of two-factor authentication (2FA).

# First page
curl -X GET \
  'https://console.neon.tech/api/v2/organizations/{org_id}/members?limit=20&sort_by=joined_at&sort_order=desc' \
  -H 'Authorization: Bearer $NEON_API_KEY'

# Next page (use cursor from response.pagination.next)
curl -X GET \
  'https://console.neon.tech/api/v2/organizations/{org_id}/members?limit=20&cursor=...' \
  -H 'Authorization: Bearer $NEON_API_KEY'

"user": { "email": "user@example.com", "has_mfa": true }

We're introducing two new Neon Auth features this week.

Organization settings. You can now configure Organizations for Neon Auth from the Neon Console. Go to Auth > Configuration > Organizations (per branch) to enable or disable the plugin, set the maximum organization memberships per user and the maximum members per organization, choose the creator role (owner or admin) for new organizations, and control whether invitation emails are sent. These settings support multi-tenant apps where users create and join organizations. See Organization in the Neon Auth docs.

Webhooks. Introducing Neon Auth webhooks. Configure webhooks to receive HTTP POST requests when authentication events occur (OTP delivery, magic link delivery, user creation). Use them to replace built-in email delivery with your own channels (SMS, custom email, WhatsApp), validate signups before they complete, or sync new users to CRMs and analytics. The guide covers event types, API configuration, payload structure, signature verification, expected responses, retry behavior, and testing. See Webhooks.

We've expanded infrastructure capacity in the AWS US East (N. Virginia) region (us-east-1) with new NAT gateway IP addresses and new VPC endpoint service addresses for Private Networking.

Tip: Update your IP allowlists

If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new NAT gateway addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

If you use Private Networking in us-east-1, you can now use the additional VPC endpoint service addresses for enhanced capacity and reliability. See the Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

Network transfer (egress) is data sent from your Neon databases to clients. It's one of the usage metrics that affects your bill on paid plans, and many teams only notice it when it shows up as a line item.

We've added two things to help. First, a guide that explains what network transfer is, what typically drives it (queries, pg_dump, logical replication, log export), how to monitor it in the Console and via the Consumption API, and how to manage or reduce usage. See Reduce network transfer costs.

Second, an agent skill that guides your AI assistant through diagnosing and fixing application-side query patterns that cause excessive egress. The skill walks through analyzing your codebase for anti-patterns (such as SELECT *, missing pagination, high-frequency queries on static data, and application-side aggregation), applying fixes, and verifying with tests. To add it:

npx skills add neondatabase/agent-skills -s neon-postgres-egress-optimizer

Neon now supports two-factor authentication (2FA) for your account. Once enabled, you enter a 6-digit code from your authenticator app (for example, Google Authenticator, Authy, or 1Password) each time you log in. Set it up from your profile menu: Account settings → Set up two-factor authentication, then scan the QR code and verify with a code from your app. For details, see Two-factor authentication.

Data API Advisors is a new tab on the Monitoring page that helps you secure and tune your database when you use the Neon Data API, Neon's HTTP interface for querying your database from browsers, serverless functions, and edge runtimes. Because the Data API exposes your schema directly over HTTP, the RLS policies and security you define on your schema are critical. The advisors scan your database and report security and performance issues (such as missing RLS, sensitive columns exposed, or unindexed foreign keys) with severity levels and recommended fixes.

In the Neon Console, go to Monitoring > Data API Advisors for your branch to run a scan and view issues grouped by category.

For details, see Data API Advisors.

MCP servers make it incredibly easy to integrate tools and platforms. In this guide, learn how to combine the Neon MCP server with the Vercel MCP server so AI agents can diagnose production errors, validate database fixes on a Neon branch, and open pull requests with code changes. Try it with Claude Code or any agent that supports MCP. See AI-driven incident response with Vercel and Neon MCP.

You can now add unlimited members to each organization on the Free plan. Collaborate with teammates, invite others to your org, or keep separate workspaces for personal projects, side projects, and collaborations. No credit card required. For details, see Manage billing and Neon plans.

Info: What are orgs and members?

An organization is a workspace that owns Neon projects. Members are people you invite to the organization. Learn more.

We updated supported Postgres versions to 14.21, 15.16, 16.12, 17.8, and 18.2, respectively.

SELECT version();
PostgreSQL 18.2 (e21737f) on aarch64-unknown-linux-gnu, compiled by gcc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0, 64-bit

When a new minor version is available on Neon, it is applied the next time your compute restarts. For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.

We've added support for the timescaledb extension on Postgres 18. Install it with:

CREATE EXTENSION timescaledb;

See The timescaledb extension for setup and usage.

We've added claimable-postgres to the Neon Agent Skills collection. With this skill, your AI assistant can provide an instant temporary database via Claimable Postgres by Neon and obtain a connection string autonomously, without human intervention, account creation, or credit card. For details, see Claimable Postgres by Neon.

Tip: How to get Neon Agent Skills

npx (skills only):

npx skills add neondatabase/agent-skills -s claimable-postgres

Neon Agent Skills repository

Run multiple AI coding agents in parallel without collisions by giving each agent its own Git worktree (isolated working directory) and Neon database branch from a single repository. The guide shows how to avoid file, Git, and database conflicts and ties it together with a post-checkout hook so spinning up a new agent with its own database takes one command. See the guide: Git worktrees with Neon branching.

Use the Neon MCP Server with Google Jules to give AI agents an isolated database branch for each feature. Connect Jules to Neon MCP so it can spin up branches, apply schema changes and migrations, and open PRs without touching production. See the guide: Google Jules and Neon MCP.

Developers told us they want to quickly copy the database connection string to drop into their application. Based on that feedback, the Connect modal on the project dashboard now defaults to Connection string in the snippet dropdown instead of the psql command. You can still choose any snippet from the dropdown (e.g., psql), and your preferred option is saved for the next time you open the Connect modal.

The Neon Cursor plugin is now available. It adds Neon Skills and MCP integration to Cursor so your assistant can use workflow guidance (connection methods, ORMs, branching) and run database operations from natural language, including listing projects, creating branches, running SQL, and more. In Cursor chat, run /add-plugin neon-postgres, or run /add-plugin and search for neon. The plugin appears as Neon Postgres in the Add Plugin menu:

After installation, prompt with "Get started with Neon" to complete authentication. For setup and usage, see Cursor plugin for Neon.

We've expanded infrastructure capacity in the AWS Europe (Frankfurt) region (aws-eu-central-1). If you have IP allowlists on external systems that Neon connects to, or if you use Private Networking in this region, update your allowlists or VPC endpoint configuration to include any new addresses. See our Regions documentation for the complete list of NAT gateway IPs and the Private Networking guide for VPC endpoint service addresses by region.

A new community-contributed Neon CircleCI Orb provisions a Neon database branch per job, so your CI database is production-like in behavior with fewer "works in CI, breaks in prod" surprises. Each run gets an isolated, ephemeral branch. You can branch from a pre-migrated base to skip running migrations from scratch. The orb handles cleanup and TTL when the job ends. Because each run has its own branch, tests stay deterministic and parallel runs don't share state. Example:

version: 2.1

orbs:
  neon: dhanushreddy291/neon@1.0

workflows:
  test_workflow:
    jobs:
      - neon/run_tests:
          migrate_command: npm run db:migrate
          test_command: npm test

See the Automate branching with CircleCI guide to get started. The guide covers the neon/run_tests job and the neon/create_branch, neon/delete_branch, and neon/reset_branch commands.

You can now add members to your organization by email domain. Organization admins can add and verify one or more domains (for example, yourcompany.com) in your Neon organization Settings, under Domains.

When a user signs up or logs in to Neon with an email that matches a verified domain, they're automatically added to your Neon organization as a Member, no invite email required. They see your organization in the org switcher in the Neon Console.

This is useful for teams that want everyone within the company email domain to have access without needing to send individual invites. You simply add your domain in the Neon Console, add a TXT record at your DNS provider to verify ownership, then click Verify in the Neon Console.

Colleagues who already have Neon accounts are added to the organization the next time they log in. For the full flow and behavior (roles, multiple domains), see Add members by domain.

This week's Neon MCP Server release brings new tools for pulling Neon documentation and setup guidance into your development environment, plus a new guide for connecting Google Jules to the Neon MCP Server.

New documentation retrieval tools

The MCP Server now includes two tools so your AI agent or MCP client can fetch Neon docs on demand:

• list_docs_resources – Lists all available Neon documentation pages from the docs index. Returns page URLs and titles so you can choose which page to load.
• get_doc_resource – Fetches a specific Neon documentation page as markdown. Use list_docs_resources first to discover page slugs, then pass the slug to this tool to load the content.

Together, these tools let your agent or assistant look up setup, configuration, and how-to content from the Neon docs without leaving the chat.

Neon MCP Server on Google Jules

The Neon MCP Server is now available in Google Jules, Google's AI-powered coding assistant. Create a Neon API key, add the server in Jules settings, and you're set. Full setup steps are in Connect MCP clients to Neon.

We've published a Compute Autoscaling Report that breaks down how Neon's autoscaling compute compares to provisioned, fixed compute sizes, based on real production workloads that run on Neon.

Coming soon: Key Findings

• Production databases on Neon use 2.4x less compute and 50% less cost than if they were running on provisioned, fixed compute sizes.
• Putting the same production workloads on provisioned, fixed compute sizes would result in 55 performance degradations per database per month.
• Read replicas on Neon use 4x less compute than if they were running on provisioned, fixed compute sizes.
• Running the same small scale-to-zero workloads on provisioned, fixed compute sizes would cost 7.5x more.

The report walks through what happens when you use provisioned, fixed compute sizes vs. autoscaling compute, and how that impacts cost and performance. If you've ever wondered how much autoscaling actually saves you (or how it behaves under real traffic), the report lays it out with real data and the full methodology.

To learn more about Neon's autoscaling feature and how to enable it for your projects, see Autoscaling.

You can now specify a custom header name for API key authentication when configuring OpenTelemetry integrations. The header defaults to X-API-Key if not specified. This makes it easier to integrate with services like Honeycomb that expect a different header name for API keys.

A new consumption history API for current usage-based plans is now available on all paid plans, including Launch. The metrics returned align directly with usage-based billing, so what you query matches what you see on your invoice.

Use this API to build custom dashboards, integrate with your reporting tools, or set up usage alerts. Query at hourly, daily, or monthly granularity for metrics like compute usage, storage (root and child branches), instant restore, data transfer, and extra branches.

This example retrieves month-to-date usage for all metrics:

curl --request GET \
     --url 'https://console.neon.tech/api/v2/consumption_history/v2/projects?from=2026-02-01T00:00:00Z&to=2026-02-06T00:00:00Z&granularity=daily&org_id=$ORG_ID&metrics=compute_unit_seconds,root_branch_bytes_month,child_branch_bytes_month,instant_restore_bytes_month,public_network_transfer_bytes,private_network_transfer_bytes,extra_branches_month' \
     --header 'Accept: application/json' \
     --header 'Authorization: Bearer $NEON_API_KEY' | jq

For API details, see Retrieve project consumption metrics. For more information, see Querying consumption metrics.

Try it with your AI agent:

Copy this prompt to have an AI assistant help you build the curl command for your desired time period. View prompt

You can now configure the Neon MCP Server for all detected AI agents and editors in your workspace with a single command:

npx add-mcp https://mcp.neon.tech/mcp

This adds the MCP config to your editor; restart your editor (or enable the MCP server in settings). When you use the connection, an OAuth window will open in your browser to authorize access. For the full setup (MCP server plus agent skills and VS Code extension), use npx neonctl@latest init instead. It configures the MCP server for Cursor, VS Code, Claude Code, and others using API key authentication.

With OAuth, the MCP server uses your personal Neon account by default. To use organization projects, provide org_id or project_id in your prompt. For API key-based authentication (e.g., remote agents), use:

npx add-mcp https://mcp.neon.tech/mcp --header "Authorization: Bearer $NEON_API_KEY"

For more setup options (including global vs project-level), see Connect MCP clients to Neon and the add-mcp repository.

We've expanded extension support for Postgres 18:

To install these extensions, run:

CREATE EXTENSION pg_graphql;
CREATE EXTENSION pgx_ulid;

For a complete list of Postgres extensions supported by Neon, see Postgres extensions.

We've released a major update to the server-side Neon Auth SDK (@neondatabase/auth/next/server) for Next.js applications.

Unified entry point

The SDK now uses a single createNeonAuth() function that replaces the previous separate functions (neonAuth(), authApiHandler(), neonAuthMiddleware(), createAuthServer()). Configure authentication once and access all functionality from a single object:

// lib/auth/server.ts
import { createNeonAuth } from '@neondatabase/auth/next/server';

export const auth = createNeonAuth({
  baseUrl: process.env.NEON_AUTH_BASE_URL!,
  cookies: { secret: process.env.NEON_AUTH_COOKIE_SECRET! },
});

// Use everywhere in your app
export const { GET, POST } = auth.handler();           // API routes
export default auth.middleware({ loginUrl: '...' });   // Middleware
const { data: session } = await auth.getSession();     // Server components
await auth.signIn.email({ email, password });          // Server actions

Explicit configuration

Configuration is now explicit rather than implicit. You must pass baseUrl and cookies.secret directly to createNeonAuth() instead of relying on automatic environment variable reading, making dependencies clear and eliminating "magic" behavior.

Session caching

Session data is now automatically cached in a signed cookie, reducing API calls to the Auth Server by 95-99%. Sessions are cached for 5 minutes by default (configurable) and automatically refresh as needed.

Breaking changes

This release includes breaking changes. If you're using Neon Auth and want to upgrade to the latest SDK version, you will need to update your application code. Key changes include replacing separate auth functions with the unified createNeonAuth() API, adding a required NEON_AUTH_COOKIE_SECRET environment variable, and adding dynamic = 'force-dynamic' to server components that use auth methods.

For detailed migration instructions, see the migration guide. For complete API documentation, see the Next.js Server SDK reference.

Getting started

To see the latest SDK in action, check out the demo applications, including a Next.js demo with server components, a React + Vite demo with external UI, and a React demo with the full neon-js SDK. The repository also includes AI coding assistant skills for Cursor and Claude Code with updated setup guides and code examples. See the Neon Auth quick start and Server SDK reference to get started.

Neon Auth is a managed authentication service that branches with your database. See the Neon Auth overview to learn more.

Claimable Postgres by Neon now offers a REST API for programmatic database provisioning, making it easy to integrate Postgres into your platform, CI/CD pipelines, testing frameworks, and automation workflows.

The new API enables you to create databases with a single HTTP request:

curl -X POST https://neon.new/api/v1/database \
  -H 'Content-Type: application/json' \
  -d '{"ref": "your-app-name"}'

The API returns the ID, status, Neon project ID, connection string, claim URL, expiration timestamp, and creation/update timestamps. You can also retrieve database details using GET /api/v1/database/:id. Unclaimed databases have a 100 MB storage limit and expire after 72 hours. Claim your database to a Neon account to remove the expiration and get full Free plan limits.

The neon-new CLI also adds a new --logical-replication flag to enable logical replication for real-time sync with tools like ElectricSQL.

Update: The CLI was get-db at the time of this release; it's now neon-new.

Claimable Postgres provides instant cloud-hosted Postgres that spins up in seconds. No signup or registration required. See the Claimable Postgres documentation for more information.

We've added new NAT gateway IP addresses in the AWS US East (N. Virginia), US East (Ohio), and US West (Oregon) regions to expand infrastructure capacity. If you have IP allowlists on external systems that Neon connects to, update those allowlists to include the new addresses. Connections may be affected intermittently if traffic routes through non-allowlisted NAT gateways.

See our Regions documentation for the complete list of NAT gateway IPs for all regions.

We've added new VPC endpoint service addresses for Private Networking in the AWS US East (N. Virginia), US East (Ohio), and US West (Oregon) regions. If you've set up Private Networking in these regions, you can now use the additional endpoint service addresses for enhanced infrastructure capacity and reliability.

For the complete list of VPC endpoint service addresses by region, see our Private Networking guide.

Install our Agent Skills to teach your AI coding assistant about Neon best practices, connection methods, ORM setup, and branching workflows. Works across Claude Code, Cursor, VS Code, and other AI tools.

npx skills add neondatabase/agent-skills

Agent Skills work alongside the Neon MCP Server. The skill provides reasoning and guidance while the MCP server provides capabilities like creating branches and running queries. Learn more in our blog post on Agent Skills.

The Neon MCP Server now supports provisioning the Neon Data API for your databases with optional JWT authentication. Ask your AI assistant:

Can you provision Data API access for my database with Neon Auth authentication?

The provision_neon_data_api tool enables HTTP-based access to your Neon databases and supports multiple authentication options: unauthenticated access, Neon Auth, or external providers (Clerk, Auth0, Stytch, and others). This makes it easier to set up Data API access directly from your AI assistant without switching to the Neon Console.

To get started with the Neon MCP Server, run npx neonctl@latest init to install and configure it automatically. Learn more in Neon MCP Server.

Neon now supports Postgres 18's protocol 3.2 with enhanced cancellation keys. This protocol support applies retroactively to all Postgres versions (14, 15, 16, 17, and 18). Clients that support the new protocol will automatically benefit from these improvements without any configuration changes needed.

We've added quick actions to the Neon docs. Everything you need to go from docs to working code is now just a click away.

Quick actions available on every doc page:

• Copy page as markdown
• Open in ChatGPT or Claude
• Copy neon init command for MCP Server setup
• Connect MCP on Cursor or VS Code

Find the prompts on the documentation homepage or try them here:

• Next.js prompt
• Django prompt
• Drizzle prompt
• React Router prompt
• TanStack Start prompt
• Express prompt
• NestJS prompt
• Astro prompt
• SvelteKit prompt
• Nuxt prompt
• Laravel prompt
• Rails prompt
• Python prompt
• Go prompt
• Java prompt
• Rust prompt
• .NET prompt
• Elixir prompt
• Phoenix prompt
• Prisma prompt
• Kysely prompt
• TypeORM prompt
• SQLAlchemy prompt
• Hono prompt
• SolidStart prompt
• Reflex prompt
• JavaScript prompt
• Symfony prompt
• Quarkus prompt
• Micronaut prompt
• Redwood prompt

Both the Vercel-managed and Neon-managed integrations now automatically provision Neon Auth on preview branches when enabled on your production branch. Preview deployments get the NEON_AUTH_BASE_URL and VITE_NEON_AUTH_URL environment variables configured automatically.

Neon Auth provides managed authentication that stores user profiles in your database. When your database branches, auth data branches with it, making it easy to test authentication in isolated preview environments. Learn more.

To see this in action, check out this new end-to-end guide: Testing Auth Changes Safely with Vercel and Neon Branching.

The neon init command now configures both the Neon MCP Server and the Neon VS Code Extension in a single step:

npx neonctl@latest init

This command authenticates via OAuth, creates a Neon API key, and sets up:

• Neon MCP Server: Lets AI assistants manage your Neon projects, branches, and databases through natural language commands
• Neon VS Code Extension: Brings database schema browsing, SQL editing, and table data management directly into your IDE

Previously introduced as separate features (MCP Server setup in December and VS Code Extension in January), you can now get your complete AI-powered database development environment configured with one command in Cursor or VS Code.

For more information, see Connect MCP clients to Neon and Get started with the Neon VS Code Extension.

You might notice a new Neon logo across the site, dashboard, and docs. Same Neon. New mark.

The logo is refreshed while staying true to the elephant and N we founded the company with. This update brings Neon's visual identity into the Databricks universe as we continue growing together, helping more than a million developers ship faster with Postgres.

If you reference Neon in your product, docs, or integrations, download the official assets at neon.com/brand. The page includes logo files, usage guidelines, and brand-safe variants for light and dark backgrounds.

For more on the design thinking behind the new logo, see the blog post.

Neon uses PgBouncer for connection pooling, allowing thousands of client connections to share a smaller pool of actual Postgres connections. The monitoring page in the Neon Console now includes Pooler client connections and Pooler server connections graphs (these display data when you use a pooled connection). The Pooler client connections graph shows connections from your applications to PgBouncer, while Pooler server connections displays the actual connections from PgBouncer to Postgres. These graphs help you understand connection usage patterns, identify bottlenecks, and determine when to adjust your pool size or compute resources. For more information, see Monitoring dashboard.

Pooler client connections

Pooler server connections

Additionally, the OpenTelemetry and Datadog integrations now export PgBouncer connection pooling metrics, giving you visibility into pooler client and server connections in your observability platform alongside the new charts in the Neon Console. New integrations automatically include these metrics. To enable them for existing integrations, you can either edit the integration settings to trigger a collector upgrade or delete and recreate the integration.

The Neon Create Branch GitHub Action now supports retrieving branch-specific URLs for Neon Auth and the Neon Data API. This makes it easy to run integration tests against isolated branch environments with the same auth and data access patterns you use in production. Set get_auth_url: true or get_data_api_url: true in your workflow to access the auth_url and data_api_url outputs for your test branch.

- name: Create Neon Branch
  uses: neondatabase/create-branch-action@v6
  id: create-branch
  with:
    project_id: ${{ vars.NEON_PROJECT_ID }}
    branch_name: feature-branch
    api_key: ${{ secrets.NEON_API_KEY }}
    get_auth_url: true
    get_data_api_url: true
- name: Use outputs
  run: |
    echo "Auth URL: ${{ steps.create-branch.outputs.auth_url }}"
    echo "Data API URL: ${{ steps.create-branch.outputs.data_api_url }}"

The Neon VS Code Extension brings a revamped database development experience directly into your IDE. Connect to your Neon organizations, projects, and branches, browse schemas in a rich tree view, run SQL queries, and view or edit table data in a spreadsheet-like interface, all without leaving your editor.

This release replaces the previous Neon Local extension. The new extension no longer uses a local proxy or localhost connection strings. Instead, it helps you manage direct Neon connection strings for your branches.

The extension also automatically configures the Neon MCP Server, enabling AI-powered workflows for managing projects, branches, and databases from your coding agent.

Available for VS Code, Cursor, Windsurf, and other VS Code-compatible editors. Get started with the Neon VS Code Extension.

From the Neon team, we'd like to extend a warm and heartfelt Happy New Year to every member of our community.

What a year 2025 was. In May, Neon joined Databricks, but our mission hasn't changed. We're still focused on delivering the best Postgres experience for developers and AI agents.

Beyond that, we shipped a ton of features in 2025. You can see everything we built here.

Here's the thing though, none of this happens without you. Your feedback, whether you chat with us in Discord, ping us on Twitter, or drop it in the console, that's what shapes what we build. Every suggestion, bug report, and feature request matters to us.

So as we kick off 2026, we want to ask What should we ship next?

Got a feature you're waiting for? A bug that's causing you trouble? An idea that would take things to the next level? We want to hear it.

You can share your feedback on Discord, Twitter/X, or via the Send Feedback modal in the Neon Console.

Thank you for being part of this journey with us. Let's build great things together in 2026! 🚀

Accidentally deleted a project? You can now recover it within 7 days of deletion. This feature restores your entire project infrastructure, including all branches, endpoints, compute configurations, and project settings. Your connection strings, collaborators, and snapshots all come back exactly as they were.

Recovery is available through the CLI and API. There are no storage costs or recovery fees during the 7-day recovery window.

For more information, see Recover a deleted project.

Another week, yet another increase: The Neon Free plan now includes:

• 80 projects
• 100 projects

That's 100 separate database projects you can spin up, experiment with, and build on. Whether you're prototyping ideas, learning Postgres, or running multiple side projects, you've got plenty of room to work.

This change applies automatically to all Free plan users. No action required. For more information about plan limits, see Neon plans.

Learn about why we're increasing project limits on the Free plan

Connecting AI editors to the Neon MCP Server is now a single command:

npx neonctl@latest init

This command authenticates via OAuth, automatically creates a Neon API key, and configures Cursor, VS Code, or Claude Code CLI to connect to Neon. It handles all the setup steps that previously required manual configuration file edits and API key management. Once configured, you can immediately ask your AI assistant to create projects, manage branches, or query your database.

If you're an existing Neon MCP user, setting up the MCP Server this way means you won't be prompted to repeatedly reconnect through browser-based OAuth flows. Your local configuration and API key are created and saved for reuse.

For more information, see Connect MCP clients to Neon.

We've added address-specific masking functions to data masking in the Neon Console. These functions provide specialized handling for text fields like street addresses, cities, and postal codes, letting you mask location data while preserving geographic patterns.

As well, all masking functions are now organized into categories (Names, Email Addresses, Phone Numbers, and Addresses).

For more information about data masking, see Data anonymization.

Your AI editor can now scaffold complete authentication flows with Neon Auth. We've published AI rules, MCP prompt templates, and a Claude skill that teach AI assistants how to integrate Neon Auth into your apps. These tools detect your framework, install the right packages, create the necessary files, and follow best practices automatically.

The setup includes:

• AI rules
• MCP prompt templates
• Claude skill

This means you can open Cursor, Claude, or VS Code, ask your AI assistant to "add Neon Auth," and let it handle the implementation.

Learn more in our blog post, Teaching AI to Do Auth (So You Don't Have To).

We've rebuilt Neon Auth using Better Auth as the foundation. Auth was the last part of Neon that didn't yet branch. Now it does. All authentication data lives directly in your Neon database, so when you branch, your entire auth state branches with it.

Users, sessions, organizations, configuration, and JWKS are stored in a dedicated neon_auth schema. Each branch gets its own isolated auth endpoint. No more external identity provider, no webhook syncing, no drift between environments.

What branchable auth enables:

• Preview environments that actually work. Spin up a branch that mirrors production exactly: same users, same roles, same permissions. Test full signup, login, password reset, and OAuth flows before release.
• Safe multi-tenant testing. Clone your environment, invite test organizations, modify access rules, and confirm permissions propagate correctly without risking production data.
• Real auth in CI/CD. Test the complete user lifecycle in automated pipelines with real authentication, not mocked tokens.

How it works:

• Auth lives in your database. Your user model sits in Postgres, evolving with your migrations and integrating naturally with your schema.

• Works with RLS automatically. Your Row-Level Security policies can reference the authenticated user directly, without duplicate identity tables.

• Data API integration. JWTs from Neon Auth are validated by the Data API, so authenticated queries work with your RLS policies out of the box.

• One SDK for everything. The new @neondatabase/neon-js package brings Neon Auth, Data API, and database access together:

  import { createAuthClient } from '@neondatabase/neon-js/auth';
  import { NeonAuthUIProvider, AuthView } from '@neondatabase/neon-js/auth/react/ui';
  
  const authClient = createAuthClient(import.meta.env.VITE_NEON_AUTH_URL);
  
  export default function App() {
    return (
      <NeonAuthUIProvider authClient={authClient}>
        <AuthView pathname="sign-in" />
      </NeonAuthUIProvider>
    );
  }

Neon Auth is available on all plans, including Free. Get started with Next.js, React, or TanStack.

"Owning your auth means keeping your user model inside your architecture. Neon users now get that ownership while letting Better Auth take care of the parts that make authentication hard." – Bereket Engida, creator of Better Auth

Read more: Meet the New Neon Auth: Branchable Identity in Your Database and The Case for Owning Your Auth

Another week, another increase: The Neon Free plan now includes:

• 70 projects
• 80 projects

More projects means more room to experiment, prototype, and build without worrying about limits.

This change applies automatically to all Free plan users. No action required. For more information about plan limits, see Neon plans.

Learn about why we're increasing project limits on the Free plan

We've removed the $5 monthly minimum from our paid plans. Neon is now purely usage-based: if you use $3 one month, that's the bill you'll receive.

For more details, see Neon plans.

We've increased the project limit on the Free plan to 70 projects.

That's 70 separate database projects you can spin up, experiment with, and build on. Whether you're prototyping ideas, learning Postgres, or running multiple side projects, you've got plenty of room to work.

This change applies automatically to all Free plan users. No action required. For more information about plan limits, see Neon plans.

Learn about why we increased project limits on the Free plan

We updated supported Postgres versions to 14.20, 15.15, 16.11, 17.7, and 18.1, respectively.

When a new minor version is available on Neon, it is applied the next time your compute restarts. For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.

The Neon Data API provides a ready-to-use REST API for your Neon database, letting you query tables, views, and functions using standard HTTP requests. We've added two new options to the Advanced settings panel:

• OpenAPI mode: Enables automatic generation of an OpenAPI schema for your Data API. Use it to generate API documentation, build typed client libraries, import your API into Postman, or integrate with API gateways.
• Enable server timing headers: Adds Server-Timing headers to API responses, showing how long different parts of each request took to process. Use this to debug slow queries, measure performance, and troubleshoot latency issues.

To learn more about Data API advanced settings, see Manage Data API.

Kiro announced powers at AWS re:Invent, a new way for developers to access curated tools directly from the IDE. Neon is one of the first launch partners, alongside Figma, Stripe, and Postman.

With the Neon power, you can manage your Postgres databases without leaving Kiro:

• Deploy instantly: Provision a Neon database in seconds whenever your workflow needs a Postgres backend.
• Branch for safe testing: Create lightweight, isolated copies of your database to test migrations, validate queries, or run integration tests without touching production.
• Time-travel and restore: Roll back to any past state, inspect historical data, or restore from a previous point in time.

Read more: Just Launched: Neon Is Now a Kiro Power

GitHub Copilot now supports custom agents, and we've built two specialized agents that bring Neon's branching workflow directly into your IDE:

• Neon Migration Specialist: Safe Postgres migrations with zero downtime. Test schema changes in isolated database branches, validate, then apply to production, all automated with support for Prisma, Drizzle, or your favorite ORM.

• Neon Performance Analyzer: Identify and fix slow Postgres queries automatically. Analyzes execution plans, tests optimizations in isolated branches, and provides clear before/after performance metrics with actionable code fixes.

Both agents leverage Neon's instant branching to give you a safe environment for testing database changes before they hit production.

To learn more about using these agents, see Neon agents for GitHub Copilot.

Another week, another increase: The Neon Free plan now includes:

• 50 projects
• 60 projects

More projects means more room to experiment, prototype, and build without worrying about limits.

This change applies automatically to all Free plan users. No action required. For more information about plan limits, see Neon plans.

Learn about why we're increasing project limits on the Free plan

The one-command Neon setup, which configures the Neon MCP Server for AI-assisted project onboarding, now supports VS Code with GitHub Copilot and Claude Code CLI in addition to Cursor.

Run this command in your project directory:

npx neonctl@latest init

┌  Adding Neon to your project
│
◆  Which editor(s) would you like to configure? (Space to toggle each option, Enter to confirm your selection)
│  ◼ Cursor
│  ◼ VS Code
│  ◻ Claude CLI
│
◒  Authenticating
┌────────┬──────────────────┬────────┬────────────────┐
│ Login  │ Email            │ Name   │ Projects Limit │
├────────┼──────────────────┼────────┼────────────────┤
│ alex   │ alex@domain.com  │ Alex   │ 60             │
└────────┴──────────────────┴────────┴────────────────┘
◇  Authentication successful ✓
│
◇  Installed Neon MCP server
│
◇  Success! Neon is now ready to use with Cursor / VS Code.
│
│
◇  What's next? ─────────────────────────────────────────────────────────────╮
│                                                                            │
│  Restart Cursor / VS Code and type in "Get started with Neon" in the chat  │
│                                                                            │
├────────────────────────────────────────────────────────────────────────────╯

After setup, ask your AI assistant to "Get started with Neon" to launch an interactive onboarding guide. The guide analyzes your codebase and walks you through selecting or creating a project, configuring connection strings, installing dependencies, and more, all with contextual recommendations.

For more details about this feature, see our blog post.

HIPAA compliance is now supported for Postgres 18 projects in AWS regions. You can now create Postgres 18 projects in HIPAA-enabled Neon organizations and enable HIPAA compliance on existing Postgres 18 projects.

For more information, see HIPAA compliance.

Whether you're building an agent platform, a developer tool that needs instant Postgres, or a SaaS that offers databases to users, there's a platform integration path designed for your use case:

☑ AI Agents integration: For codegen and agent platforms that need database versioning and isolated environments (platforms like Replit and CMS systems like Strapi)

☑ Claimable database flow: For plugins and platforms that want instant Postgres as part of their developer experience, with no signup required upfront (see TanStack, Netlify DB, or try Claimable Postgres)

☑ Embedded Postgres: For SaaS platforms offering Postgres to users (platforms like Retool, which manages 300k+ databases, and Koyeb, which offers serverless Postgres)

☑ OAuth integration: For tools that interact with existing Neon accounts (platforms like Hasura Cloud, which uses OAuth for authentication and database provisioning)

If you're building an agent platform, check out the Neon Agent Plan, designed specifically for platforms that need to manage large fleets of databases with flexible resource limits and instant provisioning. Early-stage startups can also apply to the Neon Startup Program for startup credits.

We've increased the Free plan project limit again! The Neon Free plan now includes:

• 30 projects
• 50 projects

This gives you even more room for side projects, prototypes, experiments, and learning new stacks.

This change applies automatically to all Free plan users. No action required. For more information about plan limits, see Neon plans.

Last week, we announced Data masking for creating anonymized branches (see the November 14 changelog). This week, you'll find the APIs for this feature available in the Neon API Reference.

Example request:

curl -X POST \
  'https://console.neon.tech/api/v2/projects/{project_id}/branch_anonymized' \
  -H 'Authorization: Bearer $NEON_API_KEY' \
  -H 'Accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "masking_rules": [
      {
        "database_name": "neondb",
        "schema_name": "public",
        "table_name": "users",
        "column_name": "email",
        "masking_function": "anon.dummy_free_email()"
      },
      {
        "database_name": "neondb",
        "schema_name": "public",
        "table_name": "users",
        "column_name": "age",
        "masking_function": "anon.random_int_between(25,65)"
      }
    ],
    "start_anonymization": true
  }'

The new APIs include:

• Create anonymized branch
• Get masking rules
• Update masking rules
• Start anonymization
• Get anonymization status

For usage examples and request/response details, see Data anonymization APIs.

We've migrated neonstatus.com to a new provider. The domain remains the same and all historical incident data has been preserved.

If you've previously subscribed to the Neon Status page via RSS, you'll need to update your feed. For instructions, see Neon status.

Neon now offers a data masking feature that makes it easy to create anonymized branches for development and testing. Define masking rules through the Neon Console or API to protect sensitive data like email addresses, names, phone numbers, and other personally identifiable information. Apply these rules to create a branch with production-like data that's safe to share with your team.

This feature uses the PostgreSQL Anonymizer extension (anon) under the hood.

For more information, see Data anonymization.

When creating a branch in the Neon Console, auto-delete is now enabled by default (set to 1 day). You can uncheck this option or adjust the timeframe as needed. This new default helps reduce storage costs and prevent the accumulation of unused branches.

Console only: This change only affects branches created through the Neon Console. Branches created via API or CLI are unaffected.

This change will be rolled out to all Console users in the coming days.

For more information, see Branch expiration.

We've added several new capabilities to the Neon MCP Server:

• Search across resources - You can now search across all your Neon resources with a single query. Ask your AI assistant:

  Can you search for "production" across my Neon resources?

  The assistant will search through organizations, projects, and branches, returning structured results with direct links to the Neon Console. Use the companion fetch tool to get detailed information about any resource.

• Read-only mode - We've added read-only mode for safe operation in cloud and production environments. Enable it by adding the x-read-only: true header to your MCP configuration:

  {
    "mcpServers": {
      "Neon": {
        "url": "https://mcp.neon.tech/mcp",
        "headers": {
          "x-read-only": "true"
        }
      }
    }
  }

  When enabled, the server restricts all operations to read-only tools. Only list and describe tools are available, and SQL queries automatically run in read-only transactions, providing a safe method for querying and analyzing production databases without any risk of accidental modifications.

• Guided onboarding - The new load_resource tool provides comprehensive getting-started guidance directly through your AI assistant. Ask "Get started with Neon" or "Help me set up my first project," and the assistant will load detailed instructions covering organization setup, project configuration, connection strings, schema creation, and migrations. This works in IDEs that don't fully support MCP resources and ensures onboarding guidance is explicitly loaded when you need it.

For more information, see Neon MCP Server.

WebSocket connections are now more stable during long-running queries and in edge runtime environments. The serverless proxy now prevents connection timeouts during idle periods, particularly benefiting applications with long-duration queries, analytics workloads, or deployments on edge runtimes like Vercel Edge Runtime.

We've reduced compute pricing by up to 25% across our plans:

• Launch plan: Now $0.106 per CU-hour (previously $0.14)
• Scale plan: Now $0.222 per CU-hour (previously $0.26)
• Agent plan: Now $0.106 per CU-hour (previously $0.14)

These price reductions apply immediately to all usage going forward. No action is required; you'll automatically benefit from the new lower rates on your next billing cycle.

For detailed pricing information and usage examples, see Neon plans. To learn more about these price reductions, see our blog post.

We're pleased to announce that the Neon Free plan now includes:

• 20 projects
• 30 projects

This means more room for side projects, prototypes, experiments, and learning new stacks.

This change applies automatically to all Free plan users; no action required. For more information about plan limits, see Neon plans.

We've introduced a new command that configures the Neon MCP (Model Context Protocol) Server, giving your AI assistant full context about your Neon project (including connection details, schema, and best practices). Run this command in your app's root directory:

npx neonctl@latest init

The command walks you through an interactive setup:

npx neonctl@latest init
┌  Adding Neon to your project
│
◒  Authenticating.
┌────────┬──────────────────┬────────┬────────────────┐
│ Login  │ Email            │ Name   │ Projects Limit │
├────────┼──────────────────┼────────┼────────────────┤
│ alex   │ alex@domain.com  │ Alex   │ 20             │
└────────┴──────────────────┴────────┴────────────────┘
◇  Authentication successful ✓
│
◇  Installed Neon MCP server
│
◇  Success! Neon is now ready to use with Cursor.
│
│
◇  What's next? ────────────────────────────────────────────────────────────────────────────╮
│                                                                                           │
│  Restart Cursor and ask Cursor to "Get started with Neon using MCP Resource" in the chat  │
│                                                                                           │
├───────────────────────────────────────────────────────────────────────────────────────────╯
│
└  Have feedback? Email us at feedback@neon.tech

After setup, restart Cursor and ask your AI assistant to "Get started with Neon using MCP Resource" to launch an interactive 7-step onboarding guide. The guide analyzes your codebase and walks you through selecting or creating a project, configuring connection strings, installing dependencies (@neondatabase/serverless or pg), setting up an ORM like Prisma or Drizzle, and creating your database schema, all with contextual recommendations tailored to your environment.

This feature is currently in beta for Cursor, with VS Code and Claude Code support coming soon. For more details, see our blog post.

You can now manage automated backup schedules via the Neon API. Previously, backup schedules could only be configured through the Console. With the new API endpoints, you can programmatically view and update backup schedules for your branches, enabling infrastructure-as-code workflows and automated backup management.

Available endpoints:

• GET /projects/{project_id}/branches/{branch_id}/backup_schedule: View the current backup schedule for a branch
• PUT /projects/{project_id}/branches/{branch_id}/backup_schedule: Update the backup schedule configuration

This makes it easier to standardize backup policies across projects and integrate backup scheduling into your deployment pipelines.

For more information, see Backup & restore.

Vercel integration users now have full access to Neon's current usage-based pricing plans (Free, Launch, and Scale). Previously, Vercel integration users were limited to Neon's legacy plans. Free plan Vercel users have been automatically migrated to the new Neon Free plan. This change gives you access to all the latest features and pricing options, including:

• Usage-based pricing with $5/month minimum on paid plans
• Enhanced compute options and autoscaling
• Advanced features like database branching for preview deployments
• Flexible project and branch limits

To upgrade your plan, visit the Storage tab in your Vercel Dashboard, select your database, navigate to Settings > Update Configuration, click the integration settings link, and click Change Plan.

For more information, see Neon plans.

The Backup & Restore page in the Neon Console is now available to all users. It combines instant point-in-time restore with snapshots to help you protect your data and recover from accidental changes, data loss, or schema issues. The snapshots feature is now in Beta with new capabilities for automated snapshot management. Use the Enhanced view toggle to access the new Backup & Restore page with snapshot capabilities, or toggle it off to return to the previous Restore page.

Snapshots (Beta):

• Scheduled snapshots: Automate snapshots with daily, weekly, or monthly backup schedules (available on paid plans, excluding the Agent plan)

• Flexible retention: Configure how long to keep automated snapshots before they're automatically deleted

Limits and pricing: The Free plan includes 1 snapshot, while paid plans include 10 snapshots. Snapshot storage is billed at $0.09/GB-month as of May 1, 2026.

Instant restore improvements:

• Preview data before restoring: The instant point-in-time restore feature now includes a Preview data button that lets you browse tables, run queries, and compare schemas at the selected restore point before committing to the restore operation
• Improved timezone display: The date/time picker for instant restore now shows times in your project's region timezone, and snapshot names include the region timezone for clarity

Together, these features help you maintain reliable recovery points for your production databases without manual intervention.

We've expanded extension support for Postgres 18.

Now available on Postgres 18:

For a complete list of Postgres extensions supported by Neon, see Postgres extensions.

We've updated the serving logic in our documentation, guides, and PostgreSQL Tutorial sites to serve raw markdown in response to web requests from user-agents we can identify as LLM Agents (like ChatGPT, Claude, Copilot, etc...)

The result is 80-100x smaller page sizes, 6x speed-up, and most importantly fewer tokens costing you money and occupying your context windows as you work with codegen agents to ship faster.

We've added pre-built AI prompts to our integration guides to help you get started with Neon faster in your AI-enabled code editor. Simply copy a prompt from any guide and paste it into your AI assistant (Cursor, GitHub Copilot, Claude Code, etc.) for step-by-step setup assistance tailored to your stack.

Guides with AI prompts:

• ORMs & Drivers: TypeORM, SQLAlchemy, Neon Serverless Driver, Prisma
• JavaScript/TypeScript Frameworks: Next.js, Astro, SvelteKit, Nuxt, Solid Start, Express, NestJS, Hono, RedwoodJS, Node.js
• Python Frameworks: Django, Reflex
• PHP Frameworks: Laravel, Symfony
• Ruby: Ruby on Rails
• Java Frameworks: Quarkus (JDBC), Quarkus (Reactive), Micronaut (Kotlin)
• Languages: Python, JavaScript, Go, Java, Rust, Elixir, Elixir with Ecto, .NET, .NET Entity Framework

Each prompt provides your AI assistant with the context it needs to configure dependencies, set up environment variables, establish database connections, and create working examples.

We're actively improving these prompts based on your feedback. Share your experience through the Feedback form in the Neon Console or join the conversation on Discord.

We've recently launched a Neon Open Source Program to support Postgres-powered open source projects. If your open source project uses Postgres and is ready to grow, we'd love to hear from you.

Visit the Neon Open Source Program page to learn more about the benefits and apply.

We've launched a new plugin that brings Neon's capabilities directly into Claude Code. The new plugin includes:

• Claude Skills to streamline key workflows:

  • neon-drizzle: Set up Drizzle ORM with Neon
  • neon-serverless: Configure connections with Neon's serverless Postgres driver
  • neon-toolkit: Manage databases, projects, and branches using the Neon API
  • add-neon-knowledge: Access Neon documentation snippets and usage examples

• Neon MCP server integration that lets Claude interact with Neon in real time to query projects, manage databases and branches, and run SQL or migrations

• Context rules (.mdc files) that can be used in other AI tools like Cursor

Install it from our marketplace:

/plugin marketplace add neondatabase-labs/ai-rules
/plugin install neon-plugin@neon

For more information, see Claude Code plugin for Neon.

Our MCP server now supports schema diff generation and zero-downtime migration creation. Ask your AI assistant:

Can you generate a schema diff for branch br-feature-auth in project my-app?

The assistant will compare the branch schema with its parent, show what changed, and offer to generate a zero-downtime migration to apply those changes to the parent branch.

This makes it easier to develop schema changes on feature branches and promote them when ready. For more information, see Neon MCP Server.

We've added breadcrumb navigation to branch pages, making it easier to understand and navigate your branch hierarchy. When viewing a child branch, you'll now see the full lineage path (e.g., production / development / feature-branch) with visual branch indicators. The page heading has also been updated to "Child branch overview" for better clarity when working with nested branches.

We've expanded extension support for Postgres 18 and updated several extension versions.

Now available on Postgres 18:

Version updates across all supported Postgres versions:

To upgrade from a previous version of an extension, follow the instructions in Update an extension version.

For a complete list of Postgres extensions supported by Neon, see Postgres extensions.

Scale plan users can now adjust their scale to zero timeout directly in the Neon Console. Simply select Edit compute from the menu on the Compute tab to set a custom timeout. The Scale plan allows you to set this as low as 1 minute, a setting that was previously only available via the Neon API.

Scale to zero helps minimize costs by automatically placing inactive databases in an idle state. The timeout setting controls how fast that happens. To learn more, refer to our Scale to zero guide.

Managing your project's branches is now easier with convenient preset options. When creating or configuring a branch, choose to automatically expire it after 1 hour, 1 day, or a week. No need to manually calculate and select a specific date and time.

Setting branch expiration times can help reduce costs. To learn more, check out our Branch expiration guide.

We've added new NAT gateway IP addresses in the AWS US East (N. Virginia) region to expand infrastructure capacity. If you have external IP allow lists that enable connections from external services into Neon, update those allow lists soon to include the new addresses to avoid connectivity issues.

See our Regions documentation for the complete list of NAT gateway IPs for all regions.

We've added a new VPC endpoint service address for Private Networking in the AWS US East (N. Virginia) region. If you're setting up Private Networking in the us-east-1 region, you can now use the additional endpoint service address for enhanced infrastructure capacity and reliability.

For the complete list of VPC endpoint service addresses by region, see our Private Networking guide.

Run end-to-end tests using isolated database branches. We've published guides showing how to use Neon's database branching with Playwright and Cypress to create isolated test environments for every pull request. Each PR gets its own database branch with automated schema migrations, ensuring your E2E tests run against the exact schema changes you're testing.

• Automated E2E Testing with Neon Branching and Playwright
• Automated E2E Testing with Neon Branching and Cypress

Paid plan users will soon begin receiving weekly usage reports on Mondays. These reports provide month-to-date usage and costs across all billing metrics (including compute, storage, extra branches, and network transfer), helping you track spending and optimize costs before your monthly bill is finalized.

For cost optimization strategies for Neon, please refer to our Cost optimization guide.

We've added support for pgvector v0.8.1 on Postgres 18. This new version of pgvector adds support for Postgres 18 and improves binary_quantize function performance.

Pulumi, an open-source infrastructure-as-code (IaC) tool, can now be used to provision and manage your Neon projects as code. Using familiar programming languages or formats such as TypeScript, Python, Go, C#, Java, or YAML, you can define your Neon projects, branches, databases, compute endpoints, and roles alongside your other cloud resources. This integration uses a community-developed provider bridged from the Terraform provider for Neon.

import * as neon from '@pulumi/neon';

To get started, see Manage Neon with Pulumi.

You can now use Neon with SST, an open-source framework for building full-stack applications on your own infrastructure. SST's support for Pulumi and Terraform providers enables you to manage Neon resources directly in your sst.config.ts alongside your serverless applications, with automated database provisioning for your deployments.

npx sst add neon

To learn how, see Manage Neon with SST.

We've made several major improvements to the Data API (Beta):

The Data API page now includes a new Build your first app tab with a streamlined setup flow. This new tab lets you clone our note-taking demo app directly from the UI using your project's credentials, making it easy to get started with the Data API.

Once set up, you can follow our tutorials to learn Data API queries and Row-Level Security using the same demo app.

We've added a new converter tool to help you translate existing SQL queries into PostgREST syntax. Useful for developers migrating from direct SQL queries or learning PostgREST patterns.

Try the converter here.

We've rebuilt the Data API from the ground up in Rust while maintaining 100% PostgREST compatibility. This new architecture delivers better performance, multi-tenancy support, and improved resource efficiency, while maintaining the same PostgREST API.

Learn more in our Data API docs or read about the architectural improvements in our blog post.

We've shipped several improvements to Instagres, our tool for instant Postgres database provisioning without configuration or account creation.

• Streamlined CLI: The npx neon-new command now runs entirely in your terminal with no browser interaction or CAPTCHA required.
• New claim command: We added a neon-new claim command that launches the claim URL in your browser, letting you easily claim the database to your Neon account if you want to keep it.
• Better Vite integration: The Vite plugin for Instagres now outputs a named export for improved auto-completion, adds envPrefix support for public environment variable prefixes, and adds Vite 7 to peerDependencies. Learn more about the Vite plugin here.

Try Instagres at neon.new or get started with npx neon-new. Update: The CLI was npx neondb at the time of this release; it's now npx neon-new.

Neon now supports Postgres 18 in preview. To try it out, create a new project and select 18 as the Postgres version.

While in preview, there are a few limitations to keep in mind.

To learn more about the new features and improvements in Postgres 18:

• Read our blog post: Postgres 18 Is Out: Try it on Neon
• Review the official Postgres 18 release notes

We've released Elephantshark, an open-source Ruby script from Neon for monitoring Postgres network traffic.

Elephantshark sits between Postgres clients and servers, decrypting and re-encrypting SSL/TLS traffic while logging protocol messages. It works with all Postgres-protocol traffic, not just Neon databases. It can also generate SSLKEYLOGFILE entries for Wireshark.

• Get Elephantshark on GitHub
• Read the blog post

We've added snapshot APIs for AI agents and code generation platforms that need database versioning. You can create point-in-time database versions, roll back when things break, and keep connection strings stable during development. This makes it safer for agents to experiment with schema changes and revert when needed. Works for production rollbacks as well as temporary preview branches.

# Create a snapshot to save current state
curl --request POST \
     --url 'https://console.neon.tech/api/v2/projects/{project_id}/branches/{branch_id}/snapshot?name=version-session-1&expires_at=2025-08-13T00:00:00Z' \
     --header 'authorization: Bearer $NEON_API_KEY'

# Roll back to a previous version (keeps same connection string)
curl --request POST \
     --url 'https://console.neon.tech/api/v2/projects/{project_id}/snapshots/{snapshot_id}/restore' \
     --header 'authorization: Bearer $NEON_API_KEY' \
     --header 'content-type: application/json' \
     --data '{"target_branch_id": "br-main-123", "finalize_restore": true}'

Learn more in these guides:

• Database versioning with snapshots guide
• Demo repo
• Build Checkpoints for Your Agent Using Neon Snapshots

Building a full-stack AI agent? Apply to our Agents Program for custom limits and special pricing.

Our latest addition to the beta Data API makes setup even smoother. The Data API configuration now includes an option to automatically apply GRANT statements for the public schema. When you enable "Grant public schema access to authenticated users", Neon handles the database permissions for you, setting you up to then write your RLS policies. See Get started with the Data API.

We just doubled the compute hours you get in your Neon Free Plan. You get up to 20 projects, each with:

• 100 CU-hours of monthly compute (up from 50)
• Snapshot APIs
• 0.5 GB Storage
• Autoscaling
• Branching
• Read replicas
• Instant restore

If you are a free plan user, this change has already been applied to your account; no action required.

We've built an interactive dashboard to explore Postgres extension adoption across the Neon platform. See which extensions are trending, track monthly install counts, and discover new extensions that might be useful for your projects. The dashboard shows real-time data on 83+ available extensions, from popular ones like pgvector (30k+ installs) to emerging extensions gaining traction.

• Explore the dashboard
• Read about the top 10 most popular extensions

You can now enable HIPAA compliance for your Neon projects directly in the console. HIPAA sets national standards for protecting health information, and is required for apps handling Protected Health Information (PHI). This is available on the Scale plan. HIPAA support is currently available at no additional cost. When we begin charging for HIPAA support, it will become a paid add-on. Read more in our HIPAA compliance docs.

Neon Private Networking, which allows secure connections via AWS PrivateLink and keeps traffic within AWS's private network, now includes support for IPv6 addresses. This enables better connectivity for applications that require IPv6 support and helps future-proof your database connections. Previously, only IPv4 was supported.

You can now connect ChatGPT to the Neon MCP Server using custom Model Context Protocol (MCP) connectors.

This integration makes it easy to extend ChatGPT with Neon's database capabilities so you can query, manage, and interact with your Neon projects directly within ChatGPT.

👉 Read the blog to get started.

We're excited to share Neon Testing, a community-built library by Mikael Lirbank that makes it easy to run integration tests against Neon databases.

Instead of relying on mocks or maintaining local test databases, Neon Testing uses Neon's branching to provision disposable Postgres test databases for each test file. This means your tests run against the same schema and constraints as production, catching issues that mocks can miss (like unique constraint failures and transaction rollbacks).

• Read the blog: Neon Testing: a Vitest Library for Your Integration Tests
• Install from npm: neon-testing
• Learn more about the project: Mikael's website

Neon's OpenTelemetry (OTEL) integration has a new step-by-step guide for sending your Neon project's metrics and Postgres logs to New Relic, a cloud-based observability platform that helps developers and organizations monitor, debug, and optimize the performance of their applications and infrastructure.

Check out the guide from contributor Dhanush Reddy: Getting started with Neon and New Relic.

We've introduced a new horizontal navigation bar in the Neon Docs to make it easier to find what you need. You can now quickly scan across the top-level menus, each with a dropdown of related topics. When you select a menu item, a dedicated left-hand sidebar for that topic area opens, giving you a clear view of everything available within that section.

This update improves discoverability and helps you move through the docs more efficiently.

We're happy to announce our new Agent Plan for AI agent platforms that need to provision thousands of databases.

The Agent Plan provides custom project and branch limits, higher API rate limits for instant provisioning, and credits for your free tier users. It's designed for platforms like Replit, v0, and Databutton that create databases on behalf of their users. Key features include automatic scale-to-zero, instant restores, and Neon Auth and Data API at no extra cost. Learn more.

We've added a Refresh schema cache button to the Data API page, making it easier to update your REST endpoints when you modify your database schema. We've also continued our performance enhancements, including eliminating API cold starts, as we prepare the Data API for GA. Learn more about the Data API in the docs.

We've added a new reset_from_parent tool to the Neon MCP Server that allows resetting a branch back to its parent branch state. This simplifies branch management when LLMs change schemas or when creating fresh development branches. Learn more in the MCP Server docs.

We've added a new VPC endpoint service address for Private Networking in the AWS Europe (Frankfurt) region. If you're setting up Private Networking in the eu-central-1 region, you can now use the additional endpoint service address for enhanced infrastructure capacity and reliability.

For the complete list of VPC endpoint service addresses by region, see our Private Networking guide.

We've doubled the Free plan project limit from 10 to 20. No more one-in, one-out; add more side projects and prototypes without hitting the limit.

• We introduced a new list_shared_projects tool that lets users see projects shared with them. This addresses a gap where project collaborators couldn't list Neon projects they were part of. For an overview of Neon MCP Server tools, see Supported tools.

• We improved error handling and refined the logic used for Neon org selection.

• You can now manage your Neon database directly from Claude Code using the Neon MCP Server Check out our new guide to get started. It covers both remote (OAuth) and local setup options: Get started with Claude Code and Neon Postgres MCP Server

• Are you a Cursor user? Try the one-click Neon MCP Server install:

  cursor://anysphere.cursor-deeplink/mcp/install?name=Neon&config=eyJ1cmwiOiJodHRwczovL21jcC5uZW9uLnRlY2gvbWNwIn0%3D

Neon Local and Neon Local Connect bring the power of Neon's cloud database branching directly to your local development environment.

• Neon Local is a Docker-based proxy that creates a smart local interface to your Neon database, providing a static connection that automatically routes to your active cloud database branch.

• Neon Local Connect extends this with a full-featured VS Code extension, offering database schema browsing, built-in SQL editing, table data management, and branch switching, all without leaving your IDE.

Ready to transform your local development workflow? Check out our new guide: Getting started with Neon Local and Neon Local Connect

The pg_repack extension lets you to efficiently remove bloat by rewriting tables and indexes online, with minimal locking.

Previously, enabling pg_repack required opening a support ticket so our team could grant you permission on the repack schema. That's no longer necessary; you now have access by default. No support ticket means the extension is available on all Neon plans.

If you previously installed pg_repack without assistance from Neon support, you'll need to drop the extension and reinstall it on your database to apply the new repack schema permission.

Learn more about the extension in our docs: pg_repack

The Data API (Beta) now has its own page in the project sidebar for easier discovery and activation. You can also enable it for any database, not just the default one. The setup asks you to enable Neon Auth as your auth provider (recommended), but you can choose Other provider if you have your own JWKS URL (or skip this step until later). We're also making significant improvements under the hood in preparation for GA. Stay tuned!

Learn more in our Data API docs.

You can now restore to your root branches' snapshots from any branch in your project, giving more flexibility in restoring data for your workflows; simply select the branch you want to restore in the sidebar.

Additionally, each snapshot card now shows the snapshot expiration date. The soon-to-be introduced backup scheduler will let you specify an expiration date. For now, the expiration date is never, but you can manually delete a snapshot at any time.

We've introduced usage-based pricing for Neon paid plans, starting at just $5/month. Pay only for what you use. This plan update also includes more storage on the Free plan. For details, see the pricing page and read the blog post.

Branch expiration is now available to all Neon users! Previously available only to Early Access users, you can now set an expiry date to automatically delete branches at a specified time, helping keep projects clean and reduce storage costs for temporary branches.

Set an expiration time when creating or updating branches via the API, CLI, GitHub Actions, or Neon Console, up to 30 days ahead of time. When that time comes, the branch and its compute endpoints are permanently deleted.

To learn more, see our Branch expiration guide.

Neon Local, a service that lets you work with your Neon cloud database locally from Docker, now supports connecting your app to any existing branch in your Neon project. Previously, Neon Local only supported creating ephemeral branches that were automatically deleted when the container stopped.

Additionally, Neon Local Connect, the VS Code extension for Neon Local (also supported in Cursor, Windsurf, and other VS Code-compatible editors), now includes:

• Database Schema view – Browse databases, schemas, tables, columns, and relationships right from your IDE. Quickly inspect structures, explore relationships, and perform table actions like querying, truncating, or dropping, all without leaving your editor.
• Built-in SQL Editor – Run queries directly in your IDE, view and filter results in a table, export data, and see execution stats. Perfect for testing changes or debugging without switching to an external SQL client.

These updates make it easier to explore your database, run queries, and manage schema changes without leaving your development environment.

To learn more, see Neon Local.

App.build, Neon's open-source reference implementation for agent builders, now supports running open-weight LLMs via Ollama, LMStudio, and OpenRouter, letting you build apps without cloud API dependency or associated costs. You can also access large open-weight models through OpenRouter.

LLM_BEST_CODING_MODEL=openrouter:qwen/qwen3-coder LLM_UNIVERSAL_MODEL=openrouter:z-ai/glm-4.5-air uv run generate "Create another to-do app, but give it a Roman Empire style, because I can't stop thinking about it."

Read the post for more: App.build Now Supports Open Source Models

We've added support for a new Postgres extension. Developed by our very own Konstantin Knizhnik, the online_advisor extension provides actionable tips for faster queries, based on your real workload:

• Recommend indexes for heavy filtering
• Suggest extended statistics when estimates are off
• Flag queries that should use prepared statements

For more about this new extension, refer to the online_advisor guide.

We've added new NAT gateway IP addresses in the AWS Europe (Frankfurt) region to expand infrastructure capacity. If you have external IP allowlists that enable connections from external services into Neon, update those allowlists soon to include the new addresses to avoid connectivity issues.

AWS Europe (Frankfurt) – aws-eu-central-1

• 3.66.63.165
• 18.194.181.241
• 52.58.17.95

See our Regions documentation for the full list of NAT gateway IPs.

We'll soon be migrating neonstatus.com to a new provider. We'll share more details, including the migration date, once it's confirmed.

Neon's OpenTelemetry (OTEL) integration now has a step-by-step guide for sending your project's metrics and Postgres logs to Better Stack, an observability platform for unified logging, monitoring, and alerting.

Check out the guide from contributor Dhanush Reddy: Getting started with Neon and Better Stack.

We've added new snapshot restore workflows that let you choose how you want to restore from your existing snapshots:

• One-step restore instantly restores a selected snapshot to the current branch
• Multi-step restore creates a new branch from the selected snapshot, which you can then inspect or test before finalizing the restore

These restore methods are also available via the Neon API for building AI agent checkpoints and other automated workflows.

To try out these snapshot features, sign up for the Early Access Program. Learn more in our backup and restore guide.

Early Access users can now set an expiry date to automatically delete branches at a specified time, helping keep projects clean and reduce storage costs for temporary branches.

To give your branch an end date, set the expires_at timestamp when creating or updating the branch via the API, CLI, or Neon Console, up to 30 days ahead of time. When that time comes, the branch and its compute endpoints are permanently deleted.

Use cases

• CI/CD pipelines with ephemeral test branches
• Time-boxed feature development
• Temporary demos or testing environments
• AI workflows requiring automated cleanup

To try branch expiration and other upcoming features, sign up for the Early Access Program.

You can now easily access the Neon Local Connect VS Code extension directly from the Getting started widget on your Project Dashboard. This makes it faster to set up your development environment with the localhost connection experience.

app.build, Neon's open-source reference architecture for agentic codegen, now has a web-based interface in addition to the terminal CLI, making it easier to create full-stack apps directly from your browser. Learn more in the blog post: Launching a Web UI for app.build

app.build also now supports building and deploying Laravel apps. Check out the blog post: Generate Laravel Apps from a Prompt. Thanks to the @laravelphp team for helping us build the template 🤝

Drizzle Studio, which powers the Tables page in the Neon Console, has been updated with several new features including a new Database studio view.

You can now create Postgres roles from the Tables page. Define a role name, select from a list of commonly granted privileges, set a password, and click Review and Create.

For more advanced privilege assignments, click the Add privilege link when creating a role to build your GRANT statements.

Define your own Postgres RLS policies or use a RLS policy template. The "based on user_id" templates can be used with our Neon RLS feature, which integrates third-party JWT-based authentication providers like Auth0 and Clerk.

View your schema definition, alter it, enable RLS, and more.

The new Database studio view makes it easy to explore your database objects (including schemas, tables, views, roles, and policies) all in one place.

To open the view, select Database studio from the Tables page:

Use the top navbar to navigate:

The Neon MCP extension is now listed in the Goose registry, making it easier for developers using Goose and Block Protocol to integrate Neon MCP into their workflows.

Users of Private Networking can now view configured VPC endpoints on the project settings page in the Neon Console.

Private Networking is available on Neon's Business and Enterprise plans. If you're on a different plan, you can request a trial from your project's settings page.

Neon Auth now supports sending emails for user invites, password resets, and notifications.

Use our shared email server for development, then switch to your own provider when you're ready. Read more in the docs.

We've expanded access to our Neon AI Assistant! Previously available for Launch and Scale plan users, the AI Assistant is now available for all users, including Free plan. Find it under ? > Get help in the Console. Our AI assistant can help:

• Answer questions about Neon features, workflows, and troubleshooting.
• Find relevant documentation and best practices.

You can now use Devin, Cognition Lab's AI software engineer, with Neon's MCP server through Cognition Lab's new MCP (Model Context Protocol) marketplace! This helps Devin manage your Neon databases using natural language commands for tasks like creating projects, running SQL queries, and performing database migrations.

This integration demonstrates how Neon's MCP server, designed as a workflow-first API for LLMs, enables AI agents to safely and confidently tackle complex database challenges.

Read the full blog post to learn more, or read our MCP server docs to see how it works.

Recently, we added the channel_binding=require option to connection strings and snippets in the Neon console, improving connection security. You can read more about this update in our blog post.

Now, we've also updated the connection strings returned by the Neon CLI and Neon API to include the same security enhancement.

CLI example

neon cs --project-id purple-cake-43891234

Will now return

postgresql://neondb_owner:[password]@ep-shiny-sound-a5ydo1ie.us-east-2.aws.neon.tech/testingneon?sslmode=require&channel_binding=require

For upgrade instructions for the CLI, see Upgrading the Neon CLI.

You can now monitor your Neon databases with Grafana Cloud using our OpenTelemetry integration, which lets you forward metrics and Postgres logs from Neon to any OTEL-compatible observability platform.

Check out the Grafana Cloud integration guide for setup instructions, a list of available metrics, and example dashboards.

OTEL support is available on Neon's Scale, Business, and Enterprise plans.

The Neon Local Connect VS Code Extension lets you develop with Neon using a familiar localhost connection string. Your app connects to localhost:5432 like a local Postgres instance, but the underlying Neon Local service routes traffic to your actual Neon branch in the cloud.

Key features:

• Static connection string: Use postgres://neon:npg@localhost:5432/<your_database> for all branches; no need to update your app config when switching branches
• Branch management: Create, switch, or reset branches directly from the VS Code panel
• Ephemeral branches: Automatically create and cleanup temporary branches for testing and experiments
• Integrated tools: Launch psql shell, SQL Editor, or Table View without leaving your IDE

The extension is available on both the VS Code Marketplace and OpenVSX Marketplace (for Cursor, Windsurf, and other VS Code forks).

Learn more in our docs: Neon Local Connect extension.

app.build, our open-source agent for turning AI-generated code snippets into full-stack, deployed applications on Neon, now supports building data apps and ML dashboards with Python.

You can try it today:

npx @app.build/cli --template=python

To learn more about app.build and its capabilities, read the blog post and visit app.build.

We've made several upgrades to Neon's storage layer to make your databases faster, especially for large and write-heavy workloads. Improvements include smarter sharding, compressed WAL transmission, faster disk writes, and more responsive compaction.

Most users will see better ingest performance, lower read latency, and faster uploads automatically.

Learn more in our blog post: Recent Storage Performance Improvements at Neon

We've launched a new Neon AI Assistant, available for all Launch and Scale plan users. Find it under ? > Get help in the Console. Our AI assistant can help:

• Answer questions about Neon features, workflows, and troubleshooting.
• Find relevant documentation and best practices.
• Create support tickets related to your issue, connecting you directly with our support team when you need deeper help.

📌 You can expect to see the AI Assistant on the Free plan soon.

You can now delete Neon Auth users directly from the Auth UI (or programmatically via the Delete Auth User) API endpoint. This action soft-deletes the user in neon_auth.users_sync by setting the deleted_at column, rather than removing the record entirely.

Previously, deleting a user required running a SQL statement against the neon_auth.users_sync table. You may still want to use SQL deletion if you need to fully remove a user and all associated data.

You asked, we delivered. The Neon Console sidebar is now collapsible, giving you more space to focus on your work. Good for smaller screens or when you just need a little extra room.

We've added some polish to our branch creation page to make it easier to understand your options.

• You can now choose between Current data, Past data, Schema-only, and Anonymized data branch options, all from a streamlined, modal-style layout.

• The page now displays the size limit for schema-only branches based on your plan, so you'll know up front how much data you can seed or add.

• There's now a direct link to our anonymization docs in the Anonymized data option, a reminder that you can anonymize data manually while we work on full in-app support.

  

You can now assign custom names to your branch's computes. In the Neon Console, go to the Branches page, select a branch, and open the Compute tab. Click the edit icon next to a compute to rename it.

You can also set a name when adding a new compute.

This enhancement is supported for both primary (read-write) and read replica computes.

We're excited to announce that Neon is now the official database partner of TanStack, and that we've released new open-source tools to simplify Postgres integration across the TanStack and Vite ecosystems:

• Create TanStack Add-on
  Instantly set up a fullstack application with a Neon Postgres database with one simple command: pnpm create tanstack --add-on neon

• Instagres (formerly Neon Launchpad)
  Instantly spin up a Postgres database with Instagres; no signup required. Perfect for workshops and rapid prototyping. Try it at neon.new. Update: The URL has returned to neon.new after a period at pg.new. To learn more, see our Claimable Postgres docs.

• neon-new (CLI)
  Bootstrap Neon Postgres database with the neon-new CLI:
  npx neon-new --yes
  Or integrate programmatically via instantNeon().

• Vite Plugin for Neon
  Use Claimable Postgres to spin up a Postgres database with any Vite app:
  npm add -D vite-plugin-neon-new

Update: The CLI was npx neondb and the Vite plugin was @neondatabase/vite-plugin-postgres at the time of this release; they are now npx neon-new and vite-plugin-neon-new.

These open-source tools are designed to streamline fullstack development with TanStack, Vite, and Postgres. Learn more:

• Neon Joins TanStack
• Instagres: A Tool For Instant Postgres, No Login Needed
• Claimable Postgres Docs

You can now manage your project's OAuth providers (Google, GitHub, Microsoft) directly in the Neon Auth config tab: enable or disable providers, and choose between using shared Neon Auth credentials or setting up your own custom client credentials.

New API endpoints also let you manage providers programmatically:

• Add an OAuth provider
• List OAuth providers
• Update an OAuth provider
• Delete an OAuth provider

To learn more, see the Neon Auth documentation.

You can now add the Neon MCP Server to Cursor with a single click. Look for the Add to Cursor button in our MCP Server docs and in the GitHub repo, or try it here:

cursor://anysphere.cursor-deeplink/mcp/install?name=Neon&config=eyJ1cmwiOiJodHRwczovL21jcC5uZW9uLnRlY2gvc3NlIn0%3D

Connection strings and snippets in the Neon Console now include channel_binding=require by default, providing stronger protection against man-in-the-middle (MITM) attacks for psql and other libpq-based clients:

postgresql://alex:AbC123dEf@ep-cool-darkness-a1b2c3d4-pooler.us-east-2.aws.neon.tech/dbname?sslmode=require&channel_binding=require

Channel binding works alongside sslmode=require to cryptographically link your TLS connection and authentication credentials, making it nearly impossible for attackers to intercept or impersonate your database connections, strengthening security without required client-side root certificate setup.

Most libpq-based clients support this option transparently. For others (e.g., Go's pgdriver), compatibility may vary.

We recommend updating your connection strings to include channel_binding=require if you're using a libpq-based client.

Learn more in our blog post: Why Postgres needs better connection security defaults.

We've made it easier for you to set up Neon RLS (Row Level Security) for your Neon Auth projects. The Auth page now displays your Stack Auth project details, including the JWKS URL needed for RLS setup.

To get started adding RLS to your Neon Auth project:

1. Copy the JWKS URL from the Configuration tab of your Auth page.
2. Paste it into the RLS authentication provider setup on the Settings > RLS for your project.
3. Follow our UI to get RLS set up for your tables.

See Neon RLS for more info.

We've added new NAT gateway IP addresses in three AWS regions to expand infrastructure capacity. If you have external IP allowlists that enable connections from external services into Neon, update those allowlists soon to include the new addresses to avoid connectivity issues.

AWS US East (N. Virginia) – aws-us-east-1

• 13.219.161.141
• 34.235.208.71
• 34.239.66.10

AWS US East (Ohio) – aws-us-east-2

• 3.16.227.37
• 3.128.6.252
• 52.15.165.218

AWS US West (Oregon) – aws-us-west-2

• 35.83.202.11
• 35.164.221.218
• 44.236.56.140

See our Regions documentation for the full list of NAT gateway IPs.

The neon_superuser role now supports Postgres Event Triggers. Unlike regular triggers, which are attached to a single table and capture only DML events, event triggers are global to a particular database and are capable of capturing DDL events.

Event trigger support enables various tools and platforms that utilize this functionality, including pgroll, Zero, and Readyset, among others.

For more about event triggers, see PostgreSQL Event Trigger.

Instagres enables instant provisioning of a Postgres database without configuration or account creation. If you're not familiar, you can learn more here: Instagres: A Tool For Instant Postgres, No Login Needed

Instagres now supports database seeding, allowing developers to automatically populate databases with SQL scripts during database initialization. This feature streamlines the development workflow by enabling instant database setup with sample data. The seeding capability is also available through the Vite plugin integration, making it accessible in Vite-based projects.

To try it from your terminal:

npx neon-new --seed /path/to/file.sql

Update: The CLI command was npx neondb at the time of this release; it's now npx neon-new.

For more details, see:

• Neondb CLI Changelog
• Vite Plugin Changelog

As announced earlier, we're rolling out scheduled updates that include Postgres version upgrades, security patches, and Neon feature improvements.

These updates are applied during your project's maintenance window or the next time the compute restarts. Most updates take only a few seconds.

Updates for Business amd Enterprise plan projects will begin rolling out on July 9, 2025; you'll receive an email notice for updates 7 days in advance. You can also check for update notices and configure your preferred update window in the Neon Console. Learn how.

Computes larger than 8 CU or those configured to autoscale beyond 8 CU are not updated automatically. You must restart these computes manually. See Updating large computes.

To apply updates ahead of schedule, see Applying updates ahead of schedule.

Need help? Reach out to Neon Support.

Neon now supports OpenTelemetry! You can send metrics and Postgres logs from Neon to any OpenTelemetry-compatible backend. You can enable the integration from the Integrations page in the Neon Console. For setup instructions, refer to our OpenTelemetry docs, with example configuration for New Relic.

The Neon Data API is now in open beta for all users. Instantly turn your Neon Postgres database into a REST API. No backend required. Query tables, views, and functions right from your client app using standard HTTP verbs (GET, POST, PATCH, DELETE), powered by PostgREST.

We've improved our onboarding to make it easier to get Neon Auth and RLS set up as needed to safely use the Data API in your app.

Learn more in our getting started guide. Or try this tutorial walkthrough of our demo note-taking app.

Check out the live demo to see it in action.

The Neon MCP Server now supports API key-based authentication for remote access, in addition to OAuth. This allows for simpler authentication using your Neon API key (personal or organization) for programmatic access.

{
  "mcpServers": {
    "Neon": {
      "url": "https://mcp.neon.tech/mcp",
      "headers": {
        "Authorization": "Bearer <$NEON_API_KEY>"
      }
    }
  }
}

For Neon MCP Server setup instructions, see our guide.

Last week, we introduced app.build, our open-source reference implementation for building AI-powered applications on top of Neon. Unlike LLMs that generate isolated snippets, app.build uses agent architecture to turn prompts into fully deployed, production-ready applications, complete with frontend, backend, and a Neon Postgres database.

This week, in addition to installing app.build using npx, you can now install it using Homebrew.

📌 We also fixed an issue where newly built apps could flicker between the "Under Construction" page and the actual app. Apps now load consistently.

• Neon MCP Server now has a homepage: We've launched a new homepage for the Neon MCP Server at mcp.neon.tech, making it easier to understand what the MCP Server does and what tools it supports.

• Streamable HTTP support: The Neon MCP Server now supports streamable HTTP as an alternative to Server-Sent Events (SSE) for streaming responses. This makes it easier to consume streamed data in environments where SSE is not ideal (such as CLI tools, backend services, or AI agents). To use streamable HTTP, make sure to use the latest remote MCP server, and specify the https://mcp.neon.tech/mcp endpoint.

  {
    "mcpServers": {
      "neon": {
        "command": "npx",
        "args": ["-y", "mcp-remote@latest", "https://mcp.neon.tech/mcp"]
      }
    }
  }

We're very happy to join the codegen community with app.build, our open-source reference implementation for building codegen products on top of Neon. app.build is an agent that converts AI-generated code snippets into complete, deployed applications. While LLMs handle isolated coding problems well, app.build uses agent architecture to create production-ready apps.

• Beyond code snippets - Transforms prompts into complete, deployed applications with frontend, backend, and database
• Community-driven development - Open source for developers to bring their own models and run locally
• True agent architecture - Iterates on code, runs tests, and responds to feedback until everything works
• Instant deployment - Ships working apps with real infrastructure

npx @app.build/cli

With this single command, you can create and deploy a complete application with its own GitHub repository.

The agent decomposes app creation into validated tasks, running checks at each step to ensure everything works. This divide-and-conquer approach enables reliable generation of complex applications beyond simple code snippets.

Join us: GitHub - Built in the open for developers exploring AI-powered development.

Introducing Instagres at neon.new, which enables instant Postgres database provisioning without any configuration or account creation. This feature allows you to get a fully functional database in seconds and demonstrates Neon's claimable database capabilities in action. You can build similar experiences to Instagres in your own application using the APIs documented in the integration guide.

• Zero-configuration setup - No account required to get started
• Multiple access methods - Browser interface, CLI tools, and development integrations
• Claimable databases - Keep your database by claiming it with a Neon account within 72 hours

Get started immediately by visiting neon.new in your browser, running npx neon-new from the command line, or integrating automatic database provisioning into Vite projects with vite-plugin-neon-new.

Update: The CLI was npx neondb and the Vite plugin was @neondatabase/vite-plugin-postgres at the time of this release; they are now npx neon-new and vite-plugin-neon-new.

We're excited to announce that Neon is now powering Netlify DB, a new service that lets you provision production-ready Postgres databases directly from your Netlify project. Built on top of Instagres, Netlify DB makes it possible to spin up a fully configured Neon database with just one click in the Netlify Dashboard or a single CLI command (netlify init db).

Netlify DB is designed to be the perfect database for AI-native development, offering:

• Instant provisioning with no external signup required
• Automatic environment variable configuration
• Zero-config setup with your deployed functions
• The ability to claim your database and link it to your Neon account when you're ready

This integration is part of Netlify's Agent Week initiative, making it easier for both developers and AI agents to build applications with a production-ready database. Learn more in the Netlify DB documentation.

You can now whitelist redirect URIs for your deployed app directly in Neon Auth, without needing to create a Stack Auth account or transfer your project. This makes it easier to manage your app's authentication settings and simplifies your workflow.

You can now enable Neon Auth directly from the Neon Postgres Integration on Vercel. Enable it when creating a database, or later by going to the Storage tab in Vercel, selecting your database, and updating the Settings.

Neon Auth makes it easy to add authentication to your app. User data is stored in your Neon Postgres database, so you can query it like any other table and join it with your app data.
Learn more in the Neon Auth guide.

The Backup & Restore page (available in Early Access) includes two updates:

• The Instant point-in-time restore selector now defaults to the current time, making it easier to restore to the present or a recent point in time.

  

• You can now edit the snapshot name, an improvement based on feedback from our Early Access users.

  

We've published new guides to help you get the most out of your Postgres database:

• Getting started with ElectricSQL and Neon
• Build an AI-powered knowledge base chatbot using n8n and Neon Postgres
• Using Neon Postgres with Zapier
• Explore our latest Postgres extension guides

For users of the Neon Postgres Integration on Vercel, we've made it easier to get started with Neon Auth. When you connect a Vercel project to a Neon database, the integration now sets the environment variables required to use Neon Auth in your Next.js project:

• NEXT_PUBLIC_STACK_PROJECT_ID
• NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY
• STACK_SECRET_SERVER_KEY

These variables enable quick setup of Neon Auth, which syncs user profiles to your Neon database, making them queryable via the neon_auth.users_sync table. This simplifies authentication workflows in your app and removes the need to configure these values manually in Vercel.

To try Neon Auth, you can quickly deploy the Next.js template for Neon Auth, which is preconfigured to use these variables.

For more details on how the Neon integration sets Vercel environment variables, see our Vercel Native Integration guide.

We updated supported Postgres versions to 14.18, 15.13, 16.9, and 17.5, respectively.

When a new minor version is available on Neon, it is applied the next time your compute restarts (for any reason). For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.

Neon's Import Data Assistant can help you move your data when you need to update your Postgres version or change regions. Check out the docs for details on how to use it for these scenarios.

During this week's product team hackathon, Peter Bendel (Postgres Performance Engineer) took top prize with a hardware project that streams Arduino sensor data directly into Neon. The project uses NeonPostgresOverHTTP, an open-source library available in the official Arduino Library Manager.

We've published new guides to help you get the most out of Neon:

• HONC Guide - Building serverless Task APIs with Hono, Drizzle ORM, Neon, and Cloudflare for edge-enabled data applications
• Zero Guide - Integrating Zero by Rocicorp with Neon to build reactive, real-time applications with client-side cache and instant UI updates
• File storage integration guides for AWS S3, Azure Blob Storage, Cloudflare R2, and more - Learn how to store files in external services while tracking metadata in Neon
• RedWoodSDK Guide - Connecting Neon to RedwoodSDK, a framework for building full-stack applications on Cloudflare

We're excited to announce the Neon Data API, now available in Early Access! Instantly turn your Neon Postgres database into a REST API. No backend required. Query tables, views, and functions right from your client app using standard HTTP verbs (GET, POST, PATCH, DELETE), powered by PostgREST.

What can you do with the Neon Data API?

• Query your database from any client using HTTP or PostgREST-compatible SDKs (postgrest-js, postgrest-py, postgrest-go)
• Secure your API with Neon Auth or your own JWKS

Once enabled, you'll get a unique API endpoint for your project. Here's how you might query your data from postgrest-js:

const { data, error } = await postgrest
  .from('notes')
  .select('id, title, created_at, owner_id, shared')
  .eq('owner_id', user.id)
  .order('created_at', { ascending: false });

Want to try it?

The Data API is in Early Access and requires an invite. Message us from the Console or on Discord and we'll get you set up.

Learn more in our getting started guide.

We've launched a new Neon credit system in the console that we'll use for promotions, referrals, and goodwill. To test the new system, we're offering a $20.00 credit to Free plan users who upgrade to a paid Neon plan.

Claim your $20 credit

The credit will appear at the top of the Neon console and is automatically applied to your account when you upgrade.