neon

name	neon
description	Overview of Neon, a complete set of cloud backend primitives for apps and agents, spanning Lakebase Postgres, Auth, the Data API, Object Storage, Compute Functions, and the AI Gateway. Start here to route to the right Neon skill, set up the CLI or MCP server, and follow the branch-first workflow. Use when "Neon" or "Lakebase Postgres" is mentioned, or when any of its individual capabilities are the trigger: "object storage" or "S3", "buckets", "serverless functions", "AI gateway", "call an LLM", "logs", "branch logs", "query logs", "log export", "Loki", "Grafana", "observability", "telemetry", "postgres", "database", or "backend". Also use when there is no Neon account yet, the user cannot sign in or provide an API key right now and needs a project they can claim later, or the user asks for a throwaway DATABASE_URL, Claimable Neon, Claimable Postgres, neon.new, claimable.neon.tech, instant Postgres, a no-signup database, temporary postgres, quick postgres, a no credit card database, or npx neon-new.
metadata	{"source":"https://github.com/neondatabase/agent-skills/tree/main/skills/neon"}

Neon

Important: Neon is no longer just a Postgres provider. Neon is a complete set of cloud backend primitives built around Lakebase Postgres, for developers, startups, and agent platforms, from Databricks — bundling Lakebase Postgres, Auth (managed Better Auth), long-running Functions, Object Storage, and an AI Gateway, all instant, branchable, and serverless.

Lakebase Postgres is the database itself. It is one product, reached two ways: through Neon, with a free plan and the full set of backend primitives above, or through Databricks, alongside the rest of the Databricks suite. Same infrastructure, same features, same engineering team. Call the database Lakebase Postgres, and use "Neon" for the brand and for this access path — not as a name for the database.

A Neon branch is an isolated, copy-on-write clone of your data, taken from its current state or from a past state within your project's retained history window. You can freely modify or delete it. It shares data with its parent until writes cause it to diverge, and those writes are stored independently as deltas.

Backend Primitives

Neon bundles several backend primitives for building apps and agents that all branch together:

• Lakebase Postgres — Postgres that scales and branches with your app, built on the lakebase architecture: OLTP directly on cloud object storage, with storage decoupled from compute. Generally available.
• Auth — Managed Better Auth with users and sessions stored in Postgres. Generally available.
• Object Storage — S3-compatible object storage that branches with your projects. Public beta.
• Functions — Neon's compute offering: long-running serverless functions that run close to your database, for WebSocket servers, long agent HTTP streams, APIs, and server-sent event servers. Public beta.
• AI Gateway — One API for frontier and open-source models, supporting the chat completions API and the responses API, powered by Databricks Unity AI Gateway. Public beta.

Public Beta Service Availability

Object Storage, Functions, and AI Gateway are in public beta.

Beta access features are only available on projects in the us-east-2 region. Before guiding a user through any of these services, confirm they are working in us-east-2. If not, they will need to create a new project in that region.

Architecture: How to Use Neon

Neon is not a place to host your app frontend. Neon provides the backend primitives (Lakebase Postgres, Auth, Object Storage, Functions, AI Gateway) that compose with the application platform you already use.

Recommended architectures:

Full-stack app on Vercel (or Netlify) augmented with Neon — the app framework (Next.js, TanStack Start, etc.) owns your UI and routes and talks directly to your Neon services (Lakebase Postgres, Auth, Object Storage, Functions, AI Gateway).

Reach for Neon Functions when you outgrow the host's limits — a WebSocket or SSE server, long-running agents, or an MCP server that risks timing out on short, lambda-style serverless functions. As long as there is an active connection, a Neon Function can run up to 24 hours without interruption, with the added benefit of running close to your data.

