Table JSON to Records Converter (Free Online Tool)

What is table json to records

Table json to records is the process of converting a table-shaped JSON export into normal JSON objects. The awkward input usually has one array for column names and another array for row values, often shaped like { "columns": [...], "rows": [...] }. That format is common in reporting APIs, spreadsheet-style JSON exports, low-code tools, and dashboard downloads, but it is hard to use directly in application code.

This free online converter turns rows and columns JSON into an array of records where every row becomes an object and every column label becomes a key. Instead of reading cell 0, cell 1, and cell 2, downstream code can read projectName, owner, or completedTasks. That makes the data easier to validate, clean, flatten, export, diff, or send into a ForgeJSON pipeline.

How to convert table json to records

Paste the table JSON into the input panel and run the converter. The default settings support the nested table envelope used by many exports: column labels at columns[0].values[0].data, rows at rows, and row values at values[0].data.

If your API response uses a simpler spreadsheet JSON format, set the headers path to the array of column names and the rows path to the array of row arrays. For example, { "headers": ["Name", "Score"], "data": [["Ada", "10"]] } uses headers as the headers path, data as the rows path, and an empty row values path because each row is already an array.

Use camelCase keys when the output should be JavaScript-friendly. Preserve keys as-is when exact column names matter for audits or handoff. If rows have too many or too few cells, choose whether to ignore extras, include extra values, or fail fast before the data reaches Normalize JSON, JSON to CSV, or another pipeline step.

table json to records example

Input
{
  "columns": [
    {
      "values": [
        {
          "data": ["Project Name", "Owner", "Creation Date", "Completed Tasks"]
        }
      ]
    }
  ],
  "rows": [
    {
      "values": [
        {
          "data": ["My Project 1", "Franklin", "7/1/2015", "387"]
        }
      ]
    },
    {
      "values": [
        {
          "data": ["My Project 2", "Beth", "7/12/2015", "402"]
        }
      ]
    }
  ]
}

Output
[
  {
    "projectName": "My Project 1",
    "owner": "Franklin",
    "creationDate": "7/1/2015",
    "completedTasks": "387"
  },
  {
    "projectName": "My Project 2",
    "owner": "Beth",
    "creationDate": "7/12/2015",
    "completedTasks": "402"
  }
]

This example shows the core conversion: the column array supplies field names, each row supplies cell values, and the converter zips them together by index. The result is normal JSON records that are easier to inspect and automate.

Common use cases of table json to records

Use table json to records when a service returns an API response rows columns shape instead of a normal array of objects. This happens in analytics products, spreadsheet integrations, database admin tools, reporting endpoints, and business intelligence exports that need to preserve table metadata.

Developers often use this converter before importing data into tests, scripts, dashboards, or LLM workflows. Once the table envelope becomes records, you can use Extract Fields from JSON to keep only important columns, Clean JSON to remove empty values, or JSON to CSV to hand the cleaned result back to spreadsheet users.

It is also useful when you need to normalize table JSON from several vendors. One API may call the headers columns, another may call them fields, and another may wrap each row in a values object. Configurable paths let you convert those variants without writing a one-off script for every export.

Common errors when using table json to records

The most common error is pointing the headers path or rows path at the wrong level. If the headers path resolves to an object instead of an array, the converter cannot build record keys. If the rows path resolves to a wrapper object instead of the row list, the tool cannot iterate through records.

Length mismatches are another frequent issue. A row with fewer cells than headers creates missing values. A row with extra cells has no obvious column name. Use strict mismatch handling when the source data should be complete, or ignore extras when the export includes trailing metadata you do not need.

Duplicate headers can also cause confusing output. Two columns named Status cannot both become status without a rule. The suffix option keeps both values by creating unique keys. If duplicate columns indicate a bad export, switch duplicate handling to error and validate the source first with the JSON Validator.

Why use this table json to records tool

This tool exists because the input shape is ugly and surprisingly common. A table envelope is compact for the system that produced it, but inconvenient for the people who need to work with it. Normal records are easier for humans to read and much easier for code to consume.

Using the browser tool is faster than writing a custom mapper when you are debugging a payload, testing an integration, or preparing a sample for another team. The output is visible immediately, and the same conversion can become part of a reusable pipeline when the workflow grows beyond a one-time paste.

The converter also keeps the transformation explicit. Paths, key casing, type inference, mismatch behavior, and duplicate header behavior are visible choices instead of hidden assumptions in a script.

table json to records vs other approaches and APIs

Table JSON to records is different from CSV to JSON. CSV to JSON starts with text rows and delimiters. This tool starts with JSON that already represents a table but separates headers from row values. If your input is a .csv string, use CSV to JSON. If your input is { "columns": [...], "rows": [...] }, use this converter.

It is also different from Normalize JSON. Normalization makes existing records share the same shape. Table JSON conversion creates the records first. In many API workflows, you convert columns and rows to JSON records, then normalize the result so missing fields, extra fields, and key order are consistent.

For APIs, this conversion is often the first cleanup step after receiving a reporting response. Convert the table envelope, inspect the record keys, then continue with validation, field extraction, flattening, or CSV export depending on the downstream contract.

Example pipeline on GitHub

The ForgeJSON Pipeline Spec repo includes a portable Table JSON to Records pipeline you can inspect, copy, or version with your own tooling:

Table JSON to Records pipeline example

The linked file is a plain JSON pipeline document using the ForgeJSON Pipeline Spec.

Related tools

• Normalize JSON - make converted records share a consistent shape.
• JSON to CSV - export converted records to spreadsheet-friendly CSV.
• CSV to JSON - convert delimiter-based spreadsheet text into JSON records.
• Extract Fields from JSON - keep only the columns you need after conversion.
• Clean JSON - trim messy values and remove noise from converted records.
• JSON Validator - check source payloads before conversion.