---
name: Neon Changelog
slug: neon-changelog
type: feed
source_url: https://neon.com/docs/changelog
organization: Neon
organization_slug: neon
total_releases: 231
latest_date: 2026-10-30
last_updated: 2026-11-06
tracking_since: 2023-03-01
canonical: https://releases.sh/neon/neon-changelog
organization_url: https://releases.sh/neon
---

<Summary type="rolling" window-days="90" release-count="13">
Neon shipped developer infrastructure across three interconnected directions: AI integration deepened with Agent Skills, MCP Server setup, and docs shortcuts that teach assistants Neon practices; platform accessibility expanded through unlimited free org members, domain-based member invites, and simplified Auth SDKs; and operational tooling matured with usage tracking APIs, connection pooling graphs, Stripe Projects integration, and two-factor authentication. The release cadence shows intentional layering—foundational auth and org features early, then AI-first features gaining prominence through the period, culminating in AI shortcuts baked into the docs themselves.
</Summary>

<Summary type="monthly" period="March 2026" release-count="4">
Focused on integrations, tooling, and developer experience. Neon added two-factor authentication for account security, shipped one-command setup for AI assistants through the MCP Server, expanded Free plan org membership to unlimited, and integrated with Stripe Projects to embed Postgres directly into the Stripe CLI workflow.
</Summary>

<Release date="October 30, 2026" published="2026-10-30T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-10-30">
## Gemini 4 Argon, Apple and Microsoft sign-in, HIPAA for backend services, new Functions templates, and more release - Oct 30, 2026

Oct 30, 2026

## Oct 30, 2026– Gemini 4 Argon, Apple and Microsoft sign-in, HIPAA for backend services, new Functions templates, and more

## Gemini 4 Argon is now available on the AI Gateway

The AI Gateway now serves Google's [Gemini 4 Argon](/docs/ai-gateway/models/gemini-4-argon), with a 1M-token context window and text, image, video, audio, and PDF input. Call it through the chat completions or native Gemini endpoint, or with the AI SDK:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { neon } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> '@neon/ai-sdk-provider'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { generateText } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> 'ai'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="3"></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-keyword)">const</span><span style="color:var(--shiki-foreground)"> { </span><span style="color:var(--shiki-token-constant)">text</span><span style="color:var(--shiki-foreground)"> } </span><span style="color:var(--shiki-token-keyword)">=</span><span style="color:var(--shiki-token-keyword)"> await</span><span style="color:var(--shiki-token-function)"> generateText</span><span style="color:var(--shiki-foreground)">({</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">  model</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-function)"> neon</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-string-expression)">'gemini-4-argon'</span><span style="color:var(--shiki-foreground)">)</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">  prompt</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'Explain database branching in one sentence.'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">});</span></span>
<span class="line" data-line="8"></span>
<span class="line" data-line="9"><span style="color:var(--shiki-token-constant)">console</span><span style="color:var(--shiki-token-function)">.log</span><span style="color:var(--shiki-foreground)">(text);</span></span>
```

To use the native Gemini endpoint, see [Gemini API](/docs/ai-gateway/gemini).

## Managed Better Auth adds Apple and Microsoft sign-in

[Managed Better Auth](/docs/auth/overview) now supports Apple and Microsoft Entra ID as OAuth providers, alongside Google, GitHub, and Vercel. Add either one from your project's **Better Auth** settings, the Neon CLI, or the Neon API, using your own Apple or Entra app credentials. See [Set up OAuth](/docs/auth/guides/setup-oauth).

![The Add OAuth Provider dialog in the Neon Console, showing GitHub, Vercel, Microsoft, and Apple](/docs/changelog/oauth_providers.png?dpl=dpl_6ohFAGg8e9q9Q52eWAa3vhEdqga6)

## Tune Lakebase Search indexes

Version 1.1.2 of the [`lakebase_vector`](/docs/extensions/lakebase-vector) extension, part of [Lakebase Search](/docs/ai/lakebase-search), is now available on Postgres 16, 17, and 18. This release adds functions that recommend `lakebase_ann.probes` settings for your index, so you can trade off recall and latency without trial and error:

- `lakebase_ann_advise` recommends `probes` values with estimated recall and measured query latency.
- `lakebase_ann_tune` recommends `probes` values with estimated recall only.
- `lakebase_ann_latency` measures average, p50, and p95 query latency for the `probes` values you supply.
- `lakebase_ann_sample` samples rows from the indexed table to use as tuning queries when you don't have real ones.

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">SELECT</span><span style="color:var(--shiki-foreground)"> probes, recall, avg_ms, p50_ms, p95_ms</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">FROM</span><span style="color:var(--shiki-foreground)"> lakebase_ann_advise(</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-token-string-expression)">  'items_embedding_idx'</span><span style="color:var(--shiki-foreground)">::regclass,</span></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-keyword)">  ARRAY</span><span style="color:var(--shiki-foreground)">(</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-token-keyword)">    SELECT</span><span style="color:var(--shiki-foreground)"> embedding </span><span style="color:var(--shiki-token-keyword)">FROM</span><span style="color:var(--shiki-foreground)"> lakebase_ann_sample(</span><span style="color:var(--shiki-token-keyword)">NULL</span><span style="color:var(--shiki-foreground)">::items, </span><span style="color:var(--shiki-token-constant)">512</span><span style="color:var(--shiki-foreground)">)</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-token-keyword)">    WHERE</span><span style="color:var(--shiki-foreground)"> embedding </span><span style="color:var(--shiki-token-keyword)">IS NOT NULL</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">  )</span></span>
<span class="line" data-line="8"><span style="color:var(--shiki-foreground)">);</span></span>
```

