ForHosting KIT · Data & Files

JSON to Excel

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.

Temporarily withdrawnPer request + per 1,000 rows$0.002

This task is not available right now, so it cannot be purchased. Nothing is charged for it.

How it works & API

Use it from WebAPIEmailApp soonTelegram soon

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

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. The result opens looking like something a person built with care, not a raw data dump.

Nested data gets a defensible answer, not a broken one

JSON regularly nests objects and arrays inside a record, and a spreadsheet cannot represent that natively. 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.

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.

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.

What you can do with it

Automated client reports

Turn API data into a polished XLSX report delivered on a schedule, without a person manually building the spreadsheet each time.

Finance and ops deliverables

Generate workbooks with properly typed numeric and date columns that a finance team can drop straight into a pivot table.

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.

FAQ

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.

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.

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.

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-xlsx

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-xlsx \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"text":"…"}'

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({
    "text": "…"
  })
});
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[&#39;KIT_KEY']}"},
    json={
    "text": "…"
},
)
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" => &#39;{"text":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"text":"…"}`)
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

{
  "text": "…"
}

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

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 →