DB Mover gives you a visual interface to copy, back up, or browse your databases. Instead of remembering pg_dump flags or mongodump arguments, you paste your connection strings, hit run, and watch live logs confirm every step. No terminal, no docs rabbit hole, just a straightforward tool that moves data from A to B.
flowchart LR
Client["Web Client (React)"]
Server["Hono API Server"]
Adapters["Database Adapters"]
MongoDB[("MongoDB")]
PostgreSQL[("PostgreSQL")]
MySQL[("MySQL")]
Redis[("Redis")]
Firebase[("Firebase")]
Client --> Server
Server --> Adapters
Adapters --> MongoDB
Adapters --> PostgreSQL
Adapters --> MySQL
Adapters --> Redis
Adapters --> Firebase
style Client fill:#1e1b4b,stroke:#6366f1,stroke-width:2px,color:#fff
style Server fill:#2e1065,stroke:#8b5cf6,stroke-width:2px,color:#fff
style Adapters fill:#2e1065,stroke:#8b5cf6,stroke-width:2px,color:#fff
style MongoDB fill:#022c22,stroke:#10b981,stroke-width:2px,color:#fff
style PostgreSQL fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#fff
style MySQL fill:#0f172a,stroke:#3b82f6,stroke-width:2px,color:#fff
style Redis fill:#4c0519,stroke:#ef4444,stroke-width:2px,color:#fff
style Firebase fill:#451a03,stroke:#f59e0b,stroke-width:2px,color:#fff
Move data between two databases of the same engine. The UI guides you through pasting both URIs, then handles the dump, transfer, and restore while streaming live progress.
sequenceDiagram
actor User
participant Client as Web App
participant Server as Hono API
participant Migration as Migration Service
participant SourceDB as Source Database
participant TargetDB as Target Database
User->>Client: Enter source & target URIs
Client->>Server: Start copy migration
Server->>Migration: Create job
Migration->>SourceDB: Connect & read data
Migration->>TargetDB: Insert records
loop While data remains
Migration->>Server: Update progress & logs (SSE)
Server->>Client: Stream status
Client->>User: Show live logs
end
Migration->>Server: Mark job completed
Server->>Client: Completion notification
Client->>User: Display success
Grab a compressed zip of your entire database with one click. The app streams the file directly to your browser, no intermediate storage needed.
sequenceDiagram
actor User
participant Client as Web App
participant Server as Hono API
participant Adapter as DB Adapter
participant SourceDB as Source Database
User->>Client: Request backup download
Client->>Server: POST /download
Server->>Adapter: Run download
Adapter->>SourceDB: Dump all data
Adapter->>Server: Pipe zip archive
Server->>Client: Stream ZIP file
Client->>User: Browser download prompt
Explore your database schema and preview up to 100 rows per table or collection, right in the browser. Read‑only by design; no accidental writes.
sequenceDiagram
actor User
participant Client as Web App
participant Server as Hono API
participant Browser as Browser Service
participant DB as Connected Database
User->>Client: Select Browse mode
Client->>Server: Request schema
Server->>Browser: List objects
Browser->>DB: Fetch collections/tables
DB->>Browser: Object list
Browser->>Server: Return objects
Server->>Client: Display schema tree
User->>Client: Click a table/collection
Client->>Server: Preview object data
Server->>Browser: Query preview
Browser->>DB: Paginated data
DB->>Browser: Rows
Browser->>Server: Preview result
Server->>Client: Show data grid
Same clean workflow for MongoDB, PostgreSQL, MySQL, Redis, and Firebase (Realtime Database & Firestore). The UI adapts to what each engine expects.
Real‑time progress bar, streaming logs with timestamps, and key stats like collections processed and documents moved. When it finishes, confetti confirms success.
Connection strings and service‑account keys stay in your browser’s session storage and are cleared when you close the tab.
- Clone the repository:
git clone https://github.com/JC-Coder/db-mover.git
- Install dependencies (root, client, and server):
cd db-mover npm run install:all - Start the development servers:
This runs both the Vite frontend (on port 5173, proxying API to 3000) and the Hono backend (on port 3000).
npm run dev
To run in production, build the client (npm run build --workspace=client), build the server (npm run build --workspace=server), then start the server with node server/dist/index.js. The built client assets will be served from the public folder.
- Visit the landing page and click Launch App.
- Pick your database engine (MongoDB, PostgreSQL, MySQL, Redis, or Firebase).
- Choose a mode: Copy (source → target), Download (backup zip), or Browse (explore data).
- Paste your connection strings. For Firebase, you’ll also upload a service‑account JSON.
- Click Start migration, Download backup, or Open Data Browser.
- For copy jobs, you’ll be taken to a live dashboard that shows progress, logs, and final stats.
- For downloads, a zip file will begin downloading immediately.
- The browser mode lets you expand a schema tree, click any table/collection, and inspect rows with a built‑in JSON viewer.
| Technology | Link |
|---|---|
| TypeScript | typescriptlang.org |
| React 18 | react.dev |
| Vite | vitejs.dev |
| Tailwind CSS | tailwindcss.com |
| Hono | hono.dev |
| MongoDB driver | mongodb.com |
| pg (PostgreSQL) | node-postgres.com |
| mysql2 | github.com/sidorares/node-mysql2 |
| ioredis | github.com/redis/ioredis |
| Firebase Admin | firebase.google.com |
| Framer Motion | framer.com/motion |
| Recharts | recharts.org |
| Archiver | archiverjs.com |
Quickly spin up the mover using Docker:
docker build -t db-mover .
docker run -p 3000:3000 db-moverDB Mover collects anonymous product-usage telemetry that powers the public /stats dashboard, and it is on by default in every install, including self-hosted ones. There is no opt-out flag: the numbers are published openly, and they are only meaningful if they describe all usage rather than a self-selected sample.
Production builds report to https://dbmover.cloud/api/telemetry/event unless VITE_PUBLIC_CENTRAL_TELEMETRY_URL says otherwise; development builds always stay same-origin. Operation results (records moved, durations, outcomes) are produced on the server rather than in the browser, so a server without its own POSTHOG_API_KEY forwards those events to the same central relay. A self-hosted install therefore makes outbound HTTPS requests to dbmover.cloud. Set DB_MOVER_CENTRAL_TELEMETRY_URL to redirect them elsewhere, or set POSTHOG_API_KEY to keep events in your own PostHog project instead. All sends are best-effort and failures never affect a migration.
Collected fields are limited to a random visitor/session UUID stored in browser storage, the current route, the referring site's hostname, screen width, database type, copy/download/browser mode, operation outcomes and durations, aggregate record and object counts, deployment type, environment, and app version. Failures report a classified code (auth_failed, host_not_found, connection_timeout, …) and never the error text.
DB Mover never collects database URLs or credentials, infrastructure hostnames, database/table/collection/key names, record contents, service-account data, raw logs, or raw error messages.
The relay endpoint accepts only known event names and property keys, requires a UUID visitor id, caps request bodies at 4 KB, and rate-limits each client to 120 events per minute. Values shaped like a URI are dropped before anything is sent.
To enable telemetry on your own deployment, set these on the server:
POSTHOG_API_KEY=<project-api-key>
POSTHOG_HOST=https://us.i.posthog.com # optional, this is the default
DB_MOVER_VERSION=1.0.0 # optional, tags events with your build version
DB_MOVER_DEPLOYMENT=self_hosted # optional, overrides host-based detection
DB_MOVER_HOSTED_DOMAIN=dbmover.cloud # optional, domain treated as the hosted deployment
DB_MOVER_CENTRAL_TELEMETRY_URL=... # optional, where a keyless server forwards eventsEvents are tagged hosted or self_hosted from the request's Host header, so the split is correct without any configuration; DB_MOVER_DEPLOYMENT is only needed to override that. The environment tag is decided by the server (NODE_ENV) — a client can mark itself as development but can never promote itself into the production numbers.
The /stats dashboard reads back aggregates through the PostHog query API (cached for 5 minutes per range), which additionally needs:
POSTHOG_PERSONAL_API_KEY=<personal-api-key>
POSTHOG_PROJECT_ID=<project-id>Hosted and self-hosted events are told apart by the browser's Origin header, which page scripts cannot forge; forwarded server events may only ever declare themselves self-hosted. Telemetry failures are non-blocking and isolated from database copy, download, browse, and page requests.
This project is licensed under the MIT License. See LICENSE for the full text.
We welcome contributions! Whether it's adding a new database adapter or improving the UI, please see our CONTRIBUTING.md.
Joseph
