PostgreSQL test data generator: populate a Postgres database with foreign keys that resolve.

From pg_dump schema to populated Postgres

Paste a pg_dump --schema-only file or your CREATE TABLE DDL in the web app, push from the VS Code or PyCharm plugin, or use the CLI. The parser reads SERIAL and GENERATED ALWAYS AS IDENTITY primary keys, REFERENCES clauses across the public and other schemas, ENUM types declared with CREATE TYPE, and DEFERRABLE constraints, so the generated rows satisfy them.

CREATE TYPE order_status AS ENUM ('pending','paid','shipped');

CREATE TABLE app_user (
    id          BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    email       CITEXT UNIQUE NOT NULL,
    tags        TEXT[] DEFAULT '{}',
    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
);

CREATE TABLE "order" (
    id          SERIAL PRIMARY KEY,
    user_id     INTEGER NOT NULL REFERENCES app_user(id),
    status      order_status NOT NULL,
    total       NUMERIC(10,2) NOT NULL,
    metadata    JSONB NOT NULL DEFAULT '{}'
);

-- → INSERT INTO app_user ... 200 rows, citext emails unique
-- → INSERT INTO "order" ... user_id resolves (declared FK),
--    status ∈ enum, total numeric, metadata valid JSONB,
--    2-19 orders per user, long-tail distributed

What you get

How it loads into Postgres

CREATE TABLE with a foreign key to FK-consistent INSERTs

Give SeedBase the same CREATE TABLE DDL Postgres already enforces and it walks the declared REFERENCES clauses to build a dependency graph. Rows come back as plain INSERT statements in topological order: every parent is inserted before any child that points at it, so a user_id always names an app_user(id) that already exists.

-- schema.sql (what Postgres enforces)
CREATE TABLE app_user (
    id          SERIAL PRIMARY KEY,
    email       CITEXT UNIQUE NOT NULL
);
CREATE TABLE "order" (
    id          SERIAL PRIMARY KEY,
    user_id     INTEGER NOT NULL REFERENCES app_user(id),
    total       NUMERIC(10,2) NOT NULL
);

-- seed.sql (generated, FK order: parents first)
INSERT INTO app_user (id, email) VALUES
  (1, 'mara.feldt@example.org'),
  (2, 'jon.aldous@example.net');

INSERT INTO "order" (id, user_id, total) VALUES
  (1, 1, 48.90),   -- user_id 1 exists above
  (2, 1, 132.00),
  (3, 2, 7.50);

Because the order is derived from the constraints themselves, the file loads into a schema with foreign keys enabled, no SET CONSTRAINTS juggling and no manual reordering. Self-referencing keys (an employee.manager_id REFERENCES employee(id)) are emitted row by row so each reference points at an earlier row. The same FK graph drives FK-complete subsetting when you pull a slice of a live database: pick the parent rows you want and every referenced row comes with them.

Load the SQL with psql -f seed.sql

The SQL export is a flat file of INSERT statements, so loading it is one command. Point psql at your database URL and run the file:

# generate seed.sql, then load it into Postgres
psql "$DATABASE_URL" -f seed.sql

# or against a local database by name
psql -d myapp_test -f seed.sql

Prefer bulk load? Export CSV instead and stream it with \copy from the client or COPY FROM on the server, one file per table in FK order:

\copy app_user FROM 'app_user.csv' WITH (FORMAT csv, HEADER true);
\copy "order"   FROM 'order.csv'    WITH (FORMAT csv, HEADER true);

Or skip files entirely and push straight into a live connection (host, port 5432, database) from the web app or CLI, with constraints enabled the whole time.

Deterministic Postgres seed data for CI

Pass a fixed seed and the same schema produces the same rows on every run, so a failing test reproduces locally with the same data. With the Node client @seedbase/client you generate and download({ format: 'sql' }) in a pipeline step, then load the file before the suite:

// seed-sql.mjs, run in CI
import { SeedbaseClient } from "@seedbase/client";
import { writeFile } from "node:fs/promises";

const client = new SeedbaseClient({ token: process.env.SEEDBASE_TOKEN });
const gen = await client.generate(process.env.SEEDBASE_PROJECT, { seed: 42, wait: true });
await writeFile("seed.sql", await client.download(gen.id, { format: "sql" }));

# .github/workflows/test.yml
- run: node seed-sql.mjs
- run: psql "$DATABASE_URL" -f seed.sql

Other stacks reach the same SQL output without Node: the CLI, the VS Code and PyCharm plugins, or the web app all export a SQL dump you load with psql -f. The full API and download options are in the docs.