The pg_repack extension is now available in Neon. This extension helps remove bloat from tables and indexes while optionally restoring the physical order of clustered indexes — all without requiring an exclusive lock during processing.
Rate limiting for Neon public API. To ensure stability and fair usage, we’ve introduced per-project rate limits to the Neon public API. This change helps prevent accidental overloads or excessive API calls that could disrupt service for other users. While most users won’t notice a difference, if your project exceeds the limit you'll receive clear error messages with retry details.
Neon API
FF: We added a new endpoint for deploying a Neon Identity integration programmatically. Neon Identity lets you sync user profiles from your auth provider directly to your database. Join the Early Access Program to try it out. Sign up here.
The Neon Chat for Visual Studio Code extension is now available in the GitHub Marketplace. This AI-powered assistant lets you chat with the latest Neon documentation without leaving your IDE.
Get answers to common questions like:
How to create a project?
How can I get started with the Neon API?
How do I create a branch using the Neon CLI?
Scheduled updates coming soon 📅
Neon is introducing scheduled updates, starting with Free Plan accounts and later expanding to Paid Plans. These updates will cover Postgres updates, security patches, and Neon feature enhancements, automatically applied to your project's computes. Here's what to expect:
Updates aren’t new, but now they’ll be scheduled so you’ll know when they’re coming and won't fall behind on important maintenance.
Updates require a compute restart, but restarts are quick and automatic — taking just a few seconds.
If your computes scale to zero & restart regularly, available updates will be applied on compute restart, removing the need for "scheduled" updates.
You’ll be able to track scheduled updates in your project settings.
Free Plan accounts will have updates scheduled in advance for a specific day and time, while Paid Plan accounts will be able to choose a preferred update window.
Stay tuned for specific details about when scheduled updates will roll out. Free Plan users can expect to see scheduled updates first, starting in early February. Scheduled updates on Paid Plans will roll out later, with updates for large compute sizes (> 8 CU) rolling out last.
Connect to external Postgres databases with the dblink extension
Neon now supports accessing external Postgres databases using the dblink extension. dblink lets you easily connect to other Postgres databases and run queries on them. It's a good choice for quick, one-off queries or situations where you need data from a remote database but don’t want to configure a foreign data wrapper.
Support for the pg_repack extension
The Postgres pg_repack extension is now available on paid Neon plans upon request. This extension helps you remove bloat from tables and indexes while optionally restoring the physical order of clustered indexes — all without requiring an exclusive lock during processing. This extension is currently available only on paid Neon plans. To enable pg_repack, open a support ticket and include your endpoint ID and the database name where you'd like the extension enabled.
Meet "Instagres": No signup, instant Postgres ✨
Neon's architecture lets us do some pretty interesting things, like creating a Postgres database in less than a second (AI agents loves this, btw). To showcase this ability, we've built "Instagres," an app that lets you generate a Postgres database URL almost instantly — no sign up required. If you'd like to keep the database for more than an hour, you can transfer it to your Neon account.
The "Instagres" app is powered by Cloudflare, React Router, and DrizzleORM.
If you like this feature or see different use cases for it, please let us know via the Feedback form in the Neon Console or our feedback channel on Discord.
Pooled connection strings are now default in the Neon Console
Pooled connection strings are now the default in the Connection Details widget in the Neon Console. Pooled connection strings include a -pooler option, which directs connections to a pooled connection port powered by PgBouncer. With support for up to 10,000 concurrent connections, connection pooling improves performance, reduces latency, and makes resource management more efficient for most applications. For specific tasks like pg_dump and other session-dependent operations like schema migrations, you can still get direct connection string at any time by disabling the connection pooling toggle in the Connection Details widget or by removing -pooler from your connection string manually.
A new version of the Neon Python SDK
Neon's Python SDK, which is a wrapper for the Neon API, has been updated to a new version (0.3.0). This new version updates the Python data types from Neon's API schema.
This SDK simplifies integration of Python applications with Neon by providing methods to programmatically manage Neon API keys, projects, branches, databases, endpoints, roles, and operations.
Fixes & improvements
Drizzle Studio update
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated to version 1.0.11. For the latest improvements and fixes, see the Neon Drizzle Studio Integration Changelog.
Console updates
Increased concurrency limits. Last week we announced increased Neon API operation concurrency limits on Neon's Free, Launch, and Scale plans. This enhancement is now supported on all Neon plans.
As noted in last week's changelog: Previously, concurrent API operations within a Neon project — such as operations on different branches — could trigger a "project already has running operations" error, where one branch operation would block others. This improvement reduces the need to work around strict concurrency limits. However, we still recommend adding retry functionality to handle rare cases where an API operation fails due to ongoing operations.
This change applies only to the Neon API. In the Neon Console, controls such as buttons that initiate new operations are still briefly disabled until ongoing operations are complete. Concurrency improvements will be reflected in the UI in a future release.
Fixes
Fixed an issue with the Create branch button in the Neon Console. Previously, the button became disabled for unfinished project operations, including those that failed due to an error. Now, the button is disabled only for project operations in the canceling, running, or scheduling state.
Neon Copilot Extension
The Neon Database Copilot Extension is now available in the GitHub Marketplace. This extension makes it easier to configure Neon for your repository. You can chat with the latest Neon documentation within the context of your repository!
Chat with curated Neon database documentation directly in GitHub Copilot and get answers to common questions like:
How to create a project?
How can I get started with the Neon API?
How do integrate the Neon API into my GitHub repository.
Setup instructions:
Install the extension
Type @neondatabase in the chat to start interacting
Coming soon, you'll be able to directly interact with Neon endpoints by simply asking questions. Additionally, new tools will enable you to create Neon databases directly from the chat interface.
Schema Diff API
Rounding out our schema diff features, Neon now supports a schema diff API endpoint (compare_schema), enabling programmatic comparison of database schemas between Neon branches. This addition complements our existing Schema Diff features available in the Console, CLI, and GitHub Action.
The pg_mooncake extension has been updated to version 0.1.0. For details about this release, see the release page.
To use the pg_mooncake extension with Neon, check out our pg_mooncake guide for more information.
To upgrade from a previous version of the extension, follow the instructions in Update an extension version.
The pg_embedding extension, deprecated in September 2023, has been removed from Neon. This extension supported the Hierarchical Navigable Small World (HNSW) algorithm for vector similarity search in Postgres. HNSW support is now available in the pgvector extension, which is also supported by Neon.
Fixes & improvements
Drizzle Studio update
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated. For the latest improvements and fixes, see the Neon Drizzle Studio Integration Changelog.
Console updates
Enhanced pagination controls on the Branches page now let you adjust rows per page and skip directly to first/last pages.
Billing period dates in the console are now consistently shown in UTC format. Previously, these dates were sometimes shown incorrectly due to timezone conversions.
The Datadog integration is now accessible from both the Integrations and Monitoring pages for all users, with availability based on your plan.
The Trust Center is now accessible from the Help Menu (?) in the Neon Console. Here you can learn about our security practices and access security documentation.
Neon API
The Create project API now defines Postgres 17 as the default version.✨
Increased concurrency limits. We've increased Neon API operation concurrency limits. Previously, concurrent API operations within a Neon project — such as operations on different branches — could trigger a "project already has running operations" error, where one branch operation would block others. This improvement reduces the need to work around strict concurrency limits. However, we still recommend adding retry functionality to handle rare cases where an API operation fails due to ongoing operations.
This enhancement is available on Neon's Free, Launch, and Scale plans and will soon roll out to all Neon plans. It applies only to the Neon API. In the Neon Console, controls such as buttons that initiate new operations are still briefly disabled until ongoing operations are complete.
We’ve added a new API endpoint to help you retrieve the total number of branches in a project. Use the following request to get the branch count for any project:
GET /api/v2/projects/{project_id}/branches/count
Example response:
{ "count": 2}
Neon CLI
The Neon CLI now creates projects with Postgres 17 by default ✨
Fixes
Data sizes are now displayed as kB, MB, GB (instead of KiB, MiB, GiB) across our console, docs, and website.
Restored the ability for Enterprise customers to set custom scale-to-zero timeout periods.
Replaced incorrect "insufficient permissions" message with a loading indicator when Organization admins open a project's Delete page.
Prevented duplicate installations of the Neon GitHub integration for organizations and personal accounts.
🎉 Happy New Year, everyone! 🎉
We're excited to kick off 2025 and let you know that we're shipping again! 🚢 Here's to an amazing year ahead. Let's go!
Postgres 17 for newly created Neon projects
Postgres 17 is now the default for newly created Neon projects. Neon continues to support Postgres 14, 15, and 16, if you prefer to stick with those. For Neon's Postgres version support policy, see Postgres Version Support.
Support for pg_cron
The Postgres pg_cron extension is now available on paid Neon plans upon request. This extension lets you schedule and manage periodic jobs directly in your Postgres database. To enable pg_cron, open a support ticket and include your endpoint ID and the database name where you'd like the extension enabled. Once added, you'll need to restart your compute to make it available.
Higher connection limits for autoscaling configurations
In Postgres, the max_connections setting controls the maximum number of simultaneous client connections the database server can handle. In Neon, this setting is configured based on your compute size. With Neon's autoscaling feature, max_connections is now defined by your maximum compute size rather than your minimum compute size.
This change significantly increases connection limits for autoscaling configurations. For example, consider an autoscaling configuration with these minimum and maximum compute sizes:
Minimum: 2 CU compute size — supports up to 901 connections
Maximum: 8 CU compute size — supports up to 3604 connections
Previously, this autoscaling configuration of 2 CU ↔ 8 CU was limited to 901 connections. Now, the same configuration allows up to 3604 connections. In this case, a 4-fold increase!
PgBouncer default_pool_size now scales
Neon supports connection pooling with PgBouncer. Previously, Neon's PgBouncer configuration set the default_pool_size to a fixed value of 64, which limited Postgres connections to 64 per user/database pair, regardless of the compute size.
Now, the default_pool_size is dynamically set to 0.9 * max_connections, enabling significantly more concurrent Postgres connections per user/database pair. Note that larger compute sizes benefit from higher max_connections limits, which result in a proportionally larger default_pool_size.
For example, on an 8 CU compute with a max_connections limit of 3604, the default_pool_size increases from 64 to 3243 (0.9 × 3604).
Neon Identity is now available in Early Access
We're excited to announce Neon Identity, a new feature that automatically syncs user profiles from your auth provider straight to your Neon database. Eliminate custom integration code and focus on building.
With Neon Identity, user profiles are synchronized to the neon_identity.users_sync table, making it easy to access user data without additional configuration.
Join the Early Access Program to try it out. Sign up here.
Currently supporting Stack Auth, more providers coming soon.
More support for AI agents
Neon is now available as a tool for AI agents on both AgentStack and Composio.
AgentStack lets you create AI agent projects from the command line. The Neon tool allows agents to create ephemeral or long-lived Postgres instances for structured data storage. View the Neon tool here to see how an AI agent can create a Neon database in less than 500 ms, connect to the database, and run SQL DDL and DML statements.
@tool("Create Neon Project and Database")def create_database(project_name: str) -> str: """ Creates a new Neon project. (this takes less than 500ms) Args: project_name: Name of the project to create Returns: the connection URI for the new project """ try: project = neon_client.project_create(project={"name": project_name}).project connection_uri = neon_client.connection_uri( project_id=project.id, database_name="neondb", role_name="neondb_owner" ).uri return f"Project/database created, connection URI: {connection_uri}" except Exception as e: return f"Failed to create project: {str(e)}"
Composio lets you connect 200+ tools to AI Agents — and it now supports Neon, enabling full integration between LLMs and AI agents and Neon's API. You can find the integration here.
Neon Auth.js adapter
We've introduced an Auth.js adapter for Neon, which enables storing user and session data in your Neon database. For adapter installation and setup instructions, see Neon Adapter in the Auth.js docs.
"Perplexity mode" for the Docs
We’ve added an AI-powered "perplexity mode" to the Neon Docs site, providing a conversational interface to quickly get the answers you need.
Our AI chat assistant is built on various sources including the Neon Docs, the Neon Discord Server, and API docs — and it's updated daily.
Click Ask Neon AI to try it out.
Fixes & improvements
Drizzle Studio update
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated. For the latest improvements and fixes, see the Neon Drizzle Studio Integration Changelog.
Console updates
We adjusted billing period start dates in the console to use UTC time. Previously, timezone differences could cause the start date to display as the last day of the previous month.
Private Networking
Fixed an issue where invalid VPC endpoint IDs would not be deleted. Invalid endpoint IDs are now transitioned to a deleted state after 24 hours and automatically removed at a later date.
Neon API
The List branches endpoint now supports sorting and pagination with the addition of sort_by, sort_order, limit, and cursor query parameters. The sorted by options include updated_at, created_at, or name, and sort_order options include asc and desc. After an initial call, pagination support lets you list the next or previous number of branches specified by the limit parameter.
Neon API Client
The TypeScript SDK for the Neon API was updated to a new version (1.11.4). The new version adds support for creating organization API keys.
Logical Replication
Before dropping a database, Neon now drops any logical replication subscriptions defined in the database.
Fixes
Fixed an issue that permitted installing the Neon GitHub integration for organizations or personal accounts where the integration was already installed.
Wrapping up 2024
As 2024 comes to a close, we focused on fixes and improvements this past week. But don’t worry — new features are already in development, and exciting updates are coming soon. We’re looking forward to sharing what’s coming in the new year, and there might even be a few interesting announcements before then. Stay tuned!
Upgrading to the latest Neon CLI version
If you use the Neon CLI, here’s a friendly reminder to upgrade to the latest version. The current version is 2.6.0, and all users should now be on a 2.x version. You can check your Neon CLI version with the following command:
If you use the Neon CLI in CI/CD tools like GitHub Actions, you can safely pin it to @latest, as we prioritize stability for CI/CD processes. For example, in a GitHub Actions workflow, you can install the latest version with npm:
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated. For the latest improvements and fixes, see the Neon Drizzle Studio Integration Changelog.
Console updates
Added a link to the Neon API Reference in the information resources menu of the console.
The Support ticket modal now supports file attachments in the Neon Console. Attachments must not exceed 5 MB.
You can now sort columns in the branches table on the Branches page.
The organization account project page now includes an Integrations column in the projects table for viewing and adding integrations.
Neon Authorize
It just keeps getting better. Drizzle ORM introduced a new with db.$withAuth method, offering a more convenient way to include user JWTs in queries to Neon.
return db .$withAuth(authToken) .select() .from(schema.todos) .where(eq(schema.todos.userId, sql`auth.user_id()`)) .orderBy(asc(schema.todos.insertedAt));
Users of the native Neon integration in Vercel can now view the Archive storage metric on the Usage page under the Storage tab in the Vercel Dashboard. For more details about archive storage in Neon, see Branch archiving.
Neon's IP Allow feature is now available for Vercel-managed organizations. This feature is supported on Neon Scale and Business plans.
Azure Integration
Support is now available for transferring projects from Neon personal accounts to Azure-created Neon organizations. Project transfers are only supported for Neon projects created in an Azure region. For more details, see Transfer Neon projects to an Azure-created Neon organization.
Neon API
We added 204 response definitions to DELETE endpoints for scenarios where a branch, database, role, or endpoint does not exist or has already been deleted. A 204 response code indicates a successful operation that does not return content.
Fixes
Fixed an issue in the console where an error toast was not displayed when offline or when the server was unreachable. A Network error is now returned in such cases.
Corrected a usability issue where the Project Creation modal defaulted to an error state, requiring users to adjust autoscaling settings before creating a project.
Resolved an issue where users encountered a confusing error message when attempting to link a Microsoft account already logged in with the same email.
Fixed a drag-to-zoom failure on Monitoring page graphs that occurred when dragging from left to right and releasing the cursor outside of the graph area.
Fixed an issue preventing the addition of a read-write compute to a branch if another branch in the project had a read-write compute.
Addressed a Something went wrong error in the console related to the loading of an organization account.
Fixed an issue that prevented Ctrl+C query cancellation requests for connections using passwordless authentication.
Larger compute sizes are here
We’ve added support for larger compute sizes:
Neon's autoscaling feature now supports a maximum setting of 16 vCPU. Compute sizes larger than 8 vCPU are available on our Business and Enterprise plans.
Neon's Business and Enterprise plans now support fixed compute sizes up to 56 vCPU. Autoscaling is not yet supported for compute sizes larger than 16 vCPU but reach out to us if you'd like to extend your limit beyond that.
Project-scoped API keys
We now support per-project API keys, offering you finer-grained access control by limiting an API key's permissions to a particular project. This applies to organization-owned projects only — when creating an Organization API key, include the project ID in the request and the resulting key will be scoped to just that project. This key grants member-level permissions only, preventing destructive actions like deleting the project.
Introducing psql.sh: run psql directly in your browser
We're excited to launch psql.sh, a browser-based version of the PostgreSQL command-line client. This new tool lets you instantly spin up a fresh database and start running SQL queries and psql commands right in your browser.
psql.sh uses Neon's branching to create instant, isolated database environments for you to experiment with. Try it out at psql.sh, or read about how we built it in our blog post: psql from the browser.
Support for pgvector 0.8.0
Neon now supports pgvector version 0.8.0. This new version adds support for iterative index scans, casts for arrays to sparsevec, and improves the performance of HNSW inserts and on-disk HNSW index builds.
If you installed this extension previously and want to upgrade to the latest version, please refer to Update an extension version for instructions.
Fixes & improvements
Drizzle Studio update
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated. For the latest improvements and fixes, see the Neon Drizzle Studio Integration Changelog.
Console updates
Fixed scrolling issues with the SQL Editor and the branches list on the Branches page. Both vertical and horizontal scrolling now work as expected.
Fixes
Improved the custom date/time selector to default to the current time, use standardized UTC format (2006-01-02T15:04:05Z), and accept manual entries in the same format.
Fixed the Current billing for this period total displayed on the Billing summary page to correctly reflect archive storage costs and current pricing. Note this was a display issue only; actual bills were unaffected.
Neon is Now Available as an Azure Native Integration
If your company uses Azure, getting started with Neon is now easier than ever. This week, we launched Neon as an Azure Native Integration, enabling developers to deploy Neon Postgres databases directly from the Azure portal.
With this new integration, you can:
Provision and manage Neon organizations directly within Azure, using the Azure portal, CLI, or SDK.
Access Neon with your Microsoft credentials for simplified security and compliance.
Azure Germany West Central (Frankfurt) — azure-gwc
Azure West US 3 (Arizona) — azure-westus3
For a full list of regions supported by Neon, see Regions.
Support for database schema management in the Neon Console
The Tables page in the Neon Console, powered by Drizzle Studio, received a major update this week. In addition to managing your data, you can now manage your database schema directly from the Tables page. New schema management options include:
Creating, altering, and dropping schemas
Creating and altering tables
Creating and altering views
Creating enums
Refreshing the database schema
We’d love to hear your thoughts on these new capabilities! Share your feedback through the Feedback form in the Neon Console or join the conversation on Discord.
We’ve released an open-source Model Context Protocol (MCP) server for Neon, enabling any MCP Client such as Claude Desktop to interact with Neon’s API using natural language. AI agents can use our MCP server to perform actions such as creating databases, running SQL queries, and managing database migrations. For more, read the announcement and try it out on GitHub.
Archive storage on paid plans
A few weeks ago, we announced branch archiving on the Free Plan, which automatically stores inactive branches in cost-efficient archive storage. This feature is now available on our paid plans: Launch, Scale, and Business. Here’s what this means for you:
More storage and reduced storage costs: Branches older than 14 days and not accessed for 24 hours are automatically archived in cost-efficient archive storage.
New archive storage allowances by plan:
Launch: 50 GB
Scale: 250 GB
Business: 2500 GB
Billing for extra archive storage: Extra storage beyond your plan’s allowance is billed at $0.10 per GB-month. Inactive branches meeting the thresholds above will now cost less.
Monitoring archive storage usage: A new archive storage metric is available on the Billing page in the Neon Console.
Archived branch details and identification: Archived branches are marked with an archive icon in the console. The Branches page shows additional details, including the date and time a branch was archived.
Automatic archiving and unarchiving: No action is needed to archive or unarchive branches. Unarchiving happens automatically when you access a branch.
Performance considerations: You should notice little to no performance difference when connecting to or querying an archived branch, except for branches with large amounts of data where initial access may take a little longer until the branch is fully unarchived.
We reduced the cost of temporarily using more storage than is in your plan's monthly allowance. Previously, if you exceeded your storage allowance, you were allocated (and billed for) an extra storage unit at a prorated price for the rest of the month, even if the overage was brief. Now, you’re billed only for the storage you use for the length of time that you use it. This will be measured per GB-month.
Fixes & improvements
Console updates
The Monitoring page graphs now display data in the local timezone instead of UTC.
We added sorting for columns in the branches table on the Branches page. In addition, default and protected branches are always listed first, and the table now supports full keyboard navigation, allowing users to tab through table cells and rows.
Neon Authorize
Neon Authorize now supports verifying an aud (audience) claim in JWTs to limit access to specific applications or services. For providers like Firebase Auth and GCP Cloud Identity, which use the same JWKS URL across all projects, defining an intended audience is required.
Configure the audience via the Neon Authorize UI or the Neon Authorize API. This enhancement adds support for Firebase Auth and GCP Cloud Identity. See Supported providers for the full list.
Deprecated the branch_id field in the Update compute endpoint; it will be removed in a future release.
Added an archived property to the branch object in the Create branch endpoint, allowing branches to be created directly in archive storage.
Vercel Native Integration
History retention and logical replication settings are now configurable in Neon projects created in Vercel-created organizations. Previously, these settings could not be modified in Neon or Vercel.
Vercel Previews Integration
Enhanced the Vercel Previews Integration drawer to make it easier to connect Neon projects to Vercel projects.
Updated the Vercel Previews Integration drawer to display connected Vercel projects in a more compact table view when more than three projects are connected.
Fixes
Resolved an issue that blocked Schema Diff operations when other project operations were in progress. Schema Diff operations are now serialized to prevent concurrency errors.
Improved the error message in the Neon SQL Editor’s text-to-SQL AI feature when it fails to fetch the database schema.
Fixed inconsistencies in usage metrics and project allowances displayed on the Billing page in the Neon Console.
Fixed an issue that allowed selecting a future date when setting a custom period on the Monitoring page.
Neon Organizations are GA! 🎉
We're happy to announce that Neon Organizations is now generally available for everyone looking to move their teams to Neon.
Create a new organization, transfer over your projects, invite your team members and get started collaborating. The Organizations feature lets you manage all of your team's projects under a single account — with billing, role management, and project transfer capabilities in one accessible location.
See Neon Organizations to get started. Organizations is a paid account feature.
Organization API keys
Along with GA for Organizations, we're also announcing support for Organization API Keys. As an admin of an organization, you control your organization's API keys. These keys provide admin-level access to all organization resources, including projects, members, and billing information.
You can access your organization's API keys from your organization settings.
Schema Diff GitHub Action
We're also introducing our Schema Diff GitHub Action to automatically compare database schemas in your pull requests. The action posts schema differences as PR comments, making it easy to review schema changes during development. It's smart about updates, maintaining a single, updated comment as you push new commits and staying quiet when there are no differences to report. See Schema Diff GitHub Action for more details.
Index: neondb-schema.sql===================================================================--- neondb-schema.sql Branch main+++ neondb-schema.sql Branch preview/pr-9-feat/add-soft-delete@@ -111,9 +111,10 @@ title text NOT NULL, content text NOT NULL, user_id integer NOT NULL, created_at timestamp without time zone DEFAULT now() NOT NULL,- updated_at timestamp without time zone DEFAULT now() NOT NULL+ updated_at timestamp without time zone DEFAULT now() NOT NULL,+ deleted_at timestamp without time zone ); ALTER TABLE public.posts OWNER TO neondb_owner;@@ -180,5 +181,5 @@ -- -- Name: __drizzle_migrations id; Type: DEFAULT; Schema: drizzle; Owner: neondb_owner ---ALTER TABLE ONLY drizzle.__drizzle_migrations ALTER COLUMN id SET DEFAULT nextval('drizzle.__drizzle_m\ No newline at end of file+ALTER TABLE ONLY drizzle.__drizzle_migrations ALTER COLUMN\ No newline at end of file
Postgres version updates
The PostgreSQL Global Development Group has released an out-of-cycle minor version update to address regressions introduced in the previous minor version update. While Neon was unaffected by these regressions, we prioritize staying up to date with the latest version. As a result, we have updated our supported PostgreSQL versions to 14.15, 15.10, 16.6, and 17.2.
When a new minor version is available on Neon, it is applied the next time your compute restarts. For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.
Neon Private Networking (Public Beta)
Neon now offers Private Networking, enabling secure database connections via AWS PrivateLink. This feature keeps all traffic between your client application and Neon database within AWS's private network, bypassing the public internet.
Any member of an Org account can apply to participate in this Public Beta by requesting access via the Organization Settings page in the Console.
And don't forget to check out this week's fixes and improvements:
Fixes & improvements
Logical Replication
Neon now automatically removes inactive replication slots (if other active slots exist) after approximately 40 hours, up from the previous 75 minutes. This change reduces the risk of unexpected slot removal. If you've implemented measures to prevent slots from becoming inactive, you can now relax those measures accordingly.
Neon Serverless Driver
Fixed an issue with insertion of Buffer and ArrayBuffer values for BYTEA fields over HTTP. Thanks to @andyjy for the fix.
Fixed an authentication error that occurred when passing the authToken property only on the sql function.
We've added .NET to the list of supported connection strings for various languages and frameworks in the Dashboard. You can now find connection details for .NET in both the connection widget and the Quickstart.
We've added a Monitor button to each listed endpoint on your Branch details page. Click the button to open the Monitoring page, displaying metrics for this endpoint.
Added quick compute size editing directly from the Branches page — just click the size link in the primary branch column to adjust your settings.
Fixes
Improved validation of API key names and Organization names: added a 64-character length limit for API key names and Org names to the API specification and improved whitespace handling in the UI.
The Create Organization modal now correctly displays your Personal account plan when creating a new organization. Previously, it sometimes showed the plan from an existing organization instead.
When transferring a project to an organization, collaborators who are organization members are automatically removed from the project's collaborator list, as they already have access through their organization membership.
Fixed billing page display issues with project limits and usage tracking during plan changes. Previously, some organizations saw incorrect counts and misaligned indicators.
Added length validation for Organization member email addresses to prevent submission of invalid values.
A new Python SDK for the Neon API
Neon has a new Python SDK, which is a wrapper for the Neon API. This SDK simplifies integration of Python applications with Neon by providing methods to programmatically manage Neon API keys, projects, branches, databases, endpoints, roles, and operations.
It's easy to install with pip:
$ pip install neon-api
Then, from Python:
from neon_api import NeonAPI# Initialize the client.neon = NeonAPI.from_environ() or NeonAPI(api_key='your_api_key')# Get the current useruser = neon.me()print(user)
In addition to the new Python SDK, Neon offers a TypeScript SDK for the Neon API. There are also community-maintained SDKs available for Go and Node.js. Learn more.
A Migration Assistant to help move your data
When you're ready to move your data to Neon, our new Migration Assistant can help. All you need to get started is a connection string for your existing database.
Enter your current database connection string, and the Assistant will:
Run some preliminary checks on your database.
Create a Neon project that best matches your current environment.
Provide pg_dump and pg_restore commands to transfer your data, pre-populated with the correct connection strings.
This feature is currently in Beta. If you have feedback, we'd love to hear it. Let us know via the Feedback form in the Neon Console or our feedback channel on Discord.
Organization account support for Vercel and GitHub integrations
Our Vercel Previews and GitHub integrations are now supported on Organization accounts. In case you're not familiar:
The Vercel Previews Integration connects your Vercel project to a Neon database and creates a database branch with each Vercel preview deployment.
The GitHub Integration connects your Neon projects to corresponding GitHub repositories, letting you bring your database to your DevOps workflow.
You can now make both integrations available to your Neon organization.
timescaledb extension support for Postgres 17
We added support for the timescaledb extension, version 2.17.1, to Postgres 17.
For a complete list of Postgres extensions supported by Neon, see Postgres extensions.
And don't forget to check out this week's fixes and improvements:
Fixes & improvements
IP Allow
We addressed an issue for IP Allow users connecting over VPN where an Access Denied modal appeared repeatedly on the SQL Editor and Tables pages in the Neon Console. To prevent this, we added a "Do not ask again" checkbox to allow users to silence the modal.
Neon API updates
We added two new endpoints for managing Neon Organizations members:
Ephemeral compute suspend timeouts for Time Travel Assist have been increased from 10 to 30 seconds. Time Travel Assist enables querying any point in your history using temporary branches and computes, which are automatically cleaned up after use. After 30 seconds of inactivity, the branch is deleted, and the endpoint is removed.
Branch archiving on the Free Plan
On the Free plan, Neon now automatically archives any branch that is older than 14 days and has not been accessed for 24 hours.
No action is required to unarchive a branch. It happens automatically as soon as you access the branch. This change reduces storage costs and enables us to grow our Free plan even further.
We updated supported Postgres versions to 14.14, 15.9, 16.5, and 17.1, respectively.
When a new minor version is available on Neon, it is applied the next time your compute restarts (for any reason). For more about how we handle Postgres version upgrades, refer to our Postgres version support policy.
And don't forget to check out this week's fixes and improvements:
Fixes & improvements
Collation support
By default, Neon now uses the C.UTF-8 collation, which supports the full range of UTF-8 encoded characters. Previously, Neon used the C collation provided by libc by default. For more about collation support in Neon, see Collation support.
Neon API updates
Improved validation of project ID lists with the Get consumption metrics for each project endpoint. Previously, restrictive validation caused the endpoint to fail for some users.
Neon CLI enhancements
The Neon CLI was updated to version 2.4.0. For upgrade instructions, see Upgrading the Neon CLI.
The branches list command now shows a branch's Current State. Branch states include:
init - the branch is being created but is not yet available for querying.
ready - the branch is fully operational and ready for querying. Expect normal query response times.
archived - the branch is stored in cost-effective archive storage. Expect slow query response times.
neon branches list --project-id green-hat-46829796┌───────────────────────────┬──────┬─────────┬───────────────┬──────────────────────┐│ Id │ Name │ Default │ Current State │ Created At │├───────────────────────────┼──────┼─────────┼───────────────┼──────────────────────┤│ br-muddy-firefly-a7kzf0d4 │ main │ true │ ready │ 2024-10-30T14:59:57Z │└───────────────────────────┴──────┴─────────┴───────────────┴──────────────────────┘
The Updated At value was removed from the branches list command output. This value reflected internal metadata changes only and provided limited value.
Drizzle Studio update
The Drizzle Studio integration that powers the Tables page in the Neon Console has been updated to version 0.0.20. For improvements and fixes in this version, see the Neon Drizzle Studio Integration Changelog.
Fixes
Fixed an issue where users who were removed from an organization got an error page when logging in to Neon. The console was incorrectly redirecting them to the organization page, which they can no longer access. Users are now directed to their personal account Projects page instead.
When you make changes to your first or last name in Account Settings, those changes are now immediately reflected. Previously, old values could sometimes persist until the page was reloaded.