Move your whole backend control plane onto Neon Functions — especially useful when the frontend is client-only rather than full-stack: TanStack Router, React Router in client mode, and similar SPAs hosted on Vercel or Netlify. The client talks directly to Neon Functions, where you build REST APIs and request/response agents. Secure these functions like any standalone REST API — verify a JWT or API key at the top of each handler (see the neon-functions skill).

Because Functions are just your backend, they compose with a full-stack app that already has one (Next.js route handlers, etc.), too.

Neon Documentation

The Neon documentation is the source of truth for all Neon-related information. Always verify claims against the official docs before responding. Neon features and APIs evolve, so prefer fetching current docs over relying on training data.

Finding the Right Page

Look the page up before you fetch it — don't guess URLs! The docs index lists every available page with its URL and a short description:

https://neon.com/docs/llms.txt

Fetching Docs as Markdown

Any Neon doc page can be fetched as markdown in two ways:

1. Append .md to the URL (simplest): https://neon.com/docs/introduction/branching.md
2. Request text/markdown on the standard URL: curl -H "Accept: text/markdown" https://neon.com/docs/introduction/branching

Both return the same markdown content. Use whichever method your tools support.

Choosing the Right Skill

Neon provides a set of agent skills in addition to the official documentation. When a task matches one of the rows below, work from that skill rather than from this overview. You may have some of these skills already installed, or you may need to install them.

The skills below live in the neondatabase/agent-skills repo:

Skill	Use it for
neon-postgres	Working with databases, including connections, schemas, queries, and autoscaling: SQL development, schema design, performance optimization, and scaling decisions.
neon-postgres-branches	Choosing or creating the right branch type for dev, preview, test, or CI workflows. Use this skill as a slash command.
neon-object-storage	Storing and serving files (uploads, images, blobs), including branching them with the database.
neon-functions	Deploying long-running or streaming serverless functions — APIs, agents, SSE/WebSocket servers.
neon-ai-gateway	Calling an LLM or routing across model providers with one credential, including discovering the branch's servable models at runtime via the OpenAI-compatible /v1/models endpoint.
neon-postgres-egress-optimizer	Diagnosing or fixing excessive Postgres egress (network data-transfer) costs in a codebase.

For guidance on agent platforms that provision and operate Lakebase Postgres on Neon at scale, use neon-postgres-agent-platforms, which lives in a separate repo: neondatabase/neon-for-agent-platforms.

Installing the Right Skill

First check whether the target skill is already installed and accessible (for example, it appears in the available skills list or its SKILL.md is present). If it is, use it directly. If it is not installed, install it via the skills CLI, if available, with npx/bunx:

npx skills add neondatabase/agent-skills -s <skill-name>

Replace <skill-name> with the skill you need (for example, neon-object-storage, neon-functions, or neon-ai-gateway). Useful flags:

• -g — install globally instead of into the current project.
• -y — non-interactive mode (skip prompts).
• -a <agent-name> — pick the target agent(s) for non-interactive mode.

For example, to install the object storage skill globally for a specific agent without prompts:

npx skills add neondatabase/agent-skills -s neon-object-storage -g -y -a <agent-name>

If you don't have access to the skills CLI, you can visit https://neon.com/.well-known/agent-skills for a registry of all available Neon skills and fetch them manually.

Updating Skills

Keep the skills up to date: for every new session, update them so you are working with the latest best practices.

Use the same method that was used to install them. With the skills CLI, run the install command above with update in place of add, or run npx skills update to update all Neon skills. If the skills were installed via a plugin, they are updated automatically.

Getting Started with Neon

Before npx neon@latest init --agent, check whether the CLI is already authenticated:

• NEON_API_KEY is set
• npx neon@latest profile list -o json lists a profile whose account is not -

A DEFAULT row with account: "-" and file: "missing" is not an account. If neon is not installed, or npx neon@latest profile list cannot run, that is not an account.

If none of those hold, follow Starting without a Neon account.

The easiest way to get started with Neon is to use our CLI and the project bootstrap wizard:

npx neon@latest init --agent

