How do I convert JSON to SQL INSERT statements?

Paste a JSON array of flat objects. The tool reads the keys of the first object to build the column list, then emits one INSERT per row. Example input [{id:1,name:"Ada"},{id:2,name:"Linus"}] becomes INSERT INTO users (id, name) VALUES (1, 'Ada'); INSERT INTO users (id, name) VALUES (2, 'Linus');. For bulk mode, choose multi-row and get a single INSERT with all VALUES tuples.

Which SQL dialects are supported?

MySQL, PostgreSQL, SQLite, and SQL Server. The main differences are string quoting (single quotes everywhere), NULL vs empty-string handling, and identifier quoting: MySQL uses backticks `col`, PostgreSQL and standard SQL use double quotes "col", SQL Server uses square brackets [col]. Pick your dialect from the dropdown; the tool uses the right identifier style and escapes strings per the dialect.

How are null values and empty strings handled?

A JSON null becomes SQL NULL (unquoted). An empty string becomes an empty SQL string (quoted single quotes). This matches most ORMs and is what you want for columns with a NOT NULL constraint vs a nullable column. If your target table has defaults and you want them to kick in, strip the key from the JSON before converting — any key not present in the row is omitted from the INSERT.

What about dates, numbers, and booleans?

Numbers are emitted unquoted (123, 3.14). Booleans emit as TRUE/FALSE for PostgreSQL and 1/0 for MySQL/SQLite/SQL Server. Dates stored as ISO strings in JSON ("2026-10-10") stay quoted and the target column must be DATE or TIMESTAMP. For a Unix timestamp (number), wrap it in to_timestamp() on PostgreSQL or FROM_UNIXTIME() on MySQL in the SQL afterwards — the tool does not auto-detect dates.

Can I generate a single bulk INSERT instead of one per row?

Yes — switch the mode to Bulk/Multi-row. The output becomes INSERT INTO table (col1, col2) VALUES (v1a, v1b), (v2a, v2b), (v3a, v3b);. Bulk inserts are 10-100x faster than row-at-a-time inserts because the database only parses and plans the query once. Watch for the max_allowed_packet (MySQL) or BUFFER_SIZE limits for very large arrays — split into batches of 500-1000 rows.

Is my data safe when I paste JSON here?

Yes. The entire conversion runs in your browser — no JSON is sent to any server, and no SQL is sent anywhere. Open your Network tab in DevTools during a conversion to confirm: zero outgoing requests. You can safely paste production data, PII, or auth tokens.

JSON to SQL INSERT — Convert JSON to Bulk INSERT Statements (Free)

Turn a JSON array into ready-to-run INSERT statements for MySQL, PostgreSQL, SQLite or SQL Server.

Why Convert JSON to SQL?

Every backend engineer eventually needs to seed a database from a JSON file: a one-off import of config rows, a dataset dump from a third-party API, a fixtures file for tests, or a bulk migration from a NoSQL store. Writing the INSERTs by hand is error-prone — one missed quote and the whole script fails halfway. Letting the SQL ORM handle it means booting the full app just to run a script. A pure converter is the shortest path: paste the JSON, copy the SQL, run it.

Example: Flat Array to INSERTs

Given this JSON:

[
  { "id": 1, "name": "Ada Lovelace",   "email": "[email protected]",   "active": true,  "signed_up_at": "2026-10-10" },
  { "id": 2, "name": "Linus Torvalds", "email": "[email protected]", "active": true,  "signed_up_at": "2026-10-09" },
  { "id": 3, "name": "Donald Knuth",   "email": null,                "active": false, "signed_up_at": "2026-10-08" }
]

Single-row mode (PostgreSQL dialect):

INSERT INTO "users" ("id", "name", "email", "active", "signed_up_at")
VALUES (1, 'Ada Lovelace', '[email protected]', TRUE, '2026-10-10');

INSERT INTO "users" ("id", "name", "email", "active", "signed_up_at")
VALUES (2, 'Linus Torvalds', '[email protected]', TRUE, '2026-10-09');

INSERT INTO "users" ("id", "name", "email", "active", "signed_up_at")
VALUES (3, 'Donald Knuth', NULL, FALSE, '2026-10-08');

Bulk mode — the same data as one statement:

INSERT INTO "users" ("id", "name", "email", "active", "signed_up_at")
VALUES
  (1, 'Ada Lovelace', '[email protected]', TRUE, '2026-10-10'),
  (2, 'Linus Torvalds', '[email protected]', TRUE, '2026-10-09'),
  (3, 'Donald Knuth', NULL, FALSE, '2026-10-08');

SQL Dialect Differences That Matter

The ANSI SQL spec says identifiers go in double quotes and strings go in single quotes. MySQL and SQL Server don't fully agree.

MySQL — identifiers in backticks: `users`.`id`. Booleans are tinyints: emit 1/0 not TRUE/FALSE(TRUE/FALSE do work as aliases, but 1/0 is portable).
PostgreSQL — identifiers in double quotes: "users"."id". Booleans are first-class: emit TRUE/FALSE. Unquoted identifiers get folded to lowercase, so quote them to preserve case.
SQLite — accepts both double quotes and backticks for identifiers. No real boolean type: emit 1/0. All strings are TEXT until cast.
SQL Server — identifiers in square brackets: [users].[id]. Booleans are BIT: emit 1/0. Dates needCAST('2026-10-10' AS DATE) if the column is DATETIME.

String Escaping — The Thing That Breaks Everything

SQL strings are delimited by single quotes. A single quote inside a string must be doubled: 'Ada's laptop' becomes'Ada''s laptop'. The tool handles this automatically. Backslashes are a trap: MySQL in default mode treats \' as an escape, but ANSI SQL does not. We emit standard ANSI double-single-quote escaping and it works in every dialect.

Unicode control characters (newlines, tabs) in strings are a different problem. The tool emits them literally inside the quoted string. If your database rejects embedded newlines, use CHAR(10) concatenation on MySQL orE'foo\nbar' escape syntax on PostgreSQL — convert the strings before pasting if you hit this.

Handling Nested Objects and Arrays

Relational databases don't natively store nested JSON (except where a column is explicitly typed as JSON). The tool flattens nested fields in one of two ways:

Serialize as JSON string (default). A nested object or array becomes a single quoted JSON string. The target column should be TEXT, JSON, or JSONB.
Flatten with dot-paths. Nested keys become parent_childcolumn names. Only works for predictable nesting — one level deep is safe, two levels gets messy.

// Input
{ "id": 1, "profile": { "bio": "...", "tags": ["ai", "ml"] } }

// Serialized as JSON
INSERT INTO users (id, profile) VALUES (1, '{"bio":"...","tags":["ai","ml"]}');

// Flattened
INSERT INTO users (id, profile_bio, profile_tags) VALUES (1, '...', '["ai","ml"]');

Bulk INSERT Performance

Row-at-a-time inserts take one round trip, one parse, and one plan per row. Bulk inserts take one round trip, one parse, and one plan for the whole batch. On MySQL and PostgreSQL, a bulk insert of 1,000 rows is roughly 50-100x faster than 1,000 single inserts over a network. Three guardrails:

Batch size. Split arrays over ~1,000 rows into chunks. MySQLmax_allowed_packet defaults to 64MB; a wide table with blobs will hit this fast.
Transactions. Wrap the bulk INSERTs in BEGIN; ... COMMIT;so a failure rolls back the whole batch and you don't end up with partially inserted data.
Conflict handling. Add ON CONFLICT DO NOTHING (PostgreSQL) or INSERT IGNORE (MySQL) to skip duplicates by primary key when re-running imports.

Common Pitfalls

Inconsistent keys. If row 1 has {id, name} and row 2 has {id, email}, the generated SQL will have mismatched VALUES. The tool uses the UNION of keys as the column list and fills missing fields with NULL — but your target table needs those columns to be nullable or defaults must exist.
Reserved words as column names. order, group,user are reserved. Quoting them with the dialect-appropriate style (backticks / double-quotes / brackets) is mandatory. The tool quotes every identifier for safety.
Dates stored as strings."2026-10-10" is a string in JSON. Target DATE columns accept the string in standard dialects, but target DATETIME on SQL Server may need an explicit CAST.
Case folding on PostgreSQL. INSERT INTO Users ... without quotes becomes users. If your table is "Users"(quoted during CREATE), use quoted identifiers everywhere.

Related JSON Tools

JSON Formatter — pretty-print and validate before converting.
JSON to CSV — alternative tabular export, useful for bulk import via COPY orLOAD DATA INFILE.
JSON Flattener — flatten nested objects before conversion if you want flat columns instead of a JSON string.
JSON Schema Validator — check array consistency before conversion to catch missing fields.