> ## Documentation Index
> Fetch the complete documentation index at: https://docs.iotools.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# API overview

> Call 800+ developer tools over one REST endpoint, or from any MCP client

Most tools on [IOTools.cloud](https://iotools.cloud) are also an API endpoint and an MCP tool — **900+ of them**. One key, one credit balance, both surfaces.

<Info>
  The API and MCP server are in **Beta**. Endpoints and response shapes are stable day to day, but not yet covered by a formal deprecation policy — breaking changes are possible with less notice than after a 1.0 release.
</Info>

<CardGroup cols={2}>
  <Card title="Get started" icon="rocket" href="/api/get-started">
    First call in about two minutes
  </Card>

  <Card title="API reference" icon="code" href="/api-reference">
    Every endpoint, with a live playground
  </Card>

  <Card title="Use it from an agent" icon="bot" href="/mcp/overview">
    Claude, Cursor, Windsurf — one config block
  </Card>

  <Card title="Credits" icon="coins" href="/concepts/credits">
    What a call costs
  </Card>
</CardGroup>

## One call

```bash theme={"system"}
curl -X POST https://api.iotools.cloud/v1/tool/case-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "inputString": "hello world", "caseStyle": "uppercase" }'
```

```json theme={"system"}
{
  "request_id": "e4042b29-…",
  "tool": "case-converter",
  "tool_version": "1.0.1",
  "outputs": { "outputString": "HELLO WORLD" },
  "credits_used": 1,
  "credits_remaining": 999
}
```

<Warning>
  Be careful calling a tool in a loop. Every call is metered — see [Credits](/concepts/credits) — so a loop with no exit condition, an off-by-one, or a retry with no backoff burns through your monthly allowance fast and can leave you with `insufficient_credits` failures partway through a batch. Check `credits_remaining` on the response, or [GET /v1/me/credits](/api-reference), before running an unattended loop over many inputs.
</Warning>

## Table and card outputs

Most output fields are plain strings. Two kinds are not: a **table** (a breakdown, a schedule, a list of matches) and a **card grid** (generated names, suggestions). Both arrive as real JSON — an array you index into, not a string you parse.

A table is one object per row, keyed by column:

```bash theme={"system"}
curl -X POST https://api.iotools.cloud/v1/tool/area-of-square-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "sideLength": "5", "unit": "cm" }'
```

```json theme={"system"}
"outputs": {
  "results": [
    { "metric": "Area", "value": "25 cm²" },
    { "metric": "Perimeter", "value": "20 cm" },
    { "metric": "Diagonal", "value": "7.07 cm" }
  ]
}
```

The keys are not guesswork — `GET /v1/tool/{slug}` describes the row on the field itself, as `items.properties`, each carrying its column's header as a `description`. So a generated client hands you a typed row. The same schema backs the MCP `output_schema`, and both surfaces return the same shape.

Alongside it, `x-iotools-columns` lists those keys in **column order**:

```json theme={"system"}
"results": {
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "metric": { "type": "string", "description": "Metric" },
      "value":  { "type": "string", "description": "Value" }
    }
  },
  "x-iotools-columns": ["metric", "value"]
}
```

Use it if you are rendering headers or writing a CSV. JSON Schema's `properties` is an unordered map, and JavaScript reorders integer-like keys inside any object — so a column named `2024` would silently sort ahead of its neighbours if you read the order off `Object.keys()`.

A card grid is `{ title, description?, image? }` per card:

```json theme={"system"}
"outputs": {
  "names": [
    { "title": "Fastt", "description": "Double Letter · 5 chars" },
    { "title": "Gobyte", "description": "Prefix/Suffix · 6 chars" }
  ]
}
```

Two things worth knowing:

* **Cell values are always strings.** A table row is a map of string to string — numbers arrive formatted (`"$16.67"`, `"100,000"`), because that is what the tool computed.
* **A few tools build their columns from your input** (pivot tables, matrix operations, CSV column extraction). There is no fixed key map for those, so their rows are arrays of cells in column order. You can tell from the schema: their `items.type` is `array` rather than `object`, and they carry no `x-iotools-columns`.

<Warning>
  This shape arrived with `tool_version` `1.0.1`. Before that, a table or card grid was a JSON-encoded **string** holding positional rows — `"[[\"Area\",\"25 cm²\"],…]"` — so older code that calls `JSON.parse()` on the field will now throw, and code that indexes `row[0]` needs `row.metric`. Nothing else in the envelope changed.
</Warning>

## Two things to know first

**Using a tool in your browser is free and unlimited. Calling it from code costs credits.** Every tool call over the API or MCP costs credits, including tools that cost nothing on the website — a per-plan minimum, or the tool's own weight if that is higher. Reading the catalog costs nothing. See [Credits](/concepts/credits).

**Not every tool has an API.** 900+ tools on the site do. The rest run entirely in your browser — camera capture, some PDF and image editing — and have no server-side equivalent to call. Calling one returns `tool_not_allowed`; see [Errors](/concepts/errors).

## What you get

<CardGroup cols={2}>
  <Card title="900+ endpoints" icon="wrench">
    Formatters, converters, generators, calculators, encoders — the same code that runs on the site.
  </Card>

  <Card title="One schema everywhere" icon="merge">
    The OpenAPI document, the MCP `inputSchema` and the runtime validator come from one source, so they cannot disagree.
  </Card>

  <Card title="Failed calls are free" icon="rotate-ccw">
    Credits are charged on entry and refunded on any 4xx or 5xx.
  </Card>

  <Card title="RFC 9457 errors" icon="triangle-alert">
    Every failure is a problem document with a stable `code` to branch on.
  </Card>
</CardGroup>