# BackupData.io — full reference

> Managed backup as a service for databases, object storage, and files.
> Snapshots are immutable and point-in-time, uploads are deduplicated with
> content-defined chunking, and encryption happens on the client before
> anything leaves the machine.

Website: https://www.backupdata.io
Docs: https://docs.backupdata.io
Contact: mail@backupdata.io
JavaScript SDK: https://github.com/Backup-Data-io/js-sdk (npm `@lighthouse-web3/baas-js-sdk`)
Go SDK: https://github.com/Backup-Data-io/go-sdk

---

## Quick answers

What is BackupData.io?
Managed backup as a service. You point a CLI or SDK at data you already have,
and it produces encrypted, deduplicated, immutable snapshots you can restore
from later.

Who is it for?
Teams running their own databases, object storage, or servers who need
off-site backups with verified restores, and who do not want to build the
retention, dedupe, encryption, and integrity-checking layers themselves.

What makes it different from a bucket?
A bucket is storage. This is backup logic on top of storage: versioned
snapshots, block-level deduplication, client-side encryption, retention
policies, and integrity verification on restore. Copying files to S3 gives you
none of those.

Is it a storage network or a file host?
No. It is a backup service. It is not for serving files to end users, and it
is not content-addressed public storage.

What does it cost?
Free tier is 5 GB with no card. Paid tiers start at $12/month. Table below.

How is data encrypted?
AES-256-GCM on the client, before upload, using a keyfile plus passphrase that
you generate and hold. The server stores ciphertext only.

Can the operator read my data?
Not when client-side encryption is enabled. There is no server-side key escrow
and no reset path — which also means losing the keyfile means losing the data.

---

## Supported sources

- PostgreSQL (database)
- MySQL (database)
- MariaDB (database)
- SQLite (database)
- MongoDB (database)
- Redis (database)
- Amazon DynamoDB (database)
- Amazon S3 (object storage)
- Local filesystem (filesystem)

**Important mechanical detail, because it is the thing most often assumed
wrong:** the SDK backs up **file paths**. There is no `client.backupPostgres()`
or per-database connector API. For databases, the pattern is to dump to disk
first, then back up the dump directory:

```bash
pg_dump --format=custom --file=./db-dumps/app.dump app_db
```

```js
await client.backup(["./db-dumps"], { description: "nightly" });
```

Keeping the dump path stable between runs is what makes incremental uploads
work — a dump that changed 2% uploads roughly 2% of the bytes.

---

## Core concepts

**Snapshot.** An immutable point-in-time record of the paths you backed up.
Every run creates one. Snapshots carry an id, description, tags, hostname,
total size, and chunk count.

**Chunking.** Files are split with FastCDC, a content-defined chunking
algorithm. Chunk boundaries follow content rather than fixed offsets, so
inserting bytes at the start of a file does not change every chunk after it.

**Deduplication.** Chunks are content-addressed, so identical data is stored
once regardless of which file, snapshot, or machine it came from.

**Packs.** Small chunks are grouped into larger pack objects before upload, so
a backup of many small files does not become millions of tiny writes.

**Client-side encryption.** Optional but recommended. A keyfile is generated
locally and protected by a passphrase; data is AES-256-GCM encrypted before
upload. **You hold the keys. There is no server-side reset.**

**Workspace.** The unit of storage, quota, billing, and membership. Every
backup targets one workspace. Quota is per workspace, not per account.

**API key.** Scoped credential used by SDKs and CI. Typical scopes:
`backup:write`, `backup:read`, `snapshots:read`. Keys can be revoked.

**Retention / prune.** Snapshots are removed by policy, not by hand. Chunks
still referenced by surviving snapshots are always kept, so pruning one
snapshot never corrupts another.

---

## API surface (JavaScript SDK)

