claimable-postgres

Provisions a 72-hour unclaimed Neon Postgres via neon.new (REST, CLI, SDK, or Vite plugin) with no signup, writing DATABASE_URL and a claim URL. Use when the user needs a throwaway DATABASE_URL for prototyping, demos, or tests. Not for production Neon projects, neon.ts IaC, Vercel-linked orgs, or Supabase. Do not use for durable Postgres that must survive beyond the claim window.

Zur Installation springen

Repository: Kayforkind/skill-slice
Letzte Quellaktivität: 14. August 2026 um 22:54
Erkannte Sprache von SKILL.md: Englisch
Sterne: 0
Forks: 0

Installationsoptionen

Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.

Quelldateien prüfen

Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.

Zurück zur Suche Zurück zur Installation

name	claimable-postgres
description	Provisions a 72-hour unclaimed Neon Postgres via neon.new (REST, CLI, SDK, or Vite plugin) with no signup, writing DATABASE_URL and a claim URL. Use when the user needs a throwaway DATABASE_URL for prototyping, demos, or tests. Not for production Neon projects, neon.ts IaC, Vercel-linked orgs, or Supabase. Do not use for durable Postgres that must survive beyond the claim window.
version	1.0.1
risk	unknown
source	https://github.com/neondatabase/agent-skills/tree/main/skills/claimable-postgres
source_repo	neondatabase/agent-skills
source_type	official
date_added	2026-07-01T00:00:00.000Z
license	Apache-2.0
license_source	https://github.com/neondatabase/agent-skills/blob/main/LICENSE

Claimable Postgres

Provision instant temporary Postgres databases via Claimable Postgres by Neon (neon.new) with no login, signup, or credit card. Databases expire after 72 hours unless claimed to a Neon account. Supports REST API, CLI, SDK, and Vite plugin.

When to Use

Use this skill when:

The user asks for a quick, temporary, or throwaway Postgres database.
The user needs a DATABASE_URL for prototyping, demos, or tests.
The user says "just give me a database" or similar.
The agent needs a database to fulfill a task (e.g. "build me a todo app with a real database") and the user has not provided a connection string.

Do not use this skill for production workloads — recommend standard Neon provisioning instead.

Prerequisites

Internet access to https://neon.new.
For the REST API path: curl (available on Windows 10+ via PowerShell, macOS, and Linux).
For the CLI path: Node.js installed (npx, yarn, pnpm, bunx, or deno).
For the SDK path: a Node.js/TypeScript project.
For the Vite plugin path: a Vite project.
Windows host is primary (PowerShell). curl commands work in PowerShell as-is.

Procedure

Choose a Method

Method	When to use
REST API	Preferred when the agent needs predictable JSON output and error handling. No runtime dependency beyond `curl`.
CLI (`npx neon-new@latest --yes`)	Convenient when Node.js is available and the user wants a simple one-command setup that writes `.env`.
SDK (`neon-new/sdk`)	Scripts or programmatic provisioning in Node.js.
Vite plugin (`vite-plugin-neon-new`)	Auto-provisions on `vite dev` if `DATABASE_URL` is missing.
Browser	Direct the user to https://neon.new when they cannot run CLI or API.

Confirm intent: If the request is ambiguous, confirm the user wants a temporary, no-signup database. Skip this if they explicitly asked for a quick or temporary database.

Provision: POST to create a database:

curl -s -X POST "https://neon.new/api/v1/database" \
  -H "Content-Type: application/json" \
  -d '{"ref": "agent-skills"}'

Parameter	Required	Description
`ref`	Yes	Tracking tag. Use `"agent-skills"` when provisioning through this skill.
`enable_logical_replication`	No	Enable logical replication (default: `false`, cannot be disabled once enabled).

Parse response: Extract connection_string, claim_url, and expires_at from the JSON response.

{
  "id": "019beb39-37fb-709d-87ac-7ad6198b89f7",
  "status": "UNCLAIMED",
  "neon_project_id": "gentle-scene-06438508",
  "connection_string": "postgresql://...",
  "claim_url": "https://neon.new/claim/019beb39-...",
  "expires_at": "2026-01-26T14:19:14.580Z",
  "created_at": "2026-01-23T14:19:14.580Z",
  "updated_at": "2026-01-23T14:19:14.580Z"
}

