JSON to Excel
Give business colleagues a workbook instead of a data file: the field names become the header row, every record becomes a row, and numbers are stored as real numbers a finance team can drop straight into a pivot table. You pay per use, with no subscription.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
a formatted XLSX from your data
Why a workbook instead of a data file
Handing a business colleague a raw data file is a dead end: they need something they can open, filter and pass on without asking what a curly brace is. A finance team wants a workbook it can build a pivot table on, a client expects a report that opens in a spreadsheet program, and an operations lead wants a file to attach to an email. A CSV can carry the same values, but it has no notion of a typed cell, so numbers and text look the same. When the file is meant to be opened and read rather than processed by another program, a real workbook is the format that respects its reader.
What ends up in the file
Every name found in the records becomes a heading in the first row, in the order it first appears, and each record becomes one row beneath it. Numeric values are stored as real numbers, so they can be summed, sorted and used in a pivot table straight away; true and false become yes-or-no cells, and everything else is stored as text. A value a record does not have leaves its cell empty. The result is a genuine workbook with one sheet. The tool expects flat records, so if a record contains a nested section, flatten your data before converting it.
Why XLSX specifically, and not just CSV
CSV can carry the same values but strips away everything that makes a spreadsheet feel finished: it has no concept of a typed cell, no column width, no distinct header styling, and no support for multiple sheets. XLSX, as a structured format built on top of XML rather than a flat text file, preserves all of that, which matters the moment the file is meant for a person rather than another program.
When the deliverable is meant to be opened and read, not just parsed, XLSX is the format that respects the audience.
What you can do with it
Finance and ops deliverables
Generate workbooks with properly typed numeric and date columns that a finance team can drop straight into a pivot table.
FAQ
Will the generated XLSX file have formatted columns, or just raw data?
Column widths and header styling are applied automatically based on your data, so the file opens looking finished rather than like a raw export.
Are numbers stored as real numbers in the workbook?
Yes. Numeric values become numeric cells you can add up, sort and use in a pivot table, true and false become yes-or-no cells, and everything else is stored as text. Nothing has to be converted by hand after opening the file.
What happens when my records do not all have the same fields?
Every name that appears in any record gets a column in the header row, in the order it first shows up, and a record that lacks a value simply leaves that cell empty. No record is dropped because of a missing field.
Why send a workbook instead of a CSV file?
A CSV carries the same values but has no idea of a typed cell, so numbers can arrive as text and need fixing. A workbook keeps each value's kind and opens directly in a spreadsheet program, which matters when the file is meant for a person.
What shape does my data need to have?
A list of flat records, one for each row you want. The names of the first records set the header, and each record fills one row. A section nested inside a record is not spread into columns, so flatten nested data first.
Related tools
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
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/data/json-to-xlsx \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"rows":[{"producto":"Café","precio":3.5,"stock":12}]}'const res = await fetch("https://api.kit.forhosting.com/data/json-to-xlsx", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"rows": [
{
"producto": "Café",
"precio": 3.5,
"stock": 12
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/data/json-to-xlsx",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"rows": [
{
"producto": "Café",
"precio": 3.5,
"stock": 12
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/data/json-to-xlsx", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"rows":[{"producto":"Café","precio":3.5,"stock":12}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"rows":[{"producto":"Café","precio":3.5,"stock":12}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/data/json-to-xlsx", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"rows": [
{
"producto": "Café",
"precio": 3.5,
"stock": 12
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "data.json_to_xlsx",
"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
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. |
Technical notes
Handing a business user a JSON file is a dead end — they need something they can open, filter and hand to a colleague without asking what a curly brace is. This endpoint takes your JSON and generates an actual XLSX workbook, with real column headers, correctly typed cells, and formatting applied automatically instead of a wall of raw text pasted into column A.
The gap between an API response and a deliverable
Most business processes end with someone opening a file, not calling an endpoint. A finance team wants a workbook they can drop a pivot table onto, a client expects a report that opens directly in their spreadsheet tool, an operations lead wants a file they can email without explaining what JSON is. Piping raw API output at these people does not work, and hand-writing an XLSX generator that produces something that looks intentional — right column widths, typed cells, a header row that is visually a header row — is a surprising amount of formatting logic for what feels like it should be a one-line conversion.
What the generated file actually looks like
The result opens looking like something a person built with care, not a raw data dump. Send JSON to POST /data/json-to-xlsx and the response is a workbook where field names become column headers, numeric fields are stored as real numbers rather than text that merely looks like a number, dates are written using Excel's native date type so sorting and filtering work correctly out of the box, and column widths are set to a sensible default based on content length instead of the tiny default that makes every fresh spreadsheet look unfinished.
Nested data gets a defensible answer, not a broken one
Rather than failing or dumping an unreadable blob into a cell, nested structures are flattened into clearly named columns using the same dot-notation logic a careful analyst would apply by hand, so an order with nested customer and shipping data becomes one coherent row instead of an unusable string of escaped characters. JSON regularly nests objects and arrays inside a record, and a spreadsheet cannot represent that natively.
Where this fits in a reporting workflow
Since the task runs asynchronously, it works well as the final step of a reporting pipeline: gather records from your application, generate the workbook here, and deliver it straight to an inbox or shared drive without a script managing formatting logic. You get a task_id immediately on submission, and the finished XLSX file arrives by webhook, ready to send exactly as is.
Integration use cases
Automated client reports
Turn API data into a polished XLSX report delivered on a schedule, without a person manually building the spreadsheet each time.
Sales or inventory exports
Convert nested JSON records, like orders with line items, into a readable multi-column workbook for a sales or warehouse team.
Non-technical stakeholder handoff
Deliver API results to a client or partner as a familiar Excel file instead of a JSON payload they have no way to open.
Technical questions
Does the JSON to Excel API preserve data types like numbers and dates?
Yes, numeric fields are written as real numbers and dates use Excel's native date type, so sorting, filtering and formulas work correctly without manual reformatting.
How does it handle nested JSON objects or arrays?
Nested structures are flattened into clearly named columns using dot notation, so a record with nested fields becomes one readable row instead of an unusable text blob.
Is there a free trial for the JSON to Excel endpoint?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
Can I generate an XLSX file from a large JSON array?
Yes, submit the array as a single async request; it is processed as one task and returns a complete workbook.
What happens if the JSON to XLSX generation fails?
The task retries automatically up to three times, and if it still fails you receive a clear error with no charge for the attempt.
How do I receive the generated Excel file?
Via a signed webhook, recommended for automated delivery, or a signed link valid for 24 hours for manual download.
How much does generating an XLSX file from JSON cost?
$0.002 per request, billed only for successfully generated files.