ForHosting KIT · Data & Files

JSON to HTML table

Nobody outside engineering wants to read raw JSON, no matter how well it is indented, but the same array of records renders instantly as a table anyone can scan. This JSON to HTML table API takes structured data and turns it into a styled HTML table you can drop straight into an email, a report, or a page.

● StableFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailApp soonTelegram soon

The gap between structured data and a readable page

An API returns JSON, a database query exports JSON, an automation pipeline passes JSON between steps — but at some point a human needs to look at that data, and a wall of braces and brackets is not how anyone wants to review a list of orders, a set of survey responses, or a table of inventory counts. Building an HTML table by hand for every report is tedious and easy to get wrong, especially once nested fields or optional columns enter the picture.

How the conversion works

You call POST /data/json-to-html with a JSON array of objects and get a task_id back immediately, since rendering runs as an asynchronous job. The service inspects the objects, builds a column from every distinct key it finds across the array, and produces a semantic HTML table with a header row and one row per object, styled with clean default CSS so it looks presentable without any extra work; cells that are missing a given key are rendered empty rather than breaking the table's shape.

Why tables remain the clearest way to show tabular data

The HTML table element has been part of the web since its earliest days, and despite decades of alternative layout techniques, nothing communicates rows and columns of comparable data as instantly as an actual table: the eye tracks a column down and a row across without any learning curve. JSON, meanwhile, is built for machines to parse reliably, not for people to scan visually — pairing the two lets each format do what it does best, machine-readable in transit and human-readable on arrival.

Where this fits an automated workflow

Use this step wherever a JSON result needs to reach a non-technical audience: turning an API response into the body of a notification email, embedding a live data snippet into an internal dashboard page, or generating the tabular section of an automated report. It slots naturally after any step that produces or transforms JSON, and the resulting markup is plain HTML that can be inlined into a larger page or email template without a rendering engine on your side.

Delivery, pricing, and status

The rendered HTML table is delivered by a signed webhook, recommended for automated reporting, or a signed link valid for 24 hours; source and output are deleted after the retention window and never used for training. Pricing is a flat $0.002 per request regardless of how many rows the array contains, and a failed task — such as JSON that is not an array of objects — is never charged after the standard three retries. This endpoint is live now.

What you can do with it

Turn API results into an email body

Convert a JSON list of new orders into a styled table and embed it directly in a daily summary email, no manual formatting required.

Build the tabular section of an automated report

Generate the HTML table for a weekly metrics report straight from the same JSON your dashboard already consumes, keeping the two perfectly in sync.

Show survey or form data to non-technical reviewers

Render submitted form responses as a table for a stakeholder who has no interest in reading raw JSON but needs to scan the results quickly.

Embed live data snippets in internal pages

Feed a JSON snapshot of inventory or ticket status into a table embedded on an internal status page, refreshed on whatever schedule your pipeline runs.

FAQ

How do I convert JSON to an HTML table with an API?

Send a JSON array of objects to POST /data/json-to-html, which returns a task_id right away; the styled table markup arrives at your signed webhook or a signed link once rendering finishes.

Is the JSON to HTML table API free?

The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.

What JSON structure does it expect?

An array of objects works best, since each object becomes a row and its keys become columns; a single object or deeply nested structures may render less predictably.

What happens with missing or inconsistent keys?

The table includes a column for every distinct key found across the array, and any object missing a given key simply shows an empty cell there, so the table shape stays consistent.

Can I customize how the table looks?

The output ships with clean default styling suitable for direct embedding; for full visual control, apply your own CSS to the returned HTML after delivery.

Can I convert large JSON arrays in bulk?

Yes. Each request is an independent asynchronous task, so you can submit many arrays in parallel and collect each rendered table by webhook as it completes.

Is the output valid HTML I can embed anywhere?

Yes, the response is standard semantic HTML table markup you can inline into an email, a report, or a web page without additional processing.

What if my JSON is nested rather than flat?

Nested objects or arrays inside a field are rendered as their JSON representation within that cell rather than expanded into extra columns, so flat records produce the cleanest tables.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/data/json-to-html

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/data/json-to-html \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/data/json-to-html", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/data/json-to-html",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/data/json-to-html", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/data/json-to-html", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "data.json_to_html",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_mb 25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →

Run — free