Changelog

Monitor queries in the Neon Console

Currently available to members in our Early Access Program, you can now monitor your active queries and query history from the Monitoring page in your Neon project.

• The Active Queries view displays up to 100 currently running queries for the selected Branch, Compute, and Database.
• The Query History view shows the top 100 previously run queries for the selected Branch, Compute, and Database. Queries can be sorted by Frequency or Average time.

For more about these new monitoring options, see Monitor active queries and Monitor query history.

Save your connection details to 1Password

If you've got the 1Password browser extension, you can now save your database connection details to 1Password directly from the Neon Console. In your Project Dashboard, click Connect, then click Save in 1Password.

Renamed Neon Authorize to Neon RLS Authorize

We've renamed our JWT-based authorization feature to Neon RLS Authorize to better reflect its core value: connecting your authentication provider's JWTs with Postgres Row-Level Security (RLS) policies. You can now find this feature under Settings > RLS Authorization in the Neon Console.

Learn more about Neon RLS Authorize or try our tutorial.

Renamed Neon Identity to Neon Auth

We've also renamed our Early Access auth integration feature to Neon Auth. Neon Auth lets you automatically sync user profiles from your authentication provider to your database. Learn more about it in Neon Auth.

Or sign up to the Early Access Program to try it out.

Scheduled updates on Free & coming soon to Launch and Scale

Two weeks ago, we announced scheduled updates for Neon, including Postgres version upgrades, security patches, and Neon feature enhancements.

This week, we introduced the Updates page in your Project Settings. Free Plan users get update notices 24 hours in advance. Updates, which take only a few seconds, are applied at the scheduled time or the next time your compute restarts.

Launch and Scale Plan users will start seeing update notices in another week or so. We aim to provide 7 days' notice for updates on paid plans. Paid users can also choose a preferred update window — you can do that now, well ahead of any planned updates.

We also support checking for scheduled updates using the Neon API.

For more information about scheduled updates, see our Updates documentation. If you have questions, please reach out to us on Discord or contact Neon Support.

The Neon Slack App is available for early access

The Neon Slack App helps you stay connected to your Neon Serverless Postgres databases. Here's what you can do with it:

• 📈 Track compute and storage usage in real time
• 🔔 Get alerts when your database approaches its performance limits
• 🟢 Quickly check the Neon platform's status

We’d love to hear your feedback. Use the /neon feedback command in Slack to share your thoughts and feature requests.

👉 See the documentation for setup instructions.

Scheduled updates on the Free Plan starting soon

Last week, we announced that Neon is introducing scheduled updates, starting with Free Plan accounts. These updates include Postgres version upgrades, security patches, and Neon feature enhancements. Your project's computes will be updated automatically at a scheduled date and time. While updates need a compute restart, it only takes a few seconds to complete.

Free Plan accounts will start seeing update notices in their projects' settings on a new Updates page in early February, at least 24 hours before any scheduled update.

Update notices for Neon's paid plans will start rolling out in the second week of February, with at least 7 days' notice before a planned update.

Stay tuned for more details.

Protect sensitive data with schema-only branches

You can now create schema-only branches that copy just the database schema from a source branch — without any data. This is ideal for working with confidential information. Instead of copying sensitive data, create a branch with just the database structure and add your own randomized or anonymized test data. It's a secure and compliant way for your team to develop and test using Neon branches.

To learn more, see Schema-only branches.

Schema-only branches are currently available through our Early Access Program. Learn how to join.

Project-scoped API keys from the Console

Recently, we added support for project-scoped API keys for your Neon Organization. These keys provide member-level authorization, scoped to a particular project. First available only via API, you can now create them from the Neon Console as well, for better visibility and management.

Learn more about creating project-scoped API keys.

Support for the postgres_fdw extension

Neon now supports the postgres_fdw (foreign data wrapper) extension. This extension lets you integrate with remote Postgres databases by defining foreign tables that map to tables in external databases. You can then query remote data as if it were stored locally. Check out our guide to learn more.

pg_cron is now available for all users

The pg_cron extension is now available to everyone using Neon. Before, you needed a paid plan and help from Neon Support to use it. See Enable the pg_cron extension to get started.

Neon Chat for Visual Studio Code

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.

Give it a try at https://www.instagres.com/ or by running npx instagres in your terminal.

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.

To learn more, read the blog post.

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.

Neon Copilot Extension

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

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

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

Setup instructions:

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

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

Schema Diff API

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

Example:

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

For detailed documentation, see Using the Schema Diff API.

Postgres extension updates

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

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

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

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

🎉 Happy New Year, everyone! 🎉

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

Postgres 17 for newly created Neon projects

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

Support for pg_cron

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

Higher connection limits for autoscaling configurations

In Postgres, the max_connections setting controls the maximum number of simultaneous client connections the database server can handle. In Neon, this setting is configured based on your compute size configuration. Previously, with Neon's autoscaling feature, max_connections was defined by your minimum compute size only. To provide more available connections, max_connections is now set according to both your minimum and maximum compute size, allowing for much larger connection limits. For more information about how max_connections is configured for your Neon computes, see Parameter settings that differ by compute size.

PgBouncer default_pool_size now scales

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

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

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

Neon Identity is now available in Early Access

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

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

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

Check out our docs to learn more.

Currently supporting Stack Auth, more providers coming soon.

More support for AI agents

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

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

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

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

Neon Auth.js adapter

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

"Perplexity mode" for the Docs

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

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

Click Ask Neon AI to try it out.