If you already have the `lakebase_vector` extension installed, run `ALTER EXTENSION lakebase_vector UPDATE` to get the new functions. See [Get recommended probes values](/docs/extensions/lakebase-vector#get-recommended-probes-values) and [Upgrade the extension and indexes](/docs/extensions/lakebase-vector#upgrade-the-extension-and-indexes).

## New Neon Functions templates

The [Function Registry](/docs/compute/functions/registry/templates) we introduced last week has six new templates, many of them combining [Functions](/docs/compute/functions/overview) with Neon's other backend services. List them and add one to your project from the Neon CLI:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> functions</span><span style="color:var(--shiki-token-string)"> templates</span><span style="color:var(--shiki-token-string)"> list</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> functions</span><span style="color:var(--shiki-token-string)"> new</span><span style="color:var(--shiki-token-string)"> mcp-postgres</span></span>
```

The new templates:

- `mcp-postgres`: an MCP server with tools that read and write a Postgres table
- `telegram-bot`: an AI chat bot that keeps its conversation history in Postgres
- `image-analysis`: an API that describes uploaded images with a vision model on [AI Gateway](/docs/ai-gateway/overview)
- `image-generation`: an API that generates images on AI Gateway and stores them in [Object Storage](/docs/storage/overview)
- `rest-api-postgres`: a REST API for a Postgres table
- `authenticated-api`: an API that only [Managed Better Auth](/docs/auth/overview) users can call

To share your own template, see the [contributing guide](https://github.com/neondatabase/examples/blob/main/registry/CONTRIBUTING.md).

## Drag and drop uploads for Object Storage

You can now upload to [Object Storage](/docs/storage/overview) from the Neon Console by dragging files and folders into a bucket. Open the **Object storage** tab on your branch, select a bucket, and drop your files. You can still use **Upload** to pick files, or **New folder** to create a subfolder. See [Buckets](/docs/storage/buckets).

![An empty Object Storage bucket in the Neon Console, with a prompt to drag files or folders here or use Upload](/docs/changelog/object_storage_drag_and_drop.png?dpl=dpl_6ohFAGg8e9q9Q52eWAa3vhEdqga6)

## HIPAA support for Neon's backend services

[HIPAA compliance](/docs/security/hipaa) now extends to Neon's backend services. In a HIPAA-enabled project, you can now use [Managed Better Auth](/docs/auth/overview), the [Data API](/docs/data-api/get-started), [Functions](/docs/compute/functions/overview), [Object Storage](/docs/storage/overview), [AI Gateway](/docs/ai-gateway/overview), and [Realtime](/docs/realtime/overview) with protected health information (PHI).

If you need a counter-signed copy of the Business Associate Agreement (BAA) for your records, you can now [request one](/baa/signed). See [Business Associate Agreement (BAA)](/docs/security/hipaa#business-associate-agreement-baa).

## Set up your coding agent for Neon

You can now set up your coding agent for Neon with a single prompt. It installs the Neon CLI, signs you in, and adds Neon's agent skills and MCP server:

```
<span class="line" data-line="1"><span>Set me up for Neon. Fetch https://neon.com/prompts/agent-setup.md and follow it.</span></span>
```

To check that your agent has the latest Neon skills, run [`neon skills status`](/docs/cli/skills#status), and update any that are outdated:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> skills</span><span style="color:var(--shiki-token-string)"> status</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> skills</span><span style="color:var(--shiki-token-string)"> update</span><span style="color:var(--shiki-token-string)"> -y</span></span>
```

## Agent prompts for Neon's backend services

Adding a Neon backend service to your app now takes one prompt. Each service has a prompt you hand to your coding agent, and the agent installs the Neon CLI, reads Neon's agent skill, links a project with `neon init`, then builds a small working example in your project to show it works.

Copy a prompt from **Set up with your agent** at the top of each service's overview page:

- [Lakebase Postgres](/docs/postgres/overview)
- [Managed Better Auth](/docs/auth/overview)
- [Functions](/docs/compute/functions/overview)
- [Object Storage](/docs/storage/overview)
- [AI Gateway](/docs/ai-gateway/overview)
- [Realtime](/docs/realtime/overview)

## Fixes & improvements

**Data API**

- You can now enable the [Data API](/docs/data-api/get-started) on branches with an [expiration date](/docs/guides/branch-expiration), from the Console or the API. When the branch expires, its Data API is removed with it.

**Managed Better Auth**

- The Managed Better Auth SDK is now [`@neon/auth`](/docs/auth/overview) (previously `@neondatabase/auth`), and the Data API client is `@neon/postgrest-js`. Import paths keep the same subpaths, such as `@neon/auth/next`. For prebuilt sign-in and account UI, use [Better Auth UI](/docs/auth/reference/ui-components), which replaces the deprecated `@neondatabase/auth-ui`.

**Vercel**

- Fixed an issue in the [Neon-Managed Vercel integration](/docs/guides/neon-managed
</Release>

<Release date="October 23, 2026" published="2026-10-23T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-10-23">
## Jev on the AI Gateway, automatic top-up for AI Gateway credits, an OAuth provider for Managed Better Auth, and more release - Oct 23, 2026

Oct 23, 2026

## Oct 23, 2026– Jev on the AI Gateway, automatic top-up for AI Gateway credits, an OAuth provider for Managed Better Auth, and more

## Jev is now available on the AI Gateway

The AI Gateway now serves TypeSafe's System One decision models, [Jev 1.14](/docs/ai-gateway/models/typesafeai-jev-1-14-0) and the open-weights [OpenJev](/docs/ai-gateway/models/openjev-qwen35-4b). Instead of generating text, they answer questions about your input with a choice, a score, or a probability that your code can act on directly. You're billed for input tokens only.

```ts
import { neon } from '@neon/ai-sdk-provider';
import { experimental_decide as decide } from 'ai';

const { answers } = await decide({
  model: neon.decisionModel('typesafeai-jev-1-14-0'),
  state: "We're growing fast and want to add more projects and team members.",
  questions: {
    upgrade: { type: 'boolean', instructions: 'Is the user interested in upgrading their plan?' },
  },
});

console.log(answers.upgrade.probability); // 0.91
```

See [Decisions](/docs/ai-gateway/decisions) to get started. To see Jev in action, [build a content moderation pipeline](/guides/jev-content-moderation) or use it to [rerank hybrid search results](/docs/ai/lakebase-search-get-started#use-jev-through-neon-ai-gateway) with Lakebase Search.

## Automatic top-up for AI Gateway credits

Keep your AI features running without watching your balance. Organization admins can now turn on **auto-reload** for AI Gateway credits: when your balance drops below a threshold you set, Neon automatically buys the amount you choose with your payment card on file. Set it up from the **AI gateway credits** card on the **Billing** page, or while you're adding credits. See [Automatic top-up](/docs/ai-gateway/prepaid-credits#automatic-top-up).

![Auto-reload credits dialog in the Neon Console](/docs/changelog/aigw_auto_reload.png?dpl=dpl_2bzypEkR8cYcZsdfJYtq6epPmhi2)

## OAuth provider for Managed Better Auth (beta)

Managed Better Auth can now act as an OAuth 2.1 authorization server, so your users can sign in to your MCP server, API, or other apps with their existing accounts. To protect an MCP server, use the [`@neon/oauth`](https://www.npmjs.com/package/@neon/oauth) SDK (beta):

```ts
import express from 'express';
import { createMcpAuth } from '@neon/oauth/mcp';
import { expressMcp } from '@neon/oauth/mcp/express';

const auth = createMcpAuth({
  baseUrl: process.env.NEON_AUTH_BASE_URL!, // your branch's Auth URL
  resource: 'https://mcp.example.com/mcp', // the MCP server URL set on the provider
});

const app = express();
app.use(expressMcp(auth)); // verifies access tokens and serves the resource metadata
```

MCP clients identify themselves with Client ID Metadata Documents by default. Dynamic client registration is now a legacy option and is off by default. See [OAuth Provider](/docs/auth/guides/plugins/oauth-provider).

## Scaffold functions and search the docs from the Neon CLI

[`neon functions new`](/docs/cli/functions#new) (Neon CLI 8.11 or later) scaffolds a [Neon Function](/docs/compute/functions/overview) from a template. There are only a couple of starter templates so far, and we'll add more over time. Run `neon functions templates list` to see them. The quickest way to try it is `neon functions new basic`, which writes a small handler that returns JSON to `functions/basic/index.ts` and adds the function to `neon.ts`. Run it locally with `neon dev`, then deploy with `neon config apply`:

```
neon functions templates list
neon functions new basic
npm install @neon/config @neon/env
neon dev
neon config apply
```

Have a function others could use? Templates live in the [Neon Function Registry](https://github.com/neondatabase/examples/tree/main/registry) on GitHub, and anyone can propose one by opening a pull request. See the [contributing guide](https://github.com/neondatabase/examples/blob/main/registry/CONTRIBUTING.md).

[`neon docs search`](/docs/cli/docs#search) (Neon CLI 8.10 or later) searches neon.com from your terminal: the docs, API reference, Postgres tutorial, guides, FAQs, changelog, and blog. You don't need to be logged in. Use `--category` and `--limit` to narrow the results:

Terminal

```
$ neon docs search "reset a branch" --limit 2

Manage branches › Reset a branch from parent
  https://neon.com/docs/manage/branches

Branching with the Neon CLI › Resetting a branch from its parent
  https://neon.com/docs/guides/branching-neon-cli
```

## A new support center in the Console

The Neon Console now has one place to get help. Open your organization menu and select **Help** \> **Get help** to ask the AI assistant, open a support ticket, or reach the community. The options you see depend on your plan. See [Support](/docs/introduction/support#open-the-support-center).

![The Support center drawer in the Neon Console](/docs/changelog/support_center.png?dpl=dpl_2bzypEkR8cYcZsdfJYtq6epPmhi2)

## Fixes & improvements

**Postgres extensions**

- `plv8` is deprecated on Neon, and now so are `plcoffee` (CoffeeScript) and `plls` (LiveScript), which ship with it on Postgres 14, 15, and 16. `CREATE EXTENSION plcoffee` and `CREATE EXTENSION plls` now fail with a deprecation message, but existing installs keep working. If you still use them, migrate functions to `plpgsql` or application code and drop the extensions. See [The plv8 extension](/docs/extensions/plv8) and [Supported Postgres extensions](/docs/extensions/pg-extensions).

**Neon Functions**

- The total size of a function's [environment variables](/docs/compute/functions/environment-variables#constraints) is now limited to 32 KiB, and deploys over the limit fail with an error. Previously, a deploy with 32 to 64 KiB of variables succeeded, but every request to the function returned a `404`.

**Object Storage**

- Objects uploaded with [multipart upload](/docs/storage/objects#multipart-upload) can now be up to 10 GiB, up from 5 GiB. Single-request uploads are still limited to 5 GiB. See [Limits](/docs/storage/overview#limits).

**AI Gateway**

- Fixed an issue where Gemini models on the [chat completions endpoint](/docs/ai-gateway/chat-completions) returned `400 Unknown name "stream_options"` when a request set `stream_options`, as the OpenAI SDK does to request usage in a stream. Requests with `parallel_tool_calls: true` now work too. Gemini doesn't support `parallel_tool_calls: false`, so leave that field out.

**Realtime**

- The [Neon Realtime](/docs/realtime/sdks/typescript) client now supports React Native (`@neon/realtime` 0.1.2 or later). Use the new `webSocketFactory` option to customize the WebSocket connection, for example to send an allowed origin.

**Neon Console**

- We updated the Drizzle Studio integration behind the [**Tables** page](/docs/guides/tables), where you browse and edit your data, to version 1.6.1. It fixes an issue with renaming schemas. For details, see the [Neon Drizzle Studio Integration Changelog](https://github.com/neondatabase/neon-drizzle-studio-changelog/blob/main/CHANGELOG.md).
- **Analyze** is now **Explain (Analyze)** in the [SQL Editor](/docs/get-started/query-with-neon-sql-editor#explain-and-analyze), with a tooltip warning that it runs data-modifying statements such as `INSERT`, `UPDATE`, `DELETE`, and `MERGE`. Explain plans now include Neon's `PREFETCH` and `FILECACHE` options, so **Explain (Analyze)** shows compute cache hits and prefetch statistics.

**Neon CLI**

- You can now create [Claimable Neon](/docs/reference/claimable-neon) projects in any AWS region that accepts new Neon projects. Pass `--region-id` to [`neon claim create`](/docs/cli/claim) or `neon init --claimable` (Neon CLI 8.8.0 or later), or `region_id` in the API request. If you leave it out, the project lands in `aws-us-east-2`, as before.
- Fixed `neon login --keyring` failing on Windows after the browser step.

**Neon API**

- New [`GET /projects/count`](/docs/reference/api/projects/count-projects) endpoint (beta) returns the number of active projects in an organization, so you don't have to page through `GET /projects`. With a personal API key, pass `org_id`. With an org API key, it's inferred.
    
    ```
    curl 'https://console.neon.tech/api/v2/projects/count?org_id=org-example-12345678' \
      -H 'Accept: application/json' \
      -H "Authorization: Bearer $NEON_API_KEY"
    ```
    
    ```
    { "count": 12 }
    ```
    

**Neon MCP Server**

- The MCP server's documentation tools are now `search_docs` and `get_doc`, replacing `list_docs_resources` and `get_doc_resource`. `search_docs` returns ranked results from across neon.com (the docs, API reference, guides, Postgres tutorial, FAQs, blog, and changelog), so your agent finds the right page without loading the whole docs index. If your agent's prompts or tool allowlists name the old tools, update them. See [Neon MCP Server](/docs/ai/neon-mcp-server#available-tools).

**Vercel integrations**

- With the [Neon-Managed Vercel integration](/docs/guides/neon-managed-vercel-integration#choose-a-production-branch), you can now choose which Neon branch supplies Vercel **Production** credentials when you connect. To change it later, go to **Integrations**, click **Manage** next to **Vercel**, and open the **Branches** tab.
- If you installed Neon from the Vercel Marketplace, you can now choose which Neon branch backs Vercel **Production**. In the Neon Console, go to **Integrations** and click **Settings** next to **Vercel**. See [Choose a production branch](/docs/guides/vercel-managed-integration#choose-a-production-branch).
- New databases created from the Vercel Marketplace can turn on [Neon Realtime](/docs/realtime/overview) (beta) at install.
- Fixed an issue where a failed update to a preview branch could stop the [Neon-Managed Vercel integration](/docs/guides/neon-managed-vercel-integration) from syncing new credentials to your Production environment, for example after a password rotation.

**OpenTelemetry integration**

- Fixed an issue where you couldn't save an [OpenTelemetry integration](/docs/guides/opentelemetry) for Dynatrace or Splunk Observability because credential validation failed.
- When you change an OpenTelemetry integration's endpoint, protocol, or endpoint overrides, you'll need to re-enter its credentials.
</Release>

<Release date="October 16, 2026" published="2026-10-16T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-10-16">
## Neon Realtime in public beta, new AI Gateway models, Stripe real-time sync, CJK search in Lakebase Search, and more release - Oct 16, 2026

## Oct 16, 2026– Neon Realtime in public beta, new AI Gateway models, Stripe real-time sync, CJK search in Lakebase Search, and more

## Neon Realtime is in public beta

Neon now has realtime, built by the team behind [Electric](/blog/electric-joins-neon). [Neon Realtime](/docs/realtime/overview) turns any SQL query into a live query. Subscribe to it and the result stays up to date as your data changes. That makes your whole app reactive, with no polling or refetch logic.

It runs directly from Lakebase Postgres, and it works with scale to zero and branching. Out of the box you get [type-safe, end-to-end reactivity](/docs/realtime/guides/reactivity), [SSR support](/docs/realtime/guides/ssr), and [instant local writes](/docs/realtime/guides/mutations).

[Video](https://www.youtube.com/watch?v=DgdKM5SHG8M)

To see what it can do, try one of the live demo apps:

- [1 Million Boxes](https://one-million-boxes.vercel.app): the world's largest game of dots and boxes, with every move synced to everyone playing
- [Hacker News Realtime](https://hackernews-realtime.vercel.app): watch Hacker News scores, comment counts, and rankings change as they happen
- [Neonbricks](https://neonbricks-app.vercel.app): build a brick model together, or ask the AI to build one for you

The source code is available from our [Realtime examples](/docs/realtime/examples/overview) page.

Agents can install the Realtime skill with `neon skills -s neon-realtime`, or use the [Neon MCP Server](/docs/ai/neon-mcp-server).

To try it yourself, enable Realtime and subscribe to a query:

```
neon realtime enable
neon realtime subscribe "SELECT * FROM items"
```

The [Realtime quickstart](/docs/realtime/quickstart) walks through the full setup, or you can start from a template with `neon bootstrap my-app --template realtime-react`.

During the beta, Realtime is available in AWS `us-east-1`, `us-east-2`, `eu-central-1`, and `ap-southeast-1`. See the [Realtime FAQ](/docs/realtime/overview#frequently-asked-questions) for what's in the beta. Give it a try and tell us what you think on [Discord](https://neon.com/discord).

## New models in the AI Gateway

We've added 11 models to the [AI Gateway](/docs/ai-gateway/overview), including new releases from Anthropic, OpenAI, Google, and xAI:

- **Anthropic:** `claude-sonnet-5-5`, `claude-haiku-5-5`
- **OpenAI:** `gpt-6-sol`, `gpt-6-luna`, `gpt-6-1-sol`
- **Google:** `gemini-3-7-flash`, `gemini-3-8-flash`
- **xAI:** `grok-4-7`
- **Open-weight models:** `deepseek-v4-1-flash`, `glm-5-3` (Zhipu AI), `bge-large-en` (BAAI embedding model)

If you haven't used the AI Gateway yet, it gives you one endpoint and one Neon credential for models from many providers, so you don't need a separate account or API key for each one. The chat completions endpoint is OpenAI-compatible, so the OpenAI SDK and other standard clients work by changing the base URL. To switch models, change the `model` field:

```js
const client = new OpenAI({
  apiKey: process.env.NEON_AI_GATEWAY_TOKEN,
  baseURL: `${process.env.NEON_AI_GATEWAY_BASE_URL}/v1`,
});

const response = await client.chat.completions.create({
  model: 'claude-sonnet-5-5',
  messages: [{ role: 'user', content: 'Hello!' }],
});
```

The AI Gateway is available on the Launch and Scale plans with [prepaid credits](/docs/ai-gateway/prepaid-credits), which give you access to every model in the catalog. To get started, follow the [AI Gateway quickstart](/docs/ai-gateway/get-started). The [model catalog](/docs/ai-gateway/overview#available-models) lists all supported models.

## Sync Stripe data to Neon in real time

**Stripe Data Pipeline** can now stream your Stripe data straight into Postgres, and Neon is one of the destinations you can pick in the Stripe Dashboard. Stripe backfills your existing data and keeps it in sync as payments, subscriptions, and customers change, so you don't need webhook handlers or Stripe API calls to keep your copy current.

The data lands in the same database as your app, so checking whether a user has an active subscription is a join:

```sql
select s.status
from users u
join stripe.subscriptions s on s.customer = u.stripe_customer_id
where u.id = $1
  and s.status in ('active', 'trialing');
```

Real-time sync to Postgres is in public preview, and you can try it for free. To set it up, add a Neon pipeline from the **Data Pipeline** page in the Stripe Dashboard, choose your Neon project, and pick the tables to sync. To learn more, read [Sync Stripe data in real-time to Neon](/blog/stripe-data-pipeline-realtime-sync-to-postgres), or see the [Stripe docs](https://docs.stripe.com/data/data-pipeline/real-time-sync-to-postgres).

## Managed Better Auth upgraded to Better Auth 1.7

[Managed Better Auth](/docs/auth/overview), Neon's managed authentication service built on the open-source [Better Auth](https://www.better-auth.com/) library, now runs Better Auth 1.7.6. Your existing apps keep working with no changes. Sessions, cookies, and JWTs are unaffected, and older SDK versions are still supported.

We've also released new SDK versions built on Better Auth 1.7.6: `@neondatabase/auth` 0.6.0-beta, `@neondatabase/neon-js` 0.8.0-beta, and `@neondatabase/auth-ui` 0.4.0-beta.

If you use a Better Auth client of your own with Managed Better Auth, use Better Auth 1.7 or later.

**Upgrade note:** With the new SDKs, `accountInfo`, `unlinkAccount`, `getAccessToken`, and `refreshToken` identify a linked account by its local account `id`, as returned by `listAccounts()`, instead of the provider's account ID. They no longer accept `providerId`. If you call these methods directly, update your code:

```js
const { data: accounts } = await authClient.listAccounts();
const google = accounts.find((a) => a.providerId === 'google');
await authClient.accountInfo({ query: { accountId: google.id } });
```

**Known issue:** In `@neondatabase/auth-ui` 0.4.0-beta, the Providers settings card can't unlink an account or show the provider email. A fix is in progress.

## Chinese, Japanese, and Korean full-text search in Lakebase Search

[Lakebase Search](/docs/ai/lakebase-search) now supports keyword search over Chinese, Japanese, and Korean (CJK) text. These languages don't put spaces between words, so Postgres's built-in full-text search can't split them into search terms. The [`lakebase_tokenizer`](/docs/extensions/lakebase-tokenizer) extension now does that for you, with ready-to-use `tokenizer_chinese`, `tokenizer_japanese`, and `tokenizer_korean` configurations:

```sql
CREATE EXTENSION IF NOT EXISTS lakebase_tokenizer;

SELECT to_tsvector('tokenizer_japanese', '関西国際空港に行きました');
-- '国際':2 '空港':3 '行く':4 '関西':1
```

The output is a standard `tsvector`, so it works with GIN indexes and with [`lakebase_text`](/docs/extensions/lakebase-text) for BM25 ranking. CJK support ships in `lakebase_tokenizer` 0.2.0. If you're already using the extension, run `ALTER EXTENSION lakebase_tokenizer UPDATE;`. Your existing configurations and indexes don't need to change. See [CJK text](/docs/extensions/lakebase-tokenizer#cjk-text) for more examples.

## Fixes & improvements

**Neon MCP Server**

- You can now choose which Postgres role the [Neon MCP Server](/docs/ai/neon-mcp-server) uses for SQL. Set `roleName` (for example, `https://mcp.neon.tech/mcp?readonly=true&roleName=app_reader`) and every SQL tool logs in as that role instead of the database owner, so the role's grants decide what your agent can read and change. With OAuth and the plain `https://mcp.neon.tech/mcp` URL, enter the role in the optional **Postgres role** field on the authorization page. When you set a role, the `get_connection_string` tool is turned off, so your agent can't get around the role by connecting as the database owner. See [Postgres role](/docs/ai/neon-mcp-server#postgres-role).
- `run_sql_transaction` is no longer available in [read-only mode](/docs/ai/neon-mcp-server#read-only-mode), because it could be used to write data. Use `run_sql` for read queries.

**Neon CLI and SDKs**

- [`neon psql`](/docs/cli/psql) now passes arguments after `--` to psql exactly as typed. Before, the CLI changed number-like values on the way through (`1.50` became `1.5` and `1e3` became `1000`), and if you didn't have psql installed, the CLI's built-in psql could crash on them. The fix also applies to `--psql` on `neon connection-string`, `neon branches create`, and `neon projects create`.
- `@neon/env` 1.6.2: `parseEnv` no longer fails with a "`NEON_FUNCTION_<SLUG>_BASE_URL` is missing" error inside deployed functions, which broke any function whose `neon.ts` declares functions. `env.functions` is now optional, so write `env.functions?.hello.baseUrl` instead of `env.functions.hello.baseUrl`. See [Type-safe environment variables](/docs/reference/neon-ts#type-safe-environment-variables).
</Release>

<Release date="October 9, 2026" published="2026-10-09T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-10-09">
## All AI Gateway models with prepaid credits, backend features with your coding agent, and new ways to send feedback release - Oct 09, 2026

## Oct 09, 2026– All AI Gateway models with prepaid credits, backend features with your coding agent, and new ways to send feedback

## All AI Gateway models now available with prepaid credits

You don't need to request access to frontier models in the [Neon AI Gateway](/docs/ai-gateway/overview) anymore. If you're on a paid plan and have prepaid credits, you can call every model in the catalog, including models from OpenAI, Anthropic, Google, Meta, and Moonshot AI. We also just added Claude Opus 5.5 (`claude-opus-5-5`). The [Models](/docs/ai-gateway/models#available-models) page has the full list.

![The AI Gateway page in the Neon Console showing the model catalog](/docs/changelog/ai_gateway_models.png?dpl=dpl_3GqHHq5SxgVUovkqzBksp5qAzFFr)

To try it, [buy some prepaid credits](/docs/ai-gateway/prepaid-credits#buy-or-top-up-credits), then follow the [AI Gateway quickstart](/docs/ai-gateway/get-started) to make your first request.

## Try Neon's backend features with your coding agent

If you haven't tried [Functions](/docs/compute/functions/overview), [Object Storage](/docs/storage/overview), or the [AI Gateway](/docs/ai-gateway/overview) yet, your coding agent is a good place to start. First, install Neon's [agent skills](/docs/ai/agent-skills) in your project so your agent (Cursor, Claude Code, Codex, or another) knows how these services work:

```
npx neon@latest skills -y
```

Then give it something to build. Here are a few ideas:

```
Add file uploads to my app with Neon Object Storage, and save each file's metadata in Postgres.
```

```
Create a Neon Function that uses the AI Gateway to summarize support tickets.
```

```
Schedule a Neon Function to run every night and delete files older than 30 days from my Object Storage bucket.
```

If you'd rather see the bigger picture first, [How a Neon backend fits together](/docs/get-started/backend-overview) walks through how these services work with Lakebase Postgres and Managed Better Auth.

## Send feedback from the CLI and MCP Server

You can now send us feedback straight from your terminal or your coding agent.

- **Neon MCP Server:** Ask your agent to send it with the new `send_feedback` tool. For example: "send Neon feedback that I'd love a TypeScript example for branching in the docs." See [Neon MCP Server](/docs/ai/neon-mcp-server#available-tools).
- **Neon CLI:** Run `neon feedback --message "<your feedback>"`. See [neon feedback](/docs/cli/feedback).

Either way, we only get your message. No account, project, or connection details come with it.

You can also use the [Feedback](https://console.neon.tech/app/projects?modal=feedback) form in the Neon Console, or join the conversation in the [feedback channel](https://discord.com/channels/1176467419317940276/1176788564890112042) on our Discord.

## Fixes & improvements

Here are the smaller updates and fixes we shipped this week.

**Console**

- Managed Better Auth plugin settings (Organizations, Magic Link, and Phone Authentication) now live under **Settings** \> **Better Auth** with the rest of your auth configuration, instead of on the **Plugins** tab. See [Plugins](/docs/auth/guides/plugins).
- You can now see your project's Object Storage usage in the **Project** panel on the branch **Overview** page. It covers all branches in the project. See [Limits](/docs/storage/overview#limits).
- Fixed an issue in the create-project flow where your region reset to US East (Ohio) when you turned on Object Storage or added a bucket.
- When you delete a project, we now remind you that its custom domains stay reserved, so you can remove any you want to reuse first. See [Delete a custom domain](/docs/compute/functions/custom-domains#delete-a-custom-domain).

**Neon CLI**

- To sign in, run `neon login`. `neon auth` still works too.
- `neon deploy` and `neon config apply` now accept `-y` (`--yes`), which says yes to every confirmation, including updates to existing settings and changes to protected branches.
- `neon config init --services postgres` creates a Postgres-only `neon.ts`. We removed the `none` option.
- If you're signed out, `neon me` now just tells you so instead of opening a browser to sign you in.
- CLI commands now look for `neon.ts` and `.env.local` in the directory that holds your project's `.neon` file.
- If the CLI fails because of a problem on our side, it now sends us an error report so we can fix it. Reports don't include your arguments, environment variables, or file contents. To turn them off, along with usage analytics, pass `--no-analytics`.

**Managed Better Auth**

- Fixed an issue where you couldn't create a user without a display name.

**New NAT gateway IPs and Private Networking endpoints in eu-central-1**

- We added NAT gateway IP addresses and Private Networking VPC endpoint service names in AWS Europe (Frankfurt) (`eu-central-1`). If you allowlist Neon's outbound IPs, add the new addresses from the [Regions](/docs/introduction/regions#nat-gateway-ip-addresses) page so outbound connections don't fail intermittently. If you use Private Networking in this region, add the new service names from the [Private Networking guide](/docs/guides/neon-private-networking).
</Release>

<Release date="October 2, 2026" published="2026-10-02T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-10-02">
## More storage for your 100 Free plan projects release - Oct 02, 2026

## Oct 02, 2026– More storage for your 100 Free plan projects

## More storage on the Free plan

![1 GB of storage per project on the Neon Free plan](/docs/changelog/1-gb-storage.png?dpl=dpl_DYu7UeqP92nhfCpmrh1V7d4fkTW6)

The Neon Free plan now gives you **1 GB of database storage per project**, up from 0.5 GB. Existing projects pick up the new limit automatically. It was one of the most requested Free plan changes.

The extra storage builds on an already-generous plan: you get up to **100 projects** on the Free plan, each with its own compute, storage, and egress. Spin up a new project for every app idea, experiment, or client demo, without paying for each project separately.

Read more in the blog post: [Neon gives you 100 projects for free, with 1 GB of Postgres storage each](https://neon.com/blog/neon-free-plan-1-gb-per-project), or see [Neon plans](/docs/introduction/plans) for the full breakdown.

## Embedding models in the Neon AI Gateway

The Neon AI Gateway now supports [embedding models](/docs/ai-gateway/embeddings), so you can turn text into vectors through the same OpenAI-compatible endpoint and Neon credential you already use for chat. Call `/v1/embeddings` with either model:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> OpenAI </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> 'openai'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="2"></span>
<span class="line" data-line="3"><span style="color:var(--shiki-token-keyword)">const</span><span style="color:var(--shiki-token-constant)"> client</span><span style="color:var(--shiki-token-keyword)"> =</span><span style="color:var(--shiki-token-keyword)"> new</span><span style="color:var(--shiki-token-function)"> OpenAI</span><span style="color:var(--shiki-foreground)">({</span></span>
<span class="line" data-line="4"><span style="color:var(--shiki-foreground)">  apiKey</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-constant)"> process</span><span style="color:var(--shiki-foreground)">.</span><span style="color:var(--shiki-token-constant)">env</span><span style="color:var(--shiki-foreground)">.</span><span style="color:var(--shiki-token-constant)">NEON_AI_GATEWAY_TOKEN</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">  baseURL</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> `</span><span style="color:var(--shiki-token-keyword)">${</span><span style="color:var(--shiki-token-constant)">process</span><span style="color:var(--shiki-foreground)">.</span><span style="color:var(--shiki-token-constant)">env</span><span style="color:var(--shiki-foreground)">.</span><span style="color:var(--shiki-token-constant)">NEON_AI_GATEWAY_BASE_URL</span><span style="color:var(--shiki-token-keyword)">}</span><span style="color:var(--shiki-token-string-expression)">/v1`</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">});</span></span>
<span class="line" data-line="7"></span>
<span class="line" data-line="8"><span style="color:var(--shiki-token-keyword)">const</span><span style="color:var(--shiki-foreground)"> { </span><span style="color:var(--shiki-token-constant)">data</span><span style="color:var(--shiki-foreground)"> } </span><span style="color:var(--shiki-token-keyword)">=</span><span style="color:var(--shiki-token-keyword)"> await</span><span style="color:var(--shiki-token-constant)"> client</span><span style="color:var(--shiki-token-function)">.</span><span style="color:var(--shiki-token-constant)">embeddings</span><span style="color:var(--shiki-token-function)">.create</span><span style="color:var(--shiki-foreground)">({</span></span>
<span class="line" data-line="9"><span style="color:var(--shiki-foreground)">  model</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'qwen3-embedding-0-6b'</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-comment)"> // or 'gte-large-en'</span></span>
<span class="line" data-line="10"><span style="color:var(--shiki-foreground)">  input</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'The quick brown fox jumps over the lazy dog.'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="11"><span style="color:var(--shiki-foreground)">  encoding_format</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'float'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="12"><span style="color:var(--shiki-foreground)">});</span></span>
<span class="line" data-line="13"><span style="color:var(--shiki-token-comment)">// data[0].embedding is a 1024-dimension vector</span></span>
```

Both models (`qwen3-embedding-0-6b` and `gte-large-en`) return 1024-dimension vectors and are billed on input tokens only. Store and search the vectors on the same branch as your data with [Lakebase Search](/docs/ai/lakebase-search) or [pgvector](/docs/extensions/pgvector). For the full reference, including the `dimensions` parameter and response format, see the [Embeddings](/docs/ai-gateway/embeddings) guide.

## Effect bindings for the Neon SDK

[Effect](https://effect.website) is a TypeScript library for building resilient apps, with typed errors, retries, timeouts, and cancellation built in. The new `@neon/effect` package wraps the [Neon Management SDK](/docs/reference/typescript-sdk) in Effect v4, so managing your Neon projects fits that model: every API call returns an `Effect`, paginated lists return a `Stream`, and SDK errors are tagged for `Effect.catchTag`. Interrupting a fiber cancels the in-flight request and readiness polling, so retries, timeouts, and cancellation compose with the rest of your program.

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { Neon</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-foreground)"> layerConfig } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> '@neon/effect'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { Effect</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-foreground)"> Stream } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> 'effect'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="3"></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-keyword)">const</span><span style="color:var(--shiki-token-constant)"> program</span><span style="color:var(--shiki-token-keyword)"> =</span><span style="color:var(--shiki-token-constant)"> Effect</span><span style="color:var(--shiki-token-function)">.gen</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-keyword)">function*</span><span style="color:var(--shiki-foreground)"> () {</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-token-keyword)">  const</span><span style="color:var(--shiki-token-constant)"> neon</span><span style="color:var(--shiki-token-keyword)"> =</span><span style="color:var(--shiki-token-keyword)"> yield*</span><span style="color:var(--shiki-foreground)"> Neon;</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-token-keyword)">  return</span><span style="color:var(--shiki-token-keyword)"> yield*</span><span style="color:var(--shiki-token-constant)"> neon</span><span style="color:var(--shiki-token-function)">.</span><span style="color:var(--shiki-token-constant)">projects</span><span style="color:var(--shiki-token-function)">.list</span><span style="color:var(--shiki-foreground)">()</span><span style="color:var(--shiki-token-function)">.pipe</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-constant)">Stream</span><span style="color:var(--shiki-token-function)">.take</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-constant)">10</span><span style="color:var(--shiki-foreground)">)</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-constant)"> Stream</span><span style="color:var(--shiki-foreground)">.runCollect);</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">});</span></span>
<span class="line" data-line="8"></span>
<span class="line" data-line="9"><span style="color:var(--shiki-token-constant)">Effect</span><span style="color:var(--shiki-token-function)">.runPromise</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-constant)">program</span><span style="color:var(--shiki-token-function)">.pipe</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-constant)">Effect</span><span style="color:var(--shiki-token-function)">.provide</span><span style="color:var(--shiki-foreground)">(layerConfig)));</span></span>
```

Install `@neon/effect` alongside `effect` v4. Read more in the blog post: [Announcing @neon/effect](https://neon.com/blog/announcing-neon-effect), or see the [Effect bindings](/docs/reference/effect-sdk) reference.

## Fixes & improvements

**Postgres extension updates**

- Updated PostGIS and its related geospatial extensions (`postgis`, `postgis_raster`, `postgis_sfcgal`, `postgis_tiger_geocoder`, `postgis_topology`, `address_standardizer`, and `address_standardizer_data_us`) to newer versions: 3.3.10 on Postgres 14 through 16, 3.5.7 on Postgres 17, and 3.6.4 on Postgres 18. To upgrade an existing installation, see [Update an extension version](/docs/extensions/pg-extensions#update-an-extension-version).
- Updated the [`hll`](https://github.com/citusdata/postgresql-hll) extension (HyperLogLog data type) to version 2.21 across all supported Postgres versions.

**AI Gateway enhancements**

- The [`@neon/ai-sdk-provider`](https://www.npmjs.com/package/@neon/ai-sdk-provider) (1.0.0) now supports embeddings. `neon.embeddingModel('qwen3-embedding-0-6b')` works with the Vercel AI SDK's `embed()` and `embedMany()`, routed through the AI Gateway with your Neon credential, so you no longer have to call the endpoint outside the provider. See [Embeddings](/docs/ai-gateway/embeddings).
- AI Gateway error responses are now consistent and safe to parse: every upstream (non-2xx) error returns a flat `{"error_code","message"}` envelope with the upstream status preserved, and upstream internal details are no longer passed through. Rate-limit and spend-limit errors now state which limit was hit and how to recover. See [AI Gateway troubleshooting](/docs/ai-gateway/troubleshooting).

**Neon Functions improvements**

- You can now delete an inherited function on a child branch. Deletion is branch-local: it removes the function from that branch only, leaving the parent and sibling branches untouched. Previously this returned a 404. See [Delete a function](/docs/compute/functions/deploy#delete-a-function).

**Serverless driver**

- **Connection parameters (`@neondatabase/serverless` 1.2.0).** The Neon serverless driver's `neon()`, `query`, and `transaction` functions now accept individual connection parameters, `user`, `password`, `host`, `port`, `database`, and `connectionString`, that supplement, override, or fully replace a connection string. Each can be a string or a sync/async function resolved on every query, so you can supply short-lived credentials (such as an OIDC token used as the password) without rebuilding the connection string. Upgrade with `npm install @neondatabase/serverless@latest`. See [Connection parameters](/docs/serverless/serverless-driver#connection-parameters).
- The JavaScript Registry (JSR) publication of the Neon serverless driver (`@neon/serverless`) is deprecated and no longer updated. The driver itself is unchanged and fully supported: install it from npm as [`@neondatabase/serverless`](https://www.npmjs.com/package/@neondatabase/serverless). Runtimes that consume JSR packages, including Deno, can install the npm package directly (for example, `deno add npm:@neondatabase/serverless`). See the [Neon serverless driver](/docs/serverless/serverless-driver) docs.

**Neon Console Tables page updates**

- The [**Tables** page](/docs/guides/tables) in the Neon Console, where you browse and edit your data, is powered by a Drizzle Studio integration. That integration has been updated to version 1.6.0. For the improvements and fixes in this version, see the [Neon Drizzle Studio Integration Changelog](https://github.com/neondatabase/neon-drizzle-studio-changelog/blob/main/CHANGELOG.md).

**Neon MCP server updates**

- The `explain_sql_statement` tool is now safe by default. Its `analyze` option defaults to `false`, so a plain `EXPLAIN` returns the query plan without running your statement. To get real execution metrics, you can pass `analyze: true` to run `EXPLAIN ANALYZE`, which executes the statement and can have side effects, so writes persist if your query modifies data. See [Neon MCP server](/docs/ai/neon-mcp-server).
- Project tools now work on project-scoped MCP connections. You can connect the MCP server to your whole Neon account or scope it to a single project (for example, ChatGPT and Codex connect to one project at a time). Tools that act on a project, such as `run_sql`, previously failed on a project-scoped connection. Now they all take the same optional `project_id`: on a project-scoped connection it's filled in for you, and on an account-wide connection you pass it as before. See [Neon MCP server](/docs/ai/neon-mcp-server).
- We refreshed the tools the Neon MCP server gives to AI agents. The `create_trigger` and `update_trigger` tools can now set up object-upload triggers (`storage_object_created`) that run a Neon Function whenever a file is uploaded to Object Storage. And `create_storage_bucket` is now flagged as potentially public-facing: because a bucket's `access_level` can make its contents readable by anyone, an agent treats creating one as something to be careful with rather than a routine internal action. See [Object Storage](/docs/storage/overview) and [Function Triggers](/docs/compute/functions/triggers/object-storage).

**Neon CLI and agent skill updates**

- `neon link` now writes a complete context to the `.neon` file: the organization (when the project has one), the project, and the branch. Org-only, unpinned, or `--no-checks` links without `--branch` now fail, so a linked directory always resolves to a specific branch. See [neon link](/docs/cli/link). To pick up this and other recent changes, [upgrade your Neon CLI client](/docs/cli/install#upgrade).
- The Neon [agent skills](/docs/ai/agent-skills) now include a **neon-auth** skill, so coding agents can set up and work with [Neon Auth](/docs/auth/overview) alongside the existing Postgres, Functions, Object Storage, and AI Gateway skills.
- `neon.ts` is Neon's [config-as-code file](/docs/reference/neon-ts), where you declare the services a project uses, such as Auth, the Data API, and Functions. The new `neon config add` command adds one of those services to an existing `neon.ts` for you (for example, `neon config add auth`), so you don't have to edit the file by hand. See [neon config](/docs/cli/config).
</Release>

<Release date="September 25, 2026" published="2026-09-25T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-09-25">
## Object Storage branch reset, workload automation with Functions, and Realtime coming to Neon release - Sep 25, 2026

## Sep 25, 2026– Object Storage branch reset, workload automation with Functions, and Realtime coming to Neon

## Reset a branch's Object Storage from its parent

[Reset from parent](/docs/guides/reset-from-parent) now rolls back a branch's [Object Storage](/docs/storage/overview) 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](/docs/guides/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.

## Lakebase Search extensions updated

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](/docs/extensions/lakebase-text#upgrade-the-extension-and-indexes).

#### note

Building search with an AI coding assistant? The `neon-postgres` [agent skill](/docs/cli/skills) now includes Lakebase Search guidance for vector, full-text, and hybrid queries. Install it with:

```
neon skills -s neon-postgres
```

## Automating workloads with Neon Functions

Last week we announced that [the Neon backend](/docs/get-started/backend-overview) is generally available, with Functions running next to your database. This week, a [new guide](/guides/neon-function-triggers-cron-and-object-storage) shows how to use Neon Functions to automate workloads with [Function Triggers](/docs/compute/functions/triggers/overview): run a Function on a UTC cron schedule or when a file lands in an [Object Storage](/docs/storage/overview) 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 is coming to Neon

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](https://neon.com/blog/electrifying-neon-building-the-realtime-backend).
</Release>

<Release date="September 18, 2026" published="2026-09-18T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-09-18">
## The Neon backend is generally available release - Sep 18, 2026

Sep 18, 2026

## Sep 18, 2026– The Neon backend is generally available

## The Neon backend is generally available

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](https://youtu.be/3NSc8rZJkec) to see how it all fits together.

- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### Lakebase Postgres
    
    100% Postgres on the Lakebase architecture: autoscaling, scale to zero, and a branch for every PR, preview, or agent session.
    
    
    
    ](/docs/postgres/overview)
- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### Object Storage
    
    S3-compatible object storage that branches with your data, so files and rows stay in sync across branches.
    
    
    
    ](/docs/storage/overview)
- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### Auth
    
    Managed Better Auth: users and sessions live in your neon\_auth schema, queryable with SQL and protected by RLS.
    
    
    
    ](/docs/auth/overview)
- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### Functions
    
    Long-running Node.js compute next to your database, now with triggers and custom domains.
    
    
    
    ](/docs/compute/functions/overview)
- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### AI Gateway
    
    One credential for frontier and open-weight models at provider prices with no markup. Buy prepaid credits to use it.
    
    
    
    ](/docs/ai-gateway/overview)
- [![](/_next/static/immutable/media/pattern.2qd_7vmtgnbf6.svg)
    
    ### Data API
    
    An instant REST endpoint over your Postgres tables, no backend server required.
    
    
    
    ](/docs/data-api/overview)

**How to get started**

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

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> skills</span></span>
```

However you build, your whole backend is declared in one [`neon.ts`](/docs/reference/neon-ts) file and applied with [`neon deploy`](/docs/cli/deploy), whether your agent writes it or you do:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-comment)">// neon.ts</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { defineConfig } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> '@neon/config/v1'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="3"></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-keyword)">export</span><span style="color:var(--shiki-token-keyword)"> default</span><span style="color:var(--shiki-token-function)"> defineConfig</span><span style="color:var(--shiki-foreground)">({</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">  auth</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-constant)"> true</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-comment)"> // managed authentication</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">  buckets</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-foreground)"> { uploads</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-foreground)"> {} }</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-comment)"> // S3-compatible object storage</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">  functions</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-foreground)"> { api</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-foreground)"> { source</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> './functions/api.ts'</span><span style="color:var(--shiki-foreground)"> } }</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-comment)"> // serverless compute</span></span>
<span class="line" data-line="8"><span style="color:var(--shiki-foreground)">  aiGateway</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-constant)"> true</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-token-comment)"> // one API for many LLMs</span></span>
<span class="line" data-line="9"><span style="color:var(--shiki-foreground)">});</span></span>
```

Get started with [How a Neon backend fits together](/docs/get-started/backend-overview) or the [full-stack quickstart](/docs/get-started/full-backend-quickstart), or scaffold a working example with [`neon bootstrap`](/docs/cli/bootstrap). Read the [launch blog post](/blog/neon-backend-is-ga) for the full story.

## New with the GA release

### Function Triggers

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](/docs/storage/overview) 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-comment)">// neon.ts</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-foreground)">functions</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> {</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-foreground)">  reports</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> {</span></span>
<span class="line" data-line="4"><span style="color:var(--shiki-foreground)">    source</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-token-string-expression)"> './functions/reports.ts'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">    triggers</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> [{ type</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'schedule'</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-foreground)"> name</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'nightly'</span><span style="color:var(--shiki-token-punctuation)">,</span><span style="color:var(--shiki-foreground)"> cron</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> '0 6 * * *'</span><span style="color:var(--shiki-foreground)"> }]</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">  }</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">}</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
```

See [Function Triggers](/docs/compute/functions/triggers/overview).

### Custom domains for Functions

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`:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-comment)">// neon.ts</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-foreground)">functions</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> {</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-foreground)">  api</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> {</span></span>
<span class="line" data-line="4"><span style="color:var(--shiki-foreground)">    source</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-token-string-expression)"> './functions/api.ts'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">    customDomains</span><span style="color:var(--shiki-token-punctuation)">:</span><span style="color:var(--shiki-foreground)"> [</span><span style="color:var(--shiki-token-string-expression)">'api.example.com'</span><span style="color:var(--shiki-foreground)">]</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">  }</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">}</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
```

Domains are branch-scoped, so a preview branch can serve from its own hostname while production keeps yours. See [Custom domains](/docs/compute/functions/custom-domains).

### Prepaid credits for the AI Gateway

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](/docs/ai-gateway/prepaid-credits).

### More regions

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](/docs/introduction/regions#product-availability).

## Turn on the backend when you create a project

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 create-project dialog with the Services section](/docs/changelog/new_create_project.png?dpl=dpl_9VXSeSyXAv52rJnApzyZKkPs5Crv)

## A redesigned project settings page

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.

![The redesigned, tabbed project Settings page](/docs/changelog/new_project_settings.png?dpl=dpl_9VXSeSyXAv52rJnApzyZKkPs5Crv)

## Organizations and account settings moved to the profile menu

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.

![The profile menu with organization switching and account settings](/docs/changelog/new_org_account_settings.png?dpl=dpl_9VXSeSyXAv52rJnApzyZKkPs5Crv)

## Fixes & improvements

**SDK**

- **`@neon/sdk` uses named parameters.** Resource methods now take a single named parameter object, for example `neon.branches.get({ projectId, branchId })`, instead of positional arguments. This is a breaking change; the SDK is now on v6. See the [TypeScript SDK reference](/docs/reference/typescript-sdk).
- **Parse trigger deliveries with `@neon/functions`.** `parseTriggerDelivery` and `parseTriggerInvocation` from `@neon/functions/triggers` validate schedule and `storage_object_created` deliveries, so handlers don't hand-check headers.

**neon.ts config**

- **Backend services are GA in `neon.ts`.** Declare `aiGateway`, `functions`, and `buckets` as top-level keys in `defineConfig`, alongside `auth` and `dataApi`. The old `preview` block still works but is deprecated and warns on `neon deploy`. See the [`neon.ts` reference](/docs/reference/neon-ts).
- **Declare Function triggers and custom domains in `neon.ts`.** Custom domains and `storage_object_created` and schedule triggers can be declared in `neon.ts` and reconciled by `neon deploy`.

**CLI**

- **`neon init` scaffolds the Data API.** You can now include the Data API when scaffolding a `neon.ts`. See the [`neon init` reference](/docs/cli/init).

**New NAT gateway IPs and Private Networking endpoints in sa-east-1**

- Added NAT gateway IP addresses and a Private Networking VPC endpoint service name in AWS South America (São Paulo) (`sa-east-1`). If you allowlist Neon's outbound IPs, add the new addresses from the [Regions](/docs/introduction/regions#nat-gateway-ip-addresses) page, or outbound connections can fail intermittently. If you use Private Networking in this region, add the new service name from the [Private Networking guide](/docs/guides/neon-private-networking).
</Release>

<Release date="September 11, 2026" published="2026-09-11T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-09-11">
## Claimable Neon, @neon/tools, and more release - Sep 11, 2026

## Sep 11, 2026– Claimable Neon, @neon/tools, and more

## Claimable Neon: provisioned by agents, claimed by humans

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](https://neon.com/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](/docs/get-started/why-neon), [the Data API](/docs/data-api/overview), and [Managed Better Auth](/docs/auth/overview) this way, with support for [Object Storage](/docs/storage/overview), [Functions](/docs/compute/functions/overview), and [AI Gateway](/docs/ai-gateway/overview) coming soon.

For how it works, see the [Claimable Neon docs](/docs/reference/claimable-neon) and the [launch blog post](https://neon.com/blog/an-agent-provisions-a-neon-backend-a-human-claims-it-later).

## Give your agent Neon tools with`@neon/tools`

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`](https://github.com/neondatabase/neon-pkgs/tree/main/packages/tools) gives it typed, function-calling tools instead of hand-written API wrappers. It turns the [`@neon/sdk`](/docs/reference/typescript-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](/docs/ai/neon-mcp-server) for coding assistants like Cursor and Claude, adding over 70 new tools. Read more in [Give your agent Neon tools](https://neon.com/blog/give-your-agent-neon-tools).

## Faster queries on large computes

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](https://neon.com/blog/improving-lakebase-compute-cache-part-1).

## Fixes & improvements

**Scheduled snapshots**

The most recent scheduled snapshot on a branch is now kept for as long as the branch has an active snapshot schedule, instead of being deleted when it reaches its retention deadline. A branch with a schedule always keeps at least one snapshot to restore from, even before its next scheduled snapshot is created. Older scheduled snapshots and manual snapshots still expire on their normal schedule.
</Release>

<Release date="September 4, 2026" published="2026-09-04T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-09-04">
## Neon backend in Europe, new AI Gateway models, Neon in Grok Bot, and CLI updates release - Sep 04, 2026

## Sep 04, 2026– Neon backend in Europe, new AI Gateway models, and CLI updates

## Neon backend in Europe, plus new AI Gateway models

The [Neon backend](/docs/get-started/backend-overview) 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](/docs/ai-gateway/models):

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

![](/_next/image?url=%2F_next%2Fstatic%2Fimmutable%2Fmedia%2Fpattern.0f2sshrf3n3qc.png&w=384&q=75)

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](/docs/get-started/backend-beta)

## Neon is now available in Grok Bot

Neon is now available as a plugin in [Grok Bot](/docs/ai/ai-grok-bot-plugin). 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](/docs/ai/agent-skills) with the [Neon MCP server](/docs/ai/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](/blog/neon-is-now-available-in-grok-bot).

## Neon CLI updates

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

- **A leaner [`neon init`](/docs/cli/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`](/docs/cli/bootstrap)); in an existing app it installs a plugin (or skills and MCP), links your project, and writes a [`neon.ts`](/docs/reference/neon-ts) config. Run it with `npx`, and pass `-y` and `--agent` for unattended runs:
    
    ```
    <span class="line" data-line="1"><span style="color:var(--shiki-token-function)">npx</span><span style="color:var(--shiki-token-string)"> neon@latest</span><span style="color:var(--shiki-token-string)"> init</span></span>
    ```
    
- **`neon env pull` writes [Neon Function](/docs/compute/functions/overview) invocation URLs**: each function's public URL is written as `NEON_FUNCTION_<SLUG>_BASE_URL`, so one function can reach another from the environment. See [Environment variables](/docs/compute/functions/environment-variables).
    
    ```
    <span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> env</span><span style="color:var(--shiki-token-string)"> pull</span></span>
    ```
</Release>

<Release date="August 28, 2026" published="2026-08-28T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-08-28">
## Install Neon into your coding agent, new Neon backend guides, and MCP stalled-query checks release - Aug 28, 2026

## Aug 28, 2026– Install Neon into your coding agent, new Neon backend guides, and MCP stalled-query checks

## Add Neon to your coding agent

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.

### neon mcp

Installs the [Neon MCP Server](/docs/cli/mcp) 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> mcp</span><span style="color:var(--shiki-token-string)"> --agent</span><span style="color:var(--shiki-token-string)"> cursor</span><span style="color:var(--shiki-token-string)"> --agent</span><span style="color:var(--shiki-token-string)"> claude-code</span><span style="color:var(--shiki-token-string)"> --read-only</span></span>
```

### neon skills

Installs [Neon's agent skills](/docs/cli/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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> skills</span><span style="color:var(--shiki-token-string)"> -s</span><span style="color:var(--shiki-token-string)"> neon</span><span style="color:var(--shiki-token-string)"> -s</span><span style="color:var(--shiki-token-string)"> neon-ai-gateway</span><span style="color:var(--shiki-token-string)"> --agent</span><span style="color:var(--shiki-token-string)"> cursor</span></span>
```

### neon plugins

Installs the [`neon-postgres` plugin](/docs/cli/plugins) 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> plugins</span><span style="color:var(--shiki-token-string)"> --agent</span><span style="color:var(--shiki-token-string)"> claude-code</span><span style="color:var(--shiki-token-string)"> -y</span></span>
```

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](https://neon.com/blog/just-landed-in-the-neon-cli).

#### Have an idea for the CLI or agent tools?

We'd love to hear it. Let us know via the [Feedback](https://console.neon.tech/app/projects?modal=feedback) form in the Neon Console or our [feedback channel](https://discord.com/channels/1176467419317940276/1176788564890112042) on Discord.

## Postgres minor version rollout history now in the docs

Our [Postgres version support policy](/docs/postgresql/postgres-version-policy#recent-minor-version-rollouts) 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:

Postgres release date

Versions in the release

First available on Neon

Time to availability

2026-08-13

[18.6](https://www.postgresql.org/docs/release/18.6/), [17.11](https://www.postgresql.org/docs/release/17.11/), [16.15](https://www.postgresql.org/docs/release/16.15/), [15.19](https://www.postgresql.org/docs/release/15.19/), [14.24](https://www.postgresql.org/docs/release/14.24/)

2026-08-18

5 days

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](/docs/manage/updates) for details.

## Get started building on the Neon backend

Two new guides show what you can build with the [Neon backend](/docs/get-started/backend-overview), 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](/guides/image-processing-api-neon-functions): resize, crop, optimize, analyze, and AI-caption images on [Neon Functions](/docs/compute/functions/overview), then store the results in your branch's [Object Storage](/docs/storage/overview) bucket.
- [Clean up orphaned S3 objects with Neon Object Storage branching](/guides/clean-up-orphaned-s3-objects-neon-branching): run a real storage-cleanup job on a branch first, where buckets [branch with your database](/docs/storage/objects#object-branching), then promote it to production once you've verified it.

![](/_next/image?url=%2F_next%2Fstatic%2Fimmutable%2Fmedia%2Fpattern.0f2sshrf3n3qc.png&w=384&q=75)

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](/docs/get-started/backend-beta)

## Connect fx to Neon's MCP server

[fx](https://fx.sh) 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">npx</span><span style="color:var(--shiki-token-string)"> add-mcp</span><span style="color:var(--shiki-token-string)"> https://mcp.neon.tech/mcp</span><span style="color:var(--shiki-token-string)"> -a</span><span style="color:var(--shiki-token-string)"> fx</span></span>
```

Then authorize from the fx shell:

```
<span class="line" data-line="1"><span>/mcp auth neon --open</span></span>
```

For the API key option and more detail, see [Connect MCP clients to Neon](/docs/ai/connect-mcp-clients-to-neon#fx).

## Fixes & improvements

**Neon MCP server updates**

- The `inspect_database` tool now includes a `stalled-queries` check. It returns a compute-wide snapshot of every client backend and parallel worker whose query group has been running longer than 30 seconds, so an agent can see what's blocking a database right now, across every database on the compute and from the moment a query stalls.
- Stalled queries are now ranked with the oldest query group first, so the longest-running blocker surfaces at the top of the results.

**New NAT gateway IPs and Private Networking endpoints in us-east-2**

- Added NAT gateway IP addresses and Private Networking VPC endpoint service names in AWS US East (Ohio) (`us-east-2`). If you allowlist Neon's outbound IPs, add the new addresses from the [Regions](/docs/introduction/regions#nat-gateway-ip-addresses) page, or outbound connections can fail intermittently. If you use Private Networking in this region, add the new service names from the [Private Networking guide](/docs/guides/neon-private-networking).
</Release>

<Release date="August 21, 2026" published="2026-08-21T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-08-21">
## Faster Lakebase Search setup, Neon CLI updates, and a Neon MCP Claude connector release - Aug 21, 2026

## Aug 21, 2026– Faster Lakebase Search setup, Neon CLI updates, and Neon MCP Claude connector release

## Faster Lakebase Search setup

[Lakebase Search](/docs/ai/lakebase-search) is now easier to install. You can install both Lakebase Search extensions (Vbase_vector`lakebase_text`) directly with the following `CREATE EXTENSION` statements from your SQL client or the [Neon SQL Editor](/docs/get-started/query-with-neon-sql-editor):

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">CREATE</span><span style="color:var(--shiki-foreground)"> EXTENSION </span><span style="color:var(--shiki-token-keyword)">IF</span><span style="color:var(--shiki-token-keyword)"> NOT</span><span style="color:var(--shiki-token-keyword)"> EXISTS</span><span style="color:var(--shiki-foreground)"> lakebase_vector CASCADE;</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">CREATE</span><span style="color:var(--shiki-foreground)"> EXTENSION </span><span style="color:var(--shiki-token-keyword)">IF</span><span style="color:var(--shiki-token-keyword)"> NOT</span><span style="color:var(--shiki-token-keyword)"> EXISTS</span><span style="color:var(--shiki-foreground)"> lakebase_text CASCADE;</span></span>
```

Previously, you had to install an additional SQL statement first to load the supporting libraries `sql` extensions may need compatibility library changes. 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](/docs/extensions/pg-extensions#update-an-extension-version) to get the latest version.

#### 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–100× faster than HNSW, and stays ready after a scale-to-zero cold start. Follow the [getting started guide note: [getting started guide](/docs/ai/lakebase-search-get-started) to enable the extensions, load sample data, and run your first vector and keyword searches.

## Postgres minor version updates

We updated supported Postgres versions to [14.24](https://www.postgresql.org/docs/release/14.24/), [15.19](https://www.postgresql.org/docs/release/15.19/), [16.15](https://www.postgresql.org/docs/release/16.15/), [17.11](https://www.postgresql.org/docs/release/17.11/), and [18.6](https://www.postgresql.org/docs/release/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](/docs/postgresql/postgres-version-policy).

## Neon CLI updates

**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`:

```
<span class="line" data-ine="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> auth</span><span style="color:var(--shiki-token-string)"> --keyring</span></span>
```

The secret is stored in the mac OS 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 inspects a single database, which also scopes scopes 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.

## Neon MCP server now an official Claude connector

The [Neon MCP server](/docs/ai/neon-mcp-server#claude-connector) 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.

![Neon connector in Claude](/docs/changelog/claude_neon_connector.png?dpl=dpl_4mGs1LBdNT99ALKNnbPRicHn9NmZ)

## Install Neon Agent Skills with Pi

You can now install [Neon Agent Skills](/docs/ai/agent-skills) with [Pi](https://pi.dev) straight from the repository:

```
<span class="line" data-ine="1"><span style="color:var(--shiki-token-function)">pi</span><span style="color:var(--shiki-token-string)"> install</span><span style="color:var(--shiki-token-string)"> git:github.com/neondatabase/agent-skills</span></span>
```

Pi reads the skills directly, so there's no separate sync step. This joins the [existing install Channels](/docs/ai/agent-skills#install), including `npx skills`, the Cursor, Claude Code, Codex, and Kimi Code plugins, and `neon init`.

### New Neon Functions guides

Two new guides show what you can build on [Neon Functions](/docs/compute/functions/overview), which run alongside your database as part of the [Neon backend back]end backend](/docs/get-started/ back-end-overview):

- [Automate Neon Functions deployments with Github Actions](/guides/neon-functions-github-actions): set up CI/CD to deploy to production on merge and create preview functions for all requests.
- [Monitor Neon Functions with Sentry](/guides/sentry-neon-functions): add error tracking, structured logs, and request tracing.
</Release>

<Release date="August 14, 2026" published="2026-08-14T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-08-14">
## Electric joins Neon, a Vercel AI SDK provider for the AI Gateway, and agent skills everywhere release - Aug 14, 2026

## Aug 14, 2026– Electric joins Neon, a Vercel AI SDK provider for the AI Gateway, and agent skills everywhere

## Electric joins Neon

**Electric, the team behind PGlite and its Postgres sync engine, is joining Neon.** Together they push Postgres all the way to the client and keep it live, so you can build real-time, collaborative, local-first, and agentic apps without hand-rolling a websocket, caching, and sync layer.

PGlite is a full Postgres that runs in a browser tab, a sandbox, or a serverless function, and the sync engine keeps it continuously in sync with your central Lakebase Postgres database. For AI agents, that makes real-time sync a built-in primitive, so they can add live, collaborative features without wiring up sync themselves.

Both PGlite and the sync engine are coming to the Neon platform alongside Neon's other backend services ([Lakebase Postgres](/docs/postgres/overview), [Auth](/docs/auth/overview), [Storage](/docs/storage/overview), [Functions](/docs/compute/functions/overview), and the [AI Gateway](/docs/ai-gateway/overview)), with deeper integration already underway. To get familiar now, our [guide to Electric on Neon](/guides/electric-sql) walks through real-time sync with Shapes and a React app.

Read the full announcement: [Electric is joining team Neon at Databricks](https://neon.com/blog/electric-joins-neon).

## Neon AI Gateway is now a Vercel AI SDK provider

The [Neon AI Gateway](/docs/ai-gateway/overview) 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](https://ai-sdk.dev/providers/community-providers/neon-ai-gateway): point the SDK at your branch and swap models without per-provider SDKs or keys.

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { neon } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> '@neon/ai-sdk-provider'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-keyword)">import</span><span style="color:var(--shiki-foreground)"> { generateText } </span><span style="color:var(--shiki-token-keyword)">from</span><span style="color:var(--shiki-token-string-expression)"> 'ai'</span><span style="color:var(--shiki-foreground)">;</span></span>
<span class="line" data-line="3"></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-keyword)">const</span><span style="color:var(--shiki-foreground)"> { </span><span style="color:var(--shiki-token-constant)">text</span><span style="color:var(--shiki-foreground)"> } </span><span style="color:var(--shiki-token-keyword)">=</span><span style="color:var(--shiki-token-keyword)"> await</span><span style="color:var(--shiki-token-function)"> generateText</span><span style="color:var(--shiki-foreground)">({</span></span>
<span class="line" data-line="5"><span style="color:var(--shiki-foreground)">  model</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-function)"> neon</span><span style="color:var(--shiki-foreground)">(</span><span style="color:var(--shiki-token-string-expression)">'gpt-5-mini'</span><span style="color:var(--shiki-foreground)">)</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="6"><span style="color:var(--shiki-foreground)">  prompt</span><span style="color:var(--shiki-token-keyword)">:</span><span style="color:var(--shiki-token-string-expression)"> 'What is serverless Postgres?'</span><span style="color:var(--shiki-token-punctuation)">,</span></span>
<span class="line" data-line="7"><span style="color:var(--shiki-foreground)">});</span></span>
```

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

#### 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](/docs/ai-gateway/get-started).

## Neon's skills and MCP install in any agent

### Support for Agent Plugins 1.0.0

Neon's [agent skills and MCP server](https://github.com/neondatabase/agent-skills) now ship as an [Agent Plugins](https://agent-plugins.org/) 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`

## Neon CLI updates

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](/docs/cli) 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> env</span><span style="color:var(--shiki-token-string)"> pull</span><span style="color:var(--shiki-token-string)"> --service</span><span style="color:var(--shiki-token-string)"> ai-gateway</span><span style="color:var(--shiki-token-string)"> --service</span><span style="color:var(--shiki-token-string)"> postgres</span></span>
```

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

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> open</span></span>
```

## Inspect a database from the Neon MCP server

We first shipped these diagnostics as the [`neon inspect db`](/docs/cli/inspect) CLI command. The same checks are now built into the [Neon MCP server](/docs/ai/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`:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">npx</span><span style="color:var(--shiki-token-string)"> neon@latest</span><span style="color:var(--shiki-token-string)"> init</span></span>
```

## Neon for Herdr

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.

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">herdr</span><span style="color:var(--shiki-token-string)"> plugin</span><span style="color:var(--shiki-token-string)"> install</span><span style="color:var(--shiki-token-string)"> neon-solutions/neon-herdr</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-function)">herdr</span><span style="color:var(--shiki-token-string)"> plugin</span><span style="color:var(--shiki-token-string)"> action</span><span style="color:var(--shiki-token-string)"> invoke</span><span style="color:var(--shiki-token-string)"> neon.herdr.dashboard</span></span>
```

Read the post: [Neon for Herdr: a Neon pane in your Herdr workspace](https://neon.com/blog/neon-for-herdr-a-neon-pane-in-your-herdr-workspace).

**New NAT gateway IPs and VPC endpoint services in US West (Oregon) and Asia Pacific (Singapore)**

We've added NAT gateway IP addresses and VPC endpoint service addresses for Private Networking in AWS US West (Oregon) (`us-west-2`) and Asia Pacific (Singapore) (`ap-southeast-1`).

#### Update your IP allowlists

If you allowlist Neon's NAT gateway IPs on external systems, add the new addresses, or connections may be affected intermittently.

See [Regions](/docs/introduction/regions#aws-nat-gateway-ip-addresses) for the full IP list and the [Private Networking guide](/docs/guides/neon-private-networking) for VPC endpoint services by region.
</Release>

<Release date="August 7, 2026" published="2026-08-07T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-08-07">
## A new Console layout for the Neon backend, more AI Gateway models, API keys and multiple accounts in the Neon CLI, and more release - Aug 07, 2026

## A new Console layout for the Neon backend

The Console sidebar has a new shape. Every branch-level [Neon backend](/docs/get-started/backend-overview) 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:

![The new Neon Console sidebar alongside the branch Overview page, which lists Postgres database, BetterAuth, Object storage, Functions, and AI Gateway with their status](/docs/changelog/backend_nav.png?dpl=dpl_92GJiQSSqLRQjQ3gppdWCveFs4n4)

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

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

## More models on the AI Gateway

We've expanded the models available through the [Neon AI Gateway](/docs/ai-gateway/overview), 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">curl</span><span style="color:var(--shiki-token-string)"> -X</span><span style="color:var(--shiki-token-string)"> POST</span><span style="color:var(--shiki-token-string-expression)"> "$NEON_AI_GATEWAY_BASE_URL/v1/chat/completions"</span><span style="color:var(--shiki-foreground)"> \</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-string)">  -H</span><span style="color:var(--shiki-token-string-expression)"> "Authorization: Bearer $NEON_AI_GATEWAY_TOKEN"</span><span style="color:var(--shiki-foreground)"> \</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-token-string)">  -H</span><span style="color:var(--shiki-token-string-expression)"> "Content-Type: application/json"</span><span style="color:var(--shiki-foreground)"> \</span></span>
<span class="line" data-line="4"><span style="color:var(--shiki-token-string)">  -d</span><span style="color:var(--shiki-token-string-expression)"> '{"model": "kimi-k3", "messages": [{"role": "user", "content": "What is Neon?"}]}'</span></span>
```

Browse the full catalog in the [model reference](/docs/ai-gateway/models#available-models), 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`](/docs/ai-gateway/models#list-available-models).

#### 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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">npx</span><span style="color:var(--shiki-token-string)"> neon@latest</span><span style="color:var(--shiki-token-string)"> init</span></span>
```

Then ask your assistant to get started with Neon. See the [backend beta guide](/docs/get-started/backend-beta) for access and setup, or [How a Neon backend fits together](/docs/get-started/backend-overview) for a tour of all five capabilities.

## Project-level permissions for all orgs

[Last week](/docs/changelog/2026-07-31#project-level-permissions) 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](/blog/neon-now-has-per-project-permissions) for the annoucement, and [User permissions](/docs/manage/user-permissions) for the complete documentation.

#### Get started with project permissions

Go from everyone-sees-everything to scoped access in about five minutes. [Read the guide](/docs/manage/project-permissions-get-started).

## API keys and multiple accounts in the Neon CLI

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.

#### New to the Neon CLI?

Install it with `npm install -g neon`, then authenticate with `neon auth`. See the [install guide](/docs/cli/install) and [CLI quickstart](/docs/cli/quickstart) to get going.

### Manage API keys with`neon api-keys`

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:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> api-keys</span><span style="color:var(--shiki-token-string)"> create</span><span style="color:var(--shiki-token-string)"> --name</span><span style="color:var(--shiki-token-string)"> ci</span><span style="color:var(--shiki-token-comment)">                                        # account key</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> api-keys</span><span style="color:var(--shiki-token-string)"> create</span><span style="color:var(--shiki-token-string)"> --name</span><span style="color:var(--shiki-token-string)"> ci</span><span style="color:var(--shiki-token-string)"> --org-id</span><span style="color:var(--shiki-token-string)"> org-example-12345678</span><span style="color:var(--shiki-token-comment)">          # organization key</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> api-keys</span><span style="color:var(--shiki-token-string)"> create</span><span style="color:var(--shiki-token-string)"> --name</span><span style="color:var(--shiki-token-string)"> agent</span><span style="color:var(--shiki-token-string)"> --project-id</span><span style="color:var(--shiki-token-string)"> green-breeze-12345678</span><span style="color:var(--shiki-token-comment)">  # one project only</span></span>
```

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](/docs/cli/api-keys) and [Manage API keys](/docs/manage/api-keys) for key types and permissions.

### Use more than one account with`neon profile`

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`:

```
<span class="line" data-line="1"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> auth</span><span style="color:var(--shiki-token-string)"> --profile</span><span style="color:var(--shiki-token-string)"> work</span><span style="color:var(--shiki-token-comment)">                                            # create or re-authenticate</span></span>
<span class="line" data-line="2"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> deploy</span><span style="color:var(--shiki-token-string)"> --profile</span><span style="color:var(--shiki-token-string)"> work</span><span style="color:var(--shiki-token-comment)">                                          # use it</span></span>
<span class="line" data-line="3"><span style="color:var(--shiki-token-function)">neon</span><span style="color:var(--shiki-token-string)"> profile</span><span style="color:var(--shiki-token-string)"> create</span><span style="color:var(--shiki-token-string)"> ci</span><span style="color:var(--shiki-token-string)"> --mint</span><span style="color:var(--shiki-token-string)"> --project-id</span><span style="color:var(--shiki-token-string)"> green-breeze-12345678</span><span style="color:var(--shiki-token-comment)">    # or hold a scoped key, no browser</span></span>
```

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](/docs/cli/profile) for the full command set and for how `--profile` resolves against `NEON_API_KEY`.

## New NAT gateway IPs and VPC endpoint services in 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.

#### 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](/docs/introduction/regions#aws-nat-gateway-ip-addresses) for the complete list of NAT gateway IPs and the [Private Networking guide](/docs/guides/neon-private-networking) for VPC endpoint service addresses by region.
</Release>

<Release date="July 31, 2026" published="2026-07-31T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-07-31">
## Project-level permissions, new Neon backend guides, Lakebase Search resources, and more release - Jul 31, 2026

Jul 31, 2026

## Jul 31, 2026– Project-level permissions, new Neon backend guides, Lakebase Search resources, and more

## Project-level permissions

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.

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

![Granting a per-project permission in the Neon Console](/docs/changelog/grant-project-permission.png?dpl=dpl_8ie1di7czvcPR1339YtpfkuEadm5)

You can manage the same access through the [Neon API](/docs/manage/user-permissions#manage-project-access-with-the-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`](/docs/cli/api) passthrough.

### What changes for existing organizations

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](/docs/guides/project-collaboration-guide) feature is being replaced by the new **Collaborator** role plus per-project permissions.

See [User permissions](/docs/manage/user-permissions) for roles, per-project levels, and how the two layers combine.

## New guides for building on the Neon backend

Two new guides show how to combine the [Neon backend](/docs/get-started/backend-overview) 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](/guides/durable-workflow-on-neon-functions): run a multi-step lead-enrichment pipeline on [Neon Functions](/docs/compute/functions/overview), with each step checkpointed so a failure retries just that step, and an executive summary generated through the [Neon AI Gateway](/docs/ai-gateway/overview).
- [Build an LLM proxy with Neon Functions, Neon AI Gateway, and Managed Better Auth](/guides/llm-proxy-neon-functions): 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.

#### 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](/docs/get-started/backend-beta) for access and setup.

## More with Lakebase Search

[Lakebase Search](/docs/ai/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](/blog/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](/guides/clip-image-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](/docs/ai/lakebase-search-get-started#enable-the-preload-libraries), then create the extensions:

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

## Fixes & improvements

**Spending notifications**

- **Spending limits have been renamed to spending notifications.** On Launch and Scale plans, spending notifications alert organization admins when monthly Neon charges reach 80% and 100% of a threshold you set, so you can catch rising usage early and avoid a surprise bill at the end of the month. See [Spending notifications](/docs/introduction/spending-notifications) for more.

**Neon MCP Server**

- The `describe_table_schema` tool now supports schema-qualified table names, such as `crm.contacts`. Previously it resolved only tables in the `public` schema, so describing a table in another schema could return the wrong table or fail. A missing table now returns a clean "table not found" error.

**Drizzle Studio**

- The Drizzle Studio integration that powers the **[Tables](/docs/guides/tables)** page in the Neon Console has been updated to version 1.5.1. New features include multi-column sorting, keyboard shortcuts, and the ability to copy table creation statements or export rows as SQL insert statements. For the full list, see the [Neon Drizzle Studio Integration Changelog](https://github.com/neondatabase/neon-drizzle-studio-changelog/blob/main/CHANGELOG.md).
</Release>

<Release date="July 24, 2026" published="2026-07-24T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-07-24">
## Postgres diagnostics and snapshots in the Neon CLI, backend log querying, and more release - Jul 24, 2026

Debug Postgres from the terminal with neon inspect db You can now run read only Postgres diagnostics straight from the Neon CLI with neon inspect db. Each subco...
</Release>

<Release date="July 17, 2026" published="2026-07-17T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-07-17">
## Neon backend beta, a new TypeScript SDK, passkey support, and Git-style CLI diffs release - Jul 17, 2026

## Jul 17, 2026– Neon backend beta, a new TypeScript SDK, passkey support, and Git-style CLI diffs

## Neon backend for apps and agents is now in beta

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 compute that runs 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](/docs/get-started/backend-beta), see [how the pieces fit together](/docs/get-started/backend-overview), or build one end to end with the [full backend quickstart](/docs/get-started/full-backend-quickstart). For the vision behind the platform, read the [announcement blog post](https://neon.com/blog/neon-backend-is-beta).

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

## New TypeScript SDK for the Neon API

We're introducing [`@neon/sdk`](https://www.npmjs.com/package/@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`](https://www.npmjs.com/package/@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](https://neon.com/blog/neon-sdk) for the full story, or see the [TypeScript SDK documentation](/docs/reference/typescript-sdk) and [migration guide](/docs/reference/migrate-api-client-to-sdk) for setup, API reference, and moving from `@neondatabase/api-client`.

## Passkey support

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](/docs/manage/accounts#passkeys) for setup steps.

![Sign in to Neon with a passkey](/docs/changelog/neon-passkey.png?dpl=dpl_GbTjgVcUgKcTTK4mq18QJJPBvxBB)

## Git-style diffs in the Neon CLI

### New`neon diff`command

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
```

### Config commands now show the same diff

[`neon.ts`](/docs/reference/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`.

## New NAT gateway IPs and VPC endpoint services in US East (Ohio), Europe (London), and Asia Pacific (Singapore)

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.

#### 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](/docs/introduction/regions#aws-nat-gateway-ip-addresses) for the complete list of NAT gateway IPs and the [Private Networking guide](/docs/guides/neon-private-networking) for VPC endpoint service addresses by region.
</Release>

<Release date="July 10, 2026" published="2026-07-10T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-07-10">
## A new neon api CLI command, Cmd+K in the Console, and more release - Jul 10, 2026

## Jul 10, 2026– A new neon api CLI command, Cmd+K in the Console, and more

## New`neon api`command in the Neon CLI

The Neon CLI now ships an [`api`](/docs/cli/api) command: call any [Neon Platform API](/docs/reference/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](https://neon.com/blog/introducing-neon-api-command) 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](/docs/cli/api) for query parameters, file bodies (`-d @file`), and output formats.

## Cmd+K support for the Neon Console

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.

![Neon Console command bar](/docs/changelog/command_k.png?dpl=dpl_FjCNkFQhwbGhuQm26LXRjo8Vavrb)

## Neon MCP Server: branch expiration on create

The [Neon MCP Server](/docs/ai/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](/docs/guides/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](/docs/ai/connect-mcp-clients-to-neon).

## New NAT gateway IPs and VPC endpoint services in US East (Ohio), Europe (London), and Asia Pacific (Singapore)

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.

#### 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](/docs/introduction/regions#aws-nat-gateway-ip-addresses) for the complete list of NAT gateway IPs and the [Private Networking guide](/docs/guides/neon-private-networking) for VPC endpoint service addresses by region.

## Postgres turns 30

Postgres turned 30 on July 8. [See our post on X](https://x.com/neondatabase/status/2074892704115470796).

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](https://neon.com/blog/postgres-18) and support the wider ecosystem through our [Open Source Program](https://neon.com/blog/neon-open-source-program). We run standard Postgres, not a fork: [Neon is Postgres](/docs/reference/compatibility), with serverless branching and autoscaling built around the database millions of developers already rely on.

Happy birthday, Postgres. 🎂🐘
</Release>

<Release date="July 3, 2026" published="2026-07-03T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-07-03">
## Neon CLI enhancements, Neon Storage in the Files SDK, and more release - Jul 03, 2026

## Jul 03, 2026– Neon CLI enhancements, Neon Storage in the Files SDK, and more

## Neon CLI enhancements

We're continually improving the Neon CLI and the developer experience around it. Recent additions include [branch-first dev loop](https://neon.com/blog/branch-first-dev-loop) (`neon link`, `neon checkout`, and `neon env pull`) commands and [`neon.ts`](/docs/reference/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](/docs/cli/install).
    
    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`](/docs/reference/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](https://starship.rs) 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](/docs/cli/config#current-branch) for more.
    

## Neon Storage in the Files SDK

[Neon Storage](/docs/storage/overview) now has a first-class adapter in the [Files SDK](https://files-sdk.dev), 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 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](https://github.com/neondatabase/examples/tree/main/with-files-sdk) for a minimal script that uploads files to a branch-scoped bucket.

> Neon 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](https://neon.com/docs/introduction/roadmap#new-backend-primitives-for-apps-and-agents).

## Learn more about Lakebase Search

We recently opened [Lakebase Search](/docs/ai/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/lakebase-search-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.

## Update snapshot expiration anytime

You can now update a snapshot's expiration with the [Update snapshot](https://api-docs.neon.tech/reference/updatesnapshot) 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"
    }
  }'
```

## Planned update notifications change

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](/docs/manage/updates).

## Neon Community Corner

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

### Neon Testing now supports Bun Test

[Neon Testing](https://www.npmjs.com/package/neon-testing), the community-built integration testing library by [Mikael Lirbank](https://www.lirbank.com/), shipped v3.0.0 with support for [Bun Test](https://bun.sh/docs/cli/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](https://www.npmjs.com/package/neon-testing) and read the [v3.0.0 release notes on GitHub](https://github.com/starmode-base/neon-testing/releases).

### Connect Neon to Gamut

[Gamut](https://www.gamut.so/mcp/developer-tools/neon), an AI agent hosting platform with native support for remote MCP servers, now connects to Neon through the [Neon MCP server](/docs/ai/neon-mcp-server). Setup uses OAuth, matching the existing client flow. To get started, [add Neon to your Gamut agent](https://www.gamut.so/mcp/developer-tools/neon).

### Docs & Postgres tutorial contributors

Our [docs](https://github.com/neondatabase/website) and [Postgres tutorials](https://neon.com/postgresql/tutorial) 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
</Release>

<Release date="June 26, 2026" published="2026-06-26T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-06-26">
## Agent skills for backend services, Lakebase Search GA, Postgres version updates, and more release - Jun 26, 2026

## Jun 26, 2026– Agent skills for backend services, Lakebase Search GA, Postgres version updates, and more

## Agent skills for Neon Storage, Functions, and AI Gateway

[Neon Agent Skills](/docs/ai/agent-skills) are instruction files that teach AI coding assistants how to work with Neon. The collection now includes skills for [Neon Functions](/docs/compute/functions/overview), [Object Storage](/docs/storage/overview), and [AI Gateway](/docs/ai-gateway/overview), the backend services currently in **private preview**.

If you haven't requested preview access yet, sign up below and we'll send you the private preview guide to get started.

![](/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fbackend-form-light-bg.0hw6xc5-jou0i.png&w=828&q=75&dpl=dpl_FoPgA7cMBiHK44dfiC342vFffWzt)![](/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fbackend-form-dark-bg.0z5y63_tcub5u.png&w=828&q=75&dpl=dpl_FoPgA7cMBiHK44dfiC342vFffWzt)

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

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](/docs/ai/agent-skills).

## Lakebase Search is now available to all users

[Lakebase Search](/docs/ai/lakebase-search) is now available to all Neon users on Postgres 16+. Two extensions, [`lakebase_vector`](/docs/extensions/lakebase-vector) and [`lakebase_text`](/docs/extensions/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](/docs/ai/lakebase-search-get-started). 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](/docs/ai/lakebase-search-get-started#combine-results-with-hybrid-search) 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](/docs/ai/lakebase-search) to get started.

## Postgres version updates

We updated supported Postgres versions to [14.23](https://www.postgresql.org/docs/release/14.23/), [15.18](https://www.postgresql.org/docs/release/15.18/), [16.14](https://www.postgresql.org/docs/release/16.14/), [17.10](https://www.postgresql.org/docs/release/17.10/), and [18.4](https://www.postgresql.org/docs/release/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](/docs/postgresql/postgres-version-policy).

## Ephemeral database branches for Vercel Eve agent sessions

In [June, Vercel introduced Eve](https://vercel.com/blog/introducing-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](/guides/vercel-eve-neon)
</Release>

<Release date="June 19, 2026" published="2026-06-19T00:00:00.000Z" url="https://neon.com/docs/changelog/2026-06-19">
## Refer a friend and earn credits, Neon backend private preview, and more release - Jun 19, 2026

## Jun 19, 2026– Refer a friend and earn credits, Neon backend private preview, and more

## Refer a friend and earn credits

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](https://discord.com/channels/1176467419317940276/1176788564890112042).

## Neon backend for apps and agents now in private preview

Neon 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.
- **Storage**: S3-compatible object storage that branches with your data.
- **AI Gateway**: one credential for frontier and open-source models (Claude, GPT, Gemini, and more).

Sign up below and we'll send you the **private preview guide** to get started.

## 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

## Introducing neon.ts: infrastructure as code for your Neon project

`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 "@neondatabase/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 `@neondatabase/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, Storage buckets, and AI Gateway in the same config. Fork a branch and you get an isolated copy of your database, files, storage, functions, and AI gateway.

See the [neon.ts reference](/docs/reference/neon-ts) for the full config schema, or read the [blog post](https://neon.com/blog/introducing-neon-ts) for a full walkthrough.

## Export Neon metrics to SigNoz

This new guide shows how to export your Postgres logs and metrics to [SigNoz](https://signoz.io) 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](/guides/signoz-otel-neon)

## Fixes & improvements

**Neon API**

The deprecated `GET /consumption_history/account` endpoint has been removed. Use `GET /consumption_history/v2/projects` instead. See [Querying consumption metrics](/docs/guides/consumption-metrics) for details.

**Vercel integration**

For [Neon-Managed (Connectable Account) Vercel integrations](/docs/guides/neon-managed-vercel-integration), rotating the selected Postgres role password in Neon now automatically syncs updated credentials to Vercel environment variables. This removes the need to manually re-save integration settings after password rotation.
</Release>

<Pagination cursor="2026-06-19T00:00:00.000Z|2026-06-19T19:04:51.669Z|rel_9hIeDzW1Ct3MYYJCsSKej" next="https://releases.sh/neon/neon-changelog.md?cursor=2026-06-19T00%3A00%3A00.000Z%7C2026-06-19T19%3A04%3A51.669Z%7Crel_9hIeDzW1Ct3MYYJCsSKej&limit=20" />
