JSON to SQL
Free online JSON to SQL converter. Turn JSON arrays into INSERT statements and optionally generate CREATE TABLE DDL scripts. Supports 20+ SQL dialects including MySQL, PostgreSQL, SQLite, and SQL Server, with automatic type inference and 100% client-side processing.
Related
About JSON to SQL: Move JSON Data into Relational Databases
JSON to SQL is the process of converting JSON-formatted data (JSON arrays or objects) into SQL scripts that a relational database can execute, specifically INSERT statements and CREATE TABLE statements. JSON (JavaScript Object Notation) is a lightweight data-interchange format used everywhere from REST APIs and front-end to back-end transport to configuration files and log records. Relational databases (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.) are the workhorse of enterprise data storage, but they require strict table structures and SQL statements to store and query data. Moving data from JSON into a relational database therefore requires turning the JSON into a SQL script.
At its core, the tool converts each object in a JSON array into one row of database data. A single object is treated as a single row, and every element of a JSON array becomes one row. Object keys become column names, and values are translated into the matching SQL literal. The whole conversion runs locally in the browser; no backend is involved.
Type inference is the central technical challenge of JSON to SQL. JSON has only six primitive types (null, boolean, number, string, array, object), whereas SQL has dozens (INT, BIGINT, FLOAT, DOUBLE, VARCHAR, TEXT, DATE, TIMESTAMP, BOOLEAN, BIT, etc.). The detectType function in this tool looks at the literal form of each value: null maps to SQL NULL; true/false maps to BOOLEAN; integers map to INT (range -2147483648 to 2147483647) or BIGINT; floats map to FLOAT/DOUBLE/REAL depending on the dialect; ISO 8601 date and date-time strings map to DATE and TIMESTAMP; short strings map to VARCHAR(255); strings longer than 255 characters map to TEXT.
Conflicts across multiple rows require special handling. If the first row of a column is INT and the second row is FLOAT, the column cannot simply be defined as INT without losing decimals. The tool implements a type-promotion algorithm: when a column's existing type conflicts with a new value, it promotes to the widest type that covers both (for example INT promotes to FLOAT). NULL is excluded from this decision so the inferred type stays stable. Because the final column type is decided after all rows are processed, the result is the globally optimal type for the dataset.
Dialect differences are another big challenge. MySQL wraps identifiers in backticks (`name`), PostgreSQL and standard SQL use double quotes ("name"), SQL Server uses square brackets ([name]). SQLite has no native BOOLEAN, so 1/0 is used. BigQuery uses INT64 for integers and STRING for text. Snowflake uses NUMBER for integers and TIMESTAMP_NTZ for timestamps. Oracle uses VARCHAR2 and NUMBER(1) for booleans. DB2 stores text in CLOB. The tool centralizes all these differences in DIALECT_CONFIG and adapts identifier quotes, data types, and boolean representations to whatever dialect the user selects.
CREATE TABLE generation builds on type inference. When the user enables "Generate CREATE TABLE" in the settings, the tool emits a CREATE TABLE statement before the INSERT block. The table name comes from the user's input (default `users`); column names come from the JSON object keys; column types come from the inferred SQL types. For dialects that support IF NOT EXISTS, the clause is added automatically to avoid errors on re-creation; for dialects that do not (Oracle PL/SQL, SQL Server T-SQL) it is omitted for compatibility. The CREATE TABLE and INSERT together form a complete initialization script that can be executed in an empty database with a single run.
Batch insert is the key to performance. Converting 10,000 rows of JSON into 10,000 separate INSERT statements is painfully slow because every statement must be parsed, planned, executed, and committed. The tool supports a configurable batch size (default 100, range 1-1000) and merges multiple rows into one INSERT using multi-value tuples (VALUES (1,2), (3,4), ...). This slashes the number of statements and yields 10-100x faster import performance on most engines. Batch size needs to be tuned for each database and server, since an oversized batch may exceed max_allowed_packet on MySQL.
JSON error tolerance is a practical feature. Real-world JSON is rarely perfect: trailing commas ([{"a":1},]), single quotes instead of double quotes ({'a':1}), unquoted keys ({a:1}), embedded comments (/* */). A strict parser rejects all of these. The tool ships with a built-in tryFixJSON repair routine that runs when JSON.parse fails; if repair succeeds the user is notified and conversion continues. This design dramatically improves the practical hit rate and avoids endless back-and-forth for small mistakes.
Client-side processing is the core architectural advantage. All JSON parsing, type inference, SQL generation, and beautification (powered by the sql-formatter library) run in the browser's JavaScript engine; nothing is ever sent to a server. There are two big benefits: first, JSON data may contain user PII (user records, order data) or business secrets (internal schemas) and local processing removes any leak risk; second, conversion speed is limited only by the device's CPU, so mid-sized data (under 10 MB) finishes almost instantly. Compared with command-line tooling (jq + sed) the tool is friendlier, and compared with online conversion services it is safer.
Use Cases
- Convert API response JSON into INSERT statements to bulk import data into MySQL, PostgreSQL, or other relational databases for analytics.
- Generate CREATE TABLE DDL from a JSON configuration or data dictionary when initializing the schema of a new project.
- Convert frontend mock JSON or test fixtures into SQL scripts to seed development, staging, or QA database environments.
- Data migration: turn JSON exports from MongoDB, Elasticsearch, or document stores into SQL scripts for relational targets.
- ETL preprocessing: normalize upstream JSON payloads into standard INSERT statements that downstream pipelines can ingest directly.
- Backup and recovery: keep critical business data in portable JSON form and regenerate SQL scripts on demand for fast restore.
- Cross-team collaboration: agree on a JSON contract and let the backend one-click generate both the schema DDL and the seed INSERT scripts.
- Teaching and demos: walk learners through how JSON data maps to SQL statements, illustrating type inference and bulk-insert mechanics.
How to Use
- Paste a JSON array or object into the left editor, click Upload to load a .json/.txt file, or click Sample to load the built-in demo.
- Pick the target SQL dialect from the dropdown in the toolbar (MySQL, PostgreSQL, SQLite, SQL Server, and 20+ others).
- Click Settings to configure the table name, whether to emit CREATE TABLE, and the batch insert size (1-1000 rows per INSERT).
- Click Convert (or use the keyboard shortcut) to parse the JSON, infer types, and render the SQL in the right panel.
- Inspect the generated SQL and the row/column totals in the status bar to verify data integrity.
- Click Copy to put the SQL on the clipboard, or click Download to save it as a .sql file (for example users.sql).
- Run the SQL inside your preferred database client (Navicat, DBeaver, pgAdmin, MySQL Workbench) to complete the data import.
Features
- Bulk INSERT generation: Convert JSON arrays into standard INSERT INTO statements with configurable batch size (1-1000 rows per statement).
- CREATE TABLE DDL output: Optional DDL block with auto-inferred types (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT).
- 20+ SQL dialects: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark, Hive, and more.
- Smart type inference: Detects null, booleans, integers, floats, ISO 8601 dates, and short or long strings and maps each to the best SQL type.
- Built-in SQL beautifier: Powered by sql-formatter, with uppercased keywords, neat indentation, and clear multi-value VALUES blocks.
- JSON error self-repair: Automatically fixes trailing commas, single quotes, and missing key quotes to keep conversions resilient.
- Type promotion logic: Conflicting types across rows are promoted to the widest compatible type (INT + FLOAT becomes FLOAT) so the DDL never truncates data.
- Custom table and column names: Table name becomes the .sql filename (e.g., users.sql); column names follow the JSON object keys.
- Flexible input: Paste JSON, upload a .json/.txt file, or load the built-in sample with a single click.
- Live row and column count: Status bar shows the total number of rows and columns after conversion for quick data validation.
- Copy and download: One-click copy to clipboard or save as a standard .sql file ready to import into any database.
- 100% browser-side: All parsing and transformation happen in client-side JavaScript; JSON never leaves your device.
FAQ
How do I convert a JSON array into SQL INSERT statements?
Paste a JSON array into the left editor and the tool converts every object into an INSERT INTO statement. Object keys become column names; values are automatically quoted or kept as numeric literals. The generated SQL can be copied and executed directly in MySQL, PostgreSQL, SQLite, or any other supported database client.
Can this tool auto-generate CREATE TABLE DDL scripts from JSON?
Yes. Enable "Generate CREATE TABLE" in the settings panel. The tool analyses every field in the JSON, infers the appropriate SQL data type (VARCHAR, INT, BIGINT, FLOAT, BOOLEAN, TIMESTAMP, DATE, TEXT, etc.) and emits a complete CREATE TABLE statement that pairs with the INSERT output to form a ready-to-run initialization script.
Which SQL dialects are supported?
The tool supports 20+ major SQL dialects, including MySQL, MariaDB, PostgreSQL, SQLite, SQL Server (T-SQL), Oracle PL/SQL, DB2, BigQuery, Snowflake, Redshift, DuckDB, ClickHouse, Trino, Spark SQL, Hive, TiDB, SingleStoreDB, and N1QL. Identifier quotes (backticks, double quotes, square brackets), data types (INT64, NVARCHAR, CLOB, etc.) and boolean representations (TRUE/FALSE vs 1/0) are automatically adapted per dialect.
How does the tool infer SQL types from JSON values?
null maps to SQL NULL; true/false maps to BOOLEAN (1/0 or BIT for SQLite/DB2/SQL Server); integers map to INT or BIGINT depending on the value range (auto-upgrades to BIGINT when the absolute value exceeds 2,147,483,647); floats map to FLOAT/DOUBLE/REAL per dialect; ISO 8601 date and date-time strings are recognized as DATE and TIMESTAMP; short strings map to VARCHAR(255); strings longer than 255 characters map to TEXT. Conflicting types across rows are automatically promoted (e.g., INT + FLOAT becomes FLOAT).
Can the generated SQL be executed directly in my database?
Yes. The generated SQL is fully standard for the chosen dialect and can be run in MySQL Workbench, Navicat, DBeaver, pgAdmin, SQL Server Management Studio, phpMyAdmin, or any other database management tool. Downloaded files are named after the table (e.g., users.sql) for easy batch import.
What happens if my JSON has syntax errors?
If the JSON contains trailing commas, missing quotes, or single quotes instead of double quotes, the tool automatically calls the built-in tryFixJSON repair function and continues the conversion. If the JSON still cannot be parsed after repair, the right panel shows the exact error location and cause. For deeply nested or severely broken JSON, run it through the JSON Formatter tool first.
Does the tool support bulk insert? How many rows per INSERT?
Yes. By default every INSERT bundles 100 rows, configurable from 1 to 1000. Converting 10,000 JSON rows therefore produces 100 multi-value INSERT statements. Compared with row-by-row inserts, this approach typically yields 10-100x faster import performance on MySQL, PostgreSQL, and similar engines.
Is my JSON data uploaded to a server?
No. This is a pure client-side application. All JSON parsing, type inference, and SQL generation happen in the browser's JavaScript engine; nothing is sent to any server. File uploads use the native FileReader API, and all data is cleared from memory when the page is refreshed. You can safely process JSON containing user PII, business secrets, or any other sensitive content.
Will ISO 8601 date strings be detected automatically?
Yes. The tool recognizes two ISO 8601 patterns: strings with a `T` separator (for example 2024-05-20T10:30:00) map to TIMESTAMP; date-only strings (for example 2024-05-20) map to DATE. Strings that do not follow ISO 8601 (for example 2024/05/20 or May 20, 2024) are treated as plain VARCHAR values.
How large a JSON file can the tool handle?
There is no hard limit; the practical limit is browser memory. Files up to 10 MB (tens of thousands of rows) run smoothly. Larger files may slow down as memory pressure increases. For very large datasets, split them into smaller batches or disable the optional beautify step in the SQL formatter to reduce memory usage.
Is the generated SQL automatically formatted?
Yes. The tool uses the sql-formatter library to beautify the output: keywords are uppercased (SELECT, INSERT INTO, VALUES, CREATE TABLE), each record sits on its own line, indentation is consistent, and empty lines are preserved for readability. The result is easy to read inside any database client and easy to edit manually afterwards.
Can I control the column order of the generated INSERT?
By default the tool uses the order of keys in the first object of the JSON array, which keeps multi-row output aligned. If different objects in the array have different key orders, the tool automatically merges and de-duplicates all keys and fills missing values with NULL. For best results, normalize the JSON with the JSON Formatter tool before conversion.
Troubleshooting
The right panel only shows "No valid objects found in JSON".
Cause 1: the JSON top level is neither an array nor an object (e.g., a bare string or number), so there is nothing to convert into rows. Fix: wrap the JSON in an array [{...}] or object {...}. Cause 2: the array contains primitive values ([1, 2, 3]) rather than objects, so there are no key names to map to columns. Fix: every array element must be an object with key/value pairs. Cause 3: the JSON failed to parse, the tryFixJSON routine ran, and the repair result is still not an object. Fix: validate the JSON with the JSON Formatter tool to find the syntax issue.
The generated SQL throws a syntax error in my database.
Cause 1: the wrong dialect is selected (for example MySQL selected but the target is PostgreSQL), so the identifier quote style is wrong. Fix: pick the correct dialect in the dropdown. Cause 2: the table or column name collides with a SQL reserved word (order, user, select, etc.). Fix: rename the table in the settings, or manually wrap the name in backticks/square brackets. Cause 3: the batch size is too large and exceeds the database's max_allowed_packet or similar limit. Fix: lower the batch size (for example to 50) in the settings.
A date field was detected as VARCHAR instead of DATE or TIMESTAMP.
Cause: the date string is not in ISO 8601 format. The tool only recognizes YYYY-MM-DD (DATE) and YYYY-MM-DDTHH:mm:ss (TIMESTAMP). Common formats it will not recognize: YYYY/MM/DD, DD-MM-YYYY, "May 20 2024", and Unix timestamps such as 1715644800. Fix: convert the date to ISO 8601 in the JSON first, or manually edit the CREATE TABLE column type to DATE or VARCHAR after conversion.
Booleans show up as 1/0 in SQLite/DB2 but I want TRUE/FALSE.
Cause: SQLite, DB2, and SQL Server do not have a native BOOLEAN type, so the dialect standard uses 1/0 (or BIT). Fix: option 1, accept 1/0 as the standard representation (1 means TRUE, 0 means FALSE); option 2, convert the value in your application layer (1 to true, 0 to false); option 3, post-process the SQL by replacing 1/0 with TRUE/FALSE and change the column type to INTEGER to read it as a boolean in your code. The tool always follows the dialect standard and does not offer a non-standard option.
The same field has different types across rows (one row string, another row number).
The tool uses a type-promotion algorithm to keep every value in the column representable. For example, if row 1 is INT and row 2 is FLOAT, the column ends up as FLOAT. If a column mixes strings and numbers, it is promoted to VARCHAR. Extreme conflicts (for example an object value in one row) are serialized as a JSON string and stored as TEXT. Validate the data with the JSON Formatter or JSON Validator before conversion to avoid surprises.
Chinese characters look garbled after importing the downloaded .sql file.
Cause: the .sql file is UTF-8 encoded, but the database client or the database itself is not set to UTF-8. Fix: option 1, set the database character set to utf8mb4 (MySQL) or UTF8 (PostgreSQL). Option 2, specify the character set on the client connection (for example MySQL CLI with --default-character-set=utf8mb4). Option 3, open the .sql file in a text editor and confirm the encoding is UTF-8 (not GBK or another encoding). The tool always produces UTF-8 .sql files.
The JSON contains nested objects or arrays. What column types are produced?
Non-primitive values (nested objects and arrays) are serialized to JSON strings and stored as TEXT. For example {"tags": ["a", "b"], "profile": {"age": 30}} produces two columns: tags TEXT and profile TEXT, both containing serialized JSON. At query time you can use JSON_EXTRACT (MySQL 5.7+) or similar JSON functions to pull out nested fields. To fully normalize nested data into separate relational tables, handle it in the application layer or use a dedicated ETL tool.
Glossary
- JSON (JavaScript Object Notation)
- A lightweight data-interchange format based on JavaScript object syntax but independent of any programming language. Supports six basic types: object ({}), array ([]), string, number, boolean, and null. Widely used for REST APIs, front-end to back-end transport, configuration files, and log records.
- SQL (Structured Query Language)
- The standard language for relational databases (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, etc.). Includes DDL (data definition, e.g., CREATE TABLE), DML (data manipulation, e.g., INSERT), DQL (data query, e.g., SELECT), and DCL (data control) sub-languages.
- INSERT statement
- A DML statement that adds rows to a table; syntax is INSERT INTO table_name (col1, col2) VALUES (val1, val2). Supports both single-value tuples and multi-value tuples (one INSERT for many rows); the latter dramatically improves bulk import performance.
- CREATE TABLE statement
- A DDL statement that creates a table by defining its name, columns, data types, and constraints (NOT NULL, PRIMARY KEY, UNIQUE, DEFAULT, etc.). The CREATE TABLE generated by this tool omits primary keys, foreign keys, and indexes to stay clean and predictable.
- SQL dialect
- The implementation differences between database vendors for the SQL standard. MySQL uses backticks, PostgreSQL uses double quotes, SQL Server uses square brackets; SQLite has no native BOOLEAN and uses 1/0; Oracle uses VARCHAR2; BigQuery uses INT64 and STRING. The same logical SQL can have different syntax across dialects.
- DDL (Data Definition Language)
- A SQL sub-language that includes CREATE, ALTER, and DROP statements, used to define and modify database structures (tables, views, indexes, constraints, etc.). The CREATE TABLE output by this tool is a DDL statement.
- DML (Data Manipulation Language)
- A SQL sub-language that includes INSERT, UPDATE, and DELETE statements, used to manipulate the data rows in tables. The INSERT INTO output by this tool is a DML statement.
- Type inference
- The process of automatically deducing the type of a value from its literal form. The tool inspects the typeof of each JSON value (null, boolean, number, string) along with its specific shape (ISO 8601 date, string length) to map it to the most appropriate SQL type.
- Identifier quote
- Special characters that wrap table and column names in SQL. MySQL uses backticks like `name`, PostgreSQL and standard SQL use double quotes like "name", SQL Server uses square brackets like [name]. Identifier quotes are used to escape reserved words and to control case sensitivity.
- ISO 8601 date format
- An international standard for representing dates and times. The format is YYYY-MM-DD for dates and YYYY-MM-DDTHH:mm:ss for date-times. Strings that match these patterns are automatically mapped to SQL DATE and TIMESTAMP types by this tool.
- VARCHAR and TEXT
- Two SQL types for variable-length strings. VARCHAR(n) has a length limit (commonly up to 65,535 bytes) and suits short strings such as names, emails, and titles. TEXT has no length limit (or a very large one) and suits long content such as descriptions and notes. By default this tool maps strings of 255 characters or fewer to VARCHAR(255) and longer strings to TEXT.
- INT and BIGINT
- Two SQL types for integers. INT (INTEGER) is normally a 32-bit signed integer with range -2147483648 to 2147483647. BIGINT is a 64-bit signed integer with a much larger range. The tool automatically upgrades integers whose absolute value exceeds the INT range to BIGINT.
- BOOLEAN type
- The SQL type for truth values. MySQL, PostgreSQL, and BigQuery support BOOLEAN natively (storing TRUE/FALSE). SQLite has no native BOOLEAN and uses 1/0 or INTEGER. SQL Server uses BIT. DB2 uses SMALLINT. The tool adapts the output automatically per dialect.
- IF NOT EXISTS clause
- An optional clause on CREATE TABLE that skips creation when the table already exists, avoiding errors on repeat runs. MySQL, PostgreSQL, SQLite, and BigQuery support it; Oracle PL/SQL and SQL Server T-SQL do not (the application must check first). The tool emits this clause only for dialects that support it.
- Batch insert
- A technique that combines many rows into a single INSERT statement using multi-value tuples, e.g., VALUES (1,2), (3,4), (5,6). Compared with row-by-row inserts, this reduces parse overhead and network round-trips and typically improves import performance by 10-100x. The tool defaults to 100 rows per INSERT and supports 1-1000.
- sql-formatter
- A JavaScript SQL beautifier that supports 20+ dialects. It uppercases keywords, applies consistent indentation, and breaks long lines. The tool uses this library as the last step in its pipeline to make the generated SQL easier to read and edit.
Supported SQL dialects and key differences
The 20+ SQL dialects supported by the tool, with their identifier quotes, integer types, and boolean representations:
| Dialect | Identifier quote | Integer type | Boolean form | IF NOT EXISTS |
|---|---|---|---|---|
| MySQL | backticks ` | INT | TRUE | yes |
| MariaDB | backticks ` | INT | TRUE | yes |
| TiDB | backticks ` | INT | TRUE | yes |
| SingleStoreDB | backticks ` | INT | TRUE | yes |
| PostgreSQL | double quotes " | INTEGER | TRUE | yes |
| Redshift | double quotes " | INTEGER | TRUE | yes |
| DuckDB | double quotes " | INTEGER | TRUE | yes |
| Trino | double quotes " | INTEGER | TRUE | yes |
| SQLite | double quotes " | INTEGER | 1/0 | yes |
| BigQuery | backticks ` | INT64 | TRUE | yes |
| Snowflake | double quotes " | NUMBER | TRUE | yes |
| DB2 | double quotes " | INTEGER | 1/0 | yes |
| DB2i | double quotes " | INTEGER | 1/0 | yes |
| Oracle PL/SQL | double quotes " | NUMBER | 1/0 | no |
| SQL Server T-SQL | square brackets [] | INT | 1/0 | no |
| Transact-SQL | square brackets [] | INT | 1/0 | no |
| Spark SQL | backticks ` | INT | TRUE | yes |
| Hive | backticks ` | INT | TRUE | yes |
| ClickHouse | backticks ` | Int32 | 1/0 | yes |
| N1QL (Couchbase) | backticks ` | NUMBER | TRUE | yes |
JSON-to-SQL type mapping rules
The full set of rules used by the detectType function to map JSON values to SQL types:
| JSON value | Example | Inferred SQL type | Detection rule |
|---|---|---|---|
null | null | NULL | JSON null maps to SQL NULL |
boolean | true / false | BOOLEAN | Dialects with native BOOLEAN use it; SQLite/DB2/SQL Server use 1/0 or BIT |
integer (32-bit) | 1, 100, -9999 | INT / INTEGER | |value| <= 2147483647 maps to INT |
integer (64-bit) | 9999999999, -1234567890 | BIGINT | |value| > 2147483647 promotes to BIGINT |
float | 3.14, -0.5, 1e10 | FLOAT / DOUBLE / REAL | Floats use FLOAT/DOUBLE/REAL per dialect |
ISO 8601 date-time | 2024-05-20T10:30:00 | TIMESTAMP | Matches /^\d{4}-\d{2}-\d{2}T/ -> TIMESTAMP |
ISO 8601 date | 2024-05-20 | DATE | Matches /^\d{4}-\d{2}-\d{2}/ -> DATE |
short string | Alice, Beijing | VARCHAR(255) | length <= 255 -> VARCHAR(255) |
long string | over 255 chars | TEXT | length > 255 -> TEXT (CLOB/NVARCHAR(MAX)/STRING depending on dialect) |
JSON to SQL vs other JSON converters
How JSON to SQL compares with the JSON to CSV, YAML, and XML converters:
| Capability | JSON to SQL | JSON to CSV | JSON to YAML | JSON to XML |
|---|---|---|---|---|
| Executable SQL output | yes (DDL + DML) | no | no | no |
| Dialect coverage | 20+ dialects | generic | generic | generic |
| Auto type inference | yes (dialect-aware) | no (plain text) | generic types | generic types |
| Batch insert optimization | yes (1-1000 per INSERT) | no | no | no |
| Schema (DDL) generation | yes | no | no | no |
| Direct database import | yes (run as-is) | manual import | manual import | manual import |
Privacy & Security
This JSON to SQL converter runs entirely in your browser. JSON parsing, type inference, SQL generation, and SQL beautification all execute in client-side JavaScript; nothing is sent to any server. File uploads use the native FileReader API and never go through an intermediate service. The tool uses no tracking cookies and collects no input or usage data. All input and output are cleared from memory as soon as the page is closed or refreshed. Safe to use on JSON that contains personal data, business secrets, or any other sensitive content.
Authoritative References
- JSON Compress
- CSV to JSON
- JSON to CSV
- JSON Diff
- JSON Escape / Unescape
- JSON Flatten
- JSON Formatter
- JSON Generator
- JSONPath Query
- JSON Merge
- JSON Repair
- JSON Schema Validator
- JSON Sort
- JSON Stringify
- JSON to HTML Table
- JSON to Java
- JSON to Markdown
- JSON to SQL
- JSON to TOML
- JSON to TypeScript
- XML to JSON
- JSON to XML
- YAML to JSON
- JSON to YAML
- JSON to Python
- JSON to Go
- JSON to Rust
- JSON to Swift
- JSON to C#
- JSON to C++
- JSON to PHP