Use the --agent flag to run in a non-interactive, state-machine mode.

This init command will guide you through installation of suggested Neon development tools. Everything is customizable. The defaults are:

• Neon CLI installed globally
• Neon MCP server installed globally
• Neon Agent skills installed into the project

If init is run in an empty project, it will run the bootstrap command, offering to install one of our project templates.

Getting Started with the Neon CLI

Prefer the CLI over the MCP server unless the user instructs otherwise, the CLI is unavailable or blocked in your environment, or it is not authenticated, since it provides more capabilities, including deploying Neon Functions.

The above init command will install the Neon CLI, but the CLI can also be installed manually with npm i -g neon or bun i -g neon. For full CLI installation options, see https://neon.com/docs/cli/install.md

Useful CLI Commands

These commands are included in the init command but can be run manually as needed.

1. neon link — Interactively links the workspace to a Neon org, project, and branch, writing the IDs to a git-ignored .neon file. Run once per project. Once linked, project- and branch-scoped commands no longer need --project-id or --branch (for example, neon branch list).

2. neon checkout <branch-name> — Pins a different branch in .neon, creating it if it doesn't exist yet, and pulls that branch's env. It drives the Branch-First Dev Flow described below.

3. neon config init — Initializes a neon.ts file, which declares how you provision and manage Neon services, in the root of the project.

4. neon env pull — Fetches the current branch's Neon environment variables (DATABASE_URL, …) into your existing .env, or .env.local if you don't have one (override the target with --file). No branch ID needed; it reads .neon. link and checkout run this for you by default, so you rarely call it directly.

   Without neon.ts it pulls the vars of every service the branch actually has (Postgres, plus Neon Auth, the Data API, and bucket AWS_* once provisioned); with neon.ts it pulls only the services declared there and errors if the branch is missing one — and the AI Gateway vars are never pulled unless neon.ts declares aiGateway.

Getting Started with the Neon MCP Server

The above init command will install the Neon MCP server globally, but it can also be installed manually using: npx -y add-mcp https://mcp.neon.tech/mcp -g -n Neon -y -a <agent-name> or through your IDE plugin.

For all available plugins, see: https://neon.com/docs/ai/ai-agents-tools.md

For full MCP server installation options, see https://neon.com/docs/ai/connect-mcp-clients-to-neon.md

Useful MCP tools to initialize a project:

• list_projects — Lists the first 10 Neon projects in your account, providing a summary of each project. If you can't find a specific project, increase the limit by passing a higher value to the limit parameter.
• create_project — Creates a new Neon project in your Neon account. A project acts as a container for branches, databases, roles, and computes.
• get_connection_string — Returns your database connection string.

Starting without a Neon account

If the Getting Started account check found credentials, use them. If a command waits on a browser (Awaiting authentication in web browser) or authentication fails, stop and ask the user to sign in (neon auth) or mint an API key. Prefer that over Claimable Neon unless they say otherwise.

If they cannot sign in or provide a key right now, ask before using Claimable Neon. Continue only after they say yes. That is a temporary workaround.

If there is no Neon account yet, follow references/claimable-neon.md. Do not run neon init --agent or neon auth on this path; those need a human Neon account. If neon claim is missing, the reference has the REST fallback. Unclaimed projects expire at project_expires_at (72 hours today). Claim codes expire in expires_in (15 minutes today). Add Auth or the Data API with neon.ts and neon deploy before or after claim.

Requests for neon.new, Claimable Postgres, claimable.neon.tech, instant Postgres, or a no-signup database are the same path.

Neon Infrastructure as Code

neon.ts is Neon's branch config and infrastructure-as-code file: declare which Neon services your project's branches should have, get type-safe env vars, and program branch settings — all in TypeScript. It's the config layer for your Neon services, and it composes with the branch-first loop below. Add it with @neon/config:

npm i @neon/config