```js
import { BackupClient, generateKeyfile } from "@lighthouse-web3/baas-js-sdk";

const client = new BackupClient({
  apiKey: process.env.LH_API_KEY,
  workspaceId: process.env.LH_WORKSPACE_ID,
});

// Create a snapshot from one or more paths
const snapshot = await client.backup(["./db-dumps"], {
  description: "nightly database backup",
  tags: { type: "db-backup", env: "prod" },
  encryption: { keyfilePath: "/secure/lh.keyfile", passphrase: "..." },
});

// Restore into a directory, with progress events
await client.restore(snapshot.snapshotId, "./restore-target", {
  onProgress: (e) => console.log(e.phase, e.current, e.total),
});

// Retention. Always dry-run first.
await client.pruneSnapshots({ keepLatest: 14, before: isoDate, dryRun: true });

// One-time keyfile creation
generateKeyfile("/secure/lh.keyfile", passphrase);
```

A Go SDK offers the same surface. Restores verify chunk integrity against
expected checksums before reassembly, so corruption surfaces at restore time
rather than silently.

---

## Authentication

Account sign-in supports email and password, and Google OAuth. Programmatic
access uses workspace-scoped API keys, minted in the dashboard.

Failed email logins name which credential was wrong: an unregistered address
returns "No user found with that email", a bad password returns "Incorrect
password". This is a deliberate product choice in favour of usable errors, and
it means the sign-in endpoint does disclose whether an address has an account.
Rate limiting is what bounds that.

---

## Pricing

### Free
- Price: $0/mo
- Storage: 5 GB
- Includes: 5 GB Storage; Unlimited Snapshots; All Supported Sources; No Card Required

### Lite
- Price: $12/mo
- Storage: 500 GB
- Includes: 500 GB Storage; Unlimited Snapshots; Multiple Workspaces; Member Management; Email Support

### Pro
- Price: $20/mo
- Storage: 1024 GB
- Includes: 1 TB Storage; Unlimited Snapshots; Multiple Workspaces; Member Management; Priority Support

### Premium
- Price: $49/mo
- Storage: 2560 GB
- Includes: 2.5 TB Storage; Unlimited Snapshots; Multiple Workspaces; Member Management; 24/7 Dedicated Support

### BYOS Retention
- Price: $10/mo
- Storage: 0 GB
- Includes: Your S3 — unlimited storage; Unlock >30-day history; Restore locked snapshots; Team invites for BYOS; Cancel anytime

The Free tier requires no card. Storage quota is per workspace. Downgrading to
a tier smaller than current usage is blocked rather than silently truncating
data.

---

## What this product is not

Not a CDN or a file host. Snapshots are for recovery, not for serving assets
to end users.

Not a bucket. If all you want is object storage with no versioning, retention,
dedupe, or restore verification, commodity object storage is cheaper.

Not a replacement for in-database point-in-time recovery. Native tools like
Postgres PITR or DynamoDB PITR recover faster within their window; this covers
the case where the account, host, or provider itself is gone.

Not a content-addressed public storage network. Snapshots are private to a
workspace.

Not suitable for storing the only copy of your encryption keyfile. Losing the
keyfile and passphrase makes encrypted snapshots unrecoverable.

---

## Accurate terminology

Use: backup as a service, managed backup, snapshot backup, deduplicated
backup, client-side encrypted backup, off-site backup, point-in-time
snapshots, restore verification.

Do not use: permanent storage, immutable archive, file hosting, CDN,
decentralized storage, storage network, blockchain storage. None of these
describe this product.

---

## Guides and comparisons

