Changelog

Neon Copilot Extension

The Neon Database Copilot Extension is now available in the GitHub Marketplace. This extension makes it easier to configure Neon for your repository. You can chat with the latest Neon documentation within the context of your repository!

Chat with curated Neon database documentation directly in GitHub Copilot and get answers to common questions like:

• How to create a project?
• How can I get started with the Neon API?
• How do integrate the Neon API into my GitHub repository.

Setup instructions:

1. Install the extension
2. Type @neondatabase in the chat to start interacting

Coming soon, you'll be able to directly interact with Neon endpoints by simply asking questions. Additionally, new tools will enable you to create Neon databases directly from the chat interface.

Schema Diff API

Rounding out our schema diff features, Neon now supports a schema diff API endpoint (compare_schema), enabling programmatic comparison of database schemas between Neon branches. This addition complements our existing Schema Diff features available in the Console, CLI, and GitHub Action.

Example:

curl --request GET \
     --url 'https://console.neon.tech/api/v2/projects/{project_id}/branches/{branch_id}/compare_schema?base_branch_id={base_branch_id}&db_name={db_name}' \
     --header 'accept: application/json' \
     --header 'authorization: Bearer $NEON_API_KEY'

For detailed documentation, see Using the Schema Diff API.

Postgres extension updates

• The pg_mooncake extension has been updated to version 0.1.0. For details about this release, see the release page.

  To use the pg_mooncake extension with Neon, check out our pg_mooncake guide for more information.

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

• The pg_embedding extension, deprecated in September 2023, has been removed from Neon. This extension supported the Hierarchical Navigable Small World (HNSW) algorithm for vector similarity search in Postgres. HNSW support is now available in the pgvector extension, which is also supported by Neon.

🎉 Happy New Year, everyone! 🎉

We're excited to kick off 2025 and let you know that we're shipping again! 🚢 Here's to an amazing year ahead. Let's go!

Postgres 17 for newly created Neon projects

Postgres 17 is now the default for newly created Neon projects. Neon continues to support Postgres 14, 15, and 16, if you prefer to stick with those. For Neon's Postgres version support policy, see Postgres Version Support.

Support for pg_cron

The Postgres pg_cron extension is now available on paid Neon plans upon request. This extension lets you schedule and manage periodic jobs directly in your Postgres database. To enable pg_cron, open a support ticket and include your endpoint ID and the database name where you'd like the extension enabled. Once added, you'll need to restart your compute to make it available.

Higher connection limits for autoscaling configurations

In Postgres, the max_connections setting controls the maximum number of simultaneous client connections the database server can handle. In Neon, this setting is configured based on your compute size. With Neon's autoscaling feature, max_connections is now defined by your maximum compute size rather than your minimum compute size.

This change significantly increases connection limits for autoscaling configurations. For example, consider an autoscaling configuration with these minimum and maximum compute sizes:

• Minimum: 2 CU compute size — supports up to 901 connections
• Maximum: 8 CU compute size — supports up to 3604 connections

Previously, this autoscaling configuration of 2 CU ↔ 8 CU was limited to 901 connections. Now, the same configuration allows up to 3604 connections. In this case, a 4-fold increase!

PgBouncer default_pool_size now scales

Neon supports connection pooling with PgBouncer. Previously, Neon's PgBouncer configuration set the default_pool_size to a fixed value of 64, which limited Postgres connections to 64 per user/database pair, regardless of the compute size.

Now, the default_pool_size is dynamically set to 0.9 * max_connections, enabling significantly more concurrent Postgres connections per user/database pair. Note that larger compute sizes benefit from higher max_connections limits, which result in a proportionally larger default_pool_size.

For example, on an 8 CU compute with a max_connections limit of 3604, the default_pool_size increases from 64 to 3243 (0.9 × 3604).

Neon Identity is now available in Early Access

We're excited to announce Neon Identity, a new feature that automatically syncs user profiles from your auth provider straight to your Neon database. Eliminate custom integration code and focus on building.

With Neon Identity, user profiles are synchronized to the neon_identity.users_sync table, making it easy to access user data without additional configuration.

Join the Early Access Program to try it out. Sign up here.

Check out our docs to learn more.

Currently supporting Stack Auth, more providers coming soon.

More support for AI agents

Neon is now available as a tool for AI agents on both AgentStack and Composio.

AgentStack lets you create AI agent projects from the command line. The Neon tool allows agents to create ephemeral or long-lived Postgres instances for structured data storage. View the Neon tool here to see how an AI agent can create a Neon database in less than 500 ms, connect to the database, and run SQL DDL and DML statements.

