Neon through Squiid

What Neon is

Neon is Postgres rebuilt for a serverless world. Storage and compute are separate, which makes two things possible that ordinary Postgres cannot do: a branch that copies an entire database instantly and cheaply, and a compute endpoint that suspends when nothing is querying it and wakes on the next connection. Point-in-time restore lets you rewind to a moment before a bad migration, and a serverless driver speaks Postgres over HTTP and websockets so edge runtimes without TCP can still query it.

Branching is what makes Neon interesting for agent-written code. Every pull request, and every risky experiment an agent proposes, can get its own database with real data shape and no shared state, then be thrown away. That converts the scariest part of letting an AI write migrations into something reversible. Scale to zero matters for the other half of the workload: side projects and internal tools that see traffic for ten minutes a day should not pay for an always-on instance. The management API is scriptable, which is why CI pipelines and agents can treat a database the way they treat a container: create it, use it, delete it.

Why connect it through Squiid

Squiid provisions the Neon project, holds the connection string and the API key, and exposes the database and the management API through https://api.squiid.io/v1/neon/... with Authorization: Bearer $SQUIID_API_KEY. Drivers work by pointing their base URL at the gateway (gateway convention). Compute hours, storage and data transfer are metered against your prepaid credits at Neon's list price, and the Launch plan passes through at $19 a month with no Squiid fee added. Branch creation by an agent is visible in the dashboard, so a forgotten branch is not a silent cost.

• One account, one key, one bill, one dashboard. Neon sits beside every other service your project uses, on the same invoice and the same credit balance.
• Key custody. Squiid holds the Neon credentials. Your code carries SQUIID_API_KEY, so DATABASE_URL, NEON_API_KEY, NEON_PROJECT_ID, PGHOST, PGPASSWORD never land in a repository, a preview deployment or an agent’s context.
• Metering you can see. Every call is counted per service and per day, so you know what Neon costs before the month ends.
• Pause on zero. When prepaid credits run out the gateway stops authorizing usage instead of running up a bill you did not fund.
• One rotation. Rotating the Squiid key cuts off every agent, worker and deployment at once, with no provider key to hunt down.

What you get

• A provisioned serverless Postgres project
• Instant database branches for previews and agent experiments
• Scale to zero when idle, with point-in-time restore
• Compute and storage metered against prepaid credits
• Neon plan cost passed through at list price

How to connect Neon

One variable replaces the provider credentials this service would normally need. Requests go to the gateway and the official SDKs work by pointing their base URL at it (gateway convention).

# .env
# replaces DATABASE_URL, NEON_API_KEY, NEON_PROJECT_ID, PGHOST, PGPASSWORD
SQUIID_API_KEY=sq_live_xxxxxxxxxxxxxxxxxxxxxxxx

# every request: https://api.squiid.io/v1/neon/...
# header:       Authorization: Bearer $SQUIID_API_KEY

Pricing through Squiid

Neon charges a plan fee plus compute hours, storage and data transfer above the included allowance, at the provider's listed price. Squiid passes that through at par: one dollar of prepaid credit is one dollar of Neon usage, with no markup and no per-request margin.

Neon Launch passes through at $19 a month at the provider’s listed price on your monthly Squiid invoice. Service subscriptions carry no Squiid fee.

Squiid adds no markup to provider prices. There is a free plan at $0 a month with a 15% fee when you top up credits, Solo at $19.97 a month with a top-up fee that starts at 8% and falls to 3.5% as your spend grows, Team from $29.97 a seat a month with the same ladder one point lower, and Custom with a rate of 3% or less. Credits are prepaid, so Neon usage stops when the balance reaches zero rather than producing an invoice you did not fund. Auto top-up with a cap keeps production running without handing anyone an open-ended card.

If you leave

Transfer: Neon's API supports moving a project between organizations, so the project moves into your own Neon organization intact. Squiid never owns your code, your schema or your domain, and the gateway speaks Neon's own API, so the client change is a base URL. The handover page lists what happens for every provider in the catalogue.

Works with every coding agent

Neon through Squiid is just an HTTP call with a bearer token, so every agentic coding tool can use it with the single key already in your environment:

• Claude Code
• Cursor
• ChatGPT
• Codex
• Grok
• Gemini CLI
• GitHub Copilot
• Windsurf
• Perplexity
• Devin
• Replit
• v0
• Lovable
• Cline

Vibe coding a feature on Neon usually means asking for it in plain language and letting the agent write the integration. Because the key is Squiid’s rather than the provider’s, it can do that without ever holding a credential that could be leaked, logged or committed.