Long-running functions, right next to your database

Your questions,
answered

• What are Neon Functions?

  Neon Functions are serverless functions you deploy onto a Neon branch, so your backend code runs in the same region as your database. DATABASE_URL is injected automatically, along with AI Gateway and Object Storage credentials when you use them. Use a Function to host an API, an MCP server, an AI agent, a real-time server, or a webhook handler without standing up separate infrastructure. Functions run JavaScript or TypeScript on the Node.js runtime.

• How are Neon Functions different from lambda-style serverless?

  Functions run next to your data and stay open for long-running work. A Function can start responding within 15 minutes and keep streaming while data flows, so agents, WebSockets, and SSE connections aren't cut off by a short execution limit. They are still serverless: idle functions can be evicted.

• When should I use Neon Functions?

  Use Functions for backend APIs, AI agents, MCP servers, WebSockets, SSE, file upload handlers, webhook handlers, and other request-driven work that benefits from running close to your data. Hosting an MCP server is a common pattern: the Function stays close to Postgres, can keep a long-lived stream open, and gets DATABASE_URL plus other Neon credentials injected automatically, so the MCP tools can query and mutate the same branch as the rest of the backend.

• Should I run my frontend on Neon Functions?

  Run your frontend on your preferred web host. Use Functions for backend work that needs longer execution, persistent connections, or direct access to your Neon services.

• Can I run cron jobs or scheduled work?

  Yes. Function Triggers let Neon invoke a deployed Function on a cron schedule. Schedules run outside the Postgres compute, so they fire even when the database is scaled to zero. This replaces the pattern of running an external scheduler or keeping a compute awake for pg_cron. For queued, retryable background jobs with their own lifecycle, pair a Function with a job queue or workflow service. A native Neon job queue is a separate, upcoming offering.

• What are Function Triggers?

  Triggers tell Neon when to invoke a deployed Function. They live on a branch and point to a Function on that branch. A child branch inherits its parent's triggers, but they arrive disabled and don't run until you enable them, so branching production for a test doesn't fire the parent's schedule a second time. The first trigger type is cron schedules, with event-based triggers that react to activity inside Neon planned next.

• What happens to my Functions when I create a branch?

  Each branch runs its own copy of a Function, at its own URL, against its own database state. Your Function configuration branches with the rest of your backend, so a preview or test branch gets an isolated Function endpoint.

• How do I deploy a Function?

  Declare the Function in neon.ts, then run neon deploy. You can also deploy a single Function with the Neon CLI.

• Can I use a custom domain?

  Yes. You can serve a Function from your own hostname, such as api.example.com, instead of its native Neon invocation URL. Register the domain from the Neon Console, CLI, SDK, or API, add the returned CNAME record at your DNS provider, and Neon issues the TLS certificate automatically through Let's Encrypt. Custom domains are included with Functions with no separate charge; traffic is billed like any other Function traffic.

• How do custom domains work with branches?

  A custom domain is attached to one Function on one branch, not to the whole project. If you register api.example.com on production, that hostname keeps pointing at the production Function after you branch. Each hostname can be registered once, so a preview branch needs its own name, such as preview.api.example.com. Adding a custom domain doesn't authenticate the Function or disable its native Neon URL, so protect the Function with application-level authentication.

• How does Functions pricing work?

  Functions are pay-as-you-go on paid plans and billed on three parts: active compute while your code runs, waiting compute while a Function is idle but held ready, and invocations. Active compute is $0.10 per Capacity-Hour on Launch and $0.12 on Scale. Waiting compute is $0.025 per Capacity-Hour on Launch and $0.03 on Scale. Invocations are $0.60 per million on both plans. See the pricing page for current rates.

• Is there a free allowance for Functions?

  The Free plan includes 10 active Capacity-Hours, 400 waiting Capacity-Hours, and 1 million invocations per project per month. Custom domains and triggers are part of Functions and don't carry a separate charge.

• Which languages and runtimes do Functions support?

  Functions run JavaScript or TypeScript on the Node.js runtime. You can deploy JS/TS handlers or code that bundles to JavaScript for Node.js. A Function is any module whose default export provides a fetch(request) method that returns a web Response, the same handler shape used by other standards-based serverless runtimes. Hono is the recommended framework.

• Which regions are Functions available in?

  Functions run in the same region as your Neon branch. Region coverage is expanding; create your project in a supported region to use Functions. See the Functions overview for the current list.