@tool("Create Neon Project and Database")
def create_database(project_name: str) -> str:
  """
  Creates a new Neon project. (this takes less than 500ms)
  Args:
      project_name: Name of the project to create
  Returns:
      the connection URI for the new project
  """
  try:
      project = neon_client.project_create(project={"name": project_name}).project
      connection_uri = neon_client.connection_uri(
          project_id=project.id, database_name="neondb", role_name="neondb_owner"
      ).uri
      return f"Project/database created, connection URI: {connection_uri}"
  except Exception as e:
      return f"Failed to create project: {str(e)}"

Composio lets you connect 200+ tools to AI Agents — and it now supports Neon, enabling full integration between LLMs and AI agents and Neon's API. You can find the integration here.

Neon Auth.js adapter

We've introduced an Auth.js adapter for Neon, which enables storing user and session data in your Neon database. For adapter installation and setup instructions, see Neon Adapter in the Auth.js docs.

"Perplexity mode" for the Docs

We’ve added an AI-powered "perplexity mode" to the Neon Docs site, providing a conversational interface to quickly get the answers you need.

Our AI chat assistant is built on various sources including the Neon Docs, the Neon Discord Server, and API docs — and it's updated daily.

Click Ask Neon AI to try it out.

Wrapping up 2024

As 2024 comes to a close, we focused on fixes and improvements this past week. But don’t worry — new features are already in development, and exciting updates are coming soon. We’re looking forward to sharing what’s coming in the new year, and there might even be a few interesting announcements before then. Stay tuned!

Upgrading to the latest Neon CLI version

If you use the Neon CLI, here’s a friendly reminder to upgrade to the latest version. The current version is 2.6.0, and all users should now be on a 2.x version. You can check your Neon CLI version with the following command:

$ neon --version
2.6.0

For upgrade instructions, see Neon CLI upgrade.

If you use the Neon CLI in CI/CD tools like GitHub Actions, you can safely pin it to @latest, as we prioritize stability for CI/CD processes. For example, in a GitHub Actions workflow, you can install the latest version with npm:

- name: Install Neon CLI
  run: npm install -g neonctl@latest

Larger compute sizes are here

We’ve added support for larger compute sizes:

• Neon's autoscaling feature now supports a maximum setting of 16 vCPU. Compute sizes larger than 8 vCPU are available on our Business and Enterprise plans.
• Neon's Business and Enterprise plans now support fixed compute sizes up to 56 vCPU. Autoscaling is not yet supported for compute sizes larger than 16 vCPU but reach out to us if you'd like to extend your limit beyond that.

Project-scoped API keys

We now support per-project API keys, offering you finer-grained access control by limiting an API key's permissions to a particular project. This applies to organization-owned projects only — when creating an Organization API key, include the project ID in the request and the resulting key will be scoped to just that project. This key grants member-level permissions only, preventing destructive actions like deleting the project.

For more details, see Create project-scoped API keys.

Introducing psql.sh: run psql directly in your browser

We're excited to launch psql.sh, a browser-based version of the PostgreSQL command-line client. This new tool lets you instantly spin up a fresh database and start running SQL queries and psql commands right in your browser.

psql.sh uses Neon's branching to create instant, isolated database environments for you to experiment with. Try it out at psql.sh, or read about how we built it in our blog post: psql from the browser.

Support for pgvector 0.8.0

Neon now supports pgvector version 0.8.0. This new version adds support for iterative index scans, casts for arrays to sparsevec, and improves the performance of HNSW inserts and on-disk HNSW index builds.

For the full list of updates, refer to the pgvector changelog.

If you installed this extension previously and want to upgrade to the latest version, please refer to Update an extension version for instructions.

Neon is Now Available as an Azure Native Integration

If your company uses Azure, getting started with Neon is now easier than ever. This week, we launched Neon as an Azure Native Integration, enabling developers to deploy Neon Postgres databases directly from the Azure portal.

With this new integration, you can:

• Provision and manage Neon organizations directly within Azure, using the Azure portal, CLI, or SDK.
• Access Neon with your Microsoft credentials for simplified security and compliance.
• Include Neon charges in your Azure bill.

For more, read the announcement.

New Azure regions

We’ve added support for two new Azure regions:

• Azure Germany West Central (Frankfurt) — azure-gwc
• Azure West US 3 (Arizona) — azure-westus3