The connection_string is a pooled connection URL. For a direct (non-pooled) connection (e.g. Prisma migrations), remove -pooler from the hostname.

Write .env: Write DATABASE_URL=<connection_string> to the project's .env (or the user's preferred file and key). Do not overwrite an existing key without confirmation.
Seed (if needed): If the user has a seed SQL file, run it:
```
psql "$DATABASE_URL" -f seed.sql
```
Report: Tell the user where the connection string was written, which key was used, and share the claim URL. Remind them: the database works now; claim within 72 hours to keep it permanently.
Optional: Offer a quick connection test (e.g. SELECT 1).

curl -s "https://neon.new/api/v1/database/{id}"

Check .env: Check the target .env for an existing DATABASE_URL (or chosen key). The CLI exits without provisioning if it finds the key. If present, offer:
1. Remove or comment out the existing line, then rerun.
2. Use --env to write to a different file (e.g. --env .env.local).
3. Use --key to write under a different variable name.
Get confirmation before proceeding.
Confirm intent: If the request is ambiguous, confirm the user wants a temporary, no-signup database. Skip this if they explicitly asked for a quick or temporary database.
Gather options: Use defaults unless context suggests otherwise (e.g. user mentions a custom env file, seed SQL, or logical replication).

Run: Always use @latest to avoid stale cached versions. --yes skips interactive prompts that would stall the agent.

npx neon-new@latest --yes --ref agent-skills --env .env.local --seed ./schema.sql

Alternative package managers: yarn dlx neon-new@latest, pnpm dlx neon-new@latest, bunx neon-new@latest, deno run -A neon-new@latest.

Option	Alias	Description	Default
`--yes`	`-y`	Skip prompts, use defaults	`false`
`--env`	`-e`	.env file path	`./.env`
`--key`	`-k`	Connection string env var key	`DATABASE_URL`
`--prefix`	`-p`	Prefix for generated public env vars	`PUBLIC_`
`--seed`	`-s`	Path to seed SQL file	none
`--logical-replication`	`-L`	Enable logical replication	`false`
`--ref`	`-r`	Referrer id (use `agent-skills` when provisioning through this skill)	none

Verify: Confirm the connection string was written to the intended file.
Report: Tell the user where the connection string was written, which key was used, and that a claim URL is in the env file. Remind them: the database works now; claim within 72 hours to keep it permanently.
Optional: Offer a quick connection test (e.g. SELECT 1).

DATABASE_URL=postgresql://...              # pooled (use for application queries)
DATABASE_URL_DIRECT=postgresql://...       # direct (use for migrations, e.g. Prisma)
PUBLIC_POSTGRES_CLAIM_URL=https://neon.new/claim/...

import { instantPostgres } from "neon-new";

const { databaseUrl, databaseUrlDirect, claimUrl, claimExpiresAt } =
  await instantPostgres({
    referrer: "agent-skills",
    seed: { type: "sql-script", path: "./init.sql" },
  });

npm install -D vite-plugin-neon-new

npm i @neon/config

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

export default defineConfig({
  auth: true, // Neon Auth, once you outgrow a bare connection string
  dataApi: true, // Data API
  branch: (branch) => (branch.exists ? {} : { ttl: "7d" }), // ephemeral non-default branches
});

neon config apply   # provision the declared services (neon deploy is an alias)

Check .env was written:

Get-Content .env | Select-String "DATABASE_URL"

Expected output:

DATABASE_URL=postgresql://...

Test the connection:

psql "$DATABASE_URL" -c "SELECT 1"

Expected output:

 ?column?
----------
        1
(1 row)

Check database status via API:
```
curl -s "https://neon.new/api/v1/database/{id}"
```
Confirm "status": "UNCLAIMED" and connection_string is present.
Verify .gitignore covers .env:
```
Get-Content .gitignore | Select-String "\.env"
```
If no match, warn the user before proceeding.