Changelog

Get early access to backends for apps and agents

Just a reminder that three new services are on their way to Neon.

• Storage: S3-compatible object storage that branches with your database
• Compute: Serverless functions that run alongside Postgres
• AI Gateway: Route and log LLM calls to OpenAI, Anthropic, or Gemini through a single proxy built into your Neon project

Get early access to the Neon backend platform

We're expanding Neon into a complete backend platform. Drop your email and we'll reach out soon for early access.

Get access

Lakebase Search (Private Preview)

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.

Request access to Lakebase Search

Lakebase Search is in private preview. Submit your email and we'll enable it for you.

Request access

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

Run neonctl psql without installing the psql client

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>

Manage Neon Auth end-to-end from the CLI

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.

A branch-first dev loop for Neon

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 @neondatabase/env package injects branch-scoped variables at runtime:

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

For the full walkthrough, see our blog post.

Fixes and improvements

Backend for apps and agents: coming soon

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

• 

  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.

• 

  Compute

  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

  Route, log, and rate-limit LLM calls to OpenAI, Anthropic, or Gemini through a single proxy 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 for newly created Neon projects

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.

5x more network transfer on all paid plans

We've increased the public network transfer (egress) allowance on all paid plans from 100 GB to 500 GB 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.

Faster Text-to-SQL in the SQL Editor

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.

Link, branch, and query from the Neon CLI

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.

Manually pay an invoice

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.

Expanded infrastructure capacity in AWS Europe (Frankfurt)

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.

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.

Neon is building the backend for apps and agents

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
• Compute — 🔜 Coming Soon
• AI Gateway — 🔜 Coming Soon

Storage is an S3-compatible object storage service that branches with your database, keeping data and storage in sync across every branch. Compute is serverless compute deployed alongside your database. The AI Gateway covers model routing, logging, and cost controls for AI workloads, 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.

Schema Diff now supports larger schemas

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.

Per-branch consumption metrics API

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.

Replayable AI agents with Neon snapshots

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.

Fixes & improvements