21 sources are listed here with a state. Each one says what it moves, what it leaves behind and the limits we know of. Sources we do not support are listed too.
Pick a source to jump to what it moves and what it does not. The command shown for a source is the invocation the migrator accepts at engine edition 5f8ea3af. Distribution is scoped during the preview, and this page does not publish an install path.
Every source below writes to one of these destinations. The rules here apply to all of them, so they are stated once.
--to stdout
Available in preview
Prints one JSON entity per line on standard output and a summary line on standard error. Nothing is written to any database.
Use it to look at a run before you write anything, and with --limit to sample a source.
--to engine --data-dir DIR
Available in preview
Writes into a local data directory through the engine library. The directory is opened exclusively, so stop the server first.
Record ids are kept. Running again over unchanged data adds nothing. A record that already exists with different content is refused as a collision, the run reports it as failed and exits with an error. It does not update.
No collection definitions are created. Records of kind coll:<name> become readable through the collection endpoints once a collection with that name exists on the server.
Created and updated timestamps on the new records are the time of the run, except for NDJSON restores.
--to http --kdb-url URL --kdb-key KEY
Beta
Posts attributes to a running server one record at a time. Record ids and vectors are not sent, so the server assigns new ids and vectors are dropped. Records of any other kind have no collection to go to.
The collections must already exist on the target. The tool asks for them to be created through an admin route that this server version does not expose, logs a warning and carries on, and the record writes then fail for a collection that is missing. Create the collections first with POST /v1/collections.
A non-success response on a record write fails the run. The tool reports it instead of counting the record as written.
3 sources
Available in preview
These migrators are reachable today and are covered by tests in the engine repository.
SQLite
Available in preview
Connects toA SQLite database file on the machine that runs the tool. The file is opened read-only and without the create flag, so the tool cannot change it, and a mistyped path is an error instead of a new empty database.
Moves
Every user table, as records of kind coll:<table>, one record per row.
Every column of a row, as an attribute. Integers, reals and text become JSON numbers and strings, NULL stays null, and a BLOB becomes a hexadecimal string.
Mixed types inside one column are kept as they are, row by row.
A stable record id: the id column when the row has one (text or integer), otherwise the SQLite rowid, hashed into a fixed ULID-format id so a second run produces the same ids.
Does not move
Views. Tables are read; views are not.
Declared column types, indexes, constraints, foreign keys and triggers. No collection definition is created, so field types and unique rules are not carried over.
SQLite internal tables (names that start with sqlite_).
Links between rows. A column that holds another row id keeps the source value and is not rewritten to the new record id.
Limits
The input must be a SQLite database file. A SQL text dump is not one and is rejected with a message that the file is not a readable SQLite database.
--tables takes a comma-separated list. A name that matches no table is an error.
A table without an id column and without a rowid (a WITHOUT ROWID table) gets random record ids, so a second run adds copies under new ids.
Test coverage: 16 tests in the engine repository cover a round trip, id rules, mixed types, blobs, WITHOUT ROWID tables, the read-only open, a missing file, a file that is not SQLite, skipped views and the limit option.
Connects toA Cloudflare D1 database held as a SQLite file, for example the local D1 state file. The file is opened with SQLite default flags, which allow writes, so work on a copy.
Moves
Every user table, as records of kind coll:<name>, one record per row, with the same row mapping and id rules as the SQLite source.
Optional renaming on the way in: --table-map posts=articles writes the posts table as the articles collection.
Does not move
Cloudflare bookkeeping tables (names that start with _cf_) and SQLite internal tables.
Views, declared column types, indexes, constraints and triggers.
Limits
The input must be a SQLite database file. A SQL text export is not one; load it into a SQLite file first.
A name in --tables that matches no table is skipped without an error.
Unlike the SQLite source, this source does not open the file read-only. Work on a copy of the file.
Test coverage: 3 tests in the engine repository cover the skipped tables, the table filter and rename, and tenant-scoped kinds.
Connects toA per-tenant NDJSON export file written by KynetraDB (GET /admin/v1/projects/{id}/export), read from local disk.
Moves
Every entity line of the export, with its original id and embedding, into the target project.
For export format version 2, the typed document-lineage records, restored through the engine destination with their history before their heads.
The export header and trailer, which are used to verify the file before the first row is written.
Does not move
Anything the export states it left out. A version 2 export lists the omitted classes and says whether each can be rebuilt; the tool prints export_complete=true or export_complete=false with that list.
Limits
Full-fidelity restore needs --to engine with --project-id naming a project that already exists in the target data directory (active or paused), the file storage backend, and the server stopped, because the directory is opened exclusively. The HTTP destination carries attributes alone and refuses a file that contains lineage records.
The integrity hash is a checksum. It detects damage, splicing and a relabelled project id; it does not show who produced the file. Keep exports in storage you trust.
The tool copies the export to a private temporary file first, so the disk needs room for the whole export, which is capped at 1 GiB. Verification runs on that copy, and rows are read from the same verified copy.
Restore is not atomic for the whole file. Ordinary rows are applied as they stream, and a later failure leaves them in place; just the staged registry subgraph is discarded. Restore into an isolated target and promote it after you have checked it.
--require-complete refuses an incomplete export and a version 1 export, which cannot show completeness. --limit cannot be combined with an export that carries lineage or registry state.
Test coverage: 26 tests for this source, 37 for the destinations and 6 for lineage restore in the engine repository, including tampered-line, wrong-project, path-swap and crash-and-retry cases.
These work, with a limitation that is written on each source. Read the limits before you point one at real data.
PocketBase
Beta
Connects toA PocketBase data file (pb_data/data.db), which is a SQLite file. It is opened with SQLite default flags, which allow writes, so work on a copy.
Moves
Each collection listed in the _collections table, as records of kind coll:<name>, one record per row, with every column as an attribute.
A stable record id: the PocketBase id, hashed into a fixed ULID-format id (a 26-character id is kept unchanged).
Does not move
File attachments. A file column is copied as the stored file name; the files themselves are not copied.
Collection definitions, API rules and indexes.
PocketBase system tables (_collections, _params, _admins, _externalAuths, _authOrigins, _otps, _superusers and _mfas).
Relationship wiring. A relation column keeps the PocketBase id it held; it is not rewritten to the new record id.
Limits
Auth collections, for example a users collection, are not skipped. They are copied as ordinary records with the columns they hold, and are not turned into KynetraDB users. The tool has no option to leave a collection out, so review the output and remove what you do not want before you load it.
The tool reads the names in the _collections table. A name without a table of the same name is skipped with a warning.
Test coverage: 1 round-trip test in the engine repository reads a synthetic five-row file.
Connects toA JSON file on the local machine, in the nested shape described below. The tool does not contact Firebase.
Moves
Documents from a file with a top-level __collections__ object, as records of kind fb:<collection>, one record per document. A subcollection becomes records of kind fb:<parent>/<child>.
The document id, used as the record id as it is.
Firestore timestamp objects ({_seconds, _nanoseconds}), converted to RFC 3339 text anywhere in a document.
Does not move
GeoPoint values, document references and binary values, which the source marks as out of scope.
Exports that span several files.
Firestore security rules and indexes, Firebase Auth users and Cloud Storage objects.
Limits
The tool reads a file in the shape described above. A file without a top-level __collections__ object produces an empty report and a success exit status, so check the read count.
Records use the kind fb:<collection>, not coll:<collection>. They are entities of that kind, not records of a collection.
The whole file is read into memory.
Test coverage: no test in the engine repository covers this source.
Connects toA PostgreSQL server over a plain TCP connection from the machine that runs the tool. The connection does not use TLS.
Moves
Tables of one schema (public by default; --schema selects another), as records of kind coll:<table>, one record per row, read through a server-side cursor in batches (--batch-size, 1000 by default).
A collection definition built for each table from its column metadata: field types, required flags, single-column unique flags, enum values as select options, and foreign keys as relation fields. The definition is handed to the destination; see the destinations below for which destinations act on it.
Record ids of the form <table>:<primary key> when the key can be read as text or as a 64-bit integer.
Foreign-key values rewritten to the id of the referenced record, unless --no-relations is given.
Table and column names, lowercased with every character other than a letter, digit or underscore replaced by an underscore.
Does not move
Views, materialised views, functions, triggers, sequences, extensions, roles and grants.
Tables of other schemas than the one selected.
Changes made in the source after the copy starts. This is a one-time copy, not replication.
Limits
No TLS. The tool connects without encryption and cannot reach a server that requires it. Run it inside a private network or through an SSH tunnel.
No test in the engine repository reads from a live PostgreSQL server. The 12 tests cover type mapping and nothing else. Run with --dry-run first, then copy a test database and compare row counts and column values, especially timestamp, UUID, numeric, array and JSON columns, before you rely on a run.
A value the row reader cannot convert is written as null without an error.
A row whose primary key cannot be read as text or as a 64-bit integer gets a random id, so a second run adds copies.
--limit caps the total number of rows written across all tables, not per table.
If a collection definition cannot be created, a warning is logged and the copy continues.
The admin route that starts this copy from the console is not working end to end; use the command line. See the Postgres migration job entry.
PostgreSQL invocationbash
kynetra-migrate --to stdout postgres --pg-url postgres://user:password@host:5432/db --schema public --dry-run
Supabase (PostgreSQL)
Beta
Connects toA Supabase project database, or any PostgreSQL server, through a connection URL. The connection does not use TLS.
Moves
Every table in the public schema, as records of kind coll:<table>, one record per row, with every column as an attribute.
A record id from the id or uuid column when it can be read as text; otherwise a random id.
Does not move
Auth users (the auth schema), Storage buckets and objects, Row Level Security policies, database functions, triggers, extensions and views. Tables of the public schema are read; nothing else is.
Table definitions. This source does not describe columns, so no collection definition is created; the PostgreSQL source builds definitions.
Limits
No TLS. The tool connects without encryption and cannot reach a server that requires it. Run it inside a private network or through an SSH tunnel.
If the connection cannot be made, the tool logs a warning, reports zero rows read and exits with a success status. Read the read and written counts in the summary line instead of relying on the exit status.
Each table is read with one query, so the rows of a table are held in memory together.
Arrays and composite types are written as text where the driver supplies a text form for them, and as null otherwise. A value the row reader cannot convert is written as null without an error.
No test in the engine repository reads from a live PostgreSQL server for this source. Copy a test database first and compare row counts and column values.
A table that cannot be queried is skipped with a warning.
Connects toA MongoDB deployment through a connection URL and a database name. Transport protection follows the options in the URL.
Moves
Every collection in the named database, as entities of kind mongo:<collection>, one entity per document.
Document fields converted to JSON: ObjectId as hexadecimal text, dates as text, binary as hexadecimal text, nested documents and arrays kept, and other BSON types written in their text form.
A stable record id hashed from the _id value. The _id field also stays in the attributes.
Does not move
GridFS files, indexes, collection options and validators, change streams, users and roles.
Limits
Every collection in the database is read. There is no option to select collections.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: 2 tests in the engine repository cover id hashing and primitive conversion. None connects to a server.
Connects toThe Algolia Browse API over HTTPS for one index, with an application id and an API key.
Moves
Records of one index, as entities of kind algolia:<index>, with every attribute except objectID.
A stable record id hashed from objectID.
Does not move
Replica indexes, rules, synonyms and index settings.
The original objectID value. It is removed from the attributes and just the hashed id remains.
Limits
The tool stops after 10 pages of 1,000 records, which is 10,000 records, with a warning and a success exit status. A larger index is copied in part.
A failed request or a non-success response ends the run early with a warning and a success exit status. Compare the read count with the size of the index.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: no test in the engine repository covers this source.
Connects toThe Meilisearch documents API for one index, with the instance URL and an API key sent as a bearer token. Use an https URL for a remote instance.
Moves
All documents of one index, fetched 1,000 at a time, as entities of kind meili:<index> with their fields unchanged.
A stable record id hashed from a text id field. A document without a text id gets an id hashed from the whole document, which changes when the document changes.
Does not move
Index settings (ranking rules, synonyms, filterable attributes), API keys and tasks.
More than one index per run.
Limits
A failed request or a non-success response ends the run early with a warning and a success exit status. Compare the read count with the size of the index.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: 2 tests in the engine repository cover id hashing. None calls the API.
Connects toThe Pinecone data-plane REST API over HTTPS for one index host, with an API key and an optional namespace.
Moves
The vectors of one namespace and their metadata, as entities of kind pinecone:<index name>, with the vector as the entity embedding and the metadata as attributes.
A stable record id hashed from the Pinecone vector id.
Does not move
Sparse vectors.
Namespaces other than the one selected, and index configuration.
The original vector id. Just the hashed id remains.
Limits
All vector ids are listed first and held in memory, then fetched in groups of 100.
If listing fails part-way, the tool continues with the ids it has listed and exits with a success status. Compare the read count with the size of the index.
The vector travels with the entity to destinations that keep embeddings, which are the engine and NDJSON destinations. The HTTP destination sends attributes alone.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: no test in the engine repository covers this source.
Connects toA Convex deployment over HTTPS, with its admin key and two helper functions that you have already deployed in your project.
Moves
The rows of every table that your list-tables function returns, as entities of kind convex:<table>, with their fields unchanged.
A stable record id hashed from the Convex _id.
Does not move
File storage, scheduled functions, auth tables, subscriptions and schema definitions.
Limits
Convex has no built-in table dump, so this source calls two functions you must add to your project. By default they are internal/migration:listTables, which returns the table names, and internal/migration:listRows, which takes a table and returns its rows. Other names can be supplied with --list-tables-fn and --list-rows-fn. If the first function is missing the tool fails with an explanatory error.
Each table is read with one call to your function, so your function decides how many rows come back in that call.
A table whose call fails is skipped with a warning.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: 2 tests in the engine repository cover id hashing and the default function names. None calls a deployment.
Connects toAn Appwrite project through its REST API over HTTPS, with a project id and an API key.
Moves
Every document of every collection of every database in the project, as entities of kind appwrite:<database name>/<collection name>, with all fields including the $-prefixed system fields.
A stable record id hashed from the document $id.
Does not move
Storage buckets, auth users, functions, teams and messaging.
Collection attribute definitions and indexes.
Limits
Documents are read 100 at a time. The lists of databases and of collections are each read with one request, so confirm that every collection appears in the output.
A collection that cannot be read is skipped with a warning.
Entities have a source-specific kind, so they are not records of a KynetraDB collection.
Test coverage: 2 tests in the engine repository cover id hashing and URL encoding. None calls the API.
These sources have no migrator. They are listed so that you do not have to find out by trying.
MySQL
Not supported
Connects toNot supported. kynetra-migrate has no MySQL subcommand.
Does not move
Everything. KynetraDB cannot read from a MySQL server.
Limits
The one place MySQL appears in the engine is the outbound PlanetScale sink, which writes from KynetraDB to a MySQL-compatible table. It goes the other direction and cannot be used to import.
The server ingestion path registers no MySQL inlet either.
To bring MySQL data in today, export it to files and load it through the HTTP API, or move it into PostgreSQL first and use the PostgreSQL source with its limits.
MariaDB
Not supported
Connects toNot supported. kynetra-migrate has no MariaDB subcommand.
Does not move
Everything. KynetraDB cannot read from a MariaDB server.
Limits
No MariaDB adapter exists in the engine code, as a source or as an outbound sink.
To bring MariaDB data in today, export it to files and load it through the HTTP API, or move it into PostgreSQL first and use the PostgreSQL source with its limits.
SQL Server and Oracle
Not supported
Connects toNot supported. kynetra-migrate has no subcommand for either.
Does not move
Everything. KynetraDB cannot read from SQL Server or Oracle.
Limits
Neither the migrator nor the server ingestion path has an adapter for these databases.
Export the data to files and load it through the HTTP API.
DynamoDB and Redis
Not supported
Connects toNot supported as sources. kynetra-migrate has no subcommand for either.
Does not move
Everything. KynetraDB cannot read from DynamoDB or Redis.
Limits
Both appear as outbound sinks alone (DynamoDB, and Redis through the Upstash REST API), which write from KynetraDB to them.
Export the data to files and load it through the HTTP API.
Elasticsearch and OpenSearch
Not supported
Connects toNot supported. kynetra-migrate has no subcommand for either.
Does not move
Everything. KynetraDB cannot read from Elasticsearch or OpenSearch.
Limits
The search-engine sources that exist are Algolia, Meilisearch and Typesense.
Export the documents to files and load them through the HTTP API.
Other vector databases (Qdrant, Weaviate, Chroma)
Not supported
Connects toNot supported. kynetra-migrate has no subcommand for them.
Does not move
Everything. KynetraDB cannot read from these vector databases.
Limits
The vector-database source that exists is Pinecone.
Export vectors and metadata to files and load them through the HTTP API, which accepts an embedding with each record.
Warehouses and streams (BigQuery, Snowflake, Redshift, ClickHouse, Databricks, Kafka)
Not supported
Connects toNot supported as sources.
Does not move
Everything. KynetraDB cannot read from these systems.
Limits
BigQuery appears as an outbound sink alone.
Export the data to files and load it through the HTTP API.
Outbound
The other direction
Outbound sinks are KynetraDB writing to another database. They are separate from the migrators above, which read from another system into KynetraDB. The note on each sink says what it does today.
PostgREST-style REST endpoint
Beta
Upserts rows into a table through an HTTP endpoint with a merge-duplicates preference, and deletes by id. Settings: KYNETRA_POSTGREST_URL, KYNETRA_POSTGREST_KEY, KYNETRA_POSTGREST_TABLE. Request shapes are covered by 2 tests against a mock server.
Supabase REST
Beta
Same row shape through the Supabase REST API with the service key. Settings: KYNETRA_SUPABASE_URL, KYNETRA_SUPABASE_SERVICE_KEY, KYNETRA_SUPABASE_TABLE. Request shapes are covered by 2 tests against a mock server.
MongoDB Atlas Data API
Beta
Upserts one document per entity keyed on the entity id and deletes by id, through the Atlas Data API over HTTPS. Confirm that your MongoDB deployment still offers the Data API before you rely on it. Settings: KYNETRA_MONGO_DATA_API, KYNETRA_MONGO_API_KEY, KYNETRA_MONGO_DATABASE, KYNETRA_MONGO_COLLECTION, KYNETRA_MONGO_DATA_SOURCE. Request shapes are covered by 2 tests against a mock server.
Amazon DynamoDB
Beta
Writes items over the DynamoDB JSON protocol with AWS Signature Version 4 signing implemented in the crate. Settings: KYNETRA_DYNAMO_REGION, KYNETRA_DYNAMO_TABLE, KYNETRA_DYNAMO_ACCESS_KEY, KYNETRA_DYNAMO_SECRET_KEY. The endpoint is fixed in code by region, so there is a configuration test and no request-shape test.
Google BigQuery
Beta
Streams rows with a deleted flag instead of removing them, so the table is append-only. Authenticates with a prepared access token that is not refreshed. Settings: KYNETRA_BIGQUERY_PROJECT, KYNETRA_BIGQUERY_DATASET, KYNETRA_BIGQUERY_TABLE, KYNETRA_GCP_TOKEN. Configuration test, no request-shape test.
Google Firestore
Beta
Patches a document per entity through the Firestore REST API, with values wrapped in the typed-value envelope. Authenticates with a prepared access token that is not refreshed. Settings: KYNETRA_FIRESTORE_PROJECT, KYNETRA_FIRESTORE_COLLECTION, KYNETRA_GCP_TOKEN. Configuration test, no request-shape test.
Cloudflare D1
Beta
Runs parameterised SQL through the D1 REST API into a table named entities with the columns id, kind, attrs, embedding, created_at and updated_at. Settings: KYNETRA_CF_ACCOUNT_ID, KYNETRA_CF_API_TOKEN, KYNETRA_CF_D1_DATABASE. Configuration test, no request-shape test.
Cloudflare Workers KV
Beta
Stores the entity JSON under the entity id. Settings: KYNETRA_CF_ACCOUNT_ID, KYNETRA_CF_API_TOKEN, KYNETRA_CF_KV_NAMESPACE. Configuration test, no request-shape test.
Cloudflare R2
Beta
Writes one JSON object per entity at a path made from its kind and id, with Signature Version 4 signing. Settings: KYNETRA_CF_R2_ACCOUNT, KYNETRA_CF_R2_BUCKET, KYNETRA_CF_R2_ACCESS_KEY, KYNETRA_CF_R2_SECRET_KEY. Configuration test, no request-shape test.
Cloudflare Vectorize
Beta
Mirrors vectors alone. An entity without an embedding is skipped. Settings: KYNETRA_CF_ACCOUNT_ID, KYNETRA_CF_API_TOKEN, KYNETRA_CF_VECTORIZE_INDEX. One test covers the skip rule; there is no request-shape test.
Upstash Redis (REST)
Beta
Sets the entity JSON as the value at the entity id through the REST interface, so the value travels in the request path and large entities are impractical. Settings: KYNETRA_REDIS_URL, KYNETRA_REDIS_TOKEN. Request shapes are covered by 2 tests against a mock server.
Pinecone
Beta
Mirrors vectors alone. An entity without an embedding is skipped. Settings: KYNETRA_PINECONE_HOST, KYNETRA_PINECONE_API_KEY. Request shapes and the skip rule are covered by 3 tests against a mock server.
PlanetScale and other MySQL-compatible tables
Beta
Inserts or updates a row per entity in a MySQL-compatible table with the columns id, kind, attrs, embedding, created_at and updated_at, and deletes by id. This writes from KynetraDB to MySQL; it is not a MySQL source. Settings: KYNETRA_PLANETSCALE_URL, KYNETRA_PLANETSCALE_TABLE. Configuration test, no request-shape test.