Prisma → Postgres seed data · deterministic · one command
Empty database → believable, working data. One command.
You ran the migrations and the screen is still blank — nothing works until data exists. So you hand-write inserts, or a Faker script that breaks a foreign key, and rewrite both after every schema change. Veriseed reads your Prisma schema and writes data that actually works: parents before children, every foreign key resolving to a row that exists.
The sharp edge is determinism: --seed 42 regenerates the exact same
data every run — from your current schema — so CI seeds stop flaking and fixtures
stop rotting. Need volume? --rows 50000, generated in seconds. The free,
open-source Core ships all of this today — locally, no account, no API key.
Pro (in active development) is designed to add AI-realistic values via a
local model, plus PII masking and subsetting.
Founding price for early supporters: $19 vs a planned $38 at launch. The free, open-source Core is live right now — no email, no key.
$ npx veriseed demo --rows 2
-- generated by veriseed (core) — FK-correct seed. Local-first.
BEGIN;
INSERT INTO "User" ("id","email","name","city","country")
VALUES (2, 'riku.ito2@example.com', 'Aoi Suzuki', 'Fukuoka', 'Japan');
INSERT INTO "Post" ("id","title","body","authorId")
VALUES (1, 'Local engine module vector system', '…', 1); -- → a User that exists
INSERT INTO "Comment" ("id","body","postId") VALUES (1, '…', 1);
COMMIT;
$ npx veriseed demo --rows 2 > a.sql; npx veriseed demo --rows 2 > b.sql
$ diff a.sql b.sql && echo identical
identicalReal Core output today (abridged — 1 of 2 rows shown per table, long text elided). Name, city, and country agree within a row via lookup, not AI — deep realism is the Pro roadmap. Default --seed 42: same schema in, byte-identical SQL out, every run.
Ask an AI chat
Fine once
Great one-off sample — more lifelike values than Core, honestly. But it caps at dozens of rows, invents parent IDs, and gives different data every ask.
Hand-rolled seed script
$0 + hours
You write the toposort and FK glue yourself — then rewrite it after every migration. Faker doesn't know your schema.
Veriseed
$0 + $19
One command from your current schema: FK-correct, any row count, deterministic via --seed. Free OSS Core today; Pro adds local-model realism — $19 founding.
The problem
Seed data is a treadmill: you write it, migrations rot it, CI flakes on it.
Three moments, one root cause: your app needs data that matches your schema, and your schema keeps changing. Hand-written seeds and Faker scripts encode yesterday's schema; Veriseed regenerates from today's.
Your fixtures rot and your tests flake
Integration and E2E tests need a seeded DB — and it has to be the same DB every run, or the suite goes flaky. Hand-written fixtures break every time a column is added, so you maintain them forever. Veriseed's --seed 42 regenerates identical data on every run, from the current schema: fixtures that can't rot, seeds you can commit, CI with no human in the loop.
Fresh clone, empty DB, blank screen
Migrations pass, the app boots, and you can verify nothing — lists are empty, joins have nothing to join. The usual fix is hand-INSERTs in dependency order, or a Faker script that references a user that doesn't exist. Veriseed: npx veriseed seed --schema schema.prisma → relations filled, foreign keys intact, the app visibly working.
Some bugs only exist at 50,000 rows
N+1 queries, missing indexes, pagination that dies — none of it shows up with 12 rows. Veriseed generates --rows 50000 (or whatever you ask) with foreign keys still valid, in seconds, locally — so you can test paging and query plans at something like production scale before production finds out.
A one-off sample? Just ask an AI chat
We mean that. If you need ten plausible rows to eyeball once, a chat LLM is fine — and its values will be more lifelike than Core's. You don't need Veriseed for that. Veriseed is for seeding that is repeated (CI, every teammate, every preview env), structural (real FK graphs), or at scale — the parts chat can't do. Full comparison below.
One command, from the schema you already have
The free, open-source Core ships today: it parses your Prisma schema, orders tables so every foreign key resolves, and emits one transactional SQL file — deterministic via --seed, any volume via --rows, with light lookup-based locale coherence (name, city, country agree within a row). It runs entirely on your machine: no account, no API key, and once installed it works offline. The Pro layer (in active development) is designed to add AI-realistic values via a local model, plus PII masking and subsetting.
The obvious question
"Can't I just ask an AI chat for test data?"
For a one-off, small, eyeball-it sample — yes, and you don't need Veriseed. Chat LLMs also write more lifelike values than Core does; that's an honest win for chat. Veriseed exists for the other kind of seeding: repeated, structural, at scale, in automation.
| Asking an AI chat | Veriseed | |
|---|---|---|
| Volume | Caps out around dozens of rows, then truncates | --rows 50000 — generates exactly what you ask for, in seconds, locally |
| FK integrity at scale | Invents parent IDs that don't exist; joins break | Structural guarantee: parents inserted first, children pick from parent keys that were actually generated |
| Reproducibility | Different data every ask — flaky CI, unreproducible bugs | --seed 42 → byte-identical SQL every run, regenerated from your current schema |
| Schema fidelity | You re-paste the schema each time; constraints get dropped or drift | Parses schema.prisma itself — relations, enums, optionals, @map — the same way every run |
| Automation | Copy-paste, human in the loop | A CLI: pipe to psql, script it, run it in CI — no human needed |
| Value realism | Chat wins. Genuinely more lifelike, context-aware values | Core is lookup-coherent, not generative — deep realism is the Pro roadmap (local model, in active development) |
The honest boundary: a one-off small sample for eyeballing → an AI chat is fine; you don't need this tool. Veriseed earns its keep when the seeding is repeated (CI, every teammate, every preview environment), structural (real foreign-key graphs), or at realistic scale.
What it does
Schema in. Working, deterministic data out.
Three steps. No copying production. No service to sign up for. Point it at the schema you already have and go.
Read your schema
Veriseed parses your schema.prisma directly — models, relations, enums, optionals, @map/@@map — and builds the foreign-key graph. (Drizzle and live Postgres introspection: roadmap.)
Generate FK-correct rows
Tables are topologically ordered — parents before children — and every child picks its foreign key from parent rows that were actually generated. A seeded PRNG (--seed, default 42) makes the whole run reproducible; light lookup coherence keeps name, city, and country agreeing within a row.
Emit one transactional SQL file
A single BEGIN; … COMMIT; Postgres file — pipe it to psql or write it with --out. Columns with a @default (like createdAt) are left for the DB to fill.
$ npx veriseed seed --schema ./prisma/schema.prisma --rows 500 --seed 42 --out seed.sql
[veriseed] wrote seed.sql (8 tables, 500 rows each)
$ psql "$DATABASE_URL" -f seed.sql
✓ BEGIN … 4000 INSERTs, every foreign key resolving … COMMIT
# same schema + same --seed → the same file, byte for byte. Commit the command, not the fixtures.Real interface — these are the shipped flags (--rows default 10, --seed default 42, --out optional). The table count is illustrative of "your schema"; every table gets exactly the row count you ask for. Verified at --rows 50000: 200k INSERTs across a 4-table schema in about 2.6 seconds, locally.
Hand-rolled Faker script vs. Veriseed Core
Same users → posts relation. One of these would actually pass your tests — and regenerate identically tomorrow.
{
"id": 42,
"name": "Brad Müller",
"country": "Japan",
"city": "São Paulo", // ✗ wrong country
"authorId": 9137 // ✗ no such user
}
// …and different values every run,
// and the script breaks on the next migration.
{
"id": 2,
"name": "Aoi Suzuki",
"country": "Japan",
"city": "Fukuoka", // ✓ matches country
"authorId": 2 // ✓ a User that exists
}
// …and identical on every run (--seed 42),
// regenerated from whatever the schema is now.
The Veriseed pane shows actual Core values (from npx veriseed demo) — lookup-coherent name/city/country and an intact FK. It is deliberately not showing AI-grade realism: that's the Pro roadmap, not today's output.
Second reassurance · local & private
Your schema and data never leave your machine
Not the headline — the use cases above are — but still true, and for some teams decisive: Core generates entirely on your machine, with zero outbound calls. No account, no API key; once installed it works offline. The Pro layer is being designed to the same local-only architecture (its model would run on your machine — that's the commitment the pre-order funds, not a shipped guarantee).
- No schema upload. Generation happens on your machine — Core is a single zero-dependency script you can read. There's no API that ingests your
schema.prisma, and no telemetry of your tables. - No prod data needed. Veriseed synthesizes new rows from the structure alone — believable data that was never real, so there's no PII to leak in the first place.
- Works offline / air-gapped. Once installed, run it on a plane, in an air-gapped CI box, or behind a strict firewall — generation makes no outbound call.
- Privacy by construction, not by policy. The data can't leak to us because it never reaches us. That's the design, not a promise.
If you were weighing a cloud seeder
Cloud AI seeders vs. Veriseed — the factual version
Cloud AI seeders are more realistic today — we won't pretend otherwise. The architectural difference: theirs sends your schema out; Veriseed's Core never does. This table is a reassurance for teams with that constraint, not the pitch.
| Cloud AI seeders (e.g. Seedfast) | Veriseed | |
|---|---|---|
| AI realism | More advanced today — realistic distributions, strong column values | Core: FK-correct + light, lookup-based locale coherence (shipped). Deep AI realism is the Pro roadmap — local model, in active development |
| Schema leaves your machine | Yes — sent server-side to OpenAI to generate | Core: No — runs locally, schema never transmitted (shipped, provable offline). Pro: same local-only design (roadmap) |
| API key / account required | Yes — key + hosted account | No — Core needs no account and no key |
| Deterministic / CI-scriptable | Model output varies; needs a network hop in CI | Yes — --seed 42 is byte-identical every run; plain CLI in any pipeline |
| Works offline / air-gapped | No — requires an internet connection | Yes — once installed, Core runs fully offline; nothing leaves the box |
| Price | Subscription / metered (cloud SaaS) | Core: free & open source. Pro: $19 one-time founding pre-order |
Source: Seedfast's own docs confirm an API key and server-side OpenAI calls to generate values. "More realistic today" is an honest concession — Veriseed's Core is FK-correct and lightly coherent now; matching cloud-grade realism with a local model is the Pro bet, not a shipped claim.
Pricing
The everyday seeding is free. The harder layer is $19.
Core is free, open source, and shipped today — empty DB to working data in one command, deterministic seeds for CI, any row count for scale testing, all local. Pro adds the layer beyond that — PII masking, subsetting, and AI-realistic values via a local model — for a one-time founding price while it's built with early users.
CORE
Free & open source
Empty DB → working data, deterministic CI seeds, volume for perf tests — shipped, MIT-licensed, all on your machine.
- One command from your Prisma schema — relations, enums, optionals, defaults
- Topological insert order — foreign keys always resolve, zero orphans
- Deterministic:
--seed 42→ byte-identical data every run — CI seeds that never rot - Volume:
--rows 50000for paging / N+1 / index testing at realistic scale - Light locale coherence — name, city, country agree within a row
- Single transactional SQL file (BEGIN … COMMIT) — pipe straight to psql
- No account, no API key — runs offline once installed. MIT: fork it, audit it
Already shipped: npx veriseed demo. Join for release notes as Pro lands.
PRO
$19 $38
Everything in Core, plus what Core honestly doesn't do: share data safely (PII masking), slice a big graph referentially intact (subsetting), and values that read like the real thing — designed to run on a local model, so your schema still never leaves your machine.
- AI-realistic, column-coherent values (local model)
- Locale-correct names, city / country / postal that agree
- PII masking for safe sharing
- Subsetting — a referential-intact slice of a larger graph
- Founding-member input into the roadmap
One-time founding price (50% off the planned $38), in active development. Pre-orders are charged now and lock your price; full refund if Pro founding access doesn't ship. See FAQ on timing.
Get the free CLI — then help shape Pro
Drop your email for release notes on the free, open-source Core (deterministic seeds, volume, FK-correctness). Or pre-order founding access and get a direct line into the Pro roadmap — masking, subsetting, local-model realism.
No spam, no drip funnel. Release notes plus the occasional building-in-public update. Unsubscribe anytime.
Founding pre-orders are charged now; full refund if I don't ship founding access.
FAQ
Straight answers
Can't I just ask an AI chat to generate this?
For a one-off, small sample to eyeball — honestly, yes, and you don't need Veriseed. A chat LLM will even write more lifelike values than the free Core does; we won't pretend otherwise. Chat stops working exactly where Veriseed starts: volume (chat truncates at dozens of rows; --rows 50000 doesn't), FK integrity at scale (chat invents parent IDs; Veriseed's children reference parent rows that actually exist), reproducibility (chat gives different data every ask; --seed 42 is byte-identical every run), and automation (copy-paste vs. a CLI your CI runs with no human in the loop). If your seeding is repeated, structural, or at scale, that's Veriseed's job.
What's built today vs. what's coming?
Built and shipped today (free, open source): parses a Prisma schema, topologically orders tables, generates FK-correct rows with light locale coherence, deterministic via --seed (default 42) and any volume via --rows, and emits a single transactional SQL file. Zero dependencies, no account, no API key; once installed it works offline. In active development (Pro): AI-realistic, column-coherent values via a local model, PII masking, and subsetting. I mark roadmap as roadmap — if a feature isn't in that first list, it isn't shipped yet.
Isn't this just Faker plus a topological sort?
That's the fair version of "is this trivial?" — here's the honest answer: yes, mostly — and that glue is exactly what you keep rewriting. Faker has no schema awareness: with Faker you write the toposort, the FK-value-picking from already-generated parent primary keys, the per-row locale coherence, and a fresh script for every schema — then you fix all of it after every migration. Veriseed does that straight from your Prisma schema, deterministically (--seed for reproducible output), and emits one transactional SQL file. The Core's honest value is that glue — FK-correct, coherent-enough, local — not AI realism. AI realism is the Pro bet, clearly marked.
Does it handle real volume — like performance testing?
Yes, within honest limits: --rows generates however many rows per table you ask for, with foreign keys still valid — verified at --rows 50000 (200,000 INSERTs across a 4-table schema in about 2.6 seconds, locally). That's the region where N+1 queries, missing indexes, and pagination bugs actually show up. I'm not claiming benchmarked millions — the CLI generates what you ask for; very large runs are bounded by your disk and your database's INSERT speed, not by a service quota.
Is my schema actually safe?
Yes — for the Core, by architecture, not by promise. Veriseed's Core runs entirely on your machine, today: your schema.prisma is never uploaded, your production rows are never read, and there's no telemetry on your tables — it synthesizes brand-new rows from the schema's structure alone. You can prove it: once installed, pull the network cable and it still works. There's no server of mine for anything to leak to, because nothing ever reaches one. The Pro layer is being built to the same local-only design — the model runs on your machine — and that architectural commitment is exactly what the pre-order funds.
How is this different from Seedfast?
Architecture. Seedfast is genuinely good and more realistic today — but, per their own docs, it needs an API key and an internet connection and calls OpenAI server-side to generate values, which means your schema is sent out. Veriseed's Core runs entirely on your machine and never transmits your schema; the Pro model is being built to run locally too. If you can send your schema to a cloud SaaS, Seedfast is a strong choice. If you can't or won't, that's exactly the gap Veriseed fills.
Can a local model really match cloud realism?
Honest answer: unproven — and that's literally what the pre-order funds me to find out. On raw realism, cloud is ahead today, and we won't claim otherwise. What ships now is the open-source Core: FK-correct rows with light, lookup-based locale coherence (a name, city, and country drawn from the same locale so they don't contradict within a row) — no account, no key, fully offline. Deep AI-realistic, column-coherent values via a local model are the Pro roadmap, in active development, not a shipped claim. If a local model can't clear a usable bar, founders get a full refund. The bet is that for teams who can't send their schema out, "very good and fully local" beats "best-in-class in someone else's cloud" — and if that bet's wrong for you, the cloud tools are right there.
Why pre-order something that isn't shipped?
The free Core is real and usable right now — you never pay for that. The pre-order is only about Pro — the layer aimed at the pains Core doesn't cover: sharing data safely (PII masking), carving a referentially-intact slice out of a bigger graph (subsetting), and values that read like the real thing (AI-realistic generation via a local model). The $19 founding pre-order locks your price (vs a planned $38 at launch) and tells me that layer is worth building. Pre-orders are charged at checkout, and if founding Pro access isn't delivered to you, you get a full refund — no fine print beyond that.
Which databases and ORMs are supported?
Today: Prisma schema parsing, emitting Postgres SQL. Drizzle support and live Postgres introspection are on the roadmap — and exactly the kind of call founding members help prioritize.
Is the free Core real, or just bait?
Real and shipped. Core (schema → FK-correct, deterministic seed with light locale coherence) is free, open source, MIT-licensed, no account, runs offline once installed. You never have to pay to get correct foreign keys or reproducible CI seeds. Pro funds the harder work — local-model realism, masking, and subsetting.