Release notes

Fixes & improvements

• API: Added a Get current user details endpoint to the Neon API for retrieving information about the current Neon user. This endpoint is still under review and subject to change in a future release.
• API: Added database and role name validation to the Create a project endpoint to prevent creating databases and roles with protected names.
• API, UI: Users with whom a Neon project is shared can now access and modify all project settings except for project deletion. Only a project owner can delete a project.
• API, UI: Email addresses added when sharing a Neon project with other users are now handled in a case-insensitive manner and added to the shared project list in lowercase.
• UI: Fixed an issue that prevented recently configured default compute size settings from appearing in the Create Compute Endpoint modal.
• UI: Modified the behavior of the search field on the Branches page. Search terms less than three characters are now permitted. Previously, a search could only be performed by entering three or more characters in the search field.
• UI: Adjusted compute type naming and labels throughout the Neon Console to improve consistency.

Support for Postgres 16

Neon is pleased to announce support for Postgres 16. To use Postgres 16 with Neon, create a new Neon project and select 16 as the Postgres version. See Create a project for instructions.

To migrate data from an existing Neon project to one created with Postgres 16, refer to the dump and restore procedure described in Import data from another Neon project.

As with any database migration, always test thoroughly before migrating production systems or applications. Also, we recommend familiarizing yourself with the changes in Postgres 16, especially those affecting compatibility. For information about those changes, please refer to the official Postgres Release 16 documentation.

Postgres extension updates

The following Postgres extensions were updated to a newer version:

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

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

Fixes & improvements

• API: Increased the pagination limit for the List projects API method from 100 to 400.
• UI: Fixed an issue on the Billing page for Free Tier accounts that prevented content in the Estimate Pro plan cost section of the page from being displayed.
• UI: Updated pages and modals in the console to ensure compute size default values are displayed correctly and consistently.
• UI: Removed the Postgres configuration widget from the Neon Dashboard. The Postgres version for the project now appears in the Compute widget.
• UI: Unnecessary whitespace is now stripped from queries executed in the Neon SQL Editor during processing. Previously, queries indented with a tab character failed to run or did not run as expected.

Configure default compute settings for your project

Pro plan users can now configure default compute settings for a Neon project. Settings include Compute size, Autoscaling, and Auto-suspend delay. To define defaults, select Settings > Compute from the Neon Dashboard to open the Default compute settings page. For Free Tier users, the page shows the default settings.

Default settings are applied when creating a branch or adding a compute to a branch via the Neon Console. However, if you want a compute with different settings, you can change or override the defaults when creating a branch or adding a compute.

In addition, the Compute widget on the Neon Dashboard now shows the Default compute size for your Neon project.

Fixes & improvements

• API: Neon API v1 deprecation was announced in December, 2022. We have removed code for this early version of the Neon API. If you have not yet migrated your applications to the current version of the Neon API, please do so now.
• UI: Added a Billing page to the Neon Console for Neon Enterprise and Platform Partnership custom plan users. The Billing page is accessible from the sidebar in the Neon Console.
• UI: Addressed usability issues on the Custom tab of the Pro Plan Cost Estimator, which is accessible from the Free Tier Billing page in the Neon Console. Percentage values were not restored when switching from Enter your own values and Use a percentage. Additionally, minimum, maximum, and increment values were adjusted for Compute and Project storage metrics.
• UI: The billing period drop-down menu at the top right corner of the Billing page now uses the current billing period as the default selection instead of the oldest billing period. This change applies to Neon Pro plan accounts.

Support for custom-built Postgres extensions

Neon now supports custom-built Postgres extensions for exclusive use with your Neon account. If you developed your own Postgres extension and want to use it with Neon, send a request to support@neon.tech. For more information, see Custom-built extensions.

Support for AWS Data Migration Service (DMS)

You can now migrate data to Neon using the AWS Data Migration Service (DMS). Previously, a connection limitation prevented defining Neon as a target database endpoint. For data migration instructions, please refer to Migrate with AWS Database Migration Service (DMS).

Fixes & improvements

Neon uses the compute endpoint domain name to route incoming client connections. For example, to connect to the compute endpoint ep-mute-recipe-239816, we ask that you connect to ep-mute-recipe-239816.us-east-2.aws.neon.tech. However, the Postgres wire protocol does not transfer the domain name, so Neon relies on the Server Name Indication (SNI) extension of the TLS protocol to do this. Unfortunately, not all Postgres clients support SNI. When these clients attempt to connect, they receive an error indicating that the "endpoint ID is not specified".

Neon supports connection workarounds for this limitation, one of which uses a special endpoint connection option that allows you to specify a compute endpoint ID in an application's password field. Instead of specifying only a password, you provide a string consisting of the endpoint option and your password, separated by a semicolon. For example:

However, some client applications do not permit semicolon characters (;) in a password field. For these clients, Neon now supports using a dollar sign character $ as the delimiter:

For more information about this connection workaround, refer to our connection errors documentation.

Support for pgvector v0.5.0

We are pleased to announce support for pgvector v0.5.0 on Neon. This new version introduces:

• Hierarchical Navigable Small Worlds (HNSW) indexing for faster retrieval
• Faster distance functions
• Parallel builds for ivfflat indexes

If you already use pgvector with Neon, you can upgrade by running the following command:

Fixes & improvements

• Control Plane: The Availability Checker now uses the smallest Neon compute size (.25 Compute Units) to verify that a project's computes can start and read and write data. This change allows the Availability Checker to use pre-started computes more often, which shortens availability check operation time and reduces the impact of availability checks on infrastructure and compute costs.
• UI: Improved the Pro Plan Cost Estimator for Neon Free Tier users. To ensure accuracy, the tool now displays cost estimates only after a month of project usage. This change prevents the display of inaccurate cost estimates for new accounts. Neon Free Tier users can access the Pro Plan Cost Estimator by visiting the Billing page in the Neon Console.
• UI: Implemented a new and improved design for the Neon Sign-in page.

Neon serverless driver enhancements

The Neon serverless driver is a low-latency Postgres driver for JavaScript and TypeScript that allows you to query data from serverless and edge environments over HTTP or WebSockets in place of TCP.

The driver now supports batched queries and a larger response size for queries over HTTP.

Batched queries

You can now issue multiple queries at once in a single, non-interactive transaction using the transaction() function, which is exposed as property of the query function. For example:

The transaction() function supports the same option keys the ordinary query function — arrayMode, fullResults, and fetchOptions — plus three additional keys for transaction configuration:

• isolationMode

  Must be one of ReadUncommitted, ReadCommitted, RepeatableRead, or Serializable.

• readOnly

  Ensures that a READ ONLY transaction is used to execute queries. The default value is false.

• deferrable

  Ensures that a DEFERRABLE transaction is used to execute queries. The default value is false.

For more information, see transaction(...) function.

Larger response sizes

The maximum response size for queries over HTTP was raised from 1 MB to 10 MB.

Postgres version update

Supported Postgres versions were updated to 14.9 and 15.4, respectively.

BYPASSRLS added to the neon_superuser role

The neon_superuser role now includes the BYPASSRLS attribute, enabling members of this role to bypass the row security system when accessing tables. Roles created in the Neon console, CLI, or API, including the default role created with a Neon project, are granted membership in the neon_superuser role. For more information, see The neon_superuser role. This attribute is only included in neon_superuser roles in projects created after this release.

Fixes & improvements

• UI: Revised the Free Tier Billing page design where users can view Free Tier limits and learn about the benefits of upgrading to the Neon Pro plan. The Billing page is accessible from the sidebar in the Neon Console.
• UI: Fixed the code example drop-down menu on the Connection Details widget on the Neon Dashboard. The menu now opens above the selector if there is not enough space in the browser window for the menu to drop down.
• UI: The Project Creation modal now displays an error for invalid Auto-suspend delay settings.

History retention and point-in-time restore

You can now configure the history retention period for a Neon project. History retention enables point-in-time restore, allowing you to restore data to any point within the retention period. By default, Neon retains a 7-day history of data changes for all branches. The supported history retention range is 0 to 7 days for Free Tier users, and 0 to 30 days for Pro plan users.

The History retention setting is located in the Neon Console under Settings > Storage.

Configurable Auto-suspend

After an extensive testing period, we are pleased to announce that our Configurable auto-suspend feature has successfully transitioned out of Beta. This feature controls when a Neon compute instance scales to zero due to inactivity. For more information, see Configuring Auto-suspend for Neon computes.

Fixes & improvements

• API: The Create branch API method now creates a branch from the project's primary branch if a parent_id is not provided in the create branch request.

• API: Deprecated the pooler_enabled attribute in the Create endpoint API method. This attribute is no longer required, as you can now enable connection pooling by adding a -pooler flag to a database connection string. See Enable connection pooling.

• UI: The Compute widget on the Neon Dashboard now displays the Active computes limit for your Neon project. There is a default limit of 20 simultaneously active computes to protect Neon accounts from unintended or unexpected usage. Neon Pro plan users can increase the limit by contacting support@neon.tech.

• UI: Fixed an issue on the Downgrade dialog accessible from the Neon Pro plan Billing page that prevented selecting a reason for downgrading.

• UI: Fixed dark theme styling issues.

On-disk support for HNSW indexes with pg_embedding

Neon's pg_embedding extension, which enables graph-based vector similarity search in Postgres using the Hierarchical Navigable Small World (HNSW) algorithm (HNSW), now persists HNSW indexes to disk. In the previous pg_embedding version (0.1.0 and earlier), indexes resided in memory.

Additionally, pg_embedding now supports cosine and Manhattan distance metrics.

• Cosine distance

• Manhattan distance

If you have an existing pg_embedding installation and want to upgrade to the new version, see Upgrade to pg_embedding with on-disk indexes for instructions.

Also, be sure to check out the new Neon AI page on our website, and our docs, which include links to new AI example applications built with Neon Serverless Postgres.

Fixes & improvements

• UI: Added a billing period selector to the Billing page for Neon Pro accounts. The selector, which is positioned at the top of the Billing page, allows you to view billing metrics for current and past billing periods.
• UI: Fixed the password reveal functionality on the connection details modal displayed immediately after creating a new branch. The password was not revealed when selected, resulting in a branch connection string without a password.
• UI: Fixed several dark mode styling issues in the Neon UI and Neon-Vercel integration UI.

Autoscaling now available in all regions

Neon's Autoscaling feature, which automatically scales compute resources in response to workload, is now available in the US East (N. Virginia) — aws-us-east-1 and US West (Oregon) — aws-us-west-2 regions. With this change, Autoscaling is now available in all regions that Neon supports. Autoscaling is a Neon Pro plan feature. To learn how to enable Autoscaling in your Neon project, refer to Enabling Autoscaling in Neon.

Monitor Autoscaling with the neon_utils extension

Added support for a neon_utils extension, which provides a num_cpus() function for monitoring how Neon's Autoscaling feature allocates compute resources in response to workload. For more information, see The neon_utils extension.

Faster cold starts in all regions

Neon's Auto-suspend feature scales a compute instance to zero after a period of inactivity. A characteristic of this feature is a "cold start", which occurs when an idle compute is restarted to process requests. Recently, cold-start times have been improved through a variety of enhancements, outlined below:

• Compute pools: Instead of starting computes from zero, requests for computes are now served from pools of pre-started compute instances.
• Compute configuration optimization: Configuration changes at compute startup were eliminated where possible.
• Caching of internal IP addresses: Internal IP addresses are now cached to avoid waits for internal DNS routing.
• Concurrency improvements: Concurrency optimizations were applied to the compute startup process.
• Code path optimization: Code paths frequently accessed during compute startup were optimized.

