# FluentEDI

> Deterministic tools for AI agents. No key, no signup, no SDK.

A public HTTP API of deterministic tools for the work a language model cannot do reliably by reasoning: knowing the current time in any timezone and whether an instant falls inside a window, exact arithmetic, hashing and signature verification, canonicalizing and content-addressing JSON, repairing malformed JSON and pinpointing where it broke, querying and diffing structured data, parsing CSV correctly, converting units, colours and currencies at live ECB rates, testing regular expressions, resolving DNS, looking up WHOIS/RDAP registration for any domain or IP, validating email addresses down to their MX records, checking whether a URL is still live, and extracting the text of PDF, Word, Excel and OpenDocument files as markdown. Every tool is one stateless GET or POST returning JSON, and the same tools are exposed over the Model Context Protocol at /mcp. Coverage runs deepest in retail EDI — X12 850, 856, 810, 855 and 997 parsing and validation, and GS1 check digits — which no other free, unauthenticated service offers agents.

## How to call it

Every tool is one stateless request. No API key, no account, no rate-limit headers to negotiate.

    GET  https://www.fluentedi.com/v1/{tool}?param=value
    POST https://www.fluentedi.com/v1/{tool}          (JSON body)

Responses are `{ "ok": true, "tool": "...", "result": {...} }`. Errors are `{ "ok": false, "error": {...} }`
and always include the tool's full parameter schema plus working examples, so a failed call tells you
exactly how to make the next one succeed.

Run up to 20 tools in one round trip by POSTing to https://www.fluentedi.com/v1/batch with
`{"calls":[{"tool":"time.now","args":{}},{"tool":"hash","args":{"input":"x"}}]}`.

MCP clients: add https://www.fluentedi.com/mcp as a streamable-HTTP server. Same tools, same behaviour.

## Tools

### Time, dates and windows

