SeedBase, a maintained Neosync alternative: hosted, schema-first, self-serve

What Neosync got right

• PII anonymization: detect sensitive fields in a production database and mask them while keeping the data usable.
• FK-consistent subsetting: carve a smaller, referentially complete slice of a real database for dev and CI.
• Synthetic generation: produce relational test data when you do not want to touch production at all.
• Open source (Go and TypeScript, MIT) and self-hostable, with a clean separation of these three jobs.

If you used Neosync, you already understand the value of those three jobs. The idea was never the problem. The problem now is that the repository is archived, so the maintained, hosted future is unclear, and that is what pushes teams to look for a stable replacement.

The state of Neosync in 2026

Neosync was an open-source data security platform written mostly in Go and TypeScript under the MIT license. In 2025 it was acquired by Grow Therapy, and its GitHub repository was archived with a notice that it is no longer actively maintained. An archived repo means no maintained releases, no fixes for new database versions, and no clear hosted path going forward.

It can still run if you self-host the last published version, and the source stays online for reference, but you are building on a frozen dependency. For many teams the open question is who keeps the lights on. There is no announced community fork the way Snaplet handed its tooling to the wider community, so the realistic options are pinning the archived release yourself or moving to a maintained tool. SeedBase keeps the same three jobs and puts a hosted, supported service behind them.

Neosync vs SeedBase: where they differ

Mapping the three Neosync jobs onto SeedBase

Migration is mostly a matter of mapping Neosync's three jobs onto SeedBase. Point SeedBase at the same schema or live database, and each job has a direct home:

• Anonymization → SeedBase masking. Where Neosync anonymized production records, SeedBase detects PII and applies format-preserving masking, then gives you a privacy report of what changed. See GDPR anonymization.
• Subsetting → SeedBase subsetting. Where Neosync carved an FK-consistent slice of a real database, SeedBase does FK-complete subsetting into a smaller, referentially valid copy for dev and CI.
• Synthetic generation → SeedBase schema generation. Where Neosync generated relational synthetic data, SeedBase reads your schema (SQL dump, Django models, Prisma, or a live DB) and generates FK-consistent data with realistic distributions. See SQL test data.

You keep FK-consistent data without depending on an archived repository, and you can export everything as SQL, CSV or JSON, or push straight into a database whenever you want.

Migrating from Neosync, step by step

The move is short because SeedBase reads the schema or database you already point Neosync at. Nothing about your tables changes.

1. Create a project from your schema. Import a CREATE TABLE SQL dump (PostgreSQL or MySQL), a Django models.py, a Prisma schema, or a read-only live database URL at seedbase.dev. SeedBase reads the tables, columns and foreign keys and builds the generation blueprint.
2. Grab a free API key. One key under Settings, API keys (it looks like dr_sk_...). Put it in the SEEDBASE_TOKEN environment variable for CLI and pipeline use.
3. Pick the job per environment. Synthetic generation for a clean dev or CI database, masking for a safe copy of production, or FK-complete subsetting for a small but referentially valid slice. They share one schema, so you are not juggling three tools.
4. Pin a seed for reproducibility. Pass seed: 42 so every run, local or CI, produces the same rows. SeedBase is deterministic by seed, the same guarantee you relied on with Neosync transformers.
5. Export or push. Write the result to SQL, CSV or JSON, or push it straight into your target database. There is full export at any time, so you are never locked into the hosting.

Anonymizing production data with a privacy report

This is the direct replacement for Neosync's anonymization job. SeedBase detects PII, applies format-preserving masking so an email still looks like an email and a phone number still looks like a phone number, and keeps the masking join-consistent, so the same input maps to the same masked value across every table. The privacy report tells you exactly which columns were touched.

# Mask a live database into a safe copy, with a privacy report
seedbase mask \
  --source "postgres://readonly@prod-replica/app" \
  --out masked.sql \
  --report privacy-report.json

Because the masking is deterministic and join-consistent, a foreign key that pointed at a masked user still resolves to the same masked user in every child table. The walkthrough is on the GDPR anonymization page.

FK-complete subsetting of a real database