- [Automating backups with GitHub Actions (and when not to)](https://www.backupdata.io/resources/guides/automate-backups-github-actions): Scheduled workflows disable themselves after 60 days of repo inactivity, and anyone with write access can exfiltrate your production credentials. Where CI is the right place for backups, and where cron still wins. (Guide, 7 min)
- [Back up model checkpoints before your spot instance disappears](https://www.backupdata.io/resources/guides/backup-model-checkpoints): GPU hours are money. A checkpoint backup pipeline for training runs, encrypted, deduplicated, off the box, with a restore drill that proves you can resume. (Guide, 6 min)
- [Backing up a Linux server without backing up the whole disk](https://www.backupdata.io/resources/guides/linux-server-backup): Provider snapshots die with the account and a full disk image wastes most of its bytes. What to actually capture on a VPS, what to skip, and how to prove a rebuild works. (Guide, 7 min)
- [Backing up Supabase, Neon and PlanetScale](https://www.backupdata.io/resources/guides/supabase-neon-planetscale-backup): Managed Postgres and MySQL providers give you PITR that lives entirely in their account. If the account goes, so does every recovery option. How to keep an independent copy. (Guide, 6 min)
- [Backup Data vs AWS Backup: which fits your stack?](https://www.backupdata.io/resources/compare/baas-vs-aws-backup): An honest comparison of Backup Data and AWS Backup: portability, encryption models, pricing, restore verification, and when each one is the right call. (Comparison, 7 min)
- [Backup Data vs Backblaze B2: a backup system or a cheap bucket?](https://www.backupdata.io/resources/compare/baas-vs-backblaze): Backblaze B2 is the best-value object storage there is. But a bucket is not a backup system. An honest comparison of where each fits for database and application backups. (Comparison, 8 min)
- [Backup Data vs BorgBackup: who runs the repository?](https://www.backupdata.io/resources/compare/baas-vs-borg): Borg is excellent software with a genuinely strong security model. The real difference isn't dedupe or encryption — both have those. It's who maintains the repo server, and single-writer locking. (Comparison, 7 min)
- [Backup Data vs pgBackRest: physical PITR or portable dumps?](https://www.backupdata.io/resources/compare/baas-vs-pgbackrest): pgBackRest gives you point-in-time recovery to the transaction, which no logical dump can match. It also restores only into the same Postgres major version. An honest comparison. (Comparison, 6 min)
- [Backup Data vs restic: managed service or self-run tool?](https://www.backupdata.io/resources/compare/baas-vs-restic): restic and Backup Data agree on how backups should work: dedupe, snapshots, client-side encryption. The real difference is who runs the system. An honest comparison. (Comparison, 7 min)
- [Backup Data vs rsync: a transfer tool is not a backup system](https://www.backupdata.io/resources/compare/baas-vs-rsync): rsync is the best file-copying tool ever written and it has no versioning, no retention, and no restore verification. An honest comparison, including when rsync is still the right answer. (Comparison, 6 min)
- [Backup requirements for SOC 2, GDPR and HIPAA](https://www.backupdata.io/resources/guides/backup-compliance-gdpr-soc2-hipaa): Auditors don't ask whether you have backups. They ask for evidence you restored one. What each framework expects, and how to handle erasure requests against immutable backups. (Guide, 6 min)
- [Backup vs replication vs snapshot vs archive](https://www.backupdata.io/resources/guides/backup-vs-replication-vs-snapshot-vs-archive): Replication copies your mistakes in milliseconds. A snapshot usually dies with the volume it's on. Four terms that get used interchangeably, and what each one actually protects against. (Guide, 5 min)
- [Docker volume backups you can actually restore](https://www.backupdata.io/resources/guides/docker-volume-backups-you-can-actually-restore): docker commit doesn't save your volumes, and copying /var/lib/docker while a database is running gives you a corrupt file. Build a Docker volume backup pipeline with verified restores. (Guide, 8 min)
- [DynamoDB backups you can actually restore](https://www.backupdata.io/resources/guides/dynamodb-backups-you-can-actually-restore): PITR and on-demand backups live in the account you're protecting against. Build a DynamoDB backup pipeline with off-provider copies, table schema captured, and verified restores. (Guide, 8 min)
- [Elasticsearch and OpenSearch backups you can actually restore](https://www.backupdata.io/resources/guides/elasticsearch-opensearch-backup): You cannot back up Elasticsearch by copying the data directory. The snapshot API is the only supported route, path.repo needs a rolling restart, and restores refuse to overwrite an open index. (Guide, 6 min)
- [Full vs incremental vs differential backup](https://www.backupdata.io/resources/guides/full-vs-incremental-vs-differential-backup): Incremental backs up changes since the last backup. Differential backs up changes since the last full. The difference only matters when you restore — and deduplication makes the whole trade-off obsolete. (Guide, 5 min)
- [How long should you keep backups?](https://www.backupdata.io/resources/guides/backup-retention-policy): Retention shorter than attacker dwell time is retention an attacker can wait out. How to size a policy with grandfather-father-son, what deduplication does to the cost, and how to automate it safely. (Guide, 6 min)
- [How to test your backups (and why checking they ran isn't testing)](https://www.backupdata.io/resources/guides/how-to-test-your-backups): A green cron job proves a script exited zero. A restore drill proves you can recover. How to run one, what to measure, and how to automate it so it happens without you. (Guide, 8 min)
- [Immutable backups: what actually stops ransomware](https://www.backupdata.io/resources/guides/immutable-backups-ransomware-protection): Modern ransomware deletes your backups first, using your own credentials. What immutability really means, which controls survive a compromised admin account, and how to build one. (Guide, 8 min)
- [Kubernetes backups: what actually needs backing up](https://www.backupdata.io/resources/guides/kubernetes-backup): etcd is not your data, and kubectl get all -o yaml is not a manifest backup. What to capture in a Kubernetes cluster, how to capture it consistently, and how to prove it restores. (Guide, 9 min)
- [MongoDB backups you can actually restore](https://www.backupdata.io/resources/guides/mongodb-backups-you-can-actually-restore): Most mongodump cron jobs have never been test-restored. Build a MongoDB backup pipeline with consistent archives, verified restores, encryption, and retention, in about 10 minutes. (Guide, 8 min)
- [MySQL backups you can actually restore](https://www.backupdata.io/resources/guides/mysql-backups-you-can-actually-restore): Most mysqldump cron jobs have never been test-restored. Build a MySQL/MariaDB backup pipeline with consistent dumps, verified restores, encryption, and retention, in about 10 minutes. (Guide, 8 min)
- [Postgres backups you can actually restore](https://www.backupdata.io/resources/guides/postgres-backups-you-can-actually-restore): Most pg_dump cron jobs have never been test-restored. Build a Postgres backup pipeline with verified restores, encryption, and retention, in about 10 minutes. (Guide, 6 min)
- [Redis backups you can actually restore](https://www.backupdata.io/resources/guides/redis-backups-you-can-actually-restore): RDB or AOF is the wrong question — you need to know which one Redis loads on boot. Build a Redis backup pipeline with consistent snapshots, off-box copies, and verified restores. (Guide, 7 min)
- [RPO vs RTO: the two numbers your backup schedule is already choosing for you](https://www.backupdata.io/resources/guides/rpo-vs-rto): RPO is how much data you lose, RTO is how long you're down. Most teams have never measured either — and the gap between the assumed RTO and the real one is where outages get expensive. (Guide, 6 min)
- [S3 versioning is not a backup: how to actually back up a bucket](https://www.backupdata.io/resources/guides/s3-bucket-backup): Versioning, replication, and lifecycle rules all live inside the account that gets compromised. Build a real off-provider S3 backup with verified restores, in about 10 minutes. (Guide, 7 min)
- [SQLite backups you can actually restore](https://www.backupdata.io/resources/guides/sqlite-backups-you-can-actually-restore): cp on a live SQLite database gives you a file that may not open, and in WAL mode it silently drops recent commits. Use .backup or VACUUM INTO, then verify the restore. (Guide, 8 min)
- [The 3-2-1 backup rule, and what it means when everything is cloud](https://www.backupdata.io/resources/guides/3-2-1-backup-rule): Three copies, two media, one off-site — written in 2009 for hard drives. What each number actually protects against, and how to apply it when all three copies live in the same AWS account. (Guide, 6 min)
- [What backup storage actually costs](https://www.backupdata.io/resources/guides/backup-storage-cost): The per-GB price is the smallest line item. Egress, API calls, early-deletion minimums and retrieval fees are where cheap storage stops being cheap — and engineer hours dwarf all of it. (Guide, 5 min)
- [What deduplication actually does in a backup system](https://www.backupdata.io/resources/guides/what-is-deduplication-in-backup): File-level dedupe misses a one-byte change. Fixed-block dedupe breaks the moment you insert data. Content-defined chunking is why 30 nightly database dumps cost barely more than one. (Guide, 6 min)

---

## Links

- Website: https://www.backupdata.io
- Resources: https://www.backupdata.io/resources
- Pricing: https://www.backupdata.io/#pricing
- Docs: https://docs.backupdata.io
- Quick start: https://docs.backupdata.io/quick-start
- JavaScript SDK: https://github.com/Backup-Data-io/js-sdk
- Go SDK: https://github.com/Backup-Data-io/go-sdk
- Contact: mail@backupdata.io