- [time.now](https://www.fluentedi.com/v1/tools/time.now): Current date and time in any IANA timezone.
  Returns the authoritative current time in one or more timezones, with UTC offset, ISO week number, day of year, weekend flag, and daylight-saving state. Use this instead of guessing the date: a language model has no clock, and its training cutoff is not today.
  Parameters:
    - timezone: string (default: "UTC") — IANA timezone identifier, e.g. "UTC", "America/New_York", "Asia/Kolkata", "Europe/London".
    - also: array (default: []) — Additional timezones to report alongside the primary one.
  Example — Current time in UTC:
    https://www.fluentedi.com/v1/time/now
  Example — Current time in Tokyo:
    https://www.fluentedi.com/v1/time/now?timezone=Asia%2FTokyo
  Example — One instant across a distributed team:
    https://www.fluentedi.com/v1/time/now?timezone=America%2FLos_Angeles&also=%5B%22Europe%2FLondon%22%2C%22Asia%2FKolkata%22%5D

- [time.convert](https://www.fluentedi.com/v1/tools/time.convert): Convert a timestamp between timezones.
  Converts one instant into any number of timezones, handling daylight saving transitions correctly. Naive inputs (no Z or offset) are read as wall-clock time in `from`; inputs carrying an offset are absolute.
  Parameters:
    - time: string (default: "now") — The instant to convert: ISO 8601, a naive wall-clock time, a unix timestamp, or "now".
    - from: string (default: "UTC") — Timezone the input is expressed in (used only when it carries no offset).
    - to: array (required) — Target timezones.
  Example — A London meeting time, in New York and Tokyo:
    https://www.fluentedi.com/v1/time/convert?time=2026-08-22%2009%3A00&from=Europe%2FLondon&to=%5B%22America%2FNew_York%22%2C%22Asia%2FTokyo%22%5D
  Example — Unix timestamp to a human timezone:
    https://www.fluentedi.com/v1/time/convert?time=1755900000&to=%5B%22Asia%2FKolkata%22%5D

- [time.add](https://www.fluentedi.com/v1/tools/time.add): Add or subtract a duration from a date, calendar-aware.
  Adds years, months, weeks, days, hours, minutes and seconds to an instant. Calendar units (years, months, weeks, days) move wall-clock time and clamp overflow — Jan 31 plus one month is Feb 28 or 29, never Mar 3. Clock units (hours, minutes, seconds) add exact elapsed time and therefore cross DST boundaries.
  Parameters:
    - time: string (default: "now") — Starting instant: ISO 8601, unix timestamp, or "now".
    - timezone: string (default: "UTC") — IANA timezone identifier, e.g. "UTC", "America/New_York", "Asia/Kolkata", "Europe/London".
    - years: integer (default: 0) — Years to add (negative subtracts).
    - months: integer (default: 0) — Months to add (negative subtracts). Day-of-month is clamped.
    - weeks: integer (default: 0) — Weeks to add (negative subtracts).
    - days: integer (default: 0) — Calendar days to add (negative subtracts).
    - hours: number (default: 0) — Exact hours to add (negative subtracts).
    - minutes: number (default: 0) — Exact minutes to add (negative subtracts).
    - seconds: number (default: 0) — Exact seconds to add (negative subtracts).
    - business_days: integer (default: 0) — Weekdays to add, skipping Saturday and Sunday.
  Example — 90 days from now:
    https://www.fluentedi.com/v1/time/add?days=90
  Example — Net-30 invoice due date:
    https://www.fluentedi.com/v1/time/add?time=2026-08-22&days=30&timezone=America%2FNew_York
  Example — Five business days out:
    https://www.fluentedi.com/v1/time/add?business_days=5
  Example — One month before a launch:
    https://www.fluentedi.com/v1/time/add?time=2026-03-31&months=-1

- [time.diff](https://www.fluentedi.com/v1/tools/time.diff): Duration between two dates, in every unit.
  Computes the elapsed time between two instants: exact totals in each unit, a calendar breakdown (years/months/days rather than 'thirteen and a half months'), the count of weekdays in between, and a human phrase. Negative when `to` precedes `from`.
  Parameters:
    - from: string (default: "now") — Start instant: ISO 8601, unix timestamp, or "now".
    - to: string (default: "now") — End instant: ISO 8601, unix timestamp, or "now".
    - timezone: string (default: "UTC") — IANA timezone identifier, e.g. "UTC", "America/New_York", "Asia/Kolkata", "Europe/London".
  Example — Days until a deadline:
    https://www.fluentedi.com/v1/time/diff?to=2026-12-31
  Example — Exact age from a birth date:
    https://www.fluentedi.com/v1/time/diff?from=1990-05-14&to=now
  Example — Working days in a sprint:
    https://www.fluentedi.com/v1/time/diff?from=2026-08-03&to=2026-08-14

- [time.window](https://www.fluentedi.com/v1/tools/time.window): Test whether an instant falls inside a time window, and by how much it misses.
  Answers the questions a deadline actually poses: is this instant inside the window, how long until it opens or closes, and if it is outside, by how much. Optionally compares two windows for overlap. A window comparison that silently succeeds against the wrong bounds is a failure mode that does not raise an error anywhere — the ship window is missed, or the ASN is late, and the only symptom is a chargeback later. This computes the boundary instead of assuming it.
  Parameters:
    - start: string (required) — Window opens at this instant: ISO 8601, unix timestamp, or "now".
    - end: string (default: "") — Window closes at this instant. Omit if using `duration_hours`.
    - duration_hours: number (default: 0) — Window length in hours, used when `end` is omitted.
    - instant: string (default: "now") — The instant to test against the window.
    - timezone: string (default: "UTC") — IANA timezone used to read naive inputs and render output.
    - compare_start: string (default: "") — Start of a second window, to test for overlap with the first.
    - compare_end: string (default: "") — End of the second window.
  Example — Is the shipment inside its delivery window?:
    https://www.fluentedi.com/v1/time/window?start=2026-08-24T09%3A00%3A00Z&end=2026-08-26T17%3A00%3A00Z
  Example — A 72-hour ASN window from the ship date:
    https://www.fluentedi.com/v1/time/window?start=2026-08-24T09%3A00%3A00Z&duration_hours=72
  Example — How late was this ASN?:
    https://www.fluentedi.com/v1/time/window?start=2026-08-01T00%3A00%3A00Z&end=2026-08-02T00%3A00%3A00Z&instant=2026-08-15T00%3A00%3A00Z
  Example — Do two windows overlap?:
    https://www.fluentedi.com/v1/time/window?start=2026-08-24T09%3A00%3A00Z&end=2026-08-26T17%3A00%3A00Z&compare_start=2026-08-25T00%3A00%3A00Z&compare_end=2026-08-30T00%3A00%3A00Z

- [time.zones](https://www.fluentedi.com/v1/tools/time.zones): List or search IANA timezone identifiers with current offsets.
  Every IANA timezone the runtime supports, with its current UTC offset and local time. Search by city, region or offset to resolve a vague location like "Bangalore" to a valid identifier before calling other time tools.
  Parameters:
    - search: string (default: "") — Case-insensitive substring filter, e.g. "kolkata", "america/", "+05:30".
    - limit: integer (default: 50) — Maximum results to return.
  Example — Find the identifier for Bangalore:
    https://www.fluentedi.com/v1/time/zones?search=kolkata
  Example — Every Australian zone:
    https://www.fluentedi.com/v1/time/zones?search=australia%2F


### Scheduling

- [cron.next](https://www.fluentedi.com/v1/tools/cron.next): Validate a cron expression, explain it in English, and list its next run times.
  Parses a standard 5-field cron expression (or 6-field with leading seconds, or a macro like @daily), validates it, describes it in plain English, and computes the next run times in a given timezone with daylight-saving handled. Use it before writing a schedule to config — cron's day-of-month/day-of-week OR-semantics and step syntax are a common source of silently wrong schedules.
  Parameters:
    - expression: string (required) — Cron expression, e.g. "*/15 * * * *", "0 9 * * 1-5", "@daily".
    - timezone: string (default: "UTC") — IANA timezone the schedule runs in.
    - count: integer (default: 5) — How many upcoming run times to return.
    - from: string (default: "now") — Compute run times after this instant instead of now.
  Example — Weekday mornings in New York:
    https://www.fluentedi.com/v1/cron/next?expression=0%209%20*%20*%201-5&timezone=America%2FNew_York
  Example — Every 15 minutes:
    https://www.fluentedi.com/v1/cron/next?expression=*%2F15%20*%20*%20*%20*
  Example — Quarterly, first of the month:
    https://www.fluentedi.com/v1/cron/next?expression=0%200%201%20*%2F3%20*&count=4
  Example — Macro shorthand:
    https://www.fluentedi.com/v1/cron/next?expression=%40daily


### JSON and tabular data

- [json.query](https://www.fluentedi.com/v1/tools/json.query): Extract values from a JSON document with a JSONPath expression.
  Runs a JSONPath query and returns the matching values with their concrete paths. Supports property access, array indexing (including negative indices), slices, wildcards, recursive descent (`..`) and filters (`[?(@.price > 10)]`). Pull three fields out of a large API response without carrying the whole document through context.
  Parameters:
    - json: any (required) — The JSON document, as an object or a JSON string.
    - path: string (required) — JSONPath expression, e.g. "$.items[*].id" or "$..author".
    - first_only: boolean (default: false) — Return only the first match.
  Example — Every id in a list:
    https://www.fluentedi.com/v1/json/query?json=%7B%22items%22%3A%5B%7B%22id%22%3A1%2C%22price%22%3A5%7D%2C%7B%22id%22%3A2%2C%22price%22%3A20%7D%5D%7D&path=%24.items%5B*%5D.id
  Example — Filter by a field:
    https://www.fluentedi.com/v1/json/query?json=%7B%22items%22%3A%5B%7B%22id%22%3A1%2C%22price%22%3A5%7D%2C%7B%22id%22%3A2%2C%22price%22%3A20%7D%5D%7D&path=%24.items%5B%3F(%40.price%20%3E%2010)%5D
  Example — Find a key at any depth:
    https://www.fluentedi.com/v1/json/query?json=%7B%22a%22%3A%7B%22b%22%3A%7B%22name%22%3A%22deep%22%7D%7D%7D&path=%24..name

- [json.repair](https://www.fluentedi.com/v1/tools/json.repair): Repair malformed JSON and pinpoint the exact line and column when it cannot be repaired.
  Takes JSON that almost parses and makes it parse: markdown code fences, prose wrapped around the object, trailing commas, single or smart quotes, unquoted keys, Python True/False/None, comments, NaN, and brackets left open by a truncated response. Every change is reported, so the caller learns what its generator got wrong rather than silently depending on a fixer. When the input cannot be salvaged it returns the precise line, column and a caret pointing at the offending character — which is what makes the next attempt succeed instead of guessing.
  Parameters:
    - input: string (required) — The malformed JSON text.
    - close_truncated: boolean (default: true) — Close brackets left open by a cut-off response.
  Example — Markdown fence, trailing comma, unquoted key:
    https://www.fluentedi.com/v1/json/repair?input=%60%60%60json%0A%7B%20name%3A%20'Ada'%2C%20tags%3A%20%5B1%2C2%2C%5D%2C%20%7D%0A%60%60%60
  Example — A truncated response:
    https://www.fluentedi.com/v1/json/repair?input=%7B%22items%22%3A%5B%7B%22id%22%3A1%7D%2C%7B%22id%22%3A2
  Example — Python literals in JSON:
    https://www.fluentedi.com/v1/json/repair?input=%7B'ok'%3A%20True%2C%20'value'%3A%20None%7D

- [json.canonical](https://www.fluentedi.com/v1/tools/json.canonical): Canonicalize JSON (RFC 8785) and content-address it with SHA-256 and a CIDv1.
  Serializes a JSON document to its one canonical form — keys sorted, whitespace dropped, numbers in ECMAScript form — then hashes it. Two documents that mean the same thing produce the same digest regardless of key order or formatting, which is what makes the digest quotable as a receipt. A log line is a claim that the process which wrote it could also edit; a content address is computed from the content, so changing the content changes the address. Pair it with crypto.verify: canonicalize, sign the digest with your own key, and anyone can check the pair without trusting either of you.
  Parameters:
    - json: any (required) — The JSON document, as an object or a JSON string.
    - include_canonical: boolean (default: true) — Include the canonical serialization itself, not just its digest.
  Example — Same meaning, different key order — same digest:
    https://www.fluentedi.com/v1/json/canonical?json=%7B%22b%22%3A2%2C%22a%22%3A1%7D
  Example — Content-address a tool call for an audit trail:
    https://www.fluentedi.com/v1/json/canonical?json=%7B%22tool%22%3A%22transfer%22%2C%22args%22%3A%7B%22amount%22%3A100%2C%22to%22%3A%22B%22%2C%22from%22%3A%22A%22%7D%7D

- [json.diff](https://www.fluentedi.com/v1/tools/json.diff): Structural difference between two JSON documents, as RFC 6902-style operations.
  Compares two JSON documents key by key and reports every addition, removal and change with a JSON Pointer path. Key order and formatting are ignored, so it answers 'did the data actually change' rather than 'did the bytes change' — the right check for API responses and config drift.
  Parameters:
    - a: any (required) — First document (object or JSON string).
    - b: any (required) — Second document (object or JSON string).
  Example — Spot a config change:
    https://www.fluentedi.com/v1/json/diff?a=%7B%22replicas%22%3A2%2C%22image%22%3A%22app%3A1.0%22%7D&b=%7B%22replicas%22%3A3%2C%22image%22%3A%22app%3A1.1%22%2C%22tls%22%3Atrue%7D

- [json.schema](https://www.fluentedi.com/v1/tools/json.schema): Infer a JSON Schema from an example document.
  Generates a draft 2020-12 JSON Schema from one or more sample documents, detecting string formats (date-time, email, uri, uuid, ipv4) and merging array members into a single item schema. Turns an undocumented API response into a contract you can validate against or hand to a typed client generator.
  Parameters:
    - json: any (required) — Sample document, or an array of samples to merge.
    - title: string (default: "") — Optional schema title.
  Example — Schema from an API response:
    https://www.fluentedi.com/v1/json/schema?json=%7B%22id%22%3A%22a3f%22%2C%22created_at%22%3A%222026-08-22T10%3A00%3A00Z%22%2C%22tags%22%3A%5B%22a%22%2C%22b%22%5D%2C%22score%22%3A4.5%7D

- [api.diff](https://www.fluentedi.com/v1/tools/api.diff): Diff an API's declared contract against payloads it actually returned; classify the drift.
  Answers 'is this endpoint keeping its promise' — the failure mode where docs say one thing and the live API returns another, the schema validates, and nothing errors. Give it the declared JSON Schema (or a baseline payload to infer one from) plus one or more observed payloads. Returns a verdict, the inferred observed schema, and classified findings: type_mismatch, missing_field and enum_violation (action: block), nullable_in_practice, format_mismatch, undeclared_field and extra_field (action: warn), each with a JSON Pointer path and how many samples it affected. Declared-schema keywords outside the checked subset are listed in ignored_keywords, never silently trusted. Stateless: you hold the baseline, nothing is stored.
  Parameters:
    - declared: any — Declared contract: a JSON Schema (object or string). Omit to infer one from `baseline`.
    - baseline: any — Alternative to `declared`: a known-good payload (or array of them) to infer the contract from.
    - observed: any (required) — Payload the endpoint actually returned, or an array of payloads to check together.
    - samples: boolean (default: true) — Treat a top-level `observed` array as multiple samples rather than one array payload.
  Example — Docs promise a non-null string id and a status enum; the live API drifted:
    https://www.fluentedi.com/v1/api/diff?declared=%7B%22type%22%3A%22object%22%2C%22required%22%3A%5B%22id%22%2C%22status%22%5D%2C%22properties%22%3A%7B%22id%22%3A%7B%22type%22%3A%22string%22%7D%2C%22status%22%3A%7B%22enum%22%3A%5B%22active%22%2C%22closed%22%5D%7D%2C%22total%22%3A%7B%22type%22%3A%22integer%22%7D%7D%7D&observed=%5B%7B%22id%22%3A%22a1%22%2C%22status%22%3A%22active%22%2C%22total%22%3A10%7D%2C%7B%22id%22%3Anull%2C%22status%22%3A%22archived%22%2C%22total%22%3A10.5%2C%22currency%22%3A%22USD%22%7D%5D
  Example — No schema? Diff yesterday's payload against today's:
    https://www.fluentedi.com/v1/api/diff?baseline=%7B%22sku%22%3A%22X1%22%2C%22qty%22%3A4%7D&observed=%7B%22sku%22%3A%22X1%22%2C%22qty%22%3A%224%22%7D

- [csv.convert](https://www.fluentedi.com/v1/tools/csv.convert): Convert between CSV and JSON with correct quote handling.
  A full RFC 4180 parser: quoted fields, escaped quotes, embedded commas and newlines inside cells all survive the round trip, and the delimiter is detected automatically. Splitting CSV on commas is the classic silent data-corruption bug; this does not have it.
  Parameters:
    - input: any (required) — CSV text, or JSON array of objects when converting to CSV.
    - direction: string (default: "csv_to_json") — Conversion direction. One of: csv_to_json, json_to_csv.
    - delimiter: string (default: "auto") — Field delimiter. "auto" detects among comma, semicolon, tab and pipe.
    - header: boolean (default: true) — Treat the first CSV row as column names.
  Example — CSV with a quoted comma:
    https://www.fluentedi.com/v1/csv/convert?input=name%2Crole%0A%22Doe%2C%20Jane%22%2Cengineer%0AAda%2Cfounder
  Example — Objects back to CSV:
    https://www.fluentedi.com/v1/csv/convert?input=%5B%7B%22name%22%3A%22Ada%22%2C%22role%22%3A%22founder%22%7D%2C%7B%22name%22%3A%22Grace%22%2C%22role%22%3A%22admiral%22%7D%5D&direction=json_to_csv


### Documents (PDF, Word, Excel)

- [doc.extract](https://www.fluentedi.com/v1/tools/doc.extract): Extract the text of a PDF, Word, Excel or other document as markdown or plain text.
  Converts a document to markdown or plain text: pass a public URL or the file itself as base64, and get back the content with headings, tables and lists preserved, at a fraction of the tokens that rendered pages cost. Use it when a harness has no native reader for the format — .docx, .xlsx, .odt and .numbers rarely have one — when a document is only a URL away, or when a long PDF's text matters and its layout does not. Handles PDF (.pdf), Word (.docx), Excel (.xlsx, .xlsm, .xlsb, .xls), OpenDocument (.odt, .ods), Apple Numbers, CSV, HTML, XML, and plain-text formats such as .txt and .md. The format is detected from magic bytes, not trusted from the file name, so a PDF served from a .php URL still converts. Two honest limits: a scanned PDF with no text layer has nothing to extract (this is conversion, not OCR), and legacy binary .doc and .ppt files are not readable — resave them as .docx or .pptx. Images are refused rather than described. Documents up to 10 MB.
  Parameters:
    - url: string — Public URL of the document to fetch and convert.
    - base64: string (default: "") — The file content as base64 (or a data: URI) instead of a URL, for documents not publicly reachable. Up to 10 MB decoded.
    - filename: string (default: "") — Original file name, e.g. "report.docx". Only needed when the format cannot be detected from the URL or the bytes.
    - format: string (default: "markdown") — Output style: markdown keeps headings, tables and lists; text strips them. One of: markdown, text.
    - max_chars: integer (default: 200000) — Truncate the extracted content beyond this many characters.
    - timeout_ms: integer (default: 15000) — Fetch timeout in milliseconds when url is used.
  Example — Extract a PDF paper as markdown:
    https://www.fluentedi.com/v1/doc/extract?url=https%3A%2F%2Farxiv.org%2Fpdf%2F1706.03762
  Example — Word document to markdown:
    https://www.fluentedi.com/v1/doc/extract?url=https%3A%2F%2Fcalibre-ebook.com%2Fdownloads%2Fdemos%2Fdemo.docx
  Example — A web page as plain text:
    https://www.fluentedi.com/v1/doc/extract?url=https%3A%2F%2Fexample.com%2F&format=text


### Text

- [text.stats](https://www.fluentedi.com/v1/tools/text.stats): Count characters, words, bytes, sentences and estimated tokens; score readability.
  Measures text the way a form validator, a database column and a model context window each measure it — characters, UTF-8 bytes and estimated tokens are three different numbers, and conflating them is how 'it fits' turns into a truncation bug. Also returns Flesch reading ease and Flesch-Kincaid grade level.
  Parameters:
    - text: string (required) — Text to measure.
    - top_words: integer (default: 10) — How many of the most frequent words to return (0 disables).
  Example — Measure a draft:
    https://www.fluentedi.com/v1/text/stats?text=The%20quick%20brown%20fox%20jumps%20over%20the%20lazy%20dog.%20It%20was%20a%20bright%20cold%20day%20in%20April.

- [text.case](https://www.fluentedi.com/v1/tools/text.case): Convert a string to camelCase, snake_case, kebab-case, Title Case, a URL slug and more.
  Splits an identifier on whatever convention it currently uses — spaces, underscores, hyphens or camel humps, including acronym runs like 'HTTPServer' — then re-emits it in every common casing at once. The slug form also strips accents and punctuation for use in URLs.
  Parameters:
    - text: string (required) — Input string.
  Example — Every casing of a phrase:
    https://www.fluentedi.com/v1/text/case?text=User%20Profile%20Settings
  Example — Split an acronym-heavy identifier:
    https://www.fluentedi.com/v1/text/case?text=HTTPServerConfig

- [text.diff](https://www.fluentedi.com/v1/tools/text.diff): Unified diff between two texts, with change statistics and a similarity score.
  Produces a git-style unified diff plus structured hunks and a similarity ratio. Compare by line for code and config, or by word to see edits inside a paragraph. Useful for confirming exactly what changed before writing a file, and for summarising a change without re-reading both versions.
  Parameters:
    - a: string (required) — Original text.
    - b: string (required) — Modified text.
    - mode: string (default: "line") — Granularity of comparison. One of: line, word.
    - context: integer (default: 3) — Lines of unchanged context around each hunk.
    - ignore_whitespace: boolean (default: false) — Ignore leading/trailing whitespace differences.
  Example — Diff two config versions:
    https://www.fluentedi.com/v1/text/diff?a=host%3A%20localhost%0Aport%3A%208080%0A&b=host%3A%200.0.0.0%0Aport%3A%208080%0Atls%3A%20true%0A
  Example — Word-level edits in a sentence:
    https://www.fluentedi.com/v1/text/diff?a=the%20quick%20brown%20fox&b=the%20slow%20brown%20dog&mode=word

- [text.offset](https://www.fluentedi.com/v1/tools/text.offset): Convert between text positions: byte offset, UTF-16 index, code point, grapheme, and line/column.
  One position in a string has at least five different numbers depending on who is counting. A UTF-8 byte offset, a UTF-16 code unit index (what JavaScript and LSP use), a code point index (what Python uses), a grapheme index (what a human means by 'the third character'), and a line/column pair. An emoji is one grapheme, two code units and four bytes; a flag is one grapheme and eight bytes. Models are measurably poor at character-level positions — benchmark accuracy around 43% — and worse when the queried character sits inside a long token. This converts between all of them exactly, so an edit lands where it was meant to.
  Parameters:
    - text: string (required) — The text to measure positions in.
    - position: integer (default: 0) — The position to convert. Interpreted according to `unit`.
    - unit: string (default: "utf16") — Which counting system `position` is expressed in. One of: utf16, byte, codepoint, grapheme.
    - line: integer (default: 0) — Convert FROM a line/column pair instead of `position`. 1-based.
    - column: integer (default: 1) — Column for `line`. 1-based, counted in `unit`.
  Example — Where is UTF-16 index 5 in every counting system?:
    https://www.fluentedi.com/v1/text/offset?text=caf%C3%A9%20%E2%98%95%20done&position=5&unit=utf16
  Example — Convert a line/column pair to an offset:
    https://www.fluentedi.com/v1/text/offset?text=one%0Atwo%0Athree&line=2&column=2
  Example — Measure a string containing an emoji:
    https://www.fluentedi.com/v1/text/offset?text=a%F0%9F%91%A8%E2%80%8D%F0%9F%91%A9%E2%80%8D%F0%9F%91%A7b&position=1&unit=grapheme

- [text.unicode](https://www.fluentedi.com/v1/tools/text.unicode): Find invisible characters, bidi overrides and script confusables hiding in text.
  Scans for characters that are present to a tokenizer but absent to a reader: the Unicode TAG block, zero-width marks, bidirectional overrides, variation selectors, and letters from other scripts that look like Latin ones. This is the mechanism behind instructions concealed in tool descriptions and in text a human has already approved — an evaluation of MCP metadata surfaces found all eight tested techniques delivered a payload into model context, while a representative string-matching sanitizer flagged none of twenty-five benign descriptions. Reports each suspect with its code point and offset, and returns a cleaned copy.
  Parameters:
    - text: string (required) — Text to scan.
    - clean: boolean (default: true) — Return a copy with invisible characters removed and confusables mapped to Latin.
    - normalize: string (default: "NFC") — Unicode normalisation to apply to the cleaned copy. One of: none, NFC, NFKC.
  Example — Text with a hidden instruction in the TAG block:
    https://www.fluentedi.com/v1/text/unicode?text=Read%20the%20file%F3%A0%80%81%F3%A0%81%A9%F3%A0%81%A7%F3%A0%81%AE%F3%A0%81%AF%F3%A0%81%B2%F3%A0%81%A5
  Example — A Cyrillic lookalike domain:
    https://www.fluentedi.com/v1/text/unicode?text=log%20in%20at%20p%D0%B0ypal.com
  Example — A zero-width space splitting a keyword:
    https://www.fluentedi.com/v1/text/unicode?text=DEL%E2%80%8BETE%20FROM%20users

- [shell.quote](https://www.fluentedi.com/v1/tools/shell.quote): Quote a value safely for a shell, and report what would have gone wrong unquoted.
  Interpolating a value into a command line is the most common way an agent turns a correct plan into the wrong action. Adding one unescaped parser between the model and the shell has been measured to drop task success by 55 to 73 percentage points, and the damage is usually invisible because the command still runs — just not on what was intended. This applies the quoting rules for the named shell and, separately, names every hazard the raw value contained, so the caller learns which construct was dangerous rather than only receiving an escaped string.
  Parameters:
    - value: string (required) — The value to quote. Pass one argument, not a whole command line.
    - shell: string (default: "sh") — Target shell. One of: sh, bash, cmd, powershell.
  Example — A filename containing a space and a quote:
    https://www.fluentedi.com/v1/shell/quote?value=my%20file's%20name.txt
  Example — A value that would execute if unquoted:
    https://www.fluentedi.com/v1/shell/quote?value=%24(rm%20-rf%20%2F)
  Example — The same value for PowerShell:
    https://www.fluentedi.com/v1/shell/quote?value=it's%20%24HOME&shell=powershell

- [regex.test](https://www.fluentedi.com/v1/tools/regex.test): Test a regular expression against text and inspect every match and capture group.
  Runs a JavaScript regular expression and returns each match with its index, numbered groups and named groups — or performs a replace or split. Invalid patterns come back as a readable explanation instead of a thrown error, so a pattern can be corrected without a round trip through a broken deploy.
  Parameters:
    - pattern: string (required) — Regular expression source, without delimiters.
    - text: string (required) — Text to run the pattern against.
    - flags: string (default: "g") — Regex flags, e.g. "gi". The g flag is added automatically for match_all, replace and split.
    - operation: string (default: "match_all") — What to do with the pattern. One of: match_all, test, replace, split.
    - replacement: string (default: "") — Replacement string for the replace operation. Supports $1, $<name>.
    - limit: integer (default: 100) — Maximum matches to return.
  Example — Extract emails with capture groups:
    https://www.fluentedi.com/v1/regex/test?pattern=(%5B%5Cw.%5D%2B)%40(%5B%5Cw.%5D%2B)&text=ping%20ada%40example.com%20and%20grace%40navy.mil
  Example — Redact digits:
    https://www.fluentedi.com/v1/regex/test?pattern=%5Cd&text=card%204242%204242&operation=replace&replacement=*


### Hashing, signatures, encoding and identifiers

- [hash](https://www.fluentedi.com/v1/tools/hash): Hash or HMAC-sign text with MD5, SHA-1, SHA-256/384/512 or CRC32.
  Computes cryptographic digests and HMAC signatures. Returns hex and base64 at once, so a webhook signature can be compared in whichever encoding the provider uses. MD5 and CRC32 are included for checksums and legacy fixtures; they are not secure for authentication.
  Parameters:
    - input: string (required) — Text to hash.
    - algorithms: array (default: ["sha256"]) — Any of: md5, sha1, sha256, sha384, sha512, crc32.
    - hmac_key: string (default: "") — When set, computes HMAC-<algorithm> with this key instead of a plain digest. Not supported for md5/crc32.
    - input_encoding: string (default: "utf8") — How to read `input` into bytes. One of: utf8, hex, base64.
  Example — SHA-256 of a string:
    https://www.fluentedi.com/v1/hash?input=hello%20world
  Example — Verify a webhook signature:
    https://www.fluentedi.com/v1/hash?input=%7B%22event%22%3A%22ping%22%7D&algorithms=%5B%22sha256%22%5D&hmac_key=whsec_test
  Example — Several digests at once:
    https://www.fluentedi.com/v1/hash?input=hello%20world&algorithms=%5B%22md5%22%2C%22sha1%22%2C%22sha256%22%2C%22crc32%22%5D

- [crypto.verify](https://www.fluentedi.com/v1/tools/crypto.verify): Verify an Ed25519, ECDSA, RSA or HMAC signature against a message and public key.
  Checks a detached signature and returns a single boolean you can act on. Signature verification is not something to reason about — a signature is either valid under the key or it is not, and an agent that accepts an identity claim without checking has accepted anything. Supports Ed25519 (raw 32-byte or SPKI keys), ECDSA P-256/P-384, RSA PKCS#1 v1.5 and PSS, and HMAC-SHA256/512.
  Parameters:
    - message: string (required) — The signed message.
    - signature: string (required) — The detached signature.
    - public_key: string (required) — Public key: raw bytes, SPKI DER, or PEM. For HMAC, the shared secret.
    - algorithm: string (default: "ed25519") — Signature algorithm. One of: ed25519, ecdsa-p256, ecdsa-p384, rsa-pkcs1, rsa-pss, hmac-sha256, hmac-sha512.
    - message_encoding: string (default: "utf8") — How to read `message` into bytes. One of: utf8, hex, base64.
    - signature_encoding: string (default: "hex") — How to read `signature` into bytes. One of: hex, base64, utf8.
    - key_encoding: string (default: "hex") — How to read `public_key` when it is not PEM. One of: hex, base64, utf8.
  Example — Verify an Ed25519 signature (RFC 8032 test vector 2):
    https://www.fluentedi.com/v1/crypto/verify?message=r&signature=92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00&public_key=3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c&algorithm=ed25519

- [jwt.decode](https://www.fluentedi.com/v1/tools/jwt.decode): Decode a JWT and check its expiry, optionally verifying an HMAC signature.
  Splits a JSON Web Token, decodes header and payload, and converts every standard time claim (exp, iat, nbf, auth_time) into readable dates with a live expiry verdict. Supply `secret` to verify an HS256/384/512 signature. Decoding never validates trust on its own — an unverified token is just base64 text that anyone can forge.
  Parameters:
    - token: string (required) — The JWT (three base64url segments separated by dots). A leading "Bearer " is ignored.
    - secret: string (default: "") — HMAC secret. When provided, the signature is verified for HS256/HS384/HS512.
  Example — Inspect a token's claims and expiry:
    https://www.fluentedi.com/v1/jwt/decode?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

- [encode](https://www.fluentedi.com/v1/tools/encode): Convert text between base64, base64url, hex, URL and HTML encodings.
  Round-trips a value between encodings in one call. Handles base64url (JWT-style, no padding) and distinguishes full-URI encoding from component encoding, which is the usual cause of double-encoded query strings.
  Parameters:
    - input: string (required) — Value to convert.
    - from: string (default: "text") — Encoding of the input. One of: text, base64, base64url, hex, url, url_component, html.
    - to: string (default: "base64") — Encoding to produce. One of: text, base64, base64url, hex, url, url_component, html.
  Example — Encode to base64:
    https://www.fluentedi.com/v1/encode?input=hello%20world&to=base64
  Example — Decode a base64 string:
    https://www.fluentedi.com/v1/encode?input=aGVsbG8gd29ybGQ%3D&from=base64&to=text
  Example — Decode a JWT payload segment:
    https://www.fluentedi.com/v1/encode?input=eyJzdWIiOiIxMjMifQ&from=base64url&to=text
  Example — Escape a value for a query string:
    https://www.fluentedi.com/v1/encode?input=a%3D1%26b%3Dhello%20world&to=url_component

- [id.generate](https://www.fluentedi.com/v1/tools/id.generate): Generate UUIDv4, UUIDv7, ULID, nanoid or short random IDs.
  Cryptographically random identifiers from the edge. UUIDv7 and ULID embed a millisecond timestamp and sort lexicographically in creation order, which makes them the right default for database primary keys; UUIDv4 is fully random and does not sort. The embedded timestamp is decoded back for you.
  Parameters:
    - type: string (default: "uuid4") — Identifier format. One of: uuid4, uuid7, ulid, nanoid, hex, numeric.
    - count: integer (default: 1) — How many to generate.
    - length: integer (default: 21) — Length for nanoid, hex and numeric types.
    - uppercase: boolean (default: false) — Uppercase the output where the format allows it.
  Example — One UUIDv4:
    https://www.fluentedi.com/v1/id/generate
  Example — Sortable database keys:
    https://www.fluentedi.com/v1/id/generate?type=uuid7&count=5
  Example — Short URL slugs:
    https://www.fluentedi.com/v1/id/generate?type=nanoid&length=10&count=3


### Calculation and conversion

- [math.eval](https://www.fluentedi.com/v1/tools/math.eval): Evaluate a mathematical expression exactly.
  Evaluates arithmetic with correct operator precedence, parentheses, exponentiation, factorials, named variables and 30+ functions. Language models perform arithmetic by pattern-matching and quietly get long multiplications and compounding wrong; this computes the number instead of predicting it.
  Parameters:
    - expression: string (required) — Expression to evaluate, e.g. "(1+0.07)^30 * 1000".
    - variables: object (default: {}) — Named values usable in the expression, e.g. {"rate": 0.07}.
    - precision: integer (default: 10) — Decimal places to round the formatted result to.
  Example — Order of operations:
    https://www.fluentedi.com/v1/math/eval?expression=2%20%2B%203%20*%204%20%5E%202
  Example — Compound interest over 30 years:
    https://www.fluentedi.com/v1/math/eval?expression=principal%20*%20(1%20%2B%20rate)%20%5E%20years&variables=%7B%22principal%22%3A1000%2C%22rate%22%3A0.07%2C%22years%22%3A30%7D
  Example — Functions and constants:
    https://www.fluentedi.com/v1/math/eval?expression=hypot(3%2C%204)%20%2B%20log10(1000)%20%2B%20pi

- [unit.convert](https://www.fluentedi.com/v1/tools/unit.convert): Convert between units of length, mass, temperature, data, time, speed, area, volume, pressure, energy and angle.
  Exact unit conversion across eleven categories, using defined conversion factors rather than remembered approximations. Temperature handles offsets correctly (0°C is 32°F, not 0°F), and binary data prefixes are kept distinct from decimal ones (a GiB is not a GB).
  Parameters:
    - value: number — Quantity to convert.
    - from: string — Source unit, e.g. "km", "celsius", "gib".
    - to: string — Target unit. Must be in the same category as `from`.
    - list: boolean (default: false) — Return every supported unit grouped by category instead of converting.
    - precision: integer (default: 6) — Decimal places in the rounded result.
  Example — Kilometres to miles:
    https://www.fluentedi.com/v1/unit/convert?value=100&from=km&to=mi
  Example — Celsius to Fahrenheit:
    https://www.fluentedi.com/v1/unit/convert?value=37&from=celsius&to=fahrenheit
  Example — Storage sizes that people confuse:
    https://www.fluentedi.com/v1/unit/convert?value=1&from=tb&to=tib
  Example — Browse supported units:
    https://www.fluentedi.com/v1/unit/convert?list=true

- [color.convert](https://www.fluentedi.com/v1/tools/color.convert): Convert a colour between hex, RGB, HSL and OKLCh, and check WCAG contrast.
  Parses any CSS colour notation and re-emits it in every format including OKLCh. Supply `against` to get the WCAG 2.1 contrast ratio and pass/fail verdicts for normal and large text — the check that decides whether an interface is legible, computed rather than eyeballed.
  Parameters:
    - color: string (required) — Colour in hex, rgb(), hsl(), or a CSS name.
    - against: string (default: "") — Optional second colour to compute a WCAG contrast ratio against.
    - shades: boolean (default: false) — Also return a 50-950 lightness scale built from this hue.
  Example — Every notation for one colour:
    https://www.fluentedi.com/v1/color/convert?color=%233b82f6
  Example — Is this text legible on white?:
    https://www.fluentedi.com/v1/color/convert?color=%23767676&against=%23ffffff
  Example — Generate a palette scale:
    https://www.fluentedi.com/v1/color/convert?color=%233b82f6&shades=true

- [money.convert](https://www.fluentedi.com/v1/tools/money.convert): Convert between 30 currencies at current or historical European Central Bank reference rates.
  Converts an amount between currencies using the European Central Bank's daily reference rates — the closest thing to a neutral, citable exchange rate that exists, reaching back to 1999 for historical dates. Exchange rates are the canonical example of a fact a language model cannot know: they moved after every training cutoff and will move again tomorrow. Rates are published on ECB working days around 16:00 CET; a weekend or holiday query returns the last working day's rate, and the response always states which date the rate is actually from. These are reference rates for calculation and record-keeping — a bank or card network will apply its own spread on a real transaction.
  Parameters:
    - amount: number (default: 1) — Amount to convert.
    - from: string (required) — ISO 4217 code of the source currency.
    - to: string (default: "") — Target currency code, or several separated by commas. Empty returns every supported currency.
    - date: string (default: "") — Historical date (YYYY-MM-DD, back to 1999-01-04). Empty means the latest published rate.
  Example — What is $250 in euros today?:
    https://www.fluentedi.com/v1/money/convert?amount=250&from=USD&to=EUR
  Example — One price in several markets:
    https://www.fluentedi.com/v1/money/convert?amount=99&from=USD&to=EUR%2CGBP%2CINR%2CJPY
  Example — Rate on an invoice date:
    https://www.fluentedi.com/v1/money/convert?amount=1000&from=EUR&to=USD&date=2024-03-15


### Web and network

- [url.parse](https://www.fluentedi.com/v1/tools/url.parse): Parse, normalise or resolve a URL and break out its query parameters.
  Decomposes a URL into scheme, host, port, path, query and fragment, decodes every query parameter (keeping repeated keys as arrays), and reports whether the host is an IP address or an IDN. Can also resolve a relative reference against a base URL — the operation that quietly breaks scrapers and link-followers when done with string concatenation.
  Parameters:
    - url: string (required) — URL or relative reference to parse.
    - base: string (default: "") — Base URL to resolve a relative reference against.
    - strip_tracking: boolean (default: false) — Also return the URL with utm_* and common click-tracking parameters removed.
  Example — Break a URL into parts:
    https://www.fluentedi.com/v1/url/parse?url=https%3A%2F%2Fapi.example.com%3A8443%2Fv1%2Fitems%3Fpage%3D2%26sort%3Dasc%23results
  Example — Resolve a relative link:
    https://www.fluentedi.com/v1/url/parse?url=..%2Fimages%2Flogo.png&base=https%3A%2F%2Fexample.com%2Fdocs%2Fguide%2F
  Example — Strip campaign parameters:
    https://www.fluentedi.com/v1/url/parse?url=https%3A%2F%2Fshop.com%2Fp%2F1%3Futm_source%3Dx%26utm_medium%3Dy%26id%3D9&strip_tracking=true

- [url.scan](https://www.fluentedi.com/v1/tools/url.scan): Detect credentials, tokens and personal data leaking in a URL, and return a redacted version.
  Scans a URL's query string, path, fragment and userinfo for secrets and personal data — provider API keys, JWTs, bearer tokens, private keys, high-entropy values in credential-shaped parameters, email addresses, national identifiers and Luhn-valid card numbers. A URL is the least private place to put a secret: it is written to server logs, proxy logs, browser history and Referer headers, none of which are covered by the transport encryption. Returns a redacted URL safe to paste into a log or a ticket.
  Parameters:
    - url: string (required) — URL to scan.
    - include_low: boolean (default: true) — Include low-severity findings such as tracking parameters.
  Example — A live secret key in a query string:
    https://www.fluentedi.com/v1/url/scan?url=https%3A%2F%2Fapi.example.com%2Fv1%2Fcharges%3Fapi_key%3Dsk_live_4eC39HqLyjWDarjtT1zdp7dc
  Example — Credentials embedded in userinfo:
    https://www.fluentedi.com/v1/url/scan?url=https%3A%2F%2Fadmin%3Ahunter2%40internal.example.com%2Fdashboard
  Example — Personal data in a link:
    https://www.fluentedi.com/v1/url/scan?url=https%3A%2F%2Fexample.com%2Freset%3Femail%3Dada%40example.com%26token%3DeyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abcdefghijk

- [secret.scan](https://www.fluentedi.com/v1/tools/secret.scan): Find credentials and personal data in text, and return a redacted copy safe to share.
  Scans arbitrary text — logs, environment files, diffs, stack traces, config, command output — for provider API keys, tokens, private keys, database connection strings, credential-shaped assignments, high-entropy values, personal data and Luhn-valid card numbers. Each finding carries a line and column so it can be located, and the matched value is masked everywhere it is reported. The intended moment to call this is just before pasting output into a model, a ticket or a chat: text an agent forwards without reading is the ordinary way live credentials end up somewhere they cannot be recalled from.
  Parameters:
    - text: string (required) — Text to scan.
    - redact: boolean (default: true) — Return a copy with every finding masked.
    - include_pii: boolean (default: true) — Also flag personal data such as email addresses and phone numbers.
    - min_severity: string (default: "low") — Suppress findings below this severity. One of: low, medium, high, critical.
  Example — Check a log line before pasting it:
    https://www.fluentedi.com/v1/secret/scan?text=2026-08-24%20ERROR%20auth%20failed%20for%20key%20sk_live_4eC39HqLyjWDarjtT1zdp7dc
  Example — Sanitise an env file:
    https://www.fluentedi.com/v1/secret/scan?text=DATABASE_URL%3Dpostgres%3A%2F%2Fadmin%3Ahunter2%40db.internal%3A5432%2Fapp%0ADEBUG%3Dtrue%0AAPI_TOKEN%3Dghp_16C7e42F292c6912E7710c838347Ae178B4a
  Example — Secrets only, ignoring personal data:
    https://www.fluentedi.com/v1/secret/scan?text=contact%20ada%40example.com%20with%20token%20ghp_16C7e42F292c6912E7710c838347Ae178B4a&include_pii=false

- [http.check](https://www.fluentedi.com/v1/tools/http.check): Check whether a URL is still live: status, redirect chain, and whether a citation still says what it said.
  Resolves a URL and reports what actually happens to it — final status, the full redirect chain, content type and page title. Link rot is faster than it feels: one agent measured seven dead URLs out of 286 across fourteen days. This handles the three cases a naive checker gets wrong: an arXiv v1 to v2 redirect is a version change, not a break; a 403 is a blocked crawler, not a dead page; and a DOI can return 200 while the page behind it is now a retraction notice, which is the worst case because a simple status check passes and the reader gets something else. Response bodies are never returned — only status, headers, title and flags.
  Parameters:
    - url: string (required) — URL to check.
    - max_redirects: integer (default: 5) — How many redirects to follow.
    - timeout_ms: integer (default: 8000) — Per-request timeout in milliseconds.
  Example — Is this paper link still good?:
    https://www.fluentedi.com/v1/http/check?url=https%3A%2F%2Farxiv.org%2Fabs%2F1706.03762
  Example — Follow a shortened link to its destination:
    https://www.fluentedi.com/v1/http/check?url=https%3A%2F%2Fdoi.org%2F10.1038%2Fnature14539

- [http.assert](https://www.fluentedi.com/v1/tools/http.assert): Verify a URL actually returns what you expected — status, headers, JSON values — and return a pass/fail proof.
  The difference between an agent believing it succeeded and knowing it did. http.check tells you a URL is alive; this tells you it is correct. Assert the status, response headers, values at JSONPath expressions, substrings in the body and a latency ceiling, and get back one boolean plus a per-check breakdown showing expected against actual. An agent that has just deployed, migrated or reconfigured something can prove the outcome rather than reporting the absence of an error, which is the usual way agents claim a success they have not actually achieved.
  Parameters:
    - url: string (required) — URL to call.
    - method: string (default: "GET") — HTTP method. One of: GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS.
    - body: string (default: "") — Request body for POST, PUT and PATCH.
    - headers: object (default: {}) — Request headers to send.
    - expect_status: any (default: "") — Required status: a number, an array of acceptable numbers, or a class such as "2xx".
    - expect_headers: object (default: {}) — Response headers that must exist and contain a substring, e.g. {"content-type":"json"}.
    - expect_json: object (default: {}) — JSONPath expressions mapped to required values, e.g. {"$.status":"ok","$.items[0].id":1}.
    - expect_body_contains: array (default: []) — Substrings that must appear in the body.
    - max_response_ms: integer (default: 0) — Fail if the response takes longer than this. 0 disables the check.
    - timeout_ms: integer (default: 10000) — Request timeout.
  Example — Prove a deployment is serving correctly:
    https://www.fluentedi.com/v1/http/assert?url=https%3A%2F%2Ffluentedi.com%2Fhealth&expect_status=200&expect_json=%7B%22%24.ok%22%3Atrue%7D&max_response_ms=2000
  Example — Check an endpoint returns JSON rather than an error page:
    https://www.fluentedi.com/v1/http/assert?url=https%3A%2F%2Ffluentedi.com%2Fv1%2Ftime%2Fnow&expect_status=2xx&expect_headers=%7B%22content-type%22%3A%22json%22%7D&expect_json=%7B%22%24.ok%22%3Atrue%7D
  Example — Assert a specific value in the response:
    https://www.fluentedi.com/v1/http/assert?url=https%3A%2F%2Ffluentedi.com%2Fv1%2Fmath%2Feval%3Fexpression%3D6*7&expect_json=%7B%22%24.result.result%22%3A42%7D

- [dns.lookup](https://www.fluentedi.com/v1/tools/dns.lookup): Resolve DNS records (A, AAAA, MX, TXT, NS, CNAME, SOA, CAA and more).
  Queries public DNS over HTTPS and returns parsed records with their TTLs. Confirm where a domain actually points, read SPF/DKIM/DMARC policies out of TXT records, or check mail routing — live facts that no training corpus can supply because they change without notice.
  Parameters:
    - name: string (required) — Domain name to resolve.
    - type: string (default: "A") — DNS record type. One of: A, AAAA, CNAME, MX, TXT, NS, SOA, CAA, SRV, PTR, DNSKEY, DS.
    - dnssec: boolean (default: false) — Request DNSSEC validation.
  Example — Where does a domain point?:
    https://www.fluentedi.com/v1/dns/lookup?name=example.com&type=A
  Example — Mail servers for a domain:
    https://www.fluentedi.com/v1/dns/lookup?name=gmail.com&type=MX
  Example — Read SPF and verification records:
    https://www.fluentedi.com/v1/dns/lookup?name=cloudflare.com&type=TXT

- [net.inspect](https://www.fluentedi.com/v1/tools/net.inspect): Report the caller's IP, geolocation, network and TLS details as seen from the edge.
  Returns what a server actually observes about the caller: source IP, country and city, ASN and network operator, the Cloudflare edge location that served the request, HTTP version and TLS cipher. Useful for confirming egress IP, diagnosing a geo-routing problem, or establishing an agent's own network context.
  Parameters:
    - include_headers: boolean (default: false) — Echo the request headers back (Authorization and Cookie are redacted).
  Example — Confirm the egress IP and location:
    https://www.fluentedi.com/v1/net/inspect
  Example — Debug what headers arrive at the server:
    https://www.fluentedi.com/v1/net/inspect?include_headers=true

- [domain.lookup](https://www.fluentedi.com/v1/tools/domain.lookup): WHOIS for a domain or IP: registration and expiry dates, registrar, nameservers, status — or the network that owns an address.
  Answers the questions WHOIS used to answer, over RDAP — the structured protocol the registries themselves now serve — with no key and no scraping: who registered a domain, when it expires, which registrar and nameservers it uses, whether transfers are locked, and whether DNSSEC is signed. Give it an IP address instead and it returns the owning network: name, CIDR range, and the responsible registry. A domain that does not resolve in RDAP is reported as likely available to register — an answer, not an error. These are live registry facts that no training corpus can supply: registrations, expiries and transfers happen daily, and an agent that guesses at them guesses wrong.
  Parameters:
    - query: string (required) — Domain name or IP address to look up.
  Example — When does this domain expire, and who runs it?:
    https://www.fluentedi.com/v1/domain/lookup?query=google.com
  Example — Which network owns this IP?:
    https://www.fluentedi.com/v1/domain/lookup?query=8.8.8.8
  Example — Is this domain registered at all?:
    https://www.fluentedi.com/v1/domain/lookup?query=example.org

- [email.validate](https://www.fluentedi.com/v1/tools/email.validate): Validate an email address: syntax, whether the domain can receive mail (MX), disposable and role-account detection, typo suggestions.
  Checks everything about an email address that can be checked without sending mail: RFC-practical syntax, whether the domain actually publishes MX records (or a null MX, which is an explicit refusal to receive), whether it is a known disposable inbox or a free consumer provider, whether the local part is a role account like info@ or billing@, and whether the domain is one keystroke from a major provider — gmial.com almost always means gmail.com. What it deliberately does not claim: that the mailbox exists. Only an SMTP conversation can test that, most servers lie to probes anyway, and a tool that answered "deliverable" would be guessing. Every signal returned here is verifiable.
  Parameters:
    - email: string (required) — Email address to validate.
    - check_dns: boolean (default: true) — Also query the domain's MX records to confirm it can receive mail.
  Example — Full validation with DNS:
    https://www.fluentedi.com/v1/email/validate?email=ada.lovelace%40gmail.com
  Example — Catch a typo before it bounces:
    https://www.fluentedi.com/v1/email/validate?email=someone%40gmial.com
  Example — Syntax-only, no network:
    https://www.fluentedi.com/v1/email/validate?email=billing%40example.com&check_dns=false


### EDI and retail supply chain (X12)

- [edi.parse](https://www.fluentedi.com/v1/tools/edi.parse): Parse an X12 EDI document (850, 856, 810, 855, 997 and others) into structured JSON.
  Reads a raw ASC X12 interchange and returns it as JSON: delimiters taken from the ISA header, the ISA/GS/ST envelope decoded, every segment split into named elements, and a document-specific summary - purchase order lines for an 850, the HL shipment hierarchy and SSCCs for an 856, invoice totals for an 810. EDI is positional and delimiter-sensitive, and unreadable without a spec table; reading it by inspection produces confident nonsense, which is why this is a tool rather than a prompt.
  Parameters:
    - input: string (required) — Raw X12 EDI text, beginning with ISA where available.
    - include_segments: boolean (default: true) — Include the flat segment list alongside the summary.
  Example — Parse a purchase order:
    https://www.fluentedi.com/v1/edi/parse?input=ST*850*0001~BEG*00*SA*4500123456**20260822~N1*ST*ACME%20STORES*92*0042~PO1*1*100*EA*9.99**UP*012345678905~CTT*1~SE*6*0001~
  Example — Parse an advance ship notice:
    https://www.fluentedi.com/v1/edi/parse?input=ST*856*0001~BSN*00*SHIP001*20260822*1200*0001~HL*1**S*1~HL*2*1*O*1~HL*3*2*P*1~MAN*GM*006141411234567890~HL*4*3*I~SN1**12*EA~CTT*4~SE*10*0001~

- [edi.validate](https://www.fluentedi.com/v1/tools/edi.validate): Check an X12 document's envelope integrity and 856 HL hierarchy for the errors that cause rejections.
  Runs the structural checks a trading partner runs before rejecting a file: control numbers matching between the ISA/IEA, GS/GE and ST/SE header and trailer pairs, declared counts matching actual counts, and - for an 856 - the HL hierarchy. HL faults are the usual cause of ASN rejections and chargebacks: a parent ID naming no existing node, a duplicate HL01, an unknown level code, a missing carton level. Every finding names the segment and states what the value should have been.
  Parameters:
    - input: string (required) — Raw X12 EDI text.
    - require_levels: array (default: []) — HL level codes that must be present in an 856, e.g. ["S","O","P","I"] for a pack-level ASN.
  Example — Validate an ASN before sending it:
    https://www.fluentedi.com/v1/edi/validate?input=ST*856*0001~BSN*00*SHIP001*20260822*1200*0001~HL*1**S*1~HL*2*1*O*1~HL*3*2*P*1~MAN*GM*006141411234567890~HL*4*3*I~SN1**12*EA~CTT*4~SE*10*0001~
  Example — Catch an orphaned HL parent:
    https://www.fluentedi.com/v1/edi/validate?input=ST*856*0001~BSN*00*S1*20260822*1200*0001~HL*1**S*1~HL*2*9*O~SE*5*0001~
  Example — Require a carton level:
    https://www.fluentedi.com/v1/edi/validate?input=ST*856*0001~BSN*00*S1*20260822*1200*0001~HL*1**S*1~HL*2*1*O*1~HL*3*2*I~SE*6*0001~&require_levels=%5B%22S%22%2C%22O%22%2C%22P%22%2C%22I%22%5D

- [edi.build](https://www.fluentedi.com/v1/tools/edi.build): Generate a valid X12 856 ASN or 850 purchase order from JSON, with correct HL pointers and envelope counts.
  Compiles structured JSON into standards-valid X12. The parts that get documents rejected are exactly the parts a language model cannot hold in its head: the 856 hierarchy needs sequential HL IDs where every level names its parent's ID, and on a multi-carton, multi-SKU shipment that bookkeeping goes wrong silently. The ISA header is fixed-width — 106 characters exactly, every element space-padded to size — and one character out crashes the receiver's translator. Segment counts in SE01, CTT01, GE01 and IEA01 must agree with what was actually emitted. All of that is computed here rather than written by hand.
  Parameters:
    - document: string (default: "856") — Transaction set to build. One of: 856, 850.
    - data: object (required) — Document content. For 856: {shipment_id, ship_date, orders:[{po_number, packs:[{sscc, items:[{upc, quantity, unit}]}]}], parties:[{role,name,id}]}. For 850: {po_number, order_date, lines:[{quantity, unit, unit_price, upc, description}], parties:[...]}.
    - sender_id: string (default: "SENDER") — ISA06 sender identifier.
    - receiver_id: string (default: "RECEIVER") — ISA08 receiver identifier.
    - sender_qualifier: string (default: "ZZ") — ISA05 qualifier, e.g. ZZ, 01 (DUNS), 12 (phone).
    - receiver_qualifier: string (default: "ZZ") — ISA07 qualifier.
    - control_number: integer (default: 1) — Interchange control number (ISA13). Also seeds GS06 and ST02.
    - test_indicator: boolean (default: true) — Mark the interchange as test (ISA15 = T) rather than production (P).
    - timestamp: string (default: "") — ISO instant for the envelope date/time. Defaults to now.
    - include_envelope: boolean (default: true) — Wrap the transaction set in ISA/GS ... GE/IEA.
  Example — Build an ASN: one order, two cartons, correct HL tree:
    https://www.fluentedi.com/v1/edi/build?document=856&data=%7B%22shipment_id%22%3A%22SHIP1001%22%2C%22orders%22%3A%5B%7B%22po_number%22%3A%224500123456%22%2C%22packs%22%3A%5B%7B%22sscc%22%3A%22006141411234567890%22%2C%22items%22%3A%5B%7B%22upc%22%3A%22012345678905%22%2C%22quantity%22%3A12%2C%22unit%22%3A%22EA%22%7D%5D%7D%2C%7B%22sscc%22%3A%22006141411234567906%22%2C%22items%22%3A%5B%7B%22upc%22%3A%22012345678905%22%2C%22quantity%22%3A8%2C%22unit%22%3A%22EA%22%7D%5D%7D%5D%7D%5D%2C%22parties%22%3A%5B%7B%22role%22%3A%22ST%22%2C%22name%22%3A%22ACME%20STORES%22%2C%22id%22%3A%220042%22%7D%5D%7D
  Example — Build a purchase order:
    https://www.fluentedi.com/v1/edi/build?document=850&data=%7B%22po_number%22%3A%22PO-9001%22%2C%22order_date%22%3A%222026-08-24%22%2C%22lines%22%3A%5B%7B%22quantity%22%3A100%2C%22unit%22%3A%22EA%22%2C%22unit_price%22%3A9.99%2C%22upc%22%3A%22012345678905%22%7D%5D%2C%22parties%22%3A%5B%7B%22role%22%3A%22ST%22%2C%22name%22%3A%22ACME%20STORES%22%2C%22id%22%3A%220042%22%7D%5D%7D

- [edi.acknowledge](https://www.fluentedi.com/v1/tools/edi.acknowledge): Read a 997 or 999 acknowledgment and say which documents were accepted, which were rejected, and why.
  Decodes a Functional Acknowledgment into an answer rather than a code. A 997 reports its verdict as bare letters and numbers — AK5 of R with error 5, AK3 of 7, AK4 element 2 code 7 — which say nothing without a code table. This resolves every one into plain language, points at the failing segment position and element, and, if you supply the control numbers you sent, reconciles them so you can see what was acknowledged, what was rejected, and what never came back at all. Silence is the failure mode that costs money: an unacknowledged document is not a delivered one.
  Parameters:
    - input: string (required) — Raw 997 or 999 acknowledgment text.
    - sent: array (default: []) — Transaction set control numbers you sent (ST02 values), to reconcile against. e.g. ["0001","0002"].
  Example — A clean acceptance:
    https://www.fluentedi.com/v1/edi/acknowledge?input=ST*997*0001~AK1*SH*1~AK2*856*0001~AK5*A~AK9*A*1*1*1~SE*6*0001~
  Example — A rejection, decoded down to the element:
    https://www.fluentedi.com/v1/edi/acknowledge?input=ST*997*0002~AK1*SH*12~AK2*856*0001~AK3*HL*4**7~AK4*2**7*XX~AK5*R*5~AK9*R*1*1*0~SE*8*0002~
  Example — Reconcile against what you sent:
    https://www.fluentedi.com/v1/edi/acknowledge?input=ST*997*0003~AK1*SH*5~AK2*856*0001~AK5*A~AK9*P*2*2*1~SE*6*0003~&sent=%5B%220001%22%2C%220002%22%5D

- [gs1.checkdigit](https://www.fluentedi.com/v1/tools/gs1.checkdigit): Calculate or validate a GS1 mod-10 check digit for SSCC-18, GTIN-14/13/12/8 and UPC.
  Computes the GS1 mod-10 check digit, or validates a complete code and says what the digit should have been. Also catches the failure behind most real-world barcode and ASN mismatches: a spreadsheet dropping leading zeros or rendering the identifier in scientific notation, silently changing it. Pass a full code to validate, or the payload without its final digit to compute one.
  Parameters:
    - code: string (required) — The code, with or without its check digit. Spaces and hyphens are ignored.
    - length: integer (default: 0) — Expected total length (8, 12, 13, 14 or 18). Inferred when omitted.
  Example — Validate a UPC-12:
    https://www.fluentedi.com/v1/gs1/checkdigit?code=036000291452
  Example — Compute the check digit for an SSCC payload:
    https://www.fluentedi.com/v1/gs1/checkdigit?code=00614141123456789
  Example — Catch a code mangled by a spreadsheet:
    https://www.fluentedi.com/v1/gs1/checkdigit?code=614141123456789&length=18

- [id.validate](https://www.fluentedi.com/v1/tools/id.validate): Validate an identifier's checksum: IBAN, card, ISBN, ISSN, ISIN, CUSIP, LEI, routing number, IMEI, ORCID, GTIN, VIN, GSTIN and more.
  Runs the real check algorithm for twenty-odd identifier schemes and says both whether it passes and what passing does not prove — which is usually the more useful half. A valid IBAN checksum does not mean the account exists; a lapsed LEI passes forever; one in ten random digit strings satisfies Luhn. Schemes with no checksum at all (BIC, IFSC, DOI, and India's PAN, whose algorithm has never been published) are reported as structure-only rather than dressed up as verified. Pass `scheme` or let it infer from shape.
  Parameters:
    - value: string (required) — The identifier to check. Spaces, hyphens and dots are ignored.
    - scheme: string (default: "auto") — Which scheme to apply. "auto" infers it from the shape. One of: auto, iban, card, luhn, isbn, isbn10, isbn13, issn, isin, cusip, lei, aba, imei, orcid, isni, ean8, ean13, gtin, upce, vin, gstin, pan, ifsc, bic, doi, verhoeff.
  Example — Validate an IBAN:
    https://www.fluentedi.com/v1/id/validate?value=GB82%20WEST%201234%205698%207654%2032
  Example — Check a card number:
    https://www.fluentedi.com/v1/id/validate?value=4242424242424242&scheme=card
  Example — Validate an Indian GSTIN:
    https://www.fluentedi.com/v1/id/validate?value=27AAPFU0939F1ZV
  Example — A LEI, where a pass means less than it appears:
    https://www.fluentedi.com/v1/id/validate?value=7LTWFZYICNSX8D621K86


### Finding your way around

- [tool.search](https://www.fluentedi.com/v1/tools/tool.search): Find the right tool for a task by describing it in plain language.
  Searches every tool by name, summary, description and keywords, and returns the closest matches with their endpoints and parameters. Use this instead of loading the whole catalogue: describe the job ("check whether a shipment is late", "fix broken JSON", "validate a barcode check digit") and call what comes back. Each result says why it matched, so a wrong match is obvious rather than plausible.
  Parameters:
    - q: string (required) — What you are trying to do, in plain language.
    - limit: integer (default: 5) — Maximum matches to return.
    - detail: boolean (default: false) — Include full parameter schemas and worked examples for each match.
  Example — Find a tool by describing the job:
    https://www.fluentedi.com/v1/tool/search?q=check%20if%20a%20date%20falls%20inside%20a%20shipping%20window
  Example — Find everything about broken JSON:
    https://www.fluentedi.com/v1/tool/search?q=fix%20malformed%20json&limit=3&detail=true
  Example — Barcode check digits:
    https://www.fluentedi.com/v1/tool/search?q=validate%20barcode%20check%20digit

- [tool.describe](https://www.fluentedi.com/v1/tools/tool.describe): Get the full parameter schema and worked examples for one tool.
  Returns everything needed to call a tool correctly: its complete JSON Schema, every parameter with type and default, and examples known to work. Pair it with tool.search — search to find the name, describe to learn the shape, then call. This exists so the catalogue does not have to be loaded into context up front.
  Parameters:
    - name: string (required) — Tool name, e.g. "time.window". Underscores and slashes are accepted too.
  Example — Learn how to call time.window:
    https://www.fluentedi.com/v1/tool/describe?name=time.window

- [tool.call](https://www.fluentedi.com/v1/tools/tool.call): Invoke any tool by name, including ones not in the default listing.
  Dispatches to any tool in the catalogue. Most clients cap how many tools they will hold at once — Cursor drops everything past roughly forty across all servers combined — so only a core set is listed by default. Everything else is reachable here. Find a name with tool.search, check its shape with tool.describe, then call it through this.
  Parameters:
    - tool: string (required) — Name of the tool to invoke.
    - args: object (default: {}) — Arguments for that tool.
  Example — Call a tool that is not in the default listing:
    https://www.fluentedi.com/v1/tool/call?tool=gs1.checkdigit&args=%7B%22code%22%3A%22036000291452%22%7D
  Example — Convert units:
    https://www.fluentedi.com/v1/tool/call?tool=unit.convert&args=%7B%22value%22%3A100%2C%22from%22%3A%22km%22%2C%22to%22%3A%22mi%22%7D


## Worked solutions

Specific failures, each with a real failing input and the exact diagnostic returned for it.

- [EDI 997 specification: every segment and code, with a live decoder](https://www.fluentedi.com/recipes/edi-997-specification): The complete AK1 through AK9 structure of a Functional Acknowledgment, every error code in every position, and an endpoint that turns one into plain language.
- [EDI 856 specification: segment structure, the HL hierarchy, and a worked ASN](https://www.fluentedi.com/recipes/edi-856-specification): What an Advance Ship Notice contains, how the HL loop encodes shipment structure, which segments are mandatory, and a complete valid example you can run.
- [EDI 850 specification: purchase order segments and a worked example](https://www.fluentedi.com/recipes/edi-850-specification): The structure of an X12 850 — BEG, N1 party loops, PO1 line items, DTM dates and CTT — with an endpoint that parses one into JSON.
- [Why an 856 ASN is rejected for HL hierarchy errors](https://www.fluentedi.com/recipes/856-asn-rejected-hl-hierarchy): The HL loop flattens a shipment's tree into a list, and every level must name the ID its parent was actually given. Here is what breaks, and how to see it before the retailer does.
- [Computing and validating an SSCC-18 check digit](https://www.fluentedi.com/recipes/sscc-18-check-digit): Every carton label in an ASN carries an SSCC-18 whose last digit is a GS1 mod-10 checksum. Here is the algorithm, and the spreadsheet behaviour that silently corrupts one.
- [SE01 segment count does not match: what the receiver is counting](https://www.fluentedi.com/recipes/se01-segment-count-mismatch): A rejection for SE01 almost always means the sender counted differently from the spec. The rule is narrower than it looks.
- [Reading a 997: what AK5, AK3 and AK4 codes actually mean](https://www.fluentedi.com/recipes/edi-997-rejection-codes): A Functional Acknowledgment reports its verdict as bare letters and numbers. Here is how to turn one into a sentence, and why silence is worse than rejection.
- [The ISA header is fixed-width: 106 characters, no exceptions](https://www.fluentedi.com/recipes/isa-segment-must-be-106-characters): Most X12 segments are delimited. ISA is not — every element has an exact width and must be padded. One character out and the receiver's parser fails before reading anything.
- [Repairing malformed JSON from a language model](https://www.fluentedi.com/recipes/llm-produced-invalid-json): Models emit JSON wrapped in prose, fenced in markdown, with trailing commas, single quotes, Python literals, or simply cut off. All of it is mechanically fixable.
- [Why agents miss deadlines: timezone and window arithmetic](https://www.fluentedi.com/recipes/agent-timezone-and-deadline-errors): A language model has no clock. It also has no reliable intuition for whether an instant falls inside a window, which is how ship windows get missed with no error anywhere.
- [Stopping credentials leaking when an agent shares logs](https://www.fluentedi.com/recipes/secrets-leaking-into-agent-logs): Agents paste logs, environment files and stack traces into models, tickets and chat. Anything in a URL or an env var goes with them.

## Machine-readable descriptors

- [OpenAPI 3.1](https://www.fluentedi.com/openapi.json)
- [Tool registry as JSON](https://www.fluentedi.com/v1/tools)
- [Worked solutions as JSON](https://www.fluentedi.com/recipes.json)
- [MCP endpoint](https://www.fluentedi.com/mcp) (streamable HTTP, protocol 2025-06-18)
- [Expanded reference](https://www.fluentedi.com/llms-full.txt)

## Terms

Free and unauthenticated, with no rate limit and no paid tier. Every tool is read-only and idempotent.

Stateless: request and response bodies are processed in memory and discarded. Nothing you send is
stored, logged as content, or used for training.

What is counted, per call: the tool name, the transport (rest, mcp or batch), whether it succeeded, the
error code if it did not, duration, the country and edge location the request arrived at, and the
user-agent string. That is ordinary access telemetry, kept to understand which tools are worth
maintaining. It never includes arguments, results, or anything derived from them.

Two tools reach the network on your behalf: dns.lookup queries a public DNS resolver, and http.check
fetches the URL you name. Both are stated in the tool description; every other tool is computed at the
edge and touches nothing external.

Version 1.1.0.