JSON to SQL Converter

Convert JSON to SQL

This tool transforms JSON data into SQL statements for database import. It generates CREATE TABLE statements with inferred column types and INSERT statements with properly escaped values.

Supported Databases

Type Mapping

The converter infers SQL types from JSON values:

Example Output

From this JSON:

[
  {"id": 1, "name": "Alice", "active": true},
  {"id": 2, "name": "Bob", "active": false}
]

PostgreSQL output:

CREATE TABLE "users" (
  "id" INT NOT NULL,
  "name" VARCHAR(50) NOT NULL,
  "active" BOOLEAN NOT NULL
);

INSERT INTO "users" ("id", "name", "active")
VALUES
  (1, 'Alice', TRUE),
  (2, 'Bob', FALSE);

Options Explained

Table name

The name used for the CREATE TABLE and INSERT statements. Automatically quoted with the appropriate syntax for your database.

Output type

• CREATE + INSERT — Full table creation with data
• CREATE TABLE only — Schema definition only
• INSERT only — Data insertion only (for existing tables)

Include NULLs

When enabled, null values are inserted as NULL. When disabled, they use DEFAULT (requires column defaults defined).

Handling Special Cases

Nested objects

Nested JSON objects and arrays are stored as JSON/JSONB columns in PostgreSQL and MySQL, or as TEXT strings in SQLite and SQL Server.

String escaping

Single quotes in strings are automatically escaped by doubling them (''). This prevents SQL injection in the generated statements.

Large datasets

Insert statements are batched (default 100 rows per statement) for better performance and to avoid query size limits.

Common Use Cases

• Database seeding — Initialize test/dev databases
• Data migration — Move data from NoSQL to SQL
• API data import — Import JSON API responses
• Schema generation — Create tables from JSON structure

Related Tools

• JSON Validator — Validate JSON before converting
• JSON to CSV — Export as CSV instead
• JSON to Excel — Export as Excel
• JSON Flatten — Flatten nested objects first

Frequently Asked Questions

Is the output safe from SQL injection?

The generated SQL properly escapes string values. However, always review generated SQL before running on production databases, and prefer parameterized queries in application code.

Can I convert a single JSON object?

Yes. Single objects are automatically wrapped in an array to generate a single-row insert.

How are column types determined?

Types are inferred from the first row of data. If your data has varying types, you may need to adjust the generated schema manually.

What about primary keys and indexes?

The generator creates basic column definitions. Add PRIMARY KEY, UNIQUE, INDEX, and other constraints manually based on your requirements.

Common Mistakes & Pro Tips

• Column types are inferred from sampled values and can guess wrong — The converter looks at the JSON values to pick a SQL type — integers become INT, decimals become a FLOAT/DECIMAL, true/false become BOOLEAN, and everything else falls back to VARCHAR or TEXT. If only the first few rows are sampled, a column that is mostly integers but occasionally has a string will be typed as INT and fail on insert. Review the generated CREATE TABLE and widen types where your data is mixed.
• Single quotes in values must be escaped or the SQL breaks — A string like O'Brien must be written as 'O''Brien' (doubling the quote) inside a SQL string literal; otherwise the statement is syntactically broken and, with untrusted input, becomes an injection vector. A correct converter doubles every embedded single quote. Never paste generated INSERTs from untrusted JSON into a production database without reviewing the escaping.
• NULL is a keyword, not the string 'NULL' — A JSON null should become the bare SQL keyword NULL (unquoted), while the four-character string "NULL" should become 'NULL' (quoted). Mixing these up either stores the literal text NULL or nulls out a column you meant to populate. Check that your converter distinguishes the JSON null type from a string that happens to read NULL.
• Nested objects and arrays have no flat column to live in — Relational columns are scalar, so a nested object or array can't map to a single typed column directly. Converters usually serialize the nested value as a JSON string and put it in a TEXT/JSON column, or skip it. If you need true relations, split the nested array into a child table with a foreign key rather than inlining it.
• Identifiers and dialects vary — VARCHAR length and AUTO_INCREMENT aren't universal — Generated DDL targets a specific dialect: MySQL uses AUTO_INCREMENT and backtick quoting, PostgreSQL uses SERIAL/IDENTITY and double-quoted identifiers, and SQLite is loosely typed. A VARCHAR(255) guess may be too short for long text, and reserved words used as column names need quoting. Confirm the output matches your target database before running it.