With these improvements, cold starts are faster in all supported regions. Cold starts in the US East (Ohio) — aws-us-east-2 region, where the Neon Control Plane is hosted, are the fastest at approximately 500 ms. Work is underway to deploy the Neon Control Plane regionally to enable the same millisecond startup times for projects in all regions. For more information about this effort, please check out the blog post from the Neon engineering team: Cold starts just got hot.

Please be aware that Neon Pro plan users can adjust or disable the Auto-suspend setting, controlling when a compute scales to zero. Additionally, Neon's Autoscaling feature allows you to scale compute resources down to a fractional size during periods of low activity.

Auto-suspend delay project defaults

Neon now provides an Auto-suspend delay control on the project creation dialog, enabling Neon Pro plan users to define a default Auto-suspend delay setting for a project's compute endpoints. The Auto-suspend delay setting defines the period of inactivity after which a compute endpoint is automatically suspended. For more information, see Create a project.

Fixes & improvements

• UI: Updated the Usage widget on the Neon Dashboard for Free Tier accounts to provide additional details about the Active time usage metric.
• UI: Fixed OAuth page styling and other minor style issues for the Neon Console dark mode theme.

Dark mode

The Neon Console now supports Dark mode. To enable dark mode, click your account in the bottom left corner of the Neon Console, and select Theme. You can choose from System, Light, or Dark mode.

Database and role management via SQL

Neon now supports database and role management via SQL. You can now manage databases and roles from the Neon SQL Editor or an SQL client, such as psql. Previously, databases and roles could only be managed in the Neon Console.

With this change, you can grant and revoke privileges for Postgres roles as you would in a stand-alone Postgres installation.

Additionally, roles created in the Neon Console, CLI, and API are now automatically granted membership in a neon_superuser role. This role defines the privileges required to perform tasks in Neon such as creating databases, roles, and extensions. To learn more, see The neon_superuser role.

Improved experience for Prisma Migrate users

Users of Prisma Migrate no longer need to manually create a shadow database in Neon.

When using the prisma migrate dev command, Prisma Migrate automatically creates and deletes a “shadow” database. This database enables Prisma Migrate to generate new migrations and detect schema drift, ensuring that no manual changes have been made to the development database.

Previously, running prisma migrate dev without manually creating and configuring a shadow database in Neon would return the following error:

The reason for this error was that it was not possible in Neon to create and delete databases via SQL. To work around this issue, you had to manually create a shadow database in Neon and specify the connection string of that database in your schema.prisma file using the shadowDatabaseUrl variable. For example:

With support for managing databases via SQL, this workaround is no longer required. You can now remove the shadowDatabaseUrl variable from your schema.prisma file.

For more information about this change and other recent developer experience improvements for users of Prisma, please refer to the blog post.

Fixes & improvements

• Control Plane: The polling interval for a branch deletion operation was decreased from approximately 20 seconds to 1 second. A branch deletion operation typically takes a few seconds but appeared to take longer due to the polling delay.
• UI: Fixed the code example copy button in the Connection Details widget, which failed to remain stationary while scrolling.

Graph-based approximate nearest neighbor search in Postgres

Neon is pleased to announce the release of our new pg_embedding extension, which enables using the Hierarchical Navigable Small World (HNSW) algorithm for graph-based approximate nearest neighbor search in Postgres and LangChain.

The pg_embedding extension increases speed by up to 20x for 99% accuracy for approximate nearest neighbor search compared to pgvector.

Implementing pg_embedding in your application involves running a few simple SQL statements. Prior knowledge of vector indexes is optional. To learn more, read the blog post, refer to the pg_embedding documentation, or checkout the AI page on our website.

Fixes & improvements

Proxy: The wake-up logic for compute nodes was updated to reduce the number of errors returned to clients attempting to connect to Neon. Wake-up logic now supports quicker retries and will skip a connection attempt if failure is expected. Additionally, a 100ms sleep interval and IO error handling were introduced to manage scenarios in which compute nodes are not yet available as they wait for a Kubernetes DNS to be propagated.

Introducing the Neon CLI

Neon is pleased to announce the release of the Neon CLI, a command-line interface that enables developers to manage Neon resources directly from the terminal. The Neon CLI supports numerous operations, including creating and managing projects, branches, databases, roles, read replicas, and more, directly from your terminal. You can also use Neon CLI commands in developer workflows and pipelines.

You can install the Neon CLI with a single command:

Homebrew is also supported:

To get started with the Neon CLI, read the blog post or refer to the Neon CLI reference.

Same-region replicas

Neon now supports same-region read replicas. Neon's read replicas are independent read-only compute instances designed to perform read operations on the same data as your read-write computes. You can instantly create one or more read replicas for any branch in your Neon project and configure the amount of vCP-U and memory allocated to each.

Potential uses for read replicas include:

• Increasing throughput: Distribute read requests among multiple read replicas to achieve higher throughput for both read-write and read-only workloads.
• Offloading read-only workloads: Assign reporting or analytical workloads to a read replica to prevent impacting the performance of read-write application workloads.
• Managing data access: Provide read-only data access to certain users or applications that do not need write access.
• Customizing resource usage: Configure different CPU and memory resources for each read replica to cater to the specific needs of different users and applications.

To learn more, refer to our read replica blog post or read the documentation: Read replicas.

Faster Postgres queries for Vercel Edge Functions

The Neon serverless driver now supports for SQL queries over HTTP, providing up to a 40% reduction in query latencies from Vercel Serverless Functions and Edge Functions for one-shot queries. The enhanced driver brings same-region query response times down to single-digit milliseconds.

Additionally, we worked with the team at Drizzle to add Neon serverless driver support for Drizzle-ORM, an ORM for TypeScript. For an example demonstrating how to use the driver with Drizzle-ORM for type safety, see How to use the driver.

Refer to the blog post to learn more: Sub-10ms Postgres queries for Vercel Edge Functions.

Fixes & improvements

• UI: Added keyboard support (Tab + Enter) for switching between Explain and Analyze tabs in the SQL Editor.
• UI: Fixed calculations in the Pro Plan Cost Estimation tool accessible from the Billing page on the Neon Free Tier. The issue resulted in incorrect cost estimates.
• UI: Fixed an issue in the SQL Editor that caused a page reload when switching between Explain and Analyze tabs.

Pro Plan Cost Estimation tool enhancements

Typical use cases and Custom tabs were added to the Pro Plan Cost Estimation tool that is accessible from the Billing page on the Neon Free Tier. This tool helps you estimate what your monthly cost would be if you upgraded to the Neon Pro plan.

• The Typical uses case tab provides cost estimates for predefined Prototype, Launch, and Scale use cases.
• The Custom tab allows you to estimate costs based on compute and storage usage values that you provide.

Fixes & improvements

• API: Added a suspend_timeout_seconds parameter to the default_endpoint_settings object in the Create project API. This parameter defines the amount of time before the project's default compute endpoint is suspended due to inactivity. The default is 300 seconds (5 minutes).
• API: Deprecated the autoscaling_limit_min_cu and autoscaling_limit_min_cu parameters in the Create project project object. You can configure these parameters in the default_endpoint_settings object instead when creating a project.
• Control Plane: The default password encryption method for roles in Neon was changed to scram-sha-256.
• Control Plane: Upgraded PGBouncer to a Bitnami version that does not wait for the Postgres instance to become accessible before starting PgBouncer. Additionally, to optimize compute startup times, the server_login_retry setting in PgBouncer's configuration was adjusted to remove any delay between Postgres connection retries.
• Control Plane: Autoscaling minimum and maximum values are now validated to ensure only valid values are permitted.
• UI: Invoices from past months did not appear on the Billing page for Neon Pro plan accounts.

Fixes & improvements

• Updated the pgvector extension to version 0.4.4. If you installed this extension previously and want to upgrade to the latest version, please refer to Update an extension version for instructions.
• Added a check for available memory when creating an Hierarchical Navigable Small World (HNSW) index using the pg_embedding extension. HNSW builds indexes in memory. Insufficient memory for the index size could result in out-of-memory errors. For related information, see Create an HNSW index.

Postgres extension support

• Added support for the pg_uuidv7 extension, which enables creating version 7 UUIDs in Postgres.
• Added support for the pg_roaringbitmap extension. Roaring bitmaps are a type of compressed bitmap that generally surpass traditional compressed bitmaps in performance.

For more information about Postgres extensions supported by Neon and how to install them, see Postgres extensions.

Fixes & improvements

• Control Plane: Improved compute startup and compute availability check times by avoiding unnecessary catalog update steps already performed during initial compute startup.
• UI: Fixed a project creation issue that occurred when specifying a long project name. The Name field in the Project Creation modal now validates project names to ensure they are no more than 64 characters in length.

Postgres extension support

• Added support for the pgx_ulid extension, which enables using ULIDs within Postgres.
• Added support for the rdkit extension, which extends Postgres with data types and functions for working with chemical informatics data, turning Postgres into a cheminformatics database.

For more information about Postgres extensions supported by Neon and how to install them, see Postgres extensions.

Pro Plan Cost Estimation tool

Introduced a Pro Plan Cost Estimation tool designed to assist Free Tier users. This tool provides an estimated cost for the Pro Plan based on your current project usage. If you've ever wondered, "How much would my monthly cost be if I upgraded to the Neon Pro plan today?", this tool provides the answer. To access it, go to the Billing page via the sidebar of the Neon Console and select Estimate costs.

Fixes & improvements

UI: The code examples accessible from the Connect Details widget on the Neon Dashboard now include a -pooler suffix in the endpoint hostname when the Pooled connection tab is selected. You no longer need to add this suffix manually. UI: - Resolved an issue where the Time field on the Branch details page incorrectly displayed the date after creating a branch from main using the Time option. Now, the field correctly displays the time.

Connection pooling support for Autoscaling computes

Connection pooling can now be used in combination with the Neon Autoscaling feature. Previously, connection pooling was only available with fixed-size computes.

Documentation updates

• Added a guide for connecting from Elixir with Ecto.
• Added a guide for connecting a Python application to Neon using Psycopg.
• Expanded our Import data from Postgres documentation to include instructions for using pg_dump with pg_restore. The pg_restore utility offers additional options that facilitate importing larger or more complex datasets.
• Added a new section describing how to import data from one Neon project to another. These instructions are useful when setting up additional projects or when you need to move data to a project in a different region or with a different Postgres version. See Import data from another Neon project.
• Added ILLA Cloud to the list of applications and clients that support connecting to Neon. See Tested applications and IDEs. ILLA Cloud is a no-code platform that enables the rapid development and deployment of internal tools. For more information about ILLA Cloud and how to connect from ILLA Cloud to Neon, refer to this recent post: ILLA Cloud announces a new partnership with Neon serverless Postgres.
• Added Appsmith to the list of applications and clients that support connecting to Neon. See Tested applications and IDEs. Appsmith is an open-source framework for building internal tools such as dashboards, database GUIs, admin panels, approval apps, customer support tools, and more.

Support for up to 10,000 simultaneous connections

Neon supports up to 10,000 simultaneous connections when using connection pooling.

Higher max_connections for larger computes

The Postgres max_connections setting is now set according to your compute size. Previously, the max_connections setting was 100. The formula that calculates the max_connections setting is RAM in bytes / 9531392 bytes. For example, a compute with 12 GB of RAM has a max_connections setting of 1351. You can check the max_connections setting by running SHOW max_connections; from the Neon SQL Editor or from a client connected to Neon. When Autoscaling is enabled, max_connections is calculated based on the minimum compute size in your Autoscaling configuration.

Fixes & improvements

