Neon pricing
Get started for free. Pay per usage as you grow.
Neon pricing plans
Lakebase Postgres
100 projects
100 CU-hrs monthly per project
1 GB of storage per project
Sizes up to 2 CU (8 GB RAM)
Unlimited team members
Backend
Managed Better Auth
5 GB of Object Storage
Functions
Realtime (Beta)
Lakebase Postgres
100 projects
$0.106 per CU-hr
$0.35 per GB-month
Sizes up to 16 CU (64 GB RAM)
3-day metrics/logs in UI
Backend
Managed Better Auth
Object Storage
Functions
AI Gateway
Realtime (Beta)
Lakebase Postgres
1,000+ projects
$0.222 per CU-hr
$0.35 per GB-month
Sizes up to 56 CU (224 GB RAM)
SLAs, HIPAA, private network
Backend
Managed Better Auth
Object Storage
Functions
AI Gateway
Realtime (Beta)
Special programs


App generation platforms
Custom rates and limits for thousands of databases.
Early-stage startups
Launch faster with up to $100k in credits.
Open source projects
Sponsorship for the open source you maintain.
- Projects and Branches
- Projects
- Branches per projectIncluded
- Additional branchesRead more
- Lakebase Postgres
- Compute rates
- Compute sizes
- Autoscaling
- Scale to zeroWhen inactive
- Database storageRoot and child branches
- HistoryInstant restore storage
- History windowFor instant restore (configurable)
- Snapshots
- Scheduled Backups
- Backend
- Managed Better Auth
- Object StorageStored volume
- FunctionsCompute and invocations
- AI Gateway
- RealtimeBeta
- Network
- IP Allow Rules
- Private NetworkingPrivate Link
- Public network transferEgress
- Private network transferBidirectional
- Account & Management
- Monitoring retentionWindow for metrics, logs
- Metrics and Logs exportDatadog, OTel
- Spending notificationsGet alerts as your spend grows
- HIPAA Compliance
- SOC 2 Report Access
- Team members
- Support Plans
- 100
- 10
- 100 CU-hoursPer Project
- Up to 2 CU (8 GB RAM)
- After 5 minutes when inactive
- Free1 GB per Project
- Freewith limited window/size
- Up to 6 hoursor 1 GB of data changes
- 1 snapshot
- Up to 60k MAUs per project
- 5 GB included
- Compute10 active capacity-hours per project400 waiting capacity-hours per projectInvocations1M invocations per project
- Free during beta
- 5 GB per project included
- 1 day
- Unlimited
- Community (Discord)
- 100
- 10
- $0.002 per branch-hour
- $0.106 per CU-hour
- Up to 16 CU (64 GB RAM)
- After 5 minutes can be disabled
- $0.35 per GB-month
- $0.20 per GB-month based on volume of data changes during your selected history window
- Up to 7 days
- 100 snapshots $0.09/GB-month
- Daily/Weekly/Monthly $0.09/GB-month
- Up to 1M MAUs per project If you're planning to go beyond that, contact us
- $0.023 per GB-month
- Compute$0.10 per active capacity-hour$0.025 per waiting capacity-hourInvocations$0.60 per 1M invocations
- List prices herePrepaid credits
- Free during betaCompute and egress billed as usual
- 500 GB per project includedthen $0.10/GB
- 3 days
- Unlimited
- Billing Support
- 1,000
- 25
- $0.002 per branch-hour
- $0.222 per CU-hour
- Up to 56 CU (224 GB RAM)
- Configurable
- $0.35 per GB-month
- $0.20 per GB-month based on volume of data changes during your selected history window
- Up to 30 days
- 100 snapshots $0.09/GB-month
- Daily/Weekly/Monthly $0.09/GB-month
- Up to 1M MAUs per project If you're planning to go beyond that, contact us
- $0.023 per GB-month
- Compute$0.12 per active capacity-hour$0.03 per waiting capacity-hourInvocations$0.60 per 1M invocations
- List prices herePrepaid credits
- Free during betaCompute and egress billed as usual
- 500 GB per project includedthen $0.10/GB
- $0.01 per GB
- 14 days
- Included
- Unlimited
Last updated on
Included in every Neon project, on every plan, by default. Lakebase Postgres and the backend around it, with high availability and compliance built in.
High availability.
Neon’s storage is multi-AZ by default, without the need for HA standbys.
Branching.
Create instant copy-on-write branches of your database, with auth, Object Storage, and Functions branching alongside it, for previews, tests, and agents.
Autoscaling and scale to zero.
Compute adjusts to load and scales to zero when idle, including on the Free plan.
Connection pooling and read replicas.
Up to 10,000 pooled connections per compute with built-in PgBouncer, and read replicas without added storage costs.
Postgres extensions.
Add extensions like pgvector, PostGIS, TimescaleDB, and many more.
Managed Better Auth.
Authentication based on Better Auth that stores users in your database and branches with it.
Data API.
Query your database over HTTP with a managed REST API, no backend server required.
Object Storage and Functions.
S3-style Object Storage and Functions in every project, with Free plan allowances, plus Realtime in beta.
Compliance.
Neon is ISO 27001 and 27701 certified, SOC 2 audited, and GDPR and CCPA compliant. HIPAA is available on Scale. See our Security page.
Your questions,
answered
Alongside Lakebase Postgres, every Neon project can use Managed Better Auth, the Data API, Object Storage, Functions, AI Gateway, and Realtime (in beta). Together they form a backend that runs next to your database: Auth, Object Storage, Functions, and AI Gateway branch with it. AI Gateway is available on Launch and Scale; everything else is on every plan, including Free.
A project in Neon is the top-level container for your environment. Each project includes all branches, with your Postgres databases and (if you deploy them) your Object Storage buckets, Functions, Managed Better Auth endpoints, and AI Gateway access.
A CU (short for Compute Unit) is Neon's way of representing Postgres database compute size. Neon databases autoscale, and CUs define how much CPU and memory your database is using at any moment. Each CU allocates approximately 4 GB of RAM, along with associated CPU.
A CU-hour is Neon's unit for measuring Postgres database compute usage. Because Neon databases scale to zero and autoscale, you're billed only for the database compute resources you actually use. In other words, your monthly database compute usage depends on:
- How many compute endpoints you're running
- How large your compute endpoints are (in CUs)
- How long they run (in hours)
For a single compute, the calculation works like this:
Monthly CU-hours = [average CU size] × [number of hours the compute runs in the month]Monthly compute cost = [monthly CU-hours] × [CU-hour price]The CU-hour price depends on your pricing plan:
- Launch plan: $0.106 per CU-hour
- Scale plan: $0.222 per CU-hour
Remember that when your database is idle, compute can scale down to zero, so you don't consume CU-hours while it's not running. Learn more about Neon's billing.
On the Free plan, each project gets 100 CU-hours of database compute per month, and compute automatically scales down to zero when idle. What this means in practice:
- You can create up to 100 projects, each with its own independent 100 CU-hour allowance
- CU-hours are only consumed while a database is actively running queries. When a project is idle, compute scales to zero and uses no CU-hours
- Usage is typically spread across short bursts of activity, not continuous runtime
A realistic example for a single project:
- The database runs at 0.25 CU, the default compute size for Free plan projects, for ~12 hours per day. It scales down to zero the rest of the time
- Over a month, this uses roughly 90 CU-hours (0.25 CU × 12 hours × 30 days), staying within the Free plan limits for that project
- At 0.25 CU, 100 CU-hours covers about 400 hours of active compute, more than half the hours in a month
This model is designed to make it practical to have many small or intermittent databases (for development, demos, previews, or experiments) without being forced into an upgrade. Learn more about our Free plan philosophy.
The Free plan is permanent, not a trial, and doesn't require a credit card. Most limits are per project, and none of them delete your data:
- If a project uses up its 100 CU-hours or 5 GB of network transfer for the month, its compute is suspended until the next billing period
- If a project exceeds 1 GB of Postgres storage, or your projects exceed 20 GB in total, operations that increase storage fail until you free space
- Branch creation fails once a project has 10 branches
Upgrading to a paid plan lifts these limits immediately. If you'd rather not upgrade yet and need more room, reach out to us about credits. We're happy to support developers and startups.
Yes. Claimable Neon gives you, or an AI agent working for you, an instant Postgres project with no account and no credit card. Claim it to a Neon account within 72 hours to keep it. Unclaimed projects are capped at 100 MB of storage and 1 GB of network transfer. See the reference.
No. Neon doesn't pause Free projects for inactivity, and there's no restore step. When a database is idle, its compute scales to zero after 5 minutes and starts again on the next query, typically within a few hundred milliseconds. Your project, data, and connection string stay the same.
Compute is suspended only if a project uses up its monthly 100 CU-hours or 5 GB of network transfer. It resumes at the start of the next billing period, or as soon as you upgrade. If you hit these limits and need more room, reach out to us about credits. We're happy to support developers and startups.
CU-hours measure Postgres database compute only. Object Storage and Functions have their own Free plan allowances, Managed Better Auth has its own MAU limit, and AI Gateway is available on paid plans. The Data API and Realtime run queries against your database, so the database compute they use counts toward your CU-hours like any other query.
The typical monthly cost estimates shown in our pricing plans are based on representative database workloads that reflect common usage patterns across different application types. These estimates cover Postgres compute and storage only. They don't factor in Object Storage, Functions, or AI Gateway usage, which are billed separately.
Each estimate combines two components:
- Database compute cost: Based on the specified CU-hours per month.
- Database storage cost: Based on the specified amount of database storage in GB.
These estimates help you compare typical workloads across plans.
Here's a detailed breakdown of each of the workload sizes and what they represent:
Intermittent load
140 CU-hours compute, 1 GB-month of storage. Typical of a small database that doesn't need to run 24/7.
A database using 140 CU-hours compute per month can scale to zero when idle, and start back up within a few hundred milliseconds when it's needed. When it's running it is set to a minimum size of 0.25 CU but can scale up to 2 CU when needed.Low load
190 CU-hours compute, 5 GB-month of storage. A small database that does need to run 24/7.
Once scale to zero is disabled, the minimum CU-hours a database can use in a month is about 182.5 (about 730 hours in a month × 0.25 minimum CU size ≈ 182.5), so this example represents a database that has scale to zero disabled but only occasionally needs to scale above the 0.25 minimum size. Good for small production applications and databases that need to be always-on for features like real-time sync.
Medium load
720 CU-hours compute, 10 GB-month of storage. Representative of a constant-load application database.
As you can see from the autoscaling chart above, 720 CU hours translates to a database that scales between 0.5 and 4 CU based on load.
High load
3,000 CU-hours compute, 100 GB-month of storage.
As an example, a database that is scaling between 3 CU and 7 CU will often use around 3000 CU hours in a month. This level represents production applications with sustained traffic, higher data volumes, and more complex queries requiring consistent compute resources.
XL load
6,000 CU-hours compute, 1,000 GB-month of storage.
A database scaling between 6 and 14 CU can use in the range of 6,000 CU hours in a month. This is representative of large-scale production workloads with high traffic volumes, extensive datasets, and applications requiring significant compute capacity and storage.
Your actual costs will vary based on:
- How much your database autoscales based on actual query load
- How long your computes run before scaling to zero
- Your actual data size and number of branches
- Your configured history window for instant restore (affects History storage costs)
Remember that Neon bills based on actual usage, not estimates. Use these workload examples as reference points, then monitor your usage in the Neon Console to understand your real costs. Learn more about how Neon billing works.
Object Storage, Functions, and AI Gateway are billed separately from Postgres compute (CU-hours). Managed Better Auth, the Data API, and Realtime have no separate charge.
Managed Better Auth is included up to 60,000 MAU per project on Free and 1 million MAU per project on paid plans.
The Data API is included on every plan. The queries it runs use your database compute and count toward network transfer, like any other query.
Realtime is free during the beta. Database compute and network transfer it generates are billed as usual.
Object Storage is $0.023 per GB-month of stored volume. There's no per-operation charge. Egress counts toward your public network transfer allowance. The Free plan includes 5 GB of Object Storage per project.
Functions are billed for active compute, waiting compute, and invocations at the rates in the plan table. The Free plan includes 10 active capacity-hours, 400 waiting capacity-hours, and 1 million invocations per project per month.
AI Gateway is available on Launch and Scale. Pricing matches the model provider's list prices, with no markup, and draws down prepaid credits. Learn how prepaid credits work, or see per-model rates.
Public network transfer is counted per project, not per account:
- Free plan: 5 GB per project per month, across up to 100 projects
- Launch and Scale: 500 GB per project per month, then $0.10 per GB
Each project's allowance is shared by everything in it: Postgres, Object Storage, and Functions. Eligible startups can apply for up to $100k in credits through the Startup Program. Learn how to reduce network transfer.
With usage, not with instance size or project count. There's no per-project or per-database fee: each project pays for the compute it actually runs (CU-hours) and the storage it holds.
- Idle databases scale to zero, so you don't pay for compute while they're suspended. Storage is still billed.
- Autoscaling sizes compute to the load within the limits you set, so you don't pay for peak capacity all month.
This makes Neon cost-efficient for many small databases, such as a database per tenant or per agent, and for intermittent or spiky workloads.
Neon's pricing is built for this pattern. Each tenant gets its own project, an isolated Postgres database with its own compute, and there's no per-project or per-database fee:
- Free plan: up to 100 projects at $0, each with its own 100 CU-hours and 1 GB of storage, enough to build and test a database-per-tenant app.
- Launch and Scale: you pay only for the compute each tenant actually runs and the storage it holds. Idle tenant databases scale to zero, so inactive tenants don't add compute cost; storage is still billed. Launch includes 100 projects, and Scale includes 1,000, with more on request.
For example, 100 tenant databases on Launch, each running at 0.25 CU for about an hour a day and storing 150 MB, use about 750 CU-hours and 15 GB of storage: roughly $85 a month in total, or about $0.85 per tenant.
Platforms that provision databases for their users at scale can apply to the Agent Plan. For design guidance, see Multitenancy with Neon.
Neon's paid plans don't require a minimum monthly spend or base fee. You're billed purely based on usage. If one month you barely use Neon, your bill might be just a few dollars.
For example, if your databases are mostly idle that month, or you only run them briefly for development or testing, you'll only pay for the compute and storage actually consumed during that time. Remember that Neon databases scale to zero by default.
No. When you're on a paid plan, database usage starts metering from zero for both compute and storage. Free plan quotas don't apply once you upgrade. Instead, you're billed purely based on actual usage, at the rates of your paid plan.
You should consider a paid plan if:
- You expect higher or more sustained usage than what's included per project on the Free plan
- You care about production guarantees, such as consistent availability, predictable performance, and never having your database paused due to usage limits
If your usage fits comfortably within the Free plan and you're not running a production workload, there's no reason to upgrade. The Free plan is designed to be genuinely useful for development and prototyping. Learn more about our Free plan philosophy.
In Neon, you don't provision or manage database storage in advance. It scales automatically and invisibly as your data grows. At the end of each month, you're billed for the database storage actually consumed per project, measured in GB-months.
Neon bills storage usage using two separate metrics:
History storage (or instant restore storage)
Instant restore relies on Neon retaining a history of database changes so you can restore a branch to a previous point in time, create branches from past states, run Time Travel queries, and more. How long that history is kept is controlled by the history window on Settings → Instant restore (1 day by default on paid plans). See History window.
History storage is billed based on the amount of Write-Ahead Log (WAL) retained within that history window, at $0.20 per GB-month on paid plans. This is billed separately from your regular database storage.
If you don't need deep recovery or long Time Travel, shorten the history window to reduce costs.
Database storage (root and child branches)
This is the storage used by your database data itself. Since Neon databases can branch, this is how branches contribute to database storage:
- Root branches are billed based on their actual data size (for example, 5 GB)
- Child branches might be billed based on the minimum of: the accumulated data changes since the branch was created, or the underlying storage footprint, which is zero if the branch is still within the history window used for instant restore (in this case, the child branch effectively shares storage with its parent).
The sum of both components will be billed as your database storage at $0.35 per GB-month.
What this implies:
- A child branch that has no data changes compared to its parent and is still within the history window does not incur additional database storage costs.
- As a child branch accumulates changes over time, its storage usage increases.
- If a child branch falls out of the history window, it becomes as expensive as a root branch, since it no longer shares storage with its parent.
To keep database storage costs low, keep child branches short-lived: set expiration times, reset them frequently, or delete branches when they're no longer needed.
Each paid plan includes a set number of branches per project at no additional cost (10 branches per project on Launch, 25 branches per project on Scale). You can create and delete branches freely within that allowance:
- If the total number of concurrent branches in a project exceeds your plan's allowance, the extra branches are billed as branch-months, prorated hourly.
- The price is $1.50 per extra branch-month (≈ $0.002 per hour)
- You're only billed for branches that exceed your included limit, and only for the time they exist.
Example: The Launch plan includes 10 branches per project. If you already have 10 branches but create 2 additional branches and keep them for 5 hours each, that'd be 10 extra branch-hours total: 10 × $0.002/hour = $0.02
How to avoid extra branch charges
- Use branch expiration. Set automatic deletion times on temporary branches so they're cleaned up when no longer needed.
- Automate cleanup. Use the Neon API or Neon CLI to periodically delete unused branches and stay within your included allowance.
Database compute is often the most variable part of a monthly bill. For Neon databases, the most effective way to control compute costs is to configure maximum autoscaling limits and scale-to-zero.
Autoscaling limits act as a built-in cost ceiling: your database will never scale beyond the limit you set, even during traffic spikes. If you want to prioritize performance over costs in a particular compute endpoint (e.g. production), choose a higher limit. If you want to optimize for cost predictability, set a lower one. Learn how to configure autoscaling limits.
Another effective way to control database compute costs is to ensure scale to zero is enabled for all non-production branches. When a branch is idle, compute scales down automatically, so you don't pay for compute while it's idle. Learn about scale to zero.
To manage database storage costs, regularly clean up unused branches, snapshots, and projects, and avoid retaining a large history window for instant restore if your use case does not require it. Learn more about optimizing storage usage.
Yes, in three ways:
- Spending notifications (Launch and Scale) email your organization at 80% and 100% of a monthly dollar threshold you set. They alert you but don't stop usage.
- Autoscaling limits cap the compute size each database can reach, which puts a ceiling on compute spend.
- Consumption limits, set per project with the Neon API, suspend compute when a project reaches a compute, storage, or data transfer quota.
- Startups: early startups that have received venture funding can apply for up to $100k in credits through the Startup Program.
- Agent platforms: platforms that provision databases for their users can apply to the Agent Plan, with sponsored free-tier infrastructure and up to $25,000 in paid-tier credits.
- Open source: the Open Source Program offers monthly sponsorships for maintainers.
Still have questions? Ask our AI.
It knows Neon inside and out.