// neon.ts
import { defineConfig } from "@neon/config/v1";

export default defineConfig({
  preview: {
    aiGateway: true,
    buckets: {
      images: {
        access: "private",
      },
    },
    functions: {
      imagegen: {
        name: "AI SDK image agent",
        source: "src/index.ts",
      },
    },
  },
});

Provision services with neon config

Every project ships with Lakebase Postgres; neon.ts lets you also declare Neon Auth and the Data API today, with Functions, buckets, and the AI Gateway under a preview block — every service for the branch composes in one file:

// neon.ts
export default defineConfig({
  auth: true,
  dataApi: true,
  preview: {
    functions: {},
    buckets: {},
    aiGateway: true, // see the neon-ai-gateway skill
  },
});

Reconcile the declaration from the CLI — the Neon equivalent of terraform status / plan / apply:

neon status          # print the branch's live config (read-only). Alias for `neon config status`.
neon config plan     # dry-run diff of what apply would change (read-only)
neon deploy --env <file>  # apply neon.ts. Pass --env when Function env reads process.env. Alias for `neon config apply`

apply / deploy provision the declared services and then pull the branch's env into your local .env.local (e.g. Pulled 5 Neon variables into .env.local: DATABASE_URL, …), so your local env always matches what's deployed.

Function env and neon deploy

neon deploy is the preferred full deployment: it applies neon.ts (services and functions) to the linked branch. neon deploy --env <file> loads that file into process.env before evaluating neon.ts, then uploads those values as Function env. Use it every time Function env reads process.env.

<file> is the gitignored file neon env pull already writes (.env if that file exists, otherwise .env.local). Env pull writes Neon-managed vars only (DATABASE_URL, NEON_AI_GATEWAY_*, …). Add every key under preview.functions.*.env to that file yourself, then pass the same path to --env.

Every declared Function env key must be a defined string. undefined (an unset process.env.X) means you listed a key you want written but the value is missing: defineConfig throws. Omit the key from neon.ts if you do not want to write it. Never coerce a missing process.env value to an empty string: that uploads "" and deletes the live key. An empty assignment in the file (KEY=) is also "". If TypeScript needs a type assertion, use process.env.X! and make sure the file actually has the value.

Use neon functions deploy when you are not applying neon.ts: a single function by slug, or a targeted --env KEY=VALUE update (that flag is not a file path).

Type-safe env vars with parseEnv

@neon/env's parseEnv takes your neon.ts config object and returns a parsed, typed env object, validated against the services you declared. The shape of env follows your config, and missing variables are flagged with clear errors.

npm i @neon/env

import { parseEnv } from "@neon/env";
import config from "./neon";

const env = parseEnv(config);

console.log(env.postgres.databaseUrl);
console.log(env.auth.baseUrl);

By default parseEnv requires every variable your config implies. When one of your apps only uses a subset, for example when you need to read DATABASE_URL but never the unpooled URL, pass an array of env-var keys to require and validate only those. The keys are typesafe: autocomplete only offers variables your config enables, and the returned shape is narrowed to exactly what you selected (so unselected variables are neither enforced nor present).

import { parseEnv } from "@neon/env";
import config from "./neon";

// Only DATABASE_URL is required and returned; DATABASE_URL_UNPOOLED is not enforced.
const { postgres } = parseEnv(config, ["DATABASE_URL"]);
console.log(postgres.databaseUrl);

// Selecting across services — only these keys are validated.
const env = parseEnv(config, ["DATABASE_URL", "NEON_AUTH_BASE_URL"]);
console.log(env.postgres.databaseUrl, env.auth.baseUrl);

Branch configuration

Beyond services, neon.ts can program what configuration new branches receive via the branch property — a function of the branch being evaluated that returns its settings:

// neon.ts
import { defineConfig } from "@neon/config/v1";

export default defineConfig({
  auth: true,
  dataApi: true,
  branch: (branch) => {