UI: Updated the Request Downgrade modal on the Billing page for Neon Pro accounts. The button label was changed, the screen height was adjusted, and other stylistic changes were applied.

Fixes & improvements

• Compute: Updated Postgres versions to 14.8 and 15.3, respectively.
• Compute: Implemented a cargo neon utility to facilitate setting up the Neon project locally. Setup instructions have been updated to reflect this change.

Autoscaling support for fractional compute sizes

Neon's Autoscaling feature now supports fractional (1/4 and 1/2) minimum compute sizes. Previously, the minimum compute size for Autoscaling was 1. Autoscaling is a Neon Pro plan feature. For configuration instructions, see Compute size and Autoscaling configuration.

Free Tier "Billing" page

Added a Billing page to the Neon Console where Free Tier users can view Free Tier limits and learn about the benefits of upgrading to the Neon Pro plan. The Billing page is accessible from the sidebar in the Neon Console.

Fixes & improvements

• UI: Implemented minor copy, stylistic, and functional improvements for the Request Downgrade modal accessed from the Billing page.
• API: Disabled docker as a compute provisioning option in the Neon Create project and Create endpoint APIs. This option is not supported with the Neon cloud service.

Fixes & improvements

• Proxy: Neon uses compute endpoint domain names to route incoming client connections. For example, to connect to the compute endpoint ep-mute-recipe-239816, we ask that you connect to ep-mute-recipe-239816.us-east-2.aws.neon.tech. However, the Postgres wire protocol does not transfer the server domain name, so Neon relies on the Server Name Indication (SNI) extension of the TLS protocol to do this. Unfortunately, not all Postgres clients support SNI. When these clients attempt to connect, they receive an error indicating that the "endpoint ID is not specified".

  As a workaround, Neon provides a special connection option that allows clients to specify the compute endpoint they are connecting to. The connection option was previously named project. This option name is now deprecated but remains supported for backward compatibility. The new name for the connection option is endpoint, which is used as shown in the following example:

  For more information about this special connection option for Postgres clients that do not support SNI, refer to our connection errors documentation.

• Pageserver: Branch deletion status was not tracked in S3 storage, which could result in a deleted branch remaining accessible.

• Pageserver: Addressed intermittent failed to flush page requests errors by adjusting Pageserver timeout settings.

Fixes & improvements

• Control Plane: Project limit checks are now performed for the Neon project owner rather than the currently logged in user. This change enables project limits to be checked against Pro plan limits rather than Free Tier limits when a Free Tier user accesses a project shared by a Pro plan user.
• Control Plane: Newly created Neon projects in a particular region are now assigned Pageservers through a random selection process, which is weighted according to Pageserver free space.
• Control Plane: Removed an unnecessary fetch of project parameters by the Activity Monitor.
• UI: Implemented usability improvements for modals. The changes ensure that modals receive focus when opened and that modal buttons are disabled until there is a valid change and while a form is being submitted. New error messages were also added.
• UI: Improved the hover effect when hovering over steps in the onboarding section on the Neon Dashboard.
• API: The Update endpoint API now permits moving an endpoint from one branch to another without specifying autoscaling_limit_max_cu and autoscaling_limit_min_cu property values, which should not be required when performing this action.
• Control Plane: Neon plan limits are now transmitted when using passwordless authentication, enabling users logging in via this method to create projects, in accordance with their plan limits.
• UI: Fixed an issue that prevented Free Tier users from creating a compute endpoint for an existing branch. The Fixed size compute setting in the Create Compute Endpoint modal defaulted to 1 vCPU, which exceeded the Free Tier compute size limit.
• UI: Fixed the Auto-suspend delay control on the Create Compute Endpoint and Edit Compute Endpoint modals to permit values up to 604800 seconds (7 days). The limit was recently increased from 86400 seconds (1 day).
• UI: Fixed issues with how icons were displayed in the Usage widget on the Neon Dashboard.

Fixes & improvements

• UI: Adjusted how Autoscaling minimum and maximum compute sizes are displayed in the Compute endpoints table on the branch details page.
• UI: Added a History retention metric to the Storage widget on the Neon Dashboard. By default, Neon retains a 7-day history of data changes to support point-in-time restore. History retention will become a configurable setting in a future release.
• UI: Enhanced the Request Downgrade modal, which is accessible from the Billing page in the console. Downgrading from Neon's Pro plan back to the Free Tier is now a fully automated and instant process. This change eliminates the previously required step of sending a downgrade request to Neon support.
• Control Plane: Adjusted the time interval for measuring compute utilization in Neon to avoid rounding decisions and ensure accuracy for fractional compute sizes.
• UI: Fixed modals in the console to enable form submission when the Enter key is pressed.
• UI: Fixed submission buttons that remained enabled after being clicked and while form data was being submitted.

Fixes & improvements

• Compute: Dockerfile updates for the neondatabase/neon repository are now automatically pushed to our public Docker Hub repository. This enhancement means that you no longer need to manually track and incorporate Dockerfile updates to build and test Neon locally. Instead, these changes will be available and ready to use directly from our Docker Hub repository.
• Safekeepers: Enabled parallel offload of WAL segments to remote storage. This change allows Safekeepers to upload up to five WAL segments concurrently.

Fixes & improvements

• Pageserver: Added WAL receiver context information for Timed out while waiting for WAL record errors. The additional information is used for diagnostic purposes.
• Safekeeper, Pageserver: Added Safekeeper and Pageserver metrics that count the number of received queries, broker messages, removed WAL segments, and connection switch events.
• Safekeeper: When establishing a connection to a Safekeeper, an Lsn::INVALID value was sent from the Safekeeper to the Pageserver if there were no WAL records to send. This incorrectly indicated to the Pageserver that the Safekeeper was lagging behind, causing the Pageserver to connect to a different Safekeeper. Instead of Lsn::INVALID, the most recent commit_lsn value is now sent instead.

Fixes & improvements

• Control Plane: Added support for configuring the Postgres default_text_search_config configuration parameter, which determines the behavior of text search functions and operators that do not have an explicit configuration. This parameter can be set for the Postgres instance using the default_endpoint_settings property in the Create project or Update project API, or using the pg_settings property in the Create endpoint or Update endpoint API. Alternatively, the parameter can be set for a specific database using ALTER DATABASE syntax:

• Control Plane: Implemented a ClusterIP service to be used instead of the existing NodePort service to support a higher number of simultaneously running computes in a single region.

• UI: Added Pooled connection and Direct connection tabs to the Connection Details widget on the Neon Dashboard, allowing you to copy a pooled or direct connection string for the selected branch, database, and role.

Support for the US East (N. Virginia) region

Added support for the US East (N. Virginia) — aws-us-east-1 region. For more information about Neon's region support, see Regions.

Postgres extension support

Added support for the ip4r and pg_hint_plan extensions. For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• Compute: Added support for lz4 and zstd WAL compression methods.
• Compute: Added support for procps, which is a set of utilities for process monitoring.
• Pageserver: Implemented syscalls changes in the WAL redo seccomp (secure computing mode) code to ensure AArch64 support.

Documentation updates

• Added a guide for using Grafbase Edge Resolvers with Neon. The guide describes how to create a GraphQL API using Grafbase and use Edge Resolvers with the Neon serverless driver to access your Neon database at the edge.
• Added a guide for using WunderGraph with Neon. WunderGraph is an open-source Backend for Frontend (BFF) framework designed to optimize developer workflows through API composition. The guide describes how you can use WunderGraph with Neon to accelerate application development.
• Added Segment to the list of applications and clients that support connecting to Neon. See Tested applications and IDEs.
• Added a topic describing how to connect to Neon securely. See Connect to Neon securely.

Fixes & improvements

• API: Enabled checking for the Neon API specification to ensure that examples are updated when the specification is modified.
• API: Added a history_retention_seconds property to the Project response body. Neon retains a 7-day history to support point-in-time restore. History retention will become a configurable parameter in a future release.
• API: Increased the maximum value of the suspend_timeout_seconds property in the Endpoint API from 86400 seconds (1 day) to 604800 seconds (7 days). This change affects the maximum Auto-suspend delay setting that Neon Pro plan users can configure when creating or editing a compute endpoint. The Auto-suspend delay setting defines the number of seconds of inactivity after which a compute endpoint is automatically suspended. The default is 300 seconds (5 minutes). For more information, see Auto-suspend configuration.
• Control Plane: Added a constraint to ensure that the maximum Autoscaling compute size is greater than or equal to the minimum compute size.
• UI: Redesigned the branch details page in the Neon Console. In addition to the information displayed previously, the page now provide usage metrics, including Active time, Compute time, Written data, and Data transfer. This information enables you to monitor usage for individual branches. Refer to our Billing page for information about the usage metrics. The compute endpoint information on the branch details page has also been expanded to include Compute size, Auto-suspend delay, and Last active information. Compute size (min) and Compute size (max) values are shown for computes with the Autoscaling feature enabled. For information about these values, see View a compute endpoint.
• UI: Added an Active time column to the table on the Branches page in the Neon Console. This column shows the number of hours the branch compute endpoint has been active for the current month.
• UI: The Connection Details dialog displayed when creating a project or a branch now provides Pooled connection and Direct connection tabs, allowing you to copy a pooled or direct connection string for the ready-to-use neondb database. For information about connection pooling in Neon, see Connection pooling.
• UI: Updated the prisma.js code example accessible from the Connection Details widget on the Neon Dashboard. The connection string now includes a connect_timeout parameter to prevent Prisma from timing out due to cold starts, and a pgbouncer=true parameter, which is required when using Prisma with a pooled connection string. For more information about using Neon with Prisma, see Connect Neon to Prisma.
• UI: Added icons and hover help to the Usage widget on the Neon Console.

Documentation updates

• Added documentation for Neon's newly released Autoscaling feature. To learn how Neon automatically and transparently scales compute on demand, see Autoscaling. Pro users can enable Autoscaling when creating a Neon project or afterward by editing a compute endpoint. For instructions, see:

  • Create a project
  • Edit a compute endpoint

• Added documentation for Neon's pg_tiktoken extension. This extension enables fast and efficient tokenization of data in your POstgres database using OpenAI's tiktoken library. To learn how to install the extension, utilize its features for tokenization and token management, and integrate the extension with ChatGPT models, see The pg_tiktoken extension.

• Added documentation for pg_vector extension. This extension enables vector similarity search and storing embeddings in Postgres. It is particularly useful for applications involving natural language processing, such as those built on top of OpenAI's GPT models. For information about vector similarity and embeddings, how to enable the pgvector extension in Neon, and how to create, store, and query vectors, see The pgvector extension.

• Reorganized our Prisma documentation into two parts to make it easier for you to get started with Prisma and Neon. The first part explains how to connect Prisma to Neon, establish connections when using Prisma Client with serverless functions, and resolve connection timeout issues. The second part describes how to configure Neon with Prisma Migrate for schema migrations.

  • Connect from Prisma to Neon
  • Use Prisma Migrate with Neon

• Added documentation describing primary and non-primary branches. Each Neon project has a primary branch called main, by default. The advantage of the primary branch is that its compute endpoint remains accessible if you exceed your project's limits, ensuring uninterrupted access to data that resides on the primary branch. Any branch not designated as the primary branch is considered a non-primary branch. To learn more, see:

  • Primary branch
  • Non-primary branch

• Added definitions for Neon operations to the glossary. An operation is an action performed by the Neon Control Plane on a Neon object or resource. Operations are typically initiated by user actions, such as creating a branch or deleting a database. Other operations are initiated by the Neon Control Plane, such as suspending a compute endpoint after a period of inactivity or checking its availability. You can monitor operations to keep an eye on the overall health of your Neon project or to check the status of specific operations. When working with the Neon API, you can poll the status of operations to ensure that an API request is completed before issuing the next API request. For more information, refer to our Operations documentation.