Neosync's second strength was carving a referentially complete slice of production. SeedBase does FK-complete subsetting: pick a starting set of rows, and it follows every foreign key so the smaller database still has every parent row each child needs. The result loads cleanly with constraints on.

# Carve a 5% FK-complete subset, masked, into a dev database
seedbase subset \
  --source "postgres://readonly@prod-replica/app" \
  --fraction 0.05 \
  --mask \
  --push "postgres://dev@localhost/app_dev"

You get a small, safe copy that behaves like production for reproducing bugs, without the size or the sensitive data.

Synthetic data as SQL, CSV, JSON, or a direct DB push

When you do not want to touch production at all, generate from the schema. Output is language-agnostic, so it fits any stack: SQL INSERT statements, CSV, JSON, or a direct push into a database.

// 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" }));

# Load it before the test suite, or skip the file and push directly
psql "$DATABASE_URL" -f seed.sql
# or: seedbase generate --project "$SEEDBASE_PROJECT" --seed 42 --push "$DATABASE_URL"

Because the data is keyed off the seed, a failing test reproduces locally with the same seed: 42. The full path, including the runnable demo, is on the SQL test data page.

When to pick which

Stay on Neosync if you specifically want self-hosted, open-source tooling, and you are comfortable running and pinning an archived, unmaintained version yourself.

Pick SeedBase when you want a hosted, maintained, self-serve alternative that will not be the next tool to go dark: FK-consistent generation from your schema, format-preserving masking with a privacy report, FK-complete subsetting, generation from your IDE or AI assistant, and full export at any time so you stay lock-in free.

Neosync alternative: FAQ

Neosync was an open-source (Go and TypeScript, MIT) data platform for synthetic test data, anonymization of production data and referentially consistent subsetting. It was acquired by Grow Therapy in 2025, and its GitHub repository was archived and marked as no longer actively maintained. An archived repo means no further maintained releases and no fixes for new database versions, so teams that relied on it are looking for a stable replacement. SeedBase is a hosted, actively maintained alternative that covers the same core jobs.

SeedBase is a maintained, hosted alternative that covers Neosync's three core jobs: synthetic generation, anonymization and subsetting. It reads your schema from a SQL dump, Django models.py, Prisma, or a live database, generates foreign-key-consistent data, detects PII and applies format-preserving masking with a privacy report, and produces FK-complete subsets. You can export to SQL, CSV or JSON, or push straight into a database, with a free tier and no self-hosting to maintain.

Map Neosync's three jobs onto SeedBase: anonymization of production data becomes SeedBase masking with a privacy report, FK-consistent subsetting becomes SeedBase subsetting, and synthetic generation becomes SeedBase schema generation. Point SeedBase at the same schema or live database, grab a free API key, and wire it into your CLI or pipeline. You keep FK-consistent data without depending on an archived repository, and you can export everything as SQL, CSV or JSON, or push directly into a database at any time.

No. SeedBase is a hosted, maintained service rather than a self-hosted open-source project. The trade-off is that there is nothing for you to host or keep patched, and no second tool death to worry about. You can export everything (SQL, CSV, JSON) at any time, so there is no lock-in, and there is a free tier without a credit card. SeedBase is bootstrapped, independent, and hosted in the EU.

Yes. SeedBase detects PII and applies format-preserving masking, which keeps emails looking like emails and phone numbers looking like phone numbers, and the masking is join-consistent so the same input maps to the same masked value across tables. It produces a privacy report so you can see what was masked. This covers the anonymization job that was one of Neosync's main strengths.

Yes. SeedBase does FK-complete subsetting: it carves a smaller, referentially valid slice of a real database so every foreign key still resolves. Combined with masking, you get a small, safe copy of production for dev and CI, which is the second job teams relied on Neosync for.

SeedBase reads schemas from PostgreSQL and MySQL SQL dumps, Django models.py, Prisma schema, or a live database connection, and it generates foreign-key-consistent data that stays consistent across hundreds of tables. Output goes to SQL, CSV or JSON, or a direct push into your database, and generation is deterministic by seed so the same seed produces the same rows on every run. It was tested against a real 20-app Django project with 226 tables.