For a full list of regions supported by Neon, see Regions.

Support for database schema management in the Neon Console

The Tables page in the Neon Console, powered by Drizzle Studio, received a major update this week. In addition to managing your data, you can now manage your database schema directly from the Tables page. New schema management options include:

• Creating, altering, and dropping schemas
• Creating and altering tables
• Creating and altering views
• Creating enums
• Refreshing the database schema

We’d love to hear your thoughts on these new capabilities! Share your feedback through the Feedback form in the Neon Console or join the conversation on Discord.

Stay updated on Drizzle Studio improvements and fixes by following the Neon Drizzle Studio Integration Changelog.

A Model Context Protocol (MCP) server for Neon

We’ve released an open-source Model Context Protocol (MCP) server for Neon, enabling any MCP Client such as Claude Desktop to interact with Neon’s API using natural language. AI agents can use our MCP server to perform actions such as creating databases, running SQL queries, and managing database migrations. For more, read the announcement and try it out on GitHub.

Archive storage on paid plans

A few weeks ago, we announced branch archiving on the Free Plan, which automatically stores inactive branches in cost-efficient archive storage. This feature is now available on our paid plans: Launch, Scale, and Business. Here’s what this means for you:

• More storage and reduced storage costs: Branches older than 14 days and not accessed for 24 hours are automatically archived in cost-efficient archive storage.
• New archive storage allowances by plan:
  • Launch: 50 GB
  • Scale: 250 GB
  • Business: 2500 GB
• Billing for extra archive storage: Extra storage beyond your plan’s allowance is billed at $0.10 per GB-month. Inactive branches meeting the thresholds above will now cost less.
• Monitoring archive storage usage: A new archive storage metric is available on the Billing page in the Neon Console.
• Archived branch details and identification: Archived branches are marked with an archive icon in the console. The Branches page shows additional details, including the date and time a branch was archived.
• Automatic archiving and unarchiving: No action is needed to archive or unarchive branches. Unarchiving happens automatically when you access a branch.
• Performance considerations: You should notice little to no performance difference when connecting to or querying an archived branch, except for branches with large amounts of data where initial access may take a little longer until the branch is fully unarchived.

For more details, see Branch archiving and Archive storage.

Simplified "extra storage"

We reduced the cost of temporarily using more storage than is in your plan's monthly allowance. Previously, if you exceeded your storage allowance, you were allocated (and billed for) an extra storage unit at a prorated price for the rest of the month, even if the overage was brief. Now, you’re billed only for the storage you use for the length of time that you use it. This will be measured per GB-month.

Neon Organizations are GA! 🎉

We're happy to announce that Neon Organizations is now generally available for everyone looking to move their teams to Neon.

Create a new organization, transfer over your projects, invite your team members and get started collaborating. The Organizations feature lets you manage all of your team's projects under a single account — with billing, role management, and project transfer capabilities in one accessible location.

See Neon Organizations to get started. Organizations is a paid account feature.

Organization API keys

Along with GA for Organizations, we're also announcing support for Organization API Keys. As an admin of an organization, you control your organization's API keys. These keys provide admin-level access to all organization resources, including projects, members, and billing information.

You can access your organization's API keys from your organization settings.

Schema Diff GitHub Action

We're also introducing our Schema Diff GitHub Action to automatically compare database schemas in your pull requests. The action posts schema differences as PR comments, making it easy to review schema changes during development. It's smart about updates, maintaining a single, updated comment as you push new commits and staying quiet when there are no differences to report. See Schema Diff GitHub Action for more details.

Index: neondb-schema.sql
===================================================================
--- neondb-schema.sql	Branch main
+++ neondb-schema.sql	Branch preview/pr-9-feat/add-soft-delete
@@ -111,9 +111,10 @@
     title text NOT NULL,
     content text NOT NULL,
     user_id integer NOT NULL,
     created_at timestamp without time zone DEFAULT now() NOT NULL,
-    updated_at timestamp without time zone DEFAULT now() NOT NULL
+    updated_at timestamp without time zone DEFAULT now() NOT NULL,
+    deleted_at timestamp without time zone
 );


 ALTER TABLE public.posts OWNER TO neondb_owner;
@@ -180,5 +181,5 @@
 --
 -- Name: __drizzle_migrations id; Type: DEFAULT; Schema: drizzle; Owner: neondb_owner
 --