Postgres extension support

Added support for the timescaledb extension, which scales Postgres for time-series data. For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• UI: Added hover help to the PRIMARY branch badge that identifies a branch as the primary branch for a project. The help message states that the compute endpoint associated with the primary branch remains accessible if you exceed project limits, ensuring uninterrupted access to the data on your primary branch.
• UI: Fixed the Neon Project Creation dialog to display a value for the Fixed Size compute option. A value was not displayed previously.
• UI: Fixed the Create Compute Endpoint and Edit Compute Endpoint dialogs to enable switching between Fixed Size and Autoscaling compute options, enabling you to configure the compute size for each compute endpoint individually. For information about Neon's Autoscaling feature, see Autoscaling.
• UI: Fixed the Edit Compute Endpoint dialog so that the Autoscaling compute provisioning slider does not permit selecting unsupported minimum values. The minimum compute size for Autoscaling is 1 vCPU and 4 GB of RAM.
• UI: Fixed an issue that caused text on the Neon Dashboard to overflow when reducing the size of the browser window.

Fixes & improvements

• Pageserver: Added disk_size and instance_type properties to the Pageserver API. This data is required to support assigning Neon projects to Pageservers based on Pageserver disk usage.
• Proxy: Added error reporting for unusually low proxy_io_bytes_per_client metric values.
• Proxy: Added support for additional domain names to enable partner integrations with Neon.
• Proxy: The passwordless authentication proxy ignored non-wildcard common names, passing a None value instead. A non-wildcard common name is now set, and an error is reported if a None value is passed.
• Safekeeper: The wal_backup_lsn is now advanced after each WAL segment is offloaded to storage to avoid lags in WAL segment cleanup.
• Safekeeper: Added a timeout for reading from the socket in the Safekeeper WAL service to avoid an accumulation of waiting threads.
• Pageserver: Corrected an issue that caused data layer eviction to occur at a percentage above the configured disk-usage threshold.

Configurable Auto-suspend

You can now configure the period of inactivity after which a compute is automatically suspended by modifying the Auto-suspend delay setting for a compute endpoint. For example, you can increase the Auto-suspend delay setting to reduce how often a compute is suspended, or you can disable the Auto-suspend feature entirely to ensure that a compute remains active. The maximum Auto-suspend delay setting is 86400 seconds (24-hours). A setting of 0 means use the default (5 minutes / 300 seconds), and a setting of -1 means never suspend the compute. You can access the configuration dialog by editing a compute endpoint.

Monitor storage on the Dashboard

Added a Storage widget to the Neon Dashboard that shows current project storage size, number of branches, and data size for the primary branch. These metrics previously appeared in the Usage widget.

Postgres extension support

Added support for the pg_stat_statements extension, which provides tracking of plan and execution statistics for SQL statements. For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• API: Added consumption_period_start and consumption_period_end properties to the Get project details API. These properties provide the date and time when Neon starts and stops measuring usage for the current billing period.
• API: Project limits for shared projects are now checked against the project owner's limits. Previously, limits were checked against the project user's limits, which could prevent a Free Tier user from making full use of a project shared by a Pro plan user.
• Control Plane: Added an option to allow the Neon Control Plane to provide a compute node configuration specification in an API call after a compute node is started. Integrations: Added information to the Neon Vercel Integration UI to indicate that Neon securely stores passwords. Neon stores a database user's password in a secure storage vault associated with the Neon project.
• UI: Removed the previously deprecated Pooler enabled option from the Edit Compute Endpoint dialog. Connection pooling is now enabled for individual connection strings instead of compute endpoints. For more information, see Connection pooling.
• UI: The Usage widget in the Neon Dashboard now shows the start date for the project usage metrics shown in the widget.
• UI: Added a link to the Pro badge that appears in the Neon Console for users that have upgraded to Neon's Pro plan. Clicking the badge directs you to the Billing page in the Neon Console.
• UI: Added a documentation link and text to the Roles page in the Neon Console explaining the purpose of roles.
• UI: Added hover help to the PRIMARY branch badge that identifies a branch as the primary branch for a project. The help message states that the compute endpoint associated with the primary branch remains accessible if you exceed project limits, ensuring uninterrupted access to the data on your primary branch.
• UI: Corrected an issue that directed users to a Something went wrong page after creating a branch without a compute endpoint.
• UI: Added missing endpoint_id to the connection examples accessible from the Connection Details widget on the Neon Dashboard.

Free Tier updates

The compute active time limit of 100 hours per month for non-primary branches, introduced on February 24, 2023, now applies to all Neon Free Tier projects. The limit was not applied to projects created before February 24 2023 to give users time to adjust their usage or upgrade to a paid plan. For information about Free Tier limits, see Free Tier. If you have questions about this change or upgrading to a paid plan, please contact Sales.

Fixes & improvements

• API: Added a branch object to the Create project endpoint that allows you to specify names for the primary branch, role, and database created with a project. Previously, specifying non-default names for these objects required additional API calls after creating a project.
• API: Updated the List project consumption endpoint description to indicate that the pagination maximum is 1000.
• Control Plane: Added an option to enable a foreground deletion policy for Kubernetes clusters, which blocks other operations until cascading resource deletions are finished. The foreground option reduces the amount of polling for operation completion.
• Control Plane: Added the ability to search for branches in S3 storage, enabling identification of branches in storage that have already been deleted in the console.
• Control Plane: Simplified SQL logging to reduce the amount of log write processing.

Fixes & improvements

Connections from the Postgres.js client for Node.js and Deno are now supported. Postgres.js recently added support for Server Name Indication (SNI), which Neon uses to route incoming connections. Postgres.js connections must pass the ssl: 'require' option. For more information about how Neon uses SNI, see How Neon routes connections.

Deno support for the Neon serverless driver

The Neon serverless driver was verified to work with Deno. Where you would install another Postgres driver, run npm install @neondatabase/serverless instead, and then import the Neon serverless driver:

Autoscaling now in Beta

A Beta version of Neon's Autoscaling feature is now available for Pro plan users in selected regions. Autoscaling allows you to specify a minimum and maximum compute size. Neon scales compute resources up and down within the specified compute size boundaries to meet workload demand. The Autoscaling feature can be enabled when creating a Neon project or by editing a compute endpoint.

Fixes & improvements

• API: Removed the quota_reset_at property from the Project consumption endpoint used by Neon partners. The property did not provide useful data.
• Control Plane: Free Tier compute endpoints are now assigned 0.25 Compute Units (CU) by default, which is equal 0.25 vCPUs and 1 GB of RAM.
• Integrations: The Neon Vercel Integration no longer resets the password of the Neon role (the Neon database user). Previously, the password was reset to enable the integration to configure Vercel environment variables that require a password. Neon now stores passwords in a secure storage vault associated with the Neon project, allowing existing passwords to be retrieved.
• UI: Designating a different branch as the primary branch of a Neon project is now supported. The compute endpoint associated with the primary branch remains accessible if you exceed project limits, ensuring uninterrupted access to data on the primary branch. You can designate a new primary branch by selecting a branch from the Branches page in the Neon console and clicking Set as primary.

Fixes & improvements

• Compute: Free space in the local file system that Neon uses for temporary files, unlogged tables, and the local file cache, is now monitored in order to maximize the space available for the local file cache.
• Pageserver: Logical size and partitioning values are now computed before threshold-based eviction of data layers to avoid downloading previously evicted data layer files when restarting a Pageserver.
• Pageserver: The delete timeline endpoint in the Pageserver management API did not return the proper HTTP code.
• Pageserver: Fixed an issue in a data storage size calculation that caused an incorrect value to be returned.
• Pageserver: Addressed unexpected data layer downloads that occurred after a Pageserver restart. The data layers most likely required for the data storage size calculation after a Pageserver restart are now retained.

Documentation updates

Added a guide for connecting Neon to PolyScale. The PolyScale service makes data-driven apps faster by simplifying global data distribution and caching. You can connect Neon to PolyScale in minutes, providing your database-backed applications with speedy access to your Neon data from anywhere in the world. For more information, see Connect Neon to PolyScale.

Fixes & improvements

• UI: Adjusted the text in the Usage widget on the Neon Dashboard that describes the expected delay time for usage metrics.
• UI: Adjusted the Project storage metric labels in the Usage widget to identify one as Project storage (usage), which is a measure of monthly storage in GiB-hrs, and the other as Project storage (size), which is a measure of the current data size.
• UI: Revised the subscription cancellation warning on the Billing page.
• UI: Updated text and links in the Neon onboarding banner in the Neon Console.
• UI: Updated the Docs link in the Neon Console sidebar to point to the new documentation landing page.

Fixes & improvements

• API: Updated the region_id description in the Project API to include a link to the list of regions supported by Neon.
• UI: Revised the style of the Unsubscribe dialog accessed from the Billing page in the Neon Console.
• UI: Updated the metric units in the Usage widget on the Neon Dashboard
• UI: Fixed an issue that prevented Usage widget metrics on the Neon Dashboard from displaying data as expected. The API that supports the widget did not provide the required data.
• UI: Fixed an issue that caused Free Tier usage to be included in metrics data displayed in the Usage widget on the Neon Dashboard after upgrading to the Neon Pro plan. This issue did not affect billing.

Fixes & improvements

• Pageserver: Improved the check for unexpected trailing data when importing a basebackup, which is tarball with files required to bootstrap a compute node.
• Pageserver: Separated the management and libpq configuration, making it possible to enable authentication for only the management HTTP API or the Compute API.
• Pageserver: Reduced the amount of metrics data collected for Pageservers.
• Pageserver, Safekeeper: Removed unused Control Plane code.
• Pageserver: JWT (JSON Web Token) generation is now permitted to fail when running Pageservers with authentication disabled, which enables running without the 'openssl' binary. This change enables switching to the EdDSA algorithm for storing JWT authentication tokens.
• Pageserver: Switched to the EdDSA algorithm for the storage JWT authentication tokens. The Neon Control Plane only supports EdDSA.
• Added metrics that enable detection of data layer eviction thrashing (repetition of eviction and on-demand download of data layers).
• Pageserver, Safekeeper: Revised $NEON_AUTH_TOKEN variable handling when connecting from a compute to Pageservers and Safekeepers.
• Pageserver: Fixed an issue that resulted in old data layers not being garbage collected.
• Proxy: All compute node connection errors are now logged.
• Proxy: Fixed an issue that caused Websocket connections through the Proxy to become unresponsive.
• Safekeeper: Added an internal metric to track bytes written or read in Postgres connections to Safekeepers, which enables monitoring traffic between availability zones.

Documentation updates

• Added a Billing page describing Neon paid plans, pricing, and related topics.

• Added instructions for using the Neon Serverless driver on Vercel Edge Functions and Cloudflare Workers. The driver is a drop-in replacement for node-postgres that allows you to query data from environments that support WebSockets but not TCP sockets.

• Added an SDK reference page, which provides links to community-created SDKs for interacting with the Neon API. Community-created SDKs include:

  • Go SDK
  • Node and Deno TypeScript SDK

  Thanks to Dmitry Kisler and Ganesh Prasannah for the contributions.

• Updated the Neon Docs landing page. The new landing page provides a visual interface for navigating the Neon documentation site.

• Added an RSS feed for the Neon Release notes.

• Redirected old Neon API reference links to the new Neon API reference.

• Updated various Neon API reference style elements to align styles with the Neon Docs site.

