Home›Formatters›Code›JSON to SQL INSERT

JSON to SQL INSERT

Code

Convert a JSON array of objects to SQL INSERT statements instantly. Supports MySQL, PostgreSQL, and SQLite dialects. In-browser — data never uploaded.

Reviewed by the thecalcu.com team · Last updated July 6, 2026

What is a JSON→SQL?

A JSON to SQL formatter converts structured JSON data, an API response, a log file, an exported dataset, into valid SQL INSERT statements ready to load into a relational database. Instead of manually mapping field names to column names and value by value, you paste the JSON and the formatter does the translation automatically.

JSON and SQL are the two most common data exchange formats in web development. Data frequently lives in one format but needs to be migrated to the other: seeding a development database from a JSON fixture file, importing an API export into a reporting table, or bootstrapping a new service from a legacy JSON dataset. Manually writing INSERT statements for even twenty rows is tedious and error-prone, a single misquoted string or unescaped apostrophe breaks the entire batch.

The formatter handles MySQL, PostgreSQL, and SQLite dialects correctly, applying the right quoting style for identifiers and the right literal format for booleans and null values. It supports both per-row and batch INSERT modes. Use it alongside the JSON Formatter to clean up your source data first, or the CSV to JSON Formatter to convert a CSV export before generating SQL.

Why Use a JSON to SQL Formatter?

Manually writing INSERT statements introduces transcription errors: a field missed, a number accidentally quoted as a string, a boolean written as true instead of 1 for MySQL. The formatter eliminates these class of mistakes by mechanically applying the correct SQL literal format for each JSON value type.

Batch mode generates a single multi-row INSERT, which is substantially faster than running individual INSERT statements in a loop, the database engine can optimise a batch insert in ways it cannot for thousands of separate round-trips. For seed data or migration scripts this matters in practice.

Who Should Use This Formatter?

Backend developers seeding local or staging databases from JSON fixture files save significant time when the fixture has dozens of fields per record. The formatter removes the mapping step entirely.

Data engineers migrating JSON exports from one system into a relational database can use it as a quick conversion layer without standing up a dedicated ETL pipeline for a one-time import.

QA engineers maintaining test data as JSON (which is human-readable and version-controllable) can regenerate the SQL seed scripts whenever the test data changes, keeping both formats in sync.

Database administrators receiving JSON data from third-party APIs who need to load it into a reporting table benefit from per-row mode, which generates individually executable statements that can be reviewed and selectively run.

What Insights Does the SQL Formatter Give You?

The primary output is a block of ready-to-run SQL. Reviewing it tells you whether the column mapping is correct, whether any values are unexpectedly null or of the wrong type, and whether nested structures need to be normalised before import.

The batch vs per-row choice informs your import strategy. A single batch INSERT is faster but all-or-nothing, if one row violates a constraint, the entire batch fails. Per-row statements let you identify and skip the problem row while still importing the rest.

The dialect selection ensures boolean and identifier handling is correct for your database, preventing common errors like inserting true as a string literal into a MySQL TINYINT column.

How to use this JSON→SQL calculator

  1. Paste your JSON into the JSON Input field. It can be a single object (produces one INSERT) or an array of objects (produces one INSERT per element).
  2. Enter the Table Name, the exact database table you want to insert into.
  3. Select the SQL Dialect: MySQL, PostgreSQL, or SQLite.
  4. Choose the Batch Size setting: "All rows in one statement" for fastest import, or "One statement per row" for granular control.
  5. Review the generated SQL in the output field. Check that column names match your schema and that value types look correct.
  6. Copy and paste into your database client, migration file, or seed script.
Show formula & methodology ↓Show less ↑

Formula & Methodology

The formatter maps JSON value types to SQL literals as follows:

| JSON type | MySQL | PostgreSQL | SQLite |
|---|---|---|---|
| String | 'value' (single-quoted) | 'value' | 'value' |
| Integer | 42 | 42 | 42 |
| Decimal | 3.14 | 3.14 | 3.14 |
| Boolean true | 1 | TRUE | 1 |
| Boolean false | 0 | FALSE | 0 |
| null | NULL | NULL | NULL |
| Object/Array | '{"key":"val"}' | '{"key":"val"}' | '{"key":"val"}' |

Single quotes inside string values are escaped by doubling them (' → ''), which is the standard SQL escaping mechanism.

Before/after example:

Input JSON:
json [{"id": 1, "name": "Alice", "active": true}, {"id": 2, "name": "Bob's", "active": false}] 

Generated SQL (PostgreSQL, per-row):
sql INSERT INTO "users" ("id", "name", "active") VALUES (1, 'Alice', TRUE); INSERT INTO "users" ("id", "name", "active") VALUES (2, 'Bob''s', FALSE);

Frequently Asked Questions

What is a JSON to SQL formatter?
A JSON to SQL formatter converts a JSON object or array of objects into SQL INSERT statements. It reads the field names as column names and the values as data to insert, generating valid SQL for MySQL, PostgreSQL, or SQLite. This saves the manual work of writing INSERT statements row by row.
Which SQL dialects does this formatter support?
The formatter supports MySQL (backtick-quoted identifiers), PostgreSQL (double-quoted identifiers, TRUE/FALSE booleans), and SQLite (double-quoted identifiers). Choose the dialect that matches your database to get correctly formatted output.
Can I convert an array of objects in one go?
Yes. Paste a JSON array and each element becomes a separate INSERT row. Use the 'Batch all rows' option to generate a single multi-row INSERT statement, which is faster for bulk imports. Use 'One per row' for individual INSERT statements that can be run selectively.
How are different value types handled?
Strings are single-quoted with internal single quotes escaped as two single quotes. Numbers are inserted as-is. Booleans become TRUE/FALSE in PostgreSQL and 1/0 in MySQL and SQLite. Null values become NULL. Nested objects and arrays are serialised to their JSON string representation.
What should I enter for the Table Name field?
Enter the exact name of the target database table. The formatter uses this name as-is in the INSERT INTO statement. If your table name contains special characters or reserved words, the dialect's quoting style (backtick for MySQL, double-quote for PostgreSQL/SQLite) is applied automatically.
Is there a limit on how many rows I can convert?
There is no hard limit, the formatter processes the entire JSON array you paste. However, very large datasets (thousands of rows) may be slow in the browser. For large imports, consider splitting the JSON into chunks or using a dedicated ETL tool.
Does the formatter validate the JSON before converting?
Yes. The input is parsed with JSON.parse() first. If the JSON is invalid, the output shows a parse error instead of broken SQL. Use the [JSON Formatter](/json-formatter/) to fix any syntax issues before converting.
What is the difference between the batch and per-row output modes?
The per-row mode generates one INSERT statement per JSON object, each ending with a semicolon. The batch mode generates a single INSERT with multiple value tuples separated by commas, this is significantly faster for large imports because the database processes one statement rather than thousands.
Is my data stored or uploaded anywhere?
Nothing leaves your device. All conversion happens in your browser, and your JSON data never leaves your device and is not transmitted to any server. This makes the tool safe for data containing sensitive fields.
Can I use the output directly in a migration file?
Yes. The generated SQL is valid and ready to paste into a .sql migration file or run in a database client. Always review the output before running it against a production database, especially to confirm column names match your schema.
What happens to nested objects inside the JSON?
Nested objects and arrays are converted to their JSON string representation and inserted as a quoted string. This is appropriate for JSON/JSONB columns in PostgreSQL. If you want nested data normalised into separate tables, you will need to restructure the JSON first.
Also known as
JSON to SQLJSON to INSERTconvert JSON to SQLgenerate SQL from JSONJSON array to SQL