ForHosting KIT · Data & Files

Excel to JSON

Excel files carry more than values — merged cells, multiple sheets, formulas that resolve to a number but are stored as an expression, dates that are secretly a serial number counting from 1900. This endpoint reads an XLSX file the way a person would, sheet by sheet, and returns structured JSON with each cell's real value, not its spreadsheet quirks.

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

Why Excel files resist naive parsing

An XLSX file is technically a zipped bundle of XML documents describing sheets, styles, shared strings and a workbook manifest, which is why writing a parser from scratch is a much bigger undertaking than it looks. Beyond the file format itself, spreadsheets carry human habits that trip up automated readers: a header row that starts on row three because someone added a title above it, a column of dates stored as an internal serial number rather than readable text, formulas that need to be evaluated rather than read literally, and merged cells that make a simple row-by-row read misalign entirely.

What the conversion actually resolves

Call POST /data/xlsx-to-json with your file and each sheet is read into its own JSON structure, with header rows detected and used as field names, dates converted from Excel's internal serial format into standard, readable date strings, and formula cells returned as their calculated value rather than the formula text itself. If your workbook has several sheets — a common pattern for exports that separate summary and detail data — each one arrives distinctly in the response instead of being merged or dropped.

A brief note on where XLSX came from

The spreadsheet as a category goes back to the earliest days of personal computing, and the XLSX format itself arrived in the mid-2000s as an XML-based replacement for the older binary XLS format, trading a compact but opaque binary layout for one that tools outside the original spreadsheet application could at least theoretically read. In practice, that openness did not make XLSX simple — it just moved the complexity from a binary spec to a verbose XML one, which is exactly the layer this endpoint absorbs on your behalf.

Who reaches for this most

This shows up constantly in workflows where the data originates outside your own systems: a client emails a budget spreadsheet, a government portal only exports XLSX, a finance team maintains a source-of-truth workbook that nobody wants to migrate off. Rather than asking non-technical stakeholders to change how they work, the conversion happens on your side, turning their familiar format into the JSON your application already speaks.

How it slots into automation

Because the task is asynchronous, it fits naturally where an XLSX file lands unpredictably — an email attachment processed by an inbox automation, a file dropped into a shared folder, an upload form on an internal tool. You get a task_id the moment you submit the file, and the parsed JSON, organized by sheet, arrives by webhook so downstream steps can start the moment it is ready.

What you can do with it

Client-submitted budget files

Automatically parse XLSX budgets or forecasts emailed in by clients into JSON your finance system can ingest without manual re-entry.

Government or institutional data exports

Convert XLSX exports from portals that only offer Excel downloads into JSON usable in a modern data pipeline.

Multi-sheet workbook processing

Read a workbook with separate sheets for regions or product lines and get each sheet back as its own distinct JSON structure.

Internal tool file uploads

Let team members upload a familiar Excel file through an internal tool and convert it to JSON behind the scenes for processing.

FAQ

Does the Excel to JSON API handle multiple sheets in one workbook?

Yes, each sheet is parsed and returned as its own distinct structure within the JSON response, so multi-sheet workbooks are never merged incorrectly.

How are Excel dates converted?

Dates stored internally as Excel's numeric serial format are converted to standard, readable date strings automatically, so you never have to decode the offset yourself.

Does it read formula results or the formula text?

It returns the calculated value of formula cells, not the underlying formula expression, matching what you would see looking at the spreadsheet.

Is there a free way to test the XLSX to JSON 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 it handle merged cells or headers that do not start on row one?

Yes, header detection accounts for common layout patterns like offset header rows, though very irregular custom layouts are read as literally as possible.

What if the XLSX file is corrupted or fails to parse?

The task retries automatically up to three times; if it still cannot be parsed, you receive a clear error with no charge for the failed attempt.

How do I get the resulting JSON back?

Through a signed webhook, recommended for automated workflows, or a signed link valid for 24 hours for manual download.

What does converting an Excel file to JSON cost?

$0.002 per request, charged only for successful conversions.

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/xlsx-to-json

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

const res = await fetch("https://api.kit.forhosting.com/data/xlsx-to-json", {
  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/xlsx-to-json",
    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/xlsx-to-json", 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/xlsx-to-json", 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.xlsx_to_json",
  "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 →