Netlify 18 ๐ Netlify Database & Branching โ Running managed serverless Postgres with isolated database branches per Deploy Preview
The hardest part of adding a database to a Netlify site has never been the query syntax. It has been the collision between two models that do not fit together. A Deploy Preview exists so that a pull request can be reviewed in a working environment before it merges. If that preview shares the production database, then a reviewer clicking “delete” while testing an admin panel destroys real customer rows. If the preview has no database at all, then the preview is not a working environment and the review is theatre. Most teams resolved this by giving up on previews for anything data-driven, or by hand-building a staging database that drifts from production within hours.
Netlify Database is a response to that collision. It is managed Postgres, provisioned with one command, with the connection string injected into the function environment automatically. The feature that matters is not Postgres itself โ Postgres is not scarce โ it is branching. Every Deploy Preview and every branch deploy gets its own copy-on-write branch of the database, forked from production at the moment of deployment. A preview that writes a thousand rows costs a few changed storage pages, not a thousand-row copy, and deleting the preview releases them.
This chapter covers the three layers in order. The first section is provisioning and connection โ what actually gets created, what environment variable carries the URL, and which of the two available drivers a serverless function should use. The second section is the branching model, including the privacy consequence that a preview branch is a snapshot of production data and therefore contains production data. The third section is the deploy lifecycle โ where migrations live, when they are applied, and why a migration that cannot survive a rollback will eventually strand a preview.
Key point: Netlify Database is managed Neon Postgres where the unit of isolation is the branch, not the server โ a Deploy Preview receives a copy-on-write fork of the production database with its own connection URL, so schema and data experiments in a pull request are invisible to production and cost only the pages that actually changed.
Why exists
The shared-staging problem. A single staging database shared by every open pull request is not isolation, it is a queue. Two engineers testing conflicting schema changes against the same instance produce failures that neither of them caused, and the failures look like application bugs. Branching makes each pull request its own environment by default, which is what a preview was supposed to mean in the first place.
The copy-cost problem. The reason nobody built per-preview databases manually is that per-preview databases are expensive. pg_dump and restore of a real schema takes minutes and doubles storage. Copy-on-write branching happens in seconds because it copies references rather than pages, and it costs nothing until the branch diverges. That economic shift is what makes the isolation practical rather than aspirational.
The fixture problem. A preview needs realistic data to review a feature honestly. Ten fabricated rows will not reveal that a pagination component breaks at four thousand. A branch carries the actual production distribution at fork time, so the preview sees realistic cardinality, realistic null rates, realistic edge cases โ without touching the live rows.
The connection-exhaustion problem. Postgres counts connections, and serverless functions scale horizontally without warning. Fifty concurrent invocations opening fifty TCP connections will exhaust the default limit on a small instance. Netlify Database is designed around this with an HTTP driver for one-shot queries and a pooled endpoint for sessions, so the correct pattern is the default rather than an optimisation the team discovers after an outage.
The migration-visibility problem. Schema changes in a previewed pull request are the only way to review them, but applying them to a shared database means everyone else sees them too. Applied to a branch, the migration runs, the reviewer sees the new column, and merging the pull request is the moment the same migration is applied to production โ with the diff already exercised.
The orphan problem. Every ad-hoc database created for a preview accumulates forever unless something deletes it. Branching ties the database’s lifetime to the deploy’s lifetime, so cleanup is a consequence of deletion rather than a chore somebody remembers once a quarter.
a. Provisioning, the connection URL, and the two drivers
Provisioning is a single CLI command run inside a linked site directory. It creates the Postgres instance in the site’s context, records it as a Netlify extension, and injects the connection string into the site’s environment so that both the build and the functions can see it.
# Run inside a directory linked to a Netlify site (netlify link)
npx netlify db init
# What it does:
# 1. provisions a Neon Postgres instance for this site
# 2. adds @netlify/neon to package.json
# 3. sets NETLIFY_DATABASE_URL in the site environment
# 4. wires the database extension for later branch provisioning
The useful thing about db init is that it is idempotent in intent โ running it against a site that already has a database reconnects rather than creating a second one. The NETLIFY_DATABASE_URL variable is injected per deploy context, which is the mechanism that makes branching work: production resolves to the production branch’s URL, and a Deploy Preview resolves to its own branch’s URL, with no code change between them.
Two drivers are available and they are not interchangeable. The first is the HTTP driver exposed by @netlify/neon, which sends each query as an HTTP request. It opens no socket, holds no connection between calls, and cannot exhaust a connection limit โ but it also cannot hold a session, so transactions, LISTEN, temporary tables, and SET statements that must persist across calls are all out of reach.
// netlify/functions/notes.ts
import { neon } from "@netlify/neon";
// neon() reads NETLIFY_DATABASE_URL from the environment automatically
const sql = neon();
export default async () => {
// Tagged templates are parameterised: values become bind parameters,
// never string concatenation, so this is injection-safe by construction
const rows = await sql`
SELECT id, title, created_at
FROM notes
WHERE published = ${true}
ORDER BY created_at DESC
LIMIT ${20}
`;
return Response.json(rows);
};
The second driver is the TCP Pool from @neondatabase/serverless, which speaks the Postgres wire protocol over WebSocket or TCP and therefore supports sessions. It is the right choice when a request genuinely needs a transaction, and it is the wrong choice for a handler that runs three independent queries, because each Pool instance costs a connection that survives until the function is frozen.
import { Pool } from "@neondatabase/serverless";
// Reuse the pool across invocations of the same warm function instance
let pool: Pool | undefined;
function getPool() {
pool ??= new Pool({
connectionString: process.env.NETLIFY_DATABASE_URL,
// Small ceiling per instance; fan-out multiplies this across invocations
max: 3,
});
return pool;
}
export default async () => {
const client = await getPool().connect();
try {
// A session is required here: both statements must commit together
await client.query("BEGIN");
await client.query("UPDATE accounts SET balance = balance - $1 WHERE id = $2", [100, 1]);
await client.query("UPDATE accounts SET balance = balance + $1 WHERE id = $2", [100, 2]);
await client.query("COMMIT");
return Response.json({ ok: true });
} catch (err) {
await client.query("ROLLBACK");
throw err;
} finally {
// Returning the client is what keeps max: 3 from becoming a deadlock
client.release();
}
};
The rule that follows from the connection arithmetic: use neon() unless you need a transaction, and when you need a transaction, keep max small and always release() in a finally. The pooled endpoint โ the hostname variant that routes through PgBouncer โ is what makes a larger max survivable, and DDL should go through the direct, unpooled URL because transaction-mode pooling and schema changes interact badly.
b. The branching model and what a branch actually contains
A branch is a fork of the database at a point in time. It is created from the production branch, it inherits the full schema, and it inherits the data as it existed at the instant of the fork. The storage is copy-on-write: the branch and its parent share every unchanged page, and a page is duplicated only when the branch modifies it.
Netlify creates a branch automatically for each Deploy Preview and each branch deploy, and injects the branch’s connection URL into that deploy’s environment under the same variable name. This is why the application code contains no branching logic at all โ it reads NETLIFY_DATABASE_URL and is correct in every context.
// Same code in production and in a preview โ the URL differs, nothing else
import { neon } from "@netlify/neon";
const sql = neon();
// In production this reads the production branch.
// In deploy-preview-42 this reads that preview's branch.
// Neither handler knows which it is, and neither should.
const [{ count }] = await sql`SELECT count(*)::int FROM orders`;
The consequence that deserves emphasis is privacy. A preview branch is not an empty schema โ it is a snapshot of production, so any personal data that lives in production also lives in the branch, and the branch is reachable by anyone who can trigger a build. Teams handling regulated data either seed a separate sanitised source for preview branching or accept that the branch inherits production rows and restrict who can open previews. Neither answer is wrong, but the choice has to be made deliberately rather than discovered during an audit.
The second consequence is directional. Writes in a preview never reach production, and writes in production after the fork never reach the preview. A preview therefore drifts in both directions from the moment it is created, which is the correct behaviour for review but means a long-lived preview is testing against stale data. Previews that stay open for weeks should be re-deployed to re-fork.
The third consequence is that schema changes must be applied to each branch, not just to production. Since every branch is forked from production’s current state, the fork already contains production’s schema โ but a pull request that adds a column needs that column in its own preview branch. That is what the migration mechanism in the next section handles.
c. Migrations and the deploy lifecycle
Netlify Database applies migrations automatically. SQL files placed in netlify/database/migrations are run against the target branch on deploy, tracked in a table so that already-applied files are skipped. The naming convention that matters is lexical ordering, so a timestamp prefix is what keeps them deterministic.
-- netlify/database/migrations/20250114103000_add_notes_table.sql
-- Forward-only. Every statement must be safe to run once, on a branch
-- that already contains whatever production contained at fork time.
CREATE TABLE IF NOT EXISTS notes (
id bigserial PRIMARY KEY,
title text NOT NULL,
body text,
published boolean NOT NULL DEFAULT false,
created_at timestamptz NOT NULL DEFAULT now()
);
-- A partial index keeps the common "published only" listing fast
-- without indexing the rows nobody queries.
CREATE INDEX IF NOT EXISTS notes_published_idx
ON notes (created_at DESC)
WHERE published = true;
Two properties make a migration safe in this model. The first is idempotence: because the branch may already contain the object if a previous deploy applied the same file, IF NOT EXISTS is not defensive noise, it is the contract. The second is that the migration must run correctly on a database whose contents you did not author โ a preview branch has production’s rows, so a NOT NULL column added without a default fails on the first existing row rather than in a test.
-- netlify/database/migrations/20250115090000_add_slug_to_notes.sql
-- BAD: fails on any branch that already contains notes without a slug
-- ALTER TABLE notes ADD COLUMN slug text NOT NULL;
-- GOOD: add nullable, backfill, then constrain โ three safe phases
ALTER TABLE notes ADD COLUMN IF NOT EXISTS slug text;
UPDATE notes
SET slug = lower(regexp_replace(title, '[^a-zA-Z0-9]+', '-', 'g'))
WHERE slug IS NULL;
ALTER TABLE notes ALTER COLUMN slug SET NOT NULL;
The ordering of the deploy is fixed and worth internalising: the branch is forked, the migrations run against the branch, and then the build and the functions start with NETLIFY_DATABASE_URL pointing at that branch. This means the application always sees a schema that includes its own migrations, and it also means a broken migration fails the deploy before any user traffic reaches the build.
Rollback is where teams get caught. A migration that ran on a preview branch cannot be undone by reverting the code, because the branch is thrown away rather than reverted. And a migration that ran on production is not undone by reverting the deploy โ the schema change is already committed. The only safe primitives are forward-only changes and compensating migrations: to undo a drop, deploy a migration that recreates the table. Anything that requires a true down-migration is a signal that the change is too large for one deploy.
// The application code must never create schema at runtime.
// This is a common reflex that breaks the moment a preview forks.
// await sql`CREATE TABLE IF NOT EXISTS ...`; // โ never in a handler
// The handler assumes the migration has already run, which is the
// invariant the deploy lifecycle guarantees.
const rows = await sql`SELECT id, slug FROM notes LIMIT 10`; // โ
Complete Example Session
// ============================================
// PART 1: PROVISIONING
// ============================================
// Run once, in a directory linked to the site:
// npx netlify db init
// Result: a Postgres instance, @netlify/neon in package.json,
// and NETLIFY_DATABASE_URL injected for every deploy context.
// ============================================
// PART 2: A SHARED CONNECTION MODULE
// ============================================
// netlify/functions/_db.ts
import { neon } from "@netlify/neon";
// Module scope means one client per warm function instance.
// The HTTP driver holds no socket, so this is cheap.
export const sql = neon();
// ============================================
// PART 3: THE FIRST MIGRATION
// ============================================
// netlify/database/migrations/20250114103000_create_notes.sql
// CREATE TABLE IF NOT EXISTS notes (
// id bigserial PRIMARY KEY,
// title text NOT NULL,
// slug text,
// published boolean NOT NULL DEFAULT false,
// created_at timestamptz NOT NULL DEFAULT now()
// );
// ============================================
// PART 4: A READ HANDLER
// ============================================
// netlify/functions/notes-list.ts
import { sql } from "./_db.js";
export default async (req: Request) => {
const url = new URL(req.url);
// Parameterised limit; never interpolate a query string into SQL
const limit = Math.min(Number(url.searchParams.get("limit") ?? 20), 100);
const rows = await sql`
SELECT id, title, slug, created_at
FROM notes
WHERE published = true
ORDER BY created_at DESC
LIMIT ${limit}
`;
return Response.json(rows);
};
// ============================================
// PART 5: A WRITE HANDLER
// ============================================
// netlify/functions/notes-create.ts
export default async (req: Request) => {
if (req.method !== "POST") return new Response("method", { status: 405 });
const { title, body } = await req.json();
// RETURNING gives back the inserted row without a second round trip
const [row] = await sql`
INSERT INTO notes (title, body, slug)
VALUES (${title}, ${body}, ${slugify(title)})
RETURNING id, title, slug, created_at
`;
return Response.json(row, { status: 201 });
};
function slugify(s: string) {
return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
}
// ============================================
// PART 6: A TRANSACTION WITH THE POOL DRIVER
// ============================================
// netlify/functions/notes-publish.ts
import { Pool } from "@neondatabase/serverless";
let pool: Pool | undefined;
const getPool = () =>
(pool ??= new Pool({ connectionString: process.env.NETLIFY_DATABASE_URL, max: 3 }));
export default async (req: Request) => {
const { id } = await req.json();
const client = await getPool().connect();
try {
await client.query("BEGIN");
// Both statements must be visible together or not at all
await client.query("UPDATE notes SET published = true WHERE id = $1", [id]);
await client.query(
"INSERT INTO audit_log (entity, entity_id, action) VALUES ($1, $2, $3)",
["note", id, "publish"]
);
await client.query("COMMIT");
} catch (err) {
await client.query("ROLLBACK"); // leave the branch unchanged
throw err;
} finally {
client.release(); // required, or max: 3 deadlocks
}
return Response.json({ ok: true });
};
// ============================================
// PART 7: A BACKFILL MIGRATION
// ============================================
// netlify/database/migrations/20250115090000_backfill_slugs.sql
// ALTER TABLE notes ADD COLUMN IF NOT EXISTS slug text;
// UPDATE notes SET slug = lower(regexp_replace(title,'[^a-zA-Z0-9]+','-','g'))
// WHERE slug IS NULL;
// ALTER TABLE notes ALTER COLUMN slug SET NOT NULL;
// ============================================
// PART 8: WHAT A PREVIEW SEES
// ============================================
// On a pull request:
// - Netlify forks a branch from production
// - the branch inherits schema AND rows as of the fork
// - migrations in this PR run against the branch only
// - NETLIFY_DATABASE_URL resolves to the branch
// Nothing in _db.ts changes. That is the whole point.
// ============================================
// PART 9: VERIFYING ISOLATION FROM THE CLI
// ============================================
// After writing rows in the preview:
// npx netlify db connect -> production branch, row absent
// Click through the preview URL -> row present in the branch
// Deploying production again -> the branch does not move
// ============================================
// PART 10: LIFECYCLE END
// ============================================
// When the pull request is merged or the preview is deleted:
// - the branch is dropped
// - pages it never modified were shared, so nothing is freed
// - pages it modified are released back
// Merging re-runs the same migration files against production.
The ten parts covered provisioning, a shared client module, the first migration, a parameterised read handler, an insert with RETURNING, a pooled transaction, a three-phase backfill migration, the preview behaviour, a way to verify isolation, and the lifecycle from fork to drop.
Quick Reference
Provisioning Commands
| Command | Effect |
|---|---|
netlify link | Associates the directory with a site |
npx netlify db init | Provisions Postgres and injects the URL |
npx netlify db connect | Opens a SQL session against a branch |
netlify deploy | Forks branch, runs migrations, builds |
Environment and Drivers
| Item | Value |
|---|---|
| Connection variable | NETLIFY_DATABASE_URL |
| Injection scope | Per deploy context, resolved per branch |
| HTTP driver | neon() from @netlify/neon |
| Session driver | Pool from @neondatabase/serverless |
| DDL / migrations | Unpooled endpoint, not the pooler |
Branch Behaviour
| Concern | Behaviour |
|---|---|
| Fork source | Production branch, at deploy time |
| Storage | Copy-on-write; shared until modified |
| Schema | Inherited from production at fork |
| Data | Snapshot of production at fork |
| Isolation | Writes never cross between branches |
| Lifetime | Tied to the deploy or preview |
Migration Rules
| Rule | Reason |
|---|---|
| Timestamp-prefixed names | Lexical ordering is the run order |
IF NOT EXISTS on DDL | Branch may already contain the object |
| Nullable โ backfill โ constrain | Fails on existing rows otherwise |
| Forward-only | A reverted deploy does not revert schema |
| Never DDL in a handler | The preview fork breaks the assumption |
Best Practices
โ Do This:
// Use the HTTP driver for one-shot queries
const sql = neon(); // โ
// Parameterise every value through the tagged template
await sql`SELECT * FROM notes WHERE id = ${id}`; // โ
// Keep the pool tiny and release in a finally
client.release(); // โ
// Make migrations idempotent
CREATE TABLE IF NOT EXISTS notes (...); // โ
// Chain nullable, backfill, constrain
ALTER TABLE notes ADD COLUMN IF NOT EXISTS slug text; // โ
// Read the URL from the environment, never hard-code it
connectionString: process.env.NETLIFY_DATABASE_URL // โ
// Cap user-supplied limits
Math.min(Number(limit), 100) // โ
โ Don’t Do This:
// Concatenate user input into SQL
await sql(`SELECT * FROM notes WHERE id = ${id}`); // โ
// Create schema at request time
await sql`CREATE TABLE IF NOT EXISTS x (...)`; // โ hidden in a handler
// Use a big pool across many concurrent invocations
new Pool({ max: 50 }); // โ
// Add NOT NULL without a default on a populated branch
ALTER TABLE notes ADD COLUMN slug text NOT NULL; // โ
// Plan to undo a deploy by reverting the commit
// (schema is already applied) // โ
// Assume a preview branch is empty
// (it is a production snapshot) // โ
Common Pitfalls
| Pitfall | Why It Happens | Fix |
|---|---|---|
| Preview breaks on a new column | Migration only ran on production | Add the migration file and redeploy the preview |
| Branch contains real customer data | Fork inherits production rows | Sanitise the source or restrict preview access |
| Connection limit reached | TCP pool per instance under fan-out | Switch to neon() for short queries |
| Migration fails on existing rows | NOT NULL with no default | Three-phase nullable, backfill, constrain |
| Preview shows stale data | Branch forked days ago | Redeploy to re-fork from current production |
| Transaction hangs | Client not released | client.release() in a finally |
| Migration ran twice | No tracking or no IF NOT EXISTS | Idempotent DDL with tracking table |
| Production query is slow | Missing index on the branched table | Add the index in a migration, not by hand |
Real-World Examples
1. Provision once
npx netlify db init
2. Shared client module
import { neon } from "@netlify/neon";
export const sql = neon();
3. Parameterised read
const rows = await sql`SELECT * FROM notes WHERE published = ${true}`;
4. Insert with RETURNING
const [row] = await sql`INSERT INTO notes (title) VALUES (${t}) RETURNING id`;
5. Transaction with release
const c = await pool.connect(); try { /* ... */ } finally { c.release(); }
6. Idempotent table
CREATE TABLE IF NOT EXISTS notes (id bigserial PRIMARY KEY, title text NOT NULL);
7. Safe column addition
ALTER TABLE notes ADD COLUMN IF NOT EXISTS slug text;
8. Partial index
CREATE INDEX IF NOT EXISTS notes_pub_idx ON notes (created_at DESC) WHERE published;
9. Guard a user-supplied limit
const limit = Math.min(Number(q.limit ?? 20), 100);
10. Verify branch isolation
npx netlify db connect # production branch: row absent
Visual
The Branch Topology
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ PRODUCTION BRANCH โ
โ main โโโบ app-prod โ
โ โ
โ PREVIEW DATABASES (one per preview) โ
โ preview-12 โโโบ db-preview-12 โ
โ preview-13 โโโบ db-preview-13 โ
โ feature-x โโโบ db-feature-x โ
โ โ
โ each branch has its own schema and data โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Copy-on-Write
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ COPY-ON-WRITE โ
โ โ
โ step 1 main โโโบ [A][B][C] โ
โ preview โโโบ [A][B][C] (shared) โ
โ โ
โ step 2 preview writes to C โ
โ main โโโบ [A][B][C] โ
โ preview โโโบ [A][B][C'] โ
โ โ
โ Result: a branch costs one page, not a copy. โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
The Deploy Lifecycle
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ DEPLOY LIFECYCLE โ
โ โ
โ 1. push to a branch โ
โ 2. Netlify forks a database branch from production โ
โ 3. migrations run against the new branch โ
โ 4. the build sees a URL for the new branch โ
โ 5. preview runs isolated from production โ
โ 6. preview deleted, branch dropped, storage back โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
The Two Drivers
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ TWO DRIVERS โ
โ โ
โ neon() HTTP one query per request โ
โ no socket, no pool, no idle connection โ
โ best for short function calls โ
โ โ
โ Pool TCP session held open โ
โ transactions, LISTEN, temp tables โ
โ needs a pooler and care when fanning out โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Summary
| Item | Value |
|---|---|
| Engine | Managed Neon Postgres |
| Provisioning | npx netlify db init |
| Connection variable | NETLIFY_DATABASE_URL |
| Isolation unit | The branch, not the server |
| Fork source | Production branch at deploy time |
| Storage model | Copy-on-write, shared until modified |
| Migrations | SQL files in netlify/database/migrations |
| Migration timing | On deploy, before the build |
| One-shot driver | neon() โ HTTP, no socket |
| Session driver | Pool โ TCP, supports transactions |
| Rollback model | Forward-only, compensating migrations |
Key takeaways:
- The branch is the unit of isolation. A Deploy Preview does not share a database with production or with another preview; it forks one, so schema and data experiments cannot leak.
- Copy-on-write is what makes it affordable. A fork is instantaneous and costs only the pages the branch modifies, which is why per-preview databases are practical here and were not practical with dump-and-restore.
- A preview branch is a production snapshot. It inherits production’s rows, not an empty schema. Decide deliberately whether that is acceptable for the data you store.
- Code contains no branching logic.
NETLIFY_DATABASE_URLresolves per context, so the same handler is correct in production and in every preview. - Use
neon()unless you need a session. The HTTP driver cannot exhaust connections; the TCP pool can, and it requiresmaxdiscipline plusrelease()in afinally. - Migrations run on deploy, per branch, before the build. They must be idempotent because the target already contains production’s objects, and they must be forward-only because a reverted deploy does not revert schema.
- Adding a column to a populated table is three steps. Nullable, backfill, then constrain โ a single
NOT NULLadd fails on the existing rows a branch brings with it.
Remember: Netlify Database solves the problem that made previews untrustworthy for data-driven applications, and it does so by changing what a database is: not a shared server, but a fork you can throw away. Provision once, read the URL from the environment, keep one query per request on the HTTP driver, and treat every schema change as a forward-only file in the migrations directory. Do that and a pull request becomes a genuine rehearsal โ realistic data, isolated writes, the migration already exercised โ so merging is confirmation rather than discovery.
Stop using slow, ad-bloated tool sites! ๐คฎ
๐ Search “KandZ Tools” on Google to use many professional utilities for free.
KandZ.me is the ultimate minimalist hub for:
โ
Finance (Mortgage, Interest, Inflation)
โ
Tech (Base64, JSON, Dev Suite, IP)
โ
Health (BMI, BMR, TDEE)
โ
Productivity (Timer, Workspace, QR)
โก๏ธ Fast & Private
๐ No data leaves your device
๐ 100% Free
๐ Use it now: https://tools.kandz.me
๐ Bookmark itโyouโll need it later!