-ALTER TABLE ONLY drizzle.__drizzle_migrations ALTER COLUMN id SET DEFAULT nextval('drizzle.__drizzle_m
\ No newline at end of file
+ALTER TABLE ONLY drizzle.__drizzle_migrations ALTER COLUMN
\ No newline at end of file

Postgres version updates

The PostgreSQL Global Development Group has released an out-of-cycle minor version update to address regressions introduced in the previous minor version update. While Neon was unaffected by these regressions, we prioritize staying up to date with the latest version. As a result, we have updated our supported PostgreSQL versions to 14.15, 15.10, 16.6, and 17.2.

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.

Neon Private Networking (Public Beta)

Neon now offers Private Networking, enabling secure database connections via AWS PrivateLink. This feature keeps all traffic between your client application and Neon database within AWS's private network, bypassing the public internet.

For details, see our guide: Neon Private Networking.

Any member of an Org account can apply to participate in this Public Beta by requesting access via the Organization Settings page in the Console.

And don't forget to check out this week's fixes and improvements:

A new Python SDK for the Neon API

Neon has a new Python SDK, which is a wrapper for the Neon API. This SDK simplifies integration of Python applications with Neon by providing methods to programmatically manage Neon API keys, projects, branches, databases, endpoints, roles, and operations.

It's easy to install with pip:

$ pip install neon-api

Then, from Python:

from neon_api import NeonAPI

# Initialize the client.
neon = NeonAPI.from_environ() or NeonAPI(api_key='your_api_key')

# Get the current user
user = neon.me()
print(user)

For more, see Python SDK for the Neon API.

A Migration Assistant to help move your data

When you're ready to move your data to Neon, our new Migration Assistant can help. All you need to get started is a connection string for your existing database.

Enter your current database connection string, and the Assistant will:

1. Run some preliminary checks on your database.
2. Create a Neon project that best matches your current environment.
3. Provide pg_dump and pg_restore commands to transfer your data, pre-populated with the correct connection strings.

For more, see Neon Migration Assistant.

Organization account support for Vercel and GitHub integrations

Our Vercel Previews and GitHub integrations are now supported on Organization accounts. In case you're not familiar:

• The Vercel Previews Integration connects your Vercel project to a Neon database and creates a database branch with each Vercel preview deployment.
• The GitHub Integration connects your Neon projects to corresponding GitHub repositories, letting you bring your database to your DevOps workflow.

You can now make both integrations available to your Neon organization.

timescaledb extension support for Postgres 17

We added support for the timescaledb extension, version 2.17.1, to Postgres 17.

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

And don't forget to check out this week's fixes and improvements:

Branch archiving on the Free Plan

On the Free plan, Neon now automatically archives any branch that is older than 14 days and has not been accessed for 24 hours.

No action is required to unarchive a branch. It happens automatically as soon as you access the branch. This change reduces storage costs and enables us to grow our Free plan even further.

To learn more, see Branch archiving.

Postgres version updates

We updated supported Postgres versions to 14.14, 15.9, 16.5, and 17.1, respectively.

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

And don't forget to check out this week's fixes and improvements:

At a glance usage metrics for paid plan users

A few weeks ago, we added at-a-glance usage metrics on the Free Plan to help users track account-level usage. This widget is now available on all Neon plans. You can find it on your Projects page in the Neon Console.

And we've added a project-level usage widget on the Project Dashboard as well, letting you know your current usage levels for the month for each individual project.

Postgres extension updates

Now available on Postgres 17:

In addition, we updated the following extension versions on Postgres 14, 15, and 16:

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

And don't forget to check out this week's fixes and improvements:

Neon Authorize

Announced at Neon Deploy, Neon Authorize lets you move Postgres Row-Level Security (RLS) policies into your codebase. By integrating with JWT-based authentication providers like Clerk and Stack Auth, this new approach simplifies your code while tightening security. Read our announcement and learn more in the docs.

Build RAG pipelines with the pgrag extension

Also introduced at Neon Deploy, our new pgrag Postgres extension lets you create end-to-end Retrieval-Augmented Generation (RAG) pipelines in Postgres. There's no need for additional programming languages or libraries. With the functions provided by pgrag, you can build a complete RAG pipeline directly within your SQL client.

pg_mooncake Support

We're also announcing support for another new Postgres extension, pg_mooncake, brought to the community by mooncake.dev. pg_mooncake introduces native columnstore tables with DuckDB execution for fast analytics directly in Postgres. You don't need complex ETL; with pg_mooncake you keep your stack simple — Postgres and Python. Check out the blog post for a deeper dive.

And don't forget to check out this week's fixes and improvements: