⌘ K
json → sql insert · bulk · typed scalars · live

Generate SQL INSERT from JSON

Convert a JSON array of objects into INSERT statements. Numbers stay numeric, booleans become TRUE/FALSE, nulls become NULL and nested objects JSON-encode into a single-quoted string.

JSON → SQL INSERT
Input
188 B
5 lines
Output
141 B
5 lines
Status
ready
live
Ratio
0.75×
out/in
input · json array
output · sql
INSERT INTO `users` (`id`, `name`, `active`, `score`)
VALUES
  (1, 'Alice', TRUE, 92.4),
  (2, 'Bob', FALSE, 78),
  (3, 'Carol', TRUE, 88.5);
Quick Start

How JSON becomes SQL

The JSON array is scanned to build a union of column names so partially-shaped records still emit. Each value is rendered with type-aware quoting: numbers and booleans stay literal, everything else becomes a single-quoted string with embedded quotes doubled.

  1. 01

    Set table name

    Backticks are added automatically for MySQL/MariaDB. Switch to double quotes for ANSI.

    Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.

    tablestricttolerantliveparse
    tbl · sourcename · live
    users
    loaded · parsedtarget · ready
  2. 02

    Paste JSON array

    Top-level must be an array of objects. The first record can omit keys later records have.

    Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.

    inputtype-preservinglosslesslivememoised
    in · optionsjson · live
    [{"id":1},{"id":2,"name":"Bob"}]
    options applied · liveround-trip
  3. 03

    Type-aware literals

    Booleans → TRUE/FALSE, numbers stay literal, strings get single-quoted, objects JSON-encode.

    Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.

    typesidempotentround-tripdiff-cleandeterministic
    type · convertedlit · ready
    true → TRUE
"hi" → 'hi'
    converted · livediff-clean
  4. 04

    Copy or download

    Drop into a migration, seed file or run against staging directly.

    Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.

    exportclipboardtarget MIMEblobclient-side
    ✓ · copiedready · done
    ✓ Copied
    shipped · ready to shipsuccess
Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Related toolsSQL to JSONCSV to SQLCSV to JSONJSON to XMLJSON to TOMLJSON to Properties
Use Cases

When to convert JSON to SQL

Seeds, fixtures, API exports.

API → DB

Materialise an API response into a relational table. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Test fixtures

Build deterministic seed SQL from JSON fixtures. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Database seeds

Generate seed scripts for dev or staging. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Migrations

Backfill a new column with values pulled from JSON exports. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

One-off loads

Import a JSON snapshot into a relational warehouse. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Documentation

Show schema + sample data side by side. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade
FAQ

Frequently asked questions

All keys across the array are unioned to form the column list; missing keys become NULL.
JSON-encoded into a single string with embedded single quotes doubled. Many databases accept this in a JSON or TEXT column.
Bulk INSERT is faster for large loads; single INSERTs are easier to review or replay piecemeal.
Backticks are used by default. Use a quick find/replace if you need double quotes for Postgres or SQL Server.
No. JSON parsing and SQL generation run locally in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!