• Updated the query example in the Neon Console onboarding banner and in the Query with Neon's SQL Editor topic in the documentation. The CREATE TABLE statement did not include a primary key, which prevented the data from being edited when accessed from pgAdmin.

Fractional compute sizes

Added support for fractional Compute Units (CU), enabling configuration of compute endpoints with a quarter or half CU. One CU has 1 vCPU and 4 GB of RAM.

Fixes & improvements

• API: Added a suspend_timeout_seconds property to the Endpoint API, which specifies the duration of inactivity (in seconds) after which a compute endpoint is automatically suspended.
• UI: Adjusted the labels and text on the Edit Compute Endpoint dialog.
• UI: Added support for Pro Plan customers to change payment details. Payment details can be changed by editing the Payment method on the Billing page in the Neon Console.
• UI: Added a Request subscription cancellation button to the Billing page in the Neon Console, which opens an Unsubscribe dialog. Customers can use the dialog to submit a plan cancellation request.
• UI: Revised the cancellation warning on the Billing page in the Neon Console.
• UI: Added a safety limit of 20 active compute endpoints. When the limit is exceeded, an endpoint is created but not activated.
• UI: When creating a branch, a complete connection string with the user name, password, and database name is now provided in the Connection Details dialog that is shown after branch creation.
• UI: Added a Usage widget to the Neon Dashboard for monitoring project usage. The usage widget tracks metrics such as Active time, Compute time, Project storage, Branches, and Current data size.
• UI: Added more domains to the console's Content Security Policy (CSP) HTTP response headers to enhance Neon Console security. CSP headers provide an additional layer of security for web pages by allowing a website to control what resources (such as scripts, stylesheets, and images) can be loaded and executed on its pages.

Introducing Neon Paid Plans

In addition to the Free Tier, Neon now offers the following paid plans:

• Pro: A usage-based plan, ideal for small-to-medium teams. With the Pro plan, you get up to 20 projects, unlimited branches, unlimited compute time, up to 200 GB of storage, and access to paid plan features such as project sharing, autoscaling (coming soon), and configurable auto-suspend compute (coming soon).
• Enterprise: A volume-based plan for medium-to-large teams and database fleets. Includes all Pro plan features plus customized limits and potential for volume discounts.
• Platform Partnership: A volume-based plan for large teams, database fleets, and resale. Includes all Enterprise plan features plus resale support.

You can learn more about Neon's paid plans and pricing on the Neon Pricing page.

Fixes & improvements

• API: Removed the physical_size property from the Branch response body in the Neon API.
• Control Plane: Addressed a memory leak that affected Neon Console performance. A memory limit was put in place prevent similar issues.
• UI: Changed the User label on the Connection Details widget to Roles. Database users are now referred to as Roles in Neon.
• UI: Added descriptive text and a documentation link to the Integrations page in the Neon Console.
• UI: Added support for sharing projects with other Neon users. Project sharing is performed from the Settings page in the Neon Console. The project sharing feature is available only to Neon paid plan users, but projects can be shared with any Neon user, including Free Tier users. For instructions, see Manage projects.
• UI: Added an Upgrade to Pro option to the Neon Console to enable upgrading from Free Tier to Neon's Pro plan. For information about Neon's paid plans, please refer to Neon plans.
• UI: Fixed the connection examples accessible from the Connection Details widget on the Neon Dashboard. Examples other than the psql example had an extra project name in the connection hostname.
• UI: Fixed the "Manage" link on the Branches widget on the Neon Dashboard. The link did not work.

Fixes & improvements

• Autoscaling: Added support for scaling Neon's local file cache size when scaling a virtual machine.

• Compute: Released a new pg_tiktoken Postgres extension, created by the Neon engineering team. The extension is a wrapper for OpenAI’s tokenizer. It provides fast and efficient tokenization of data stored in a Postgres database. The extension supports two functions:

  • The tiktoken_encode function takes text input and returns tokenized output, making it easier to analyze and process text data.
  • The tiktoken_count function returns the number of tokens in a text, which is useful for checking text length limits, such as those imposed by OpenAI’s language models.

  The pg_tiktoken code is available on GitHub.

• Compute: Added support for the Postgres prefix, hll and plpgsql_check extensions. For more information about Postgres extensions supported by Neon, see Postgres extensions.

• Compute, Pageserver, Safekeeper: Added support for RS384 and RS512 JWT tokens, used to securely transmit information as JSON objects.

• Pageserver: Removed the block cursor cache, which provided little performance benefit and would hold page references that caused deadlocks.

Fixes & improvements

• Released a new version of the Neon serverless driver (v0.2.6), which allows you to query data from Cloudflare Workers, Vercel Edge Functions, and other environments that support WebSockets. The updated driver offers:

  • Automatic import of the ws (WebSocket library) package if required, which makes the driver easier to use on StackBlitz and with Zapatos, for example.
  • More helpful error messages when connection details are not provided. For example, a more informative error message is reported if you forget to set an environment variable for the database connection or forget to include a password in your database connection string.

• Added three new example application repositories to help you get started with the Neon serverless driver on Vercel Edge Functions. The example application generates a JSON listing of the 10 nearest UNESCO World Heritage sites using IP geolocation (data copyright © 1992 – 2022 UNESCO/World Heritage Centre).

  

  • The neondatabase/neon-vercel-rawsql example demonstrates using raw SQL with Neon's serverless driver on Vercel Edge Functions.
  • The neondatabase/neon-vercel-zapatos example demonstrates using Zapatos with Neon's serverless driver on Vercel Edge Functions. Zapatos offers zero-abstraction Postgres for TypeScript.
  • The neondatabase/neon-vercel-kysely example demonstrates using kysely and kysely-codegen with Neon's serverless driver on Vercel Edge Functions. Kysely is a type-safe and autocompletion-friendly typescript SQL query builder. kysely-codegen generates Kysely type definitions from your database.

  The UNESCO World Heritage sites example is also available for the Neon serverless driver on Cloudflare Workers. See neondatabase/serverless-cfworker-demo.

Fixes & improvements

• Pageserver: Added logic to handle unexpected Write-Ahead Log (WAL) redo process failures, which could cause a Broken pipe error on the Pageserver. In case of a failure, the WAL redo process is now restarted, and requests to apply redo records are retried automatically.
• Pageserver: Added timeout logic for the copy operation that occurs when downloading a data layer. The timeout logic prevents a deadlock state if a data layer download is blocked.
• Safekeeper: Addressed Failed to open WAL file warnings that appeared in the Safekeeper log files. The warnings were due to an outdated truncate_lsn value on the Safekeeper, which caused the walproposer (the Postgres compute node) to download WAL records starting from a Log Sequence Number (LSN) that was older than the backup_lsn. This resulted in unnecessary WAL record downloads from cold storage.

Fixes & improvements

• API: Adjusted the tags in the Neon API specification that assign endpoints to categories. The new Neon API reference displays one endpoint per page. Multiple tags assigned to an endpoint resulted in endpoints not being listed under their primary category.
• UI: Updated the labels, links, and units shown on the Project limits widget on the Neon Dashboard.
• UI: Fixed the vertical alignment of buttons on authorization dialogs.
• UI: Removed a newline character from the connection string in the connection details dialog that is displayed after creating a new project.

Fixes & improvements

• Compute: Added support for the Postgres rum and pgTAP extensions. For more information about Postgres extensions supported by Neon, see Postgres extensions.
• Pageserver: A system metric that monitors physical data size overflowed when a garbage collection operation was performed on an evicted data layer.
• Pageserver: An index upload was skipped when a compaction operation did not perform an on-demand download from storage. With no on-demand downloads, the compaction function would exit before scheduling the index upload.

Documentation updates

• Added Neon API Operation endpoint examples and a topic describing how to poll operation status. When working with the Neon API programmatically, it may be necessary to poll operations to ensure that currently running API requests are finished before proceeding with the next request.

• Introduced a new Neon API documentation user interface. The new UI is more user-friendly, easier to navigate, and offers a more intuitive design, making it easier for developers to find what they need and get started with our APIs quickly. The UI can be viewed in light or dark mode and includes a Try it feature that allows you execute API requests from your browser.

  

Fixes & improvements

• API: A new cpu_used_sec property was added to the Project response body in the Neon API. This property shows the number of CPU seconds used by a branch's compute endpoints. The value resets to zero at the beginning of each billing period.
• Control Plane: By default, Neon suspends a compute endpoint after five minutes of inactivity. A custom configuration option was added to enable configuring or disabling the suspension threshold for compute endpoints. Disabling the threshold allows a compute endpoint to remain active indefinitely, which avoids latencies associated with restarting idle compute endpoints. This feature is not yet generally available. You can expect it to be introduced with Neon paid tiers.
• UI: New Neon projects now store role passwords in a secure storage vault associated with the project, allowing passwords to be retrieved from the Connection Details widget on the Neon Dashboard. Secure password storage reduces the need for password resets and facilitates the use of Neon features that require a password. The stored passwords feature is not yet available for existing Neon projects.
• UI: New Neon projects no longer include the system-managed web_access role. This role was used by the Neon SQL Editor and passwordless auth feature. With the introduction of stored passwords, the web_access role is no longer required. Removal of the web_access role also addresses permission issues encountered when attempting to perform actions as the web_access role on objects owned by other roles or vice versa.

Postgres extension support

Added support for the following Postgres extensions:

• pg_graphql
• pg_jsonschema
• pg_hashids
• pgrouting
• hypopg
• Server Programming Interface (SPI) extensions:
  • autoinc
  • insert_username
  • moddatetime
  • refint

For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• Compute: Updated supported Postgres versions to 14.7 and 15.2, respectively.
• Pageserver: Optimized the log-structured merge-tree (LSM tree) implementation to reduce write amplification.

Documentation updates

• Added a guide for using Neon with Koyeb, which is a serverless platform designed to easily deploy applications globally.
• Added Retool to our list of GUI applications and clients that support connecting to Neon.
• Updated the Vercel guide to include the following topics:
  • Add the Neon Vercel Integration to another Vercel project
  • Use the Neon integration
  • Connect Vercel and Neon manually
• Updated the Connection pooling documentation with information about how to enable pooling by adding a -pooler suffix to the compute endpoint ID in your connection string. This feature allows you to connect to the same database with pooled and non-pooled connections.
• Added descriptions for Operation, Project, Branch, and Endpoint properties to the Neon API reference.
• Updated the Neon documentation to reflect the renaming of Users to Roles in the Neon Console.

Fixes & improvements

• API: The connection_uris property in the Create branch response is no longer a required property, meaning that the field is not included in the response if the value is empty. The connection_uris property is now returned only in cases where a branch has only a single database and role.

• API: Added property descriptions for Project, Branch, Endpoint, Database, Role, and Operation endpoints.

• Control Plane: A compute endpoint now remains in an active state after resetting a password, creating a role, or creating a database. Previously, a compute endpoint was suspended following those actions. This behavior caused unnecessary latency when accessing the compute endpoint immediately afterward. The latency was due to the few seconds required to restart the compute endpoint.

• Integrations: Improved text and fixed a documentation link in the Neon Vercel Integration UI.

• UI: The Neon Free Tier now includes a compute endpoint with each branch. Previously, there was a limit of 3 endpoints per project. This limit was removed based on user feedback indicating that it was not conducive to developer workflows that create a branch for each preview deployment.

  Instead of limiting the number of endpoint computes in the Neon Free Tier, there is now a limit of 100 compute active time hours per month. Currently, the compute hour limit applies to newly created projects only. The limit does not yet apply to existing projects. We expect to apply the limit to all projects later this quarter. Regardless of the compute hour limit, you are always able to connect to the compute endpoint associated with the primary branch of your Neon project. For more information, see Technical Preview Free Tier.

  If you have any questions about how this change to Neon's Free Tier limits might impact your existing project, please contact us at support@neon.tech.

• UI: With the removal of the endpoint limit, endpoints no longer appear in the Project limits widget on the Neon Dashboard.

• UI: With the introduction of pooled connections strings (see Enable pooling), enabling pooling for a compute endpoint is deprecated. With this change, the Pooler enabled toggle on the Edit Compute Endpoint dialog is now disabled and will be removed in a future release.

• UI: Changed a column heading in the table on the Operations page from ID to Action. The items listed in the column are operation actions rather than IDs.

• UI: Renamed the Users page in the Neon Console to Roles. This change aligns Neon's terminology with Postgres, which uses the concept of "roles" to refer to database users. (See Database roles, in the PostgreSQL documentation.) All UI elements in the Neon Console were updated to reflect this change.

Fixes & improvements

• Compute: Added support for the Postgres xml2 and pgjwt extensions. For more information about Postgres extensions supported by Neon, see Postgres extensions.

• Compute: Updated the versions for the following Postgres extensions:

  • Updated the address_standardizer, address_standardizer_data_us, postgis, postgis_raster, postgis_tiger_geocoder, postgis_topology extensions to version 3.3.2.
  • Updated the plv8, plls, plcoffee extensions to 3.1.5.
  • Updated the h3_pg extension to 4.1.2.

  Updating an extension version requires running an ALTER EXTENSION <extension_name> UPDATE TO <new_version> statement. For example, to update the postgis_topology extension to the newly supported version, run this statement:

• Pageserver: Corrected the storage size metrics calculation to ensure that only active branches are counted.

• Proxy: Enabled OpenTelemetry tracing to capture all incoming requests. This change enables Neon to perform an end-to-end trace when a new connection is established.

Fixes & improvements

• API: The Neon API specification now shows the default (10) and maximum (100) pagination values for the List projects API endpoint. These settings were enforced previously but were not included in the Neon API specification.
• API: Updating a project name resulted in the loss of values defined in default_endpoint_settings property, which defines custom settings for project's compute endpoints.
• Control Plane: Increased the PgBouncer maximum client connection setting from 1000 to 10000, enabling Neon to support up to 10000 simultaneous connections. For more information about connection pooling in Neon, see Connection pooling.
• Control Plane: Added an internal retry mechanism for connections to the Neon proxy, which improves the success rate for connection attempts. The Neon proxy is a service that accepts and handles connections from clients that use the Postgres protocol.
• Control Plane: A chain of operations failed to run in the expected order due to a lock related issue. In addition to operations running out of sequence, some operations were executed more than once.
• UI: Added Content-Security-Policy (CSP) HTTP response headers to enhance Neon Console security. CSP headers provide an additional layer of security for web pages by allowing a website to control what resources (such as scripts, stylesheets, and images) can be loaded and executed on its pages.

Fixes & improvements

• Compute: Added support for the Postgres pgvector, plls and plcoffee extensions. For more information about Postgres extensions supported by Neon, see Postgres extensions.
• Pageserver: Added an experimental feature that automatically evicts layer files from Pageservers to optimize local storage space usage. When enabled for a project, Pageservers periodically check the access timestamps of the project's layer files. If the most recent layer file access is further in the past than a configurable threshold, the Pageserver removes the layer file from local storage. The authoritative copy of the layer file remains in S3. A Pageserver can download a layer file from S3 on-demand if it is needed again, to reconstruct a page version for a client request, for example.
• Proxy: Significantly reduced network latencies for WebSocket and pooled connections by implementing caching mechanism for compute node connection information and enabling the TCP_NODELAY protocol option. The TCP_NODELAY option causes segments to be sent as soon as possible, even if there is only a small amount of data. For more information, refer to the TCP protocol man page.

Fixes & improvements

• API: Added a quota_reset_at property to the Project response schema in the Neon API. This property displays a future date indicating when a resource consumption quota will be reset. For example, the Neon Free Tier offers 100 compute hours per month. The quota_reset_at property shows when that quota will be set back to 100 hours.
• API: Added a compute_seconds_limit property to the CurrentUserInfoResponse schema in the Neon API. This property defines the monthly compute limit in terms of compute seconds.
• Integrations: The Neon integration with Vercel did not create branches for preview deployments when the Vercel user ID differed from the one specified when adding the Neon integration to Vercel. This issue was encountered when using the Neon integration from a Vercel Teams account.

Fixes & improvements

• API: The default_endpoint_settings property in the Project schema was split into default_endpoint_settings and settings. The default_endpoint_settings property is now used exclusively for Postgres specific settings applied to a project's compute endpoints. The settings property is used for general project settings such as the compute quota. If you have been using createProject or updateProject API requests in your code, you may need to update those requests to account for this change.
• UI: Updated various UI elements in the Neon Console to rename Endpoints to Compute endpoints. The term Endpoint was not specific enough to accurately reflect the resource being referred to. A Compute endpoint in Neon refers the compute instance that runs Postgres.
• UI: Added a PRIMARY badge to identify the primary branch of a Neon project. The badge is visible on the Branches page in the Neon Console and in other UI elements that show a project's branches.

Postgres extension support

Added support for the Postgres postgis-sfcgal extension. For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

Compute: Added support for International Components for Unicode (ICU), which permits defining collation objects that use ICU as the collation provider. For example:

Fixes & improvements

• Integrations: You can now integrate Neon with your Vercel project directly from your Vercel account. The new integration, which is currently in Beta, is available from the Vercel Integration Marketplace. The integration allows you to connect your Vercel project to a new or existing Neon project. It also enables creating a database branch for each Vercel preview deployment and for your Vercel development environment. For more information about the Neon-Vercel integration, see Connect Vercel and Neon.

• Control Plane: You can now enable connection pooling in Neon for individual connections. Pooling is enabled by adding a -pooler suffix to the endpoint ID in the Neon hostname. For example:

  Connections that do not specify the -pooler suffix connect to the database directly. The ability to enable pooling for individual connections supports workflows that require both pooled and non-pooled connections to the same database. For example, serverless applications that use Prisma Client require a pooled connection, while Prisma Migrate requires a direct connection to the database. For more information, see Enable connection pooling.

  The previous method of enabling connection pooling for a compute endpoint is deprecated. When switching to the new per-connection method, be sure to disable connection pooling at the compute endpoint. You can do so by editing the compute endpoint.

• Console: Added validation to ensure that emails are provided in the expected format when creating a Neon account.

• Control Plane: Added validation for the Log Sequence Number (LSN) provided when creating a branch from a particular LSN value to prevent the possibility of creating a branch from an unrelated parent branch. An appropriate error is now reported when an invalid LSN value is provided.

• UI: With the removal of the endpoint limit, endpoints no longer appear in the Project limits widget on the Neon Dashboard.

Fixes & improvements

• API: The response body for projects, branches, and endpoints now exposes a creation_source property. Currently, the creation_source property identifies the console as the creation source in all cases but will eventually identify other sources, such as the Neon API.
• API: Listing projects with the Neon API now supports cursor-based pagination. Pagination enables limiting the number of responses displayed at one time, which is useful when a response includes a large number of projects. By default, the first 10 projects are returned. You can set the limit parameter to request up to 100 projects.
• API: Fixed a race condition that occurred when creating a project and attempting to fetch information about branch in the same project.
• Control Plane: Added support for OpenTelemetry for a number of operations. OpenTelemetry is an observability framework that assists in generating and capturing telemetry data from cloud-native software.
• Control Plane: Removed the stop_compute operation, which is no longer used. It was replaced by suspend_compute.
• Control Plane: Fixed a cannot execute GRANT in a read-only error that occurred when a database owner enabled the default_transaction_read_only setting, preventing the Control Plane from configuring the compute instance.
• UI: Revised the layout of the Neon Console to improve navigation. The following enhancements were implemented:
  • A new sidebar with icons replaces the navigation bar that was located at the top of the console.
  • Operations, Databases, and Users pages, previously accessed from the Settings page, are now directly accessible from the sidebar.
  • Links to Community, Feedback, Docs, Release notes, and Support, previously located in a Help menu in the navigation bar, were moved to the sidebar for easier access.
  • The Neon account avatar was moved from the top right corner of the console to the sidebar.
• UI: Fixed the positioning of selection menus in the console to avoid scrolling outside intended boundaries.

Postgres extension support

Added support for the Postgres unit extension. For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• Compute: Removed logic that updated roles each time a Neon compute instance was restarted. Roles were updated on each restart to address a password-related backward compatibility issue that is no longer relevant.
• Pageserver: Reimplemented the layer map used to track the data layers in a branch. The layer map now uses an immutable binary search tree (BST) data structure, which improves data layer lookup performance over the previous R-tree implementation. The data required to reconstruct page versions is stored as data layers in Neon Pageservers.
• Pageserver: Changed the garbage collection (gc) interval from 100 seconds to 60 minutes. This change reduces the frequency of layer map locks.
• Pageserver: Implemented an asynchronous pipe for communication with the Write Ahead Log (WAL) redo process, which helps improves OLAP query performance.

Fixes & improvements

Compute: Fixed a compute instance restart error. When a compute instance was restarted after a role was deleted in the console, the restart operation failed with a "role does not exist" error while attempting to reassign the objects owned by the deleted role.

Postgres extension support

Added support for several Postgres extensions. Newly supported extensions include:

• bloom
• pgrowlocks
• intagg
• pgstattuple
• earthdistance
• address_standardizer
• address_standardizer_data_us

For more information about Postgres extensions supported by Neon, see Postgres extensions.

Fixes & improvements

• Compute: Updated the list of Postgres client libraries and runtimes that Neon tests for connection support. The pg8000 Python Postgres driver, version 1.29.3 and higher, now supports connecting to Neon.
• Compute: Added statistics to EXPLAIN that show prefetch hits and misses for sequential scans.
• Proxy: Updated the error message that is reported when attempting to connect from a client or driver that does not support Server Name Indication (SNI). For more information about the SNI requirement, see Connection errors. Previously, the error message indicated that the "Project ID" is not specified. The error message now states that the "Endpoint ID" is not specified. Connecting to Neon with a Project ID remains supported for backward compatibility, but connecting with an Endpoint ID is now the recommended connection method. For general information about connecting to Neon, see Connect from any application.

Fixes & improvements

Pageserver: Added support for on-demand download of layer files from cold storage. Layer files contain the data required reconstruct any version of a data page. On-demand download enables Neon to quickly distribute data across Pageservers and recover from local Pageserver failures. This feature augments Neon's storage capability by allowing data to be transferred efficiently from cold storage to Pageservers whenever the data is needed.

Fixes & improvements

• API: Added a branch_logical_size_limit attribute to the Neon API Project response body, which shows the logical data size limit for project branches. This attribute replaces the logical_size_limit attribute, which was shown in the Branch response body. The Neon Free Tier limits the logical data size of a branch to 3072MB (3GB).
• API: Added the ability to delete or reassign the endpoint associated with a project's root branch. Previously, these actions could not be performed on the endpoint associated with a project's root branch. You can edit or delete an endpoint by selecting Edit or Delete from the kebab menu in the table on the Endpoints page.
• API: Updated descriptions and examples in the Neon API v2 reference.
• API: Added validation to ensure that the name specified when creating a role does not exceed 63 bytes. Role names longer than 63 bytes caused compute startup issues.
• Control Plane: Migrated older branches that were created using the Neon API v1 to their parent project. Branches created with Neon API v1 existed as separate Neon projects. After the migration, the branches exist as Neon API v2 branch and endpoint objects that belong to a parent project. Connection strings for migrated branches, which use the old project_id in the hostname, are no longer valid. Instead of the project_id, an endpoint_id must be specified in the hostname. For information about constructing a valid connection string, see Connect from any application. An email with migration instructions was sent to affected users.
• UI: Added a Pooler enabled toggle control to the Edit endpoint dialog to permit enabling or disabling connection pooling for endpoint compute instances. The same control is available on the Create endpoint dialog. Previously, connection pooling was enabled or disabled for a project, and the control was located in Settings > General. Connection pooling is disabled, by default. For more information about Neon's connection pooling feature, see Connection pooling.
• UI: Completed the migration of the Neon Console from Neon API v1 to Neon API v2. The Neon API v1 is deprecated.
• UI: Added a Region column to the Projects dialog in the Neon Console to show the region where a Neon project resides.
• UI: Improved WebSockets integration with the Neon Console, and added Websocket support for endpoint updates.
• UI: Passwords are now temporarily displayed in the Connection Details widget on the project Dashboard after project creation and password reset operations. The password is displayed until you navigate away from the Neon Console or refresh the browser.

Fixes & improvements

• API: The request body for the create branch API is now optional. Previously, a request body with branch or endpoints attributes was required. Without a request body, the default behavior is to create a branch from the project's root branch (main) without an endpoint, and the branch name is auto-generated.
• Control Plane: Neon now attempts to deploy compute resources in the same availability zone as the Pageserver.
• UI: Removed the password from the connection string that is displayed in the Connection Details widget on the Neon Dashboard after project creation. A connection string and .env file with the password are provided in a pop-up dialog after creating a project.
• UI: Neon's passwordless auth feature no longer requires selecting an endpoint for projects with a single endpoint.

Fixes & improvements

• Compute: Added support for sequential scan prefetch, which reduces round trips between Computes and Pageservers. Sequential scan prefetch allows fetching numerous pages at once instead of one by one, improving I/O performance for operations such as table scans.
• Compute: Added support for the pg_prewarm Postgres extension, which utilizes the above-mentioned sequential scan prefetch feature. The pg_prewarm extension provides a convenient way to load data into the Postgres buffer cache after a cold start. For information about Postgres extensions supported by Neon, see Postgres extensions.
• Compute: Updated supported Postgres versions to 14.6 and 15.1, respectively.
• Pageserver: Updated the storage_sync operation to make it more robust and reliable while syncing files between Pageservers and S3.
• Safekeeper: Replaced etcd subscriptions with a custom Neon storage broker. The storage broker allows Safekeepers and Pageservers to learn which storage node holds a timeline and the status of a timeline while avoiding too many connections between nodes.

Fixes & improvements

• API: Added request and response body examples to the Neon API v2 specification.
• API: Disabled deleting or changing the endpoint compute instance associated with a project's root branch.
• API: Added a logical_size_limit attribute to the branch schema, which shows the data size limit for a branch.
• API: Renamed the max_project_size attribute in Neon API v1 specification to branch_logical_size_limit.
• API: Removed the max_project_size attribute from Neon v2 API schema.
• API: Fixed a project duplication issue in the list projects method in the Neon API v1.
• Control Plane: Implemented a forced suspension of endpoints that are unresponsive for more than 2 hours.
• Control Plane: Improved the reliability of the passwordless auth feature.
• Control Plane: Fixed an issue that caused an endpoint to be created in a region other than the project's region.
• UI: Removed the Neon invite gate. An invitation is no longer required to try Neon. It is available to everyone. For more information, refer to the Neon is Live! blog post.
• UI: Released the Neon database branching feature. Branching is now available to all users. For more information, refer to the Database Branching for Postgres with Neon blog post.
• UI: Added new and improved popup dialogs for project, branch, and role creation.
• UI: Added an Endpoints page to the Neon Console for creating and managing endpoints, which are the compute resources in your Neon project. For more information about endpoints, see Endpoints.
• UI: Enabled creating branches with data up to a specified Log Sequence Number (LSN).
• UI: Updated the passwordless auth feature to show the branch name on the browser page that is displayed during authentication.
• UI: Updated the Create branch page to display the local timezone when selecting the Time option during branch creation.
• UI: Removed branches without endpoints from the branch selector in Neon SQL Editor. To query a branch, the branch must have an associated endpoint through which a connection can be established.
• UI: Added a Free tier widget to the Neon Dashboard, which shows how many branches and endpoints you have created and the status of your free tier limits. The widget also shows the data size limit per branch, which is 3GB. For information about Free Tier limits, see Neon Technical Preview Free Tier.
• UI: Enabled reset password functionality for non-root branches.

Fixes & improvements

• API: Creating branches using the Neon API v1 is now deprecated.
• API: Added support for cursor pagination when listing operations.
• API: Added validation for empty names to branch and project endpoints.
• API: Added LSN validation to the create branch endpoint.
• API: Made the parent_id and name attributes optional when creating a branch.
• API: Added a complete endpoint hostname value in the endpoint response body.
• API: Added support for changing the branch of an endpoint.
• API: Added an allow_connections flag for endpoints to permit disabling connections to the endpoint.
• API: Added support for creating a branch without an endpoint, which is now the default if the endpoints attribute is not specified. Creating a branch without an endpoint supports backup uses cases and useful in scenarios where the number of branches exceeds the number of available endpoints due to endpoint limits.
• API: Added response examples to the API specification.
• API: Create project and create endpoints now treat the region_id parameter as region.id. The attribute was previously treated as region.handle. Code that uses these endpoints may need to be updated.
• API: Fixed the ordering of operations and projects.
• API: Corrected the error reported when a duplicate branch name is used.
• Control Plane: Added handling for ID collisions when creating a branch or endpoint.
• Control Plane: Renamed the ready-to-use database created in the root branch of a Neon project from main to neondb.
• Control Plane: Added new autoscaling limits.
• Control Plane: Added a project maintenance flag.
• Control Plane: Added a region maintenance and testing flag.
• UI: Added a branch ID value and Create branch button to the branch details page in the console.
• UI: Updated the Neon Free Tier limits. See Technical Preview Free Tier for details. The new Neon Free Tier limits apply to both new and existing projects, but the previous 10 GB storage limit will be honored for existing projects that currently have more than 3 GB of data.
• UI: Added a Delete endpoint button to the Endpoints page.
• UI: Updated the Neon passwordless auth feature to select an endpoint to connect to instead of a project.
• UI: Fixed an endpoint polling issue.
• UI: Stopped polling when deleting a project.
• UI: Added handling for errors that occur when polling endpoint status.
• UI: Removed visibility of internal service roles.
• UI: Added handling for sign-in during passwordless auth.
• UI: Fixed the NodeJS connection string example in the Connection Details widget on the Dashboard.

Fixes & improvements

• Control Plane: Introduced a maintenance mode for Neon projects. When a project is placed into maintenance mode, its endpoints are forcibly suspended and modifications are not permitted until maintenance is completed.
• Control Plane: Added support for Cross-Origin Resource Sharing (CORS) to the Neon API v1 and v2.
• Control Plane: Added descriptions for endpoint categories to the Neon API v2, and changed the ApiKey tag to API Key.
• Control Plane: Added the ability to fetch all endpoints for a specified branch to the Neon API v2. Thank you to our Neon community member for the feature request.
• Control Plane: Added the ability to create endpoints without specifying an instance ID to the Neon API v2.
• Control Plane: Added the ability to retrieve information about the current user to the Neon API v2. User details such as login, email, and other parameters specified in the OpenAPI specification can now be retrieved.
• Control Plane: Added a "Content-Type" header with an "application/json" value to Neon API v2 error responses.
• Control Plane: Fixed a memory leak that occurred when handling SQL requests.
• Control Plane: Improved diagnostic information by extracting error messages from Pageserver responses during project creation.
• Control Plane: Stopped manually rolling back the current transaction when the user cancels the context. The Go driver ConnBeginTx interface performs this operation automatically.
• UI: Postgres 15 is now the default version when creating a Neon project.
• UI: Added support for renaming branches. To rename a branch, select the branch on the Branches page in the Neon Console and click Rename branch.
• UI: Added TIME and LSN fields to the branch details page for child branches. The TIME field shows the time value selected when creating a branch with data up to a specified point in time. The LSN field shows a Log Sequence Number (LSN), indicating that the branch was created with data up to that LSN.
• UI: Added a branch icon to the branch selection menu on the Databases and Users pages in the Neon Console.
• UI: Added badges for various elements on the branch details page in the Neon Console.
• UI: Fixed an issue that prevented project and endpoint statuses from being updated when making changes.

Fixes & improvements

• Pageserver, Safekeeper, Compute, and Proxy: Reduced the size of Neon storage binaries by 50% by removing dependency debug symbols from the release build.
• Pageserver: Moved the Write-Ahead Log (WAL) redo process code from Neon's postgres repository to the neon repository and created a separate wal_redo binary in order to reduce the amount of change in the postgres repository codebase.
• Compute: Updated prefetching support to store requests and responses in a ring buffer instead of a queue, which enables using prefetches from many relations concurrently.
• Pageserver and Safekeeper: Removed support for the --daemonize option from the CLI process that starts the Pageserver and Safekeeper storage components. The required library is no longer being maintained and the option was only used in our test environment.
• Pageserver: Added a tenant sizing model and an endpoint for retrieving the tenant size.

Support for more regions

Added support for the US East (Ohio), Europe (Frankfurt), and Asia Pacific (Singapore) regions, allowing you to create Neon projects closer to your application servers. For more information about Neon's region support, see Regions.

Branching enhancements

Updated Neon's branching capabilities. The following enhancements were introduced:

• Added a Branches page to the Neon Console for creating and managing branches.
• Each project now has a root branch called main.
• Branches now belong to a project. You can create a branch from your project's root branch (main) or from another branch in the project.
• You can now define the data to include in a branch. You can include all data up to the current point in time or up to a past point in time.
• Each branch is now created with a named endpoint, which is the compute instance associated with a branch. Connecting to a branch requires connecting to the branch's endpoint. You can obtain a connection string for a branch endpoint from the Connection Details widget on the Neon Dashboard.

For more information about Neon's branching capabilities, see Branching, and Manage branches.

Neon Branching capabilities are not yet publicly available. If you would like to try this feature, contact us at iwantbranching@neon.tech, describing your use case and requesting that Neon enable branching for your account.

Connection string changes

With the addition of support for new regions and updates to Neon's branching capabilities, changes were made to the hostname in Neon connection strings. Previously, a hostname had this format: <project_id>.cloud.neon.tech. With the introduction of new regions, a <region_slug> and <platform> value were added to the hostname for projects created in newly supported regions. With the update to branching capabilities, <project_id> was replaced by <endpoint_id>. As a result of these changes:

• Projects created in the original Neon region, US West (Oregon), have this hostname format: <endpoint_id>.cloud.neon.tech.
• Projects created in the newly supported regions, have this hostname format: <endpoint_id>.<region_slug>.<platform>.neon.tech.

The old hostname format continues to be supported for projects created before these changes were introduced.

Postgres keyword highlighting

Added highlighting support for Postgres 15 SQL Keywords to Neon's SQL Editor. Keywords are highlighted when entered in the SQL Editor.

Fixes & improvements

• Control Plane: Improved handling of OAuth consent challenges. A user is now directed to the destination URL to complete the login or consent request instead of receiving a 410 Gone error when resubmitting an OAuth consent challenge.
• Control Plane: Fixed memory leaks that could occur for background operations started in a context that does not expire. An operation failure could have resulted in resources not being cleaned up.
• UI: Added the ability to display the navigation bar at the top of the Neon Console as a side drawer menu on small screens.
• UI: Fixed an issue in the SQL Editor that prevented errors from being reported when rerunning multi-statement queries.
• UI: Updated the .pgpass configuration instructions provided after creating a project or resetting a password. The instructions did not include the required Postgres port number.

Fixes & improvements

• Compute: Added support for Postgres 15.0 and its Postgres extensions. For information about supported extensions, see Available Postgres extensions.
• Compute: Disabled the wal_log_hints parameter, which is the default Postgres setting. The Pageserver-related issue that required enabling wal_log_hints has been addressed, and enabling wal_log_hints is no longer necessary.
• Pageserver: Added a timeline state field to the TimelineInfo struct that is returned by the timelines internal management API endpoint. Timeline state information improves observability and communication between Pageserver modules.

Fixes & improvements

• Compute: Fixed an issue that prevented creating a database when the specified database name included trailing spaces.
• Pageserver: Fixed an INSERT ... ON CONFLICT handling issue for speculative Write-Ahead Log (WAL) record inserts. Under certain load conditions, records added with INSERT ... ON CONFLICT could be replayed incorrectly.
• Pageserver: Fixed a Free Space Map (FSM) and Visibility Map (VM) page reconstruction issue that caused compute nodes to start slowly under certain workloads.
• Pageserver: Fixed a garbage collection (GC) issue that could lead to a database failure under high load.
• Pageserver: Improved query performance for larger databases by improving R-tree layer map search. The envelope for each layer is now remembered so that it does not have to be reconstructed for each call.

Fixes & improvements

• Compute: Added support for a future implementation of sequential scan prefetch, which improves I/O performance for operations such as table scans.
• Compute: Moved the backpressure throttling algorithm to the Neon extension to minimize changes to the Neon Postgres core code, and added a backpressure_throttling_time function that returns the total time spent throttling since the system was started.
• Compute: Added support for the h3_pg and plv8 Postgres extensions. For information about Postgres extensions supported by Neon, see Postgres extensions.
• Pageserver: Increased the default compaction_period setting to 20 seconds to reduce the frequency of polling that is performed to determine if compaction is required. The frequency of polling with the previous setting of 1 could result in excessive CPU consumption when there are numerous tenants and projects.
• Pageserver: Added initial support for online tenant relocation.
• Pageserver: Added support for multiple Postgres versions.
• Proxy: Improved error messages and logging.

Fixes & improvements

• Control Plane: The availability checker now waits for the project operations queue to clear before starting.
• Control Plane: Operations for redo are now selected based on the correct status.
• Control Plane: The V2 branch creation endpoint is now accessible using an OAuth token.
• Integrations: Added OAuth support for Hasura users, enabling seamless authentication with Neon from Hasura Cloud. To learn more about connecting from Hasura Cloud to Neon, see Connect from Hasura Cloud to Neon.
• UI: The Database drop-down menu in the Connection Details widget on the Dashboard and in the Neon SQL Editor now permits selecting any created database.

Fixes & improvements

• API: Added a protected: boolean flag to the roles public API response.
• API: Changed region and platform ids from serial numbers to strings in the public API.
• API: Changed the operations id from a serial number to a UUID type in the public API.
• Control Plane: Added an internal mechanism for relocating projects between Pageservers.
• Control Plane: Stopped sending metrics to Grafana Cloud.
• Control Plane: Removed usage of the obsolete zenith_ctl binary.
• Control Plane: Split the monolithic project object into project, branches, and endpoints in the internal database schema.
• Control Plane: Fixed a passwordless auth issue that occurred when creating a new project using the project selection interface.
• Integrations: Added read, update, delete project access scopes for OAuth applications.
• Integrations: Added the ability to select access scopes and projects on the OAuth consent page.
• UI: Fixed a failure that occurred after receiving an empty response in the SQL Editor.
• UI: Fixed an issue to ensure that table names are reset when switching between schemas on the Tables page in the Neon Console.

Fixes & improvements

• Control Plane: Fixed authentication of concurrent proxy connections to an idle compute node. Previously, one of the concurrent proxy connection attempts would fail with a Failed to connect to the compute node error.
• UI: Added functionality that enables providing an OAuth app name to a client.
• UI: Fixed the title on the 'Sign in' page.
• UI: Changed the Postgres version displayed on the project dashboard to 14.5.

Fixes & improvements

• Compute: Updated the Postgres version to 14.5.
• Compute: Added support for the PostGIS extension, version 3.3.0. For information about Postgres extensions supported by Neon, see Postgres extensions.
• Proxy: Added support for forwarding the options, application_name, and replication connection parameters to compute nodes.

Fixes & improvements

• Control Plane: Implemented OAuth backend support and OAuth consent screens, which enable granting OAuth applications permission to create projects on behalf of users. Services interested in OAuth integration with Neon should contact partnerships@neon.tech.
• UI: Fixed the syntax highlighting for Golang snippets.
• UI: Fixed styles for smaller screens.

Fixes & improvements

• UI: Added a Submit Feedback feedback form to the Neon Console. The form is accessible from the Help menu.
• UI: Fixed a CORS error for API requests in the Swagger UI. The error occurred when using the 'Try it out' feature.

Fixes & improvements

• Control Plane: Added the ability to select Safekeepers from different availability zones for new projects.
• UI: Added a Tables page to the Neon Console for viewing database schemas and tables. Drop-down menus permit navigating between project databases. Table data can be viewed by selecting the table from the sidebar.
• UI: Added a Help menu to the Neon Console which provides links to various user assistance resources.
• UI: Fixed the .pgpass password file instructions that are presented when resetting a password #1825.
• UI: Added validation messages to the Project Creation dialog.
• UI: Fixed broken links in the Neon onboarding section of the Neon Console.
• UI: Updated the email addresses presented in the UI for requesting branching capabilities and support. The email address for requesting access to branching is iwantbranching@neon.tech. The email address to request support is support@neon.tech.

Fixes & improvements

• Control Plane: Set max_replication_write_lag to 15 MB to tune the backpressure mechanism and improve PostgresSQL responsiveness under load.
• Control Plane: Improved the ability to investigate performance issues by collecting and saving more detailed compute node startup time metrics.
• UI: The Neon SQL Editor now maintains a history of previously executed queries and permits saving queries. For more information about these capabilities, see Query with Neon's SQL Editor.
• UI: Added token-based authorization to Neon's public API.
• UI: Changed the display status of operations waiting in the queue from In progress to Scheduling.
• UI: Disabled controls that incorrectly remained enabled while the Neon project was in a transitive state.
• UI: Fixed incorrect encoding when switching between code samples in the Connection Details widget on the project Dashboard, and added descriptions to connection string examples.
• UI: Fixed various typos and errors.

Fixes & improvements

UI: Fixed an issue that prevented project status updates from being communicated to the Neon Console. Prior to this fix, the previous project status was reflected in the Neon Console until the page was reloaded.

Fixes & improvements

• Control Plane: Added a new version of the operations executor that includes various stability and observability improvements.
• Control Plane: Compute node logs are now dumped if the startup process fails.
• Control Plane: Added support for deleting timeline data from all storage nodes (Safekeepers and Pageserver) after project deletion.
• UI: Added validation to ensure that the API key Name field is not left blank when creating a new API Key on the Developer Settings page. For information about API keys, see Manage keys.
• UI: Added a Create branch button to the project Dashboard for selected users. To request early access to Neon branching capabilities, send an email to iwantbranching@neon.tech.
• UI: Added a detailed error message to the Neon SQL Editor for failed queries.

Fixes & improvements

• Compute: Installed the uuid-ossp extension binaries, which provide functions for generating universally unique identifiers (UUIDs). CREATE EXTENSION "uuid-ossp" is now supported. For information about extensions supported by Neon, see Available Postgres extensions.
• Compute: Added logging for compute node initialization failure during the 'basebackup' stage.
• Pageserver: Avoided busy looping when deletion from cloud storage is skipped due to failed upload tasks.
• Pageserver: Merged the 'wal_receiver' endpoint with 'timeline_detail', in the internal management API.
• Pageserver: Added reporting of the physical size with the tenant status, in the internal management API.

Fixes & improvements

• API: Changed the error reported when a concurrent operation on a project prevents acquiring a project lock. Error 423 Locked is now reported instead of 409 Conflict.
• Control plane: Implemented the usage of several instances for serving the public API and web UI to enable zero-downtime deployments.
• UI: Added an Enable pooling toggle to the project General setting page, which permits enabling or disabling connection pooling for a project. For more information about Neon connection pooling support, see Connection pooling.

Fixes & improvements

• Compute: Enabled the use of the CREATE EXTENSION statement for users that are not database owners.
• Compute: Updated the Postgres version to 14.4.
• Compute: Renamed the following custom configuration parameters:
  • zenith.page_server_connstring to neon.pageserver_connstring
  • zenith.zenith_tenant to neon.tenant_id
  • zenith.zenith_timeline to neon.timeline_id
  • zenith.max_cluster_size to neon.max_cluster_size
  • wal_acceptors to safekeepers
• Control Plane: Renamed zenith_admin role to cloud_admin.
• Pageserver: Implemented a page service fullbackup endpoint that works like basebackup but also sends relational files.
• Pageserver: Added support for importing a base backup taken from a standalone Postgres instance or another Pageserver using psql copy.
• Pageserver: Fixed the database size calculation to count Visibility Maps (VMs) and Free Space Maps (FSMs) in addition to the main fork of the relation.
• Pageserver: Updated the timeline size reported when DROP DATABASE is executed.
• Pageserver: Decreased the number of threads by running gc and compaction in a blocking tokio thread pool.
• Pageserver: Switched to per-tenant attach/detach. Download operations of all timelines for one tenant are now grouped together so that branches can be used safely with attach/detach.
• Proxy: Added support for propagating SASL/SCRAM Postgres authentication errors to clients.
• Safekeeper: Added support for backing up Write-Ahead Logs (WAL) to S3 storage for disaster recovery.
• Safekeeper: Added support for downloading WAL from S3 storage on demand.
• Safekeeper: Switched to etcd subscriptions to keep Pageservers up to date with the Safekeeper status.
• Safekeeper: Implemented JSON Web Token (JWT) authentication in the Safekeeper HTTP API.
• Safekeeper: Fixed the walreceiver connection selection mechanism:
  • Reconnecting to a Safekeeper immediately after it fails is now avoided by limiting candidates to those with the fewest connection attempts.
  • Increased the max_lsn_wal_lag default setting to avoid constant reconnections during normal work.
  • Fixed wal_connection_attempts maintenance, preventing busy reconnection loops.

Fixes & improvements

• API: Added a pooler_enabled property to the project update API call to indicate whether or not connection pooling is enabled.
• API: Fixed several bugs that could cause intermittent 409 responses, which indicate a request conflict with the current state of the target resource.
• Control Plane: Implemented connection pooling support for Neon projects, allowing Neon to support a greater number of connections. For information about enabling connection pooling for a Neon project, see Connection pooling.

Fixes & improvements

• API: Changed the user_id type from int64 to uuid.
• API: Implemented a unified JSON error response where possible, in the format of { "message": "error text" }.
• API: Made platform, region, and instance_type ids optional during new project creation.
• Control Plane: Fixed an issue that allowed the web_access system role to be modified or deleted, which could affect the functioning of the Neon SQL Editor.
• UI: The Neon Technical Preview invite code is now requested only at the first login.
• UI: Added a cover to password fields to protect passwords from view. Passwords are presented to users after performing actions such as creating a project, creating a user, or resetting a password.