. Text uses the Inter font when installed, else a system sans-serif. Web version: https://s3eidat.github.io/watermark/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `image` | string | yes | The photo: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI). |
| `text` | string | no (default `"© Your Name"`) | Watermark text (ignored when a logo is given). Default "© Your Name". |
| `logo` | string | no | Use this image as the watermark instead of text: a local path or base64. |
| `color` | string | no (default `"#ffffff"`) | Text colour. Default #ffffff. |
| `weight` | "400" \| "500" \| "600" \| "700" \| "800" \| "900" | no (default `"700"`) | Font weight. Default 700. |
| `shadow` | boolean | no (default `true`) | Soft drop shadow behind text. Default true. |
| `position` | "top-left" \| "top" \| "top-right" \| "left" \| "center" \| "right" \| "bottom-left" \| "bottom" \| "bottom-right" | no (default `"bottom-right"`) | Where the watermark sits (ignored when tiled). Default bottom-right. |
| `tiled` | boolean | no (default `false`) | Repeat the watermark across the whole photo. |
| `opacity` | number | no (default `60`) | Opacity in %. Default 60. |
| `size` | number | no (default `28`) | Watermark width as % of the photo width. Default 28. |
| `rotation` | number | no (default `0`) | Rotation in degrees (e.g. -30 for a diagonal tile). Default 0. |
| `margin` | number | no (default `4`) | Margin from the edge in % of the shorter side; spacing between tiles when tiled. Default 4. |
| `format` | "keep" \| "jpeg" \| "png" \| "webp" | no (default `"keep"`) | Output format. Default keep. |
| `quality` | integer | no (default `92`) | Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 92, same as the website. |
| `output` | string | no | Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set). |
| `returnBase64` | boolean | no (default `false`) | Also return the output as base64 in the result (only for small files). Default false. |
**Output**
| Field | Type | Description |
|---|---|---|
| `path` | string | Absolute path of the written file. |
| `bytes` | number | Size of the written file in bytes. |
| `mimeType` | string | |
| `base64` | string | |
| `width` | number | Output width in pixels. |
| `height` | number | Output height in pixels. |
| `format` | string | Output format. |
**Example**
```json
{
"image": "/photos/shoot-01.jpg",
"text": "© Studio Lina",
"position": "bottom-right",
"opacity": 60
}
```
**Example**
```json
{
"image": "/photos/proof.jpg",
"text": "PROOF",
"tiled": true,
"rotation": -25,
"opacity": 35,
"size": 26,
"margin": 3
}
```
**Example**
```json
{
"image": "/photos/product.png",
"logo": "/brand/logo.png",
"position": "top-left",
"size": 20
}
```
## Text
Counting, case, slugs, cleaning, diffs, readability, Arabic tools, numbers to words, citations.
| Tool | What it does |
|---|---|
| [`text_arabic`](#text_arabic) | Arabic text tools |
| [`text_case`](#text_case) | Case convert |
| [`text_citation`](#text_citation) | Citation generator |
| [`text_clean`](#text_clean) | Text cleaner |
| [`text_diff`](#text_diff) | Diff two texts |
| [`text_escape`](#text_escape) | Escape / unescape text |
| [`text_fancy`](#text_fancy) | Fancy text (Unicode styles) |
| [`text_layout_fix`](#text_layout_fix) | Keyboard layout fixer (EN ⇄ AR) |
| [`text_lorem`](#text_lorem) | Lorem ipsum generator |
| [`text_morse`](#text_morse) | Morse code translator |
| [`text_number_to_words`](#text_number_to_words) | Number to words (English & Arabic) |
| [`text_readability`](#text_readability) | Readability score |
| [`text_slugify`](#text_slugify) | Slugify |
| [`text_social_count`](#text_social_count) | Social media character counter |
| [`text_word_count`](#text_word_count) | Word count |
### `text_arabic` — Arabic text tools
Arabic text utilities. mode "clean": remove tashkeel (harakat and Quranic marks, optionally keeping shadda), remove tatweel (kashida), normalise letters (alef with hamza/madda/wasla → bare alef; alef maqsura and Farsi ya → ya; ta marbuta → ha; hamza on waw/ya → waw/ya), switch Latin , ; ? to Arabic punctuation, and convert digits (Arabic-Indic ↔ Western). mode "arabizi": turn Arabizi / Franco-Arabic chat text (mar7aba, 3arabi, 5ala9, el bait) into Arabic script. Returns the result with letter/word/character counts. Give "text" or a text file "path". Web version: https://s3eidat.github.io/arabic-tools/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The text to transform. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
| `mode` | "clean" \| "arabizi" | no (default `"clean"`) | "clean" = clean & normalise Arabic text (default); "arabizi" = Arabizi (Latin letters + numbers) → Arabic script. |
| `removeTashkeel` | boolean | no (default `true`) | clean: remove tashkeel / harakat (default true). |
| `keepShadda` | boolean | no (default `false`) | clean: when removing tashkeel, keep the shadda. |
| `removeTatweel` | boolean | no (default `true`) | clean: remove tatweel / kashida (default true). |
| `normalizeAlef` | boolean | no (default `false`) | clean: alef with hamza above/below, madda or wasla → bare alef. |
| `normalizeYa` | boolean | no (default `false`) | clean: alef maqsura and Farsi ya → Arabic ya. |
| `taMarbutaToHa` | boolean | no (default `false`) | clean: ta marbuta → ha. |
| `normalizeHamza` | boolean | no (default `false`) | clean: hamza on waw → waw, hamza on ya → ya. |
| `arabicPunctuation` | boolean | no (default `false`) | clean: Latin comma, semicolon and question mark → Arabic ones. |
| `digits` | "keep" \| "western" \| "arabic" | no (default `"keep"`) | clean: keep digits, convert Arabic-Indic/Persian digits to 0-9 ("western"), or 0-9 to Arabic-Indic ("arabic"). |
| `output` | string | no | Optional: write the result to this file path (or folder ending in "/") instead of returning it. |
**Output**
| Field | Type | Description |
|---|---|---|
| `text` | string | The result (omitted when written to "output"). |
| `path` | string | |
| `bytes` | number | |
| `arabicLetters` | number | |
| `words` | number | |
| `characters` | number | |
| `marksRemoved` | number | clean mode: how many tashkeel marks were removed. |
**Example**
```json
{
"mode": "arabizi",
"text": "mar7aba, kifak?"
}
```
Result:
```json
{
"text": "مرحبا، كيفك؟",
"arabicLetters": 9,
"words": 2,
"characters": 12
}
```
**Example**
```json
{
"text": "2026",
"digits": "arabic"
}
```
Result:
```json
{
"text": "٢٠٢٦",
"arabicLetters": 0,
"words": 1,
"characters": 4,
"marksRemoved": 0
}
```
### `text_case` — Case convert
Convert text case: upper, lower, title (smart: keeps small words lower and iPhone/NASA as typed), sentence, camel, pascal, snake, kebab, constant, alternate, inverse. Works line by line and handles Unicode (Arabic, accents, ß). Web version: https://s3eidat.github.io/case-convert/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | yes | Text to convert. |
| `mode` | "upper" \| "lower" \| "title" \| "sentence" \| "camel" \| "pascal" \| "snake" \| "kebab" \| "constant" \| "alternate" \| "inverse" | yes | Target case. |
**Output**
| Field | Type | Description |
|---|---|---|
| `result` | string | |
**Example**
```json
{
"text": "a tale OF two cities",
"mode": "title"
}
```
Result:
```json
{
"result": "A Tale of Two Cities"
}
```
**Example**
```json
{
"text": "XMLParser handler",
"mode": "snake"
}
```
Result:
```json
{
"result": "xml_parser_handler"
}
```
### `text_citation` — Citation generator
Format references from structured fields in APA 7, MLA 9, Chicago author-date (17th), Harvard (Cite Them Right) or IEEE, for books, book chapters, journal articles, web pages, newspaper/magazine articles, videos and reports. Handles author-count rules (et al.), initials, organisations as authors, editions, page ranges (MLA 127-53), DOIs, URLs and access dates, and title case for MLA/Chicago/IEEE. Returns each citation as plain text and HTML (italics as ), the in-text citation, missing-field hints, and the whole list as a bibliography sorted for the style (numbered for IEEE). Web version: https://s3eidat.github.io/citation-gen/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `style` | "apa" \| "mla" \| "chicago" \| "harvard" \| "ieee" | yes | Citation style: apa, mla, chicago, harvard or ieee. |
| `sources` | object[] | yes | One or more sources. |
| `autoCase` | boolean | no (default `true`) | Apply title case where the style wants it (MLA, Chicago, IEEE book titles). Default true. |
**Output**
| Field | Type | Description |
|---|---|---|
| `style` | string | |
| `citations` | object[] | In the order given. |
| `bibliographyTitle` | string | References / Works Cited / Reference list. |
| `bibliography` | string | All entries sorted for the style (IEEE: numbered in the order given), separated by blank lines. |
**Example** — Abelson, H., & Sussman, G. J. (1996). Structure and interpretation of computer programs (2nd ed.). MIT Press.
```json
{
"style": "apa",
"sources": [
{
"type": "book",
"authors": [
{
"first": "Harold",
"last": "Abelson"
},
{
"first": "Gerald Jay",
"last": "Sussman"
}
],
"title": "Structure and interpretation of computer programs",
"edition": "2",
"year": "1996",
"publisher": "MIT Press",
"place": "Cambridge, MA, USA"
}
]
}
```
Result:
```json
{
"style": "APA 7",
"citations": [
{
"text": "Abelson, H., & Sussman, G. J. (1996). Structure and interpretation of computer programs (2nd ed.). MIT Press.",
"html": "Abelson, H., & Sussman, G. J. (1996). Structure and interpretation of computer programs (2nd ed.). MIT Press.",
"inText": "(Abelson & Sussman, 1996)",
"missing": []
}
],
"bibliographyTitle": "References",
"bibliography": "Abelson, H., & Sussman, G. J. (1996). Structure and interpretation of computer programs (2nd ed.). MIT Press."
}
```
### `text_clean` — Text cleaner
Clean up text line by line with a fixed pipeline (same order as the website): strip HTML tags and decode entities → remove emojis → trim each line → collapse repeated spaces → remove empty lines → remove duplicate lines (optionally ignoring case) → sort (A–Z, Z–A, natural, by length) → reverse → shuffle (seedable) → add line numbers. Returns the cleaned text plus counts, or writes it to a file when "output" is given. Give "text" or a text file "path". Web version: https://s3eidat.github.io/text-cleaner/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The text to clean. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
| `stripHtml` | boolean | no (default `false`) | Strip HTML tags (drops script/style/comments, block ends become line breaks) and decode entities (default false). |
| `removeEmoji` | boolean | no (default `false`) | Remove emojis (©, ® and ™ are kept) (default false). |
| `trim` | boolean | no (default `true`) | Trim spaces at the start and end of each line (default true). |
| `collapseSpaces` | boolean | no (default `true`) | Collapse runs of spaces/tabs into one space (default true). |
| `removeEmptyLines` | boolean | no (default `true`) | Remove empty (whitespace-only) lines (default true). |
| `removeDuplicates` | boolean | no (default `false`) | Remove duplicate lines, keeping the first (default false). |
| `ignoreCase` | boolean | no (default `false`) | When removing duplicates, treat lines that differ only in case as duplicates (default false). |
| `sort` | "none" \| "az" \| "za" \| "natural" \| "length" | no (default `"none"`) | Sort lines: none (default), az, za, natural (item 2 before item 10), length (shortest first). |
| `reverse` | boolean | no (default `false`) | Reverse the line order (default false). |
| `shuffle` | boolean | no (default `false`) | Shuffle the lines (default false). |
| `seed` | integer | no | Seed for a reproducible shuffle (default: random). |
| `numberLines` | boolean | no (default `false`) | Prefix each line with its number ("1. ", padded) (default false). |
| `output` | string | no | Optional: write the cleaned text to this file path (or folder ending in "/") instead of returning it. |
**Output**
| Field | Type | Description |
|---|---|---|
| `text` | string | The cleaned text (omitted when written to "output"). |
| `path` | string | |
| `bytes` | number | |
| `linesIn` | number | |
| `linesOut` | number | |
| `duplicatesRemoved` | number | |
| `emptyLinesRemoved` | number | |
| `charactersOut` | number | |
| `seed` | number | Seed used for the shuffle. |
**Example**
```json
{
"text": "item 10\nitem 2\nitem 2\n\nitem 1",
"removeDuplicates": true,
"sort": "natural"
}
```
Result:
```json
{
"text": "item 1\nitem 2\nitem 10",
"linesIn": 5,
"linesOut": 3,
"duplicatesRemoved": 1,
"emptyLinesRemoved": 1,
"charactersOut": 21
}
```
### `text_diff` — Diff two texts
Compare two texts line by line (Myers diff) and return a unified diff (3 lines of context, like `diff -u`), counts of added/removed/unchanged lines, and change blocks where each removed line is paired with the added line that replaced it and the changed words are marked [-old-] / {+new+}. Can ignore whitespace and case. Works with any language (Arabic included). Up to 50,000 lines per side. Web version: https://s3eidat.github.io/diff-view/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `original` | string | no | The original text ("before"). |
| `originalPath` | string | no | Or: path to the original text file. |
| `changed` | string | no | The changed text ("after"). |
| `changedPath` | string | no | Or: path to the changed text file. |
| `ignoreWhitespace` | boolean | no (default `false`) | Treat lines that differ only in spacing as equal. |
| `ignoreCase` | boolean | no (default `false`) | Treat lines that differ only in letter case as equal. |
| `wordDiff` | boolean | no (default `true`) | Mark the changed words inside paired lines (default true). |
| `nameA` | string | no | Label for the "---" header (default "original"). |
| `nameB` | string | no | Label for the "+++" header (default "changed"). |
**Output**
| Field | Type | Description |
|---|---|---|
| `identical` | boolean | True when there is no difference (with the ignore options applied). |
| `added` | number | |
| `removed` | number | |
| `unchanged` | number | |
| `unified` | string | Unified diff text (empty when identical). |
| `changes` | object[] | Change blocks; line numbers are 1-based. |
**Example**
```json
{
"original": "one\ntwo\nthree",
"changed": "zero\none\nthree"
}
```
Result:
```json
{
"identical": false,
"added": 1,
"removed": 1,
"unchanged": 2,
"unified": "--- original\n+++ changed\n@@ -1,3 +1,3 @@\n+zero\n one\n-two\n three\n",
"changes": [
{
"removed": [],
"added": [
{
"line": 1,
"text": "zero"
}
]
},
{
"removed": [
{
"line": 2,
"text": "two"
}
],
"added": []
}
]
}
```
**Example** — changes[0]: removed marked "the [-quick-] fox", added marked "the {+slow+} fox"
```json
{
"original": "the quick fox",
"changed": "the slow fox"
}
```
Result:
```json
{
"identical": false,
"added": 1,
"removed": 1,
"unchanged": 0,
"unified": "--- original\n+++ changed\n@@ -1 +1 @@\n-the quick fox\n+the slow fox\n",
"changes": [
{
"removed": [
{
"line": 1,
"text": "the quick fox",
"marked": "the [-quick-] fox"
}
],
"added": [
{
"line": 1,
"text": "the slow fox",
"marked": "the {+slow+} fox"
}
]
}
]
}
```
### `text_escape` — Escape / unescape text
Escape or unescape a string for a target: JSON (string body), JavaScript (incl. template literals), HTML, XML, URL (encodeURIComponent, optional form +), SQL (doubled quotes, optional MySQL backslashes and wrapping quotes), CSV field (RFC 4180; comma, semicolon or tab), regex, POSIX shell single quotes, C/C++, Java/C#, and Unicode escapes (\uXXXX, \u{X}, \UXXXXXXXX, &#xX;, U+XXXX). Options per target as on the website. Set "allTargets" to get the escaped form for every target at once. Web version: https://s3eidat.github.io/text-escape/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | yes | The text to escape, or the escaped text to unescape. |
| `target` | "json" \| "js" \| "html" \| "xml" \| "url" \| "sql" \| "csv" \| "regex" \| "shell" \| "c" \| "java" \| "unicode" | yes | Format: json, js, html, xml, url, sql, csv, regex, shell, c, java, unicode. |
| `direction` | "escape" \| "unescape" | no (default `"escape"`) | escape (default) or unescape. |
| `ascii` | boolean | no (default `false`) | json/js/html/c/java: also escape non-ASCII characters (c: as UTF-8 octal). |
| `named` | boolean | no (default `false`) | html (with ascii): prefer named entities such as ©. |
| `form` | boolean | no (default `false`) | url: form style, + for spaces. |
| `wrap` | boolean | no (default `false`) | sql: wrap in single quotes (unescape: strip them). |
| `mysql` | boolean | no (default `false`) | sql: escape backslashes too (MySQL). |
| `alwaysQuote` | boolean | no (default `false`) | csv: always quote the field. |
| `delimiter` | "," \| ";" \| "\t" | no (default `","`) | csv: field delimiter (comma, semicolon or tab). |
| `unicodeFormat` | "u4" \| "ubrace" \| "u8" \| "html" \| "uplus" | no (default `"u4"`) | unicode: u4 = \uXXXX (JS, JSON, Java), ubrace = \u{X} (ES6, Rust, Swift), u8 = \UXXXXXXXX (Python, C), html = &#xX;, uplus = U+XXXX. |
| `every` | boolean | no (default `false`) | unicode: escape every character, not only non-ASCII. |
| `allTargets` | boolean | no (default `false`) | escape only: also return the text escaped for every target. |
**Output**
| Field | Type | Description |
|---|---|---|
| `result` | string | |
| `note` | string | A short hint about the target. |
| `inputCharacters` | number | |
| `outputCharacters` | number | |
| `allTargets` | object[] | |
**Example**
```json
{
"text": "O'Brien",
"target": "sql",
"wrap": true
}
```
Result:
```json
{
"result": "'O''Brien'",
"note": "Standard SQL doubles single quotes. Prefer parameterised queries over escaping.",
"inputCharacters": 7,
"outputCharacters": 10
}
```
**Example**
```json
{
"text": "a%20b%26c",
"target": "url",
"direction": "unescape"
}
```
Result:
```json
{
"result": "a b&c",
"note": "encodeURIComponent: for one query value or path segment.",
"inputCharacters": 9,
"outputCharacters": 5
}
```
### `text_fancy` — Fancy text (Unicode styles)
Restyle text with Unicode look-alike characters for bios and posts (28 styles): Bold, Italic, Bold italic, Script, Bold script, Fraktur, Bold fraktur, Double-struck, Sans-serif, Sans bold, Sans italic, Sans bold italic, Monospace, Circled, Circled dark, Squared, Squared dark, Parenthesized, Fullwidth, Small caps, Superscript, Upside down, Strikethrough, Underline, Double underline, Slashed, Overline, Wide spaced. Only Latin letters and digits change (other scripts such as Arabic and emoji pass through); some styles cover only capitals or only some symbols. Give one "style", or none to get every style. Up to 20,000 characters. Web version: https://s3eidat.github.io/fancy-text/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | yes | The text to restyle. |
| `style` | "Bold" \| "Italic" \| "Bold italic" \| "Script" \| "Bold script" \| "Fraktur" \| "Bold fraktur" \| "Double-struck" \| "Sans-serif" \| "Sans bold" \| "Sans italic" \| "Sans bold italic" \| "Monospace" \| "Circled" \| "Circled dark" \| "Squared" \| "Squared dark" \| "Parenthesized" \| "Fullwidth" \| "Small caps" \| "Superscript" \| "Upside down" \| "Strikethrough" \| "Underline" \| "Double underline" \| "Slashed" \| "Overline" \| "Wide spaced" | no | One style name (exact, e.g. "Bold", "Script", "Upside down"). Omit to get all styles. |
**Output**
| Field | Type | Description |
|---|---|---|
| `results` | object[] | |
**Example**
```json
{
"text": "Hello 2026",
"style": "Bold"
}
```
Result:
```json
{
"results": [
{
"style": "Bold",
"text": "𝐇𝐞𝐥𝐥𝐨 𝟐𝟎𝟐𝟔"
}
]
}
```
**Example** — Returns all 28 styles.
```json
{
"text": "Stay curious"
}
```
Result:
```json
{
"results": [
{
"style": "Bold",
"text": "𝐒𝐭𝐚𝐲 𝐜𝐮𝐫𝐢𝐨𝐮𝐬"
},
{
"style": "Italic",
"text": "𝑆𝑡𝑎𝑦 𝑐𝑢𝑟𝑖𝑜𝑢𝑠"
},
{
"style": "Bold italic",
"text": "𝑺𝒕𝒂𝒚 𝒄𝒖𝒓𝒊𝒐𝒖𝒔"
},
{
"style": "Script",
"text": "𝒮𝓉𝒶𝓎 𝒸𝓊𝓇𝒾ℴ𝓊𝓈"
},
{
"style": "Bold script",
"text": "𝓢𝓽𝓪𝔂 𝓬𝓾𝓻𝓲𝓸𝓾𝓼"
},
{
"style": "Fraktur",
"text": "𝔖𝔱𝔞𝔶 𝔠𝔲𝔯𝔦𝔬𝔲𝔰"
},
{
"style": "Bold fraktur",
"text": "𝕾𝖙𝖆𝖞 𝖈𝖚𝖗𝖎𝖔𝖚𝖘"
},
{
"style": "Double-struck",
"text": "𝕊𝕥𝕒𝕪 𝕔𝕦𝕣𝕚𝕠𝕦𝕤"
},
{
"style": "Sans-serif",
"text": "𝖲𝗍𝖺𝗒 𝖼𝗎𝗋𝗂𝗈𝗎𝗌"
},
{
"style": "Sans bold",
"text": "𝗦𝘁𝗮𝘆 𝗰𝘂𝗿𝗶𝗼𝘂𝘀"
},
{
"style": "Sans italic",
"text": "𝘚𝘵𝘢𝘺 𝘤𝘶𝘳𝘪𝘰𝘶𝘴"
},
{
"style": "Sans bold italic",
"text": "𝙎𝙩𝙖𝙮 𝙘𝙪𝙧𝙞𝙤𝙪𝙨"
},
{
"style": "Monospace",
"text": "𝚂𝚝𝚊𝚢 𝚌𝚞𝚛𝚒𝚘𝚞𝚜"
},
{
"style": "Circled",
"text": "Ⓢⓣⓐⓨ ⓒⓤⓡⓘⓞⓤⓢ"
},
{
"style": "Circled dark",
"text": "🅢🅣🅐🅨 🅒🅤🅡🅘🅞🅤🅢"
},
{
"style": "Squared",
"text": "🅂🅃🄰🅈 🄲🅄🅁🄸🄾🅄🅂"
},
{
"style": "Squared dark",
"text": "🆂🆃🅰🆈 🅲🆄🆁🅸🅾🆄🆂"
},
{
"style": "Parenthesized",
"text": "🄢⒯⒜⒴ ⒞⒰⒭⒤⒪⒰⒮"
},
{
"style": "Fullwidth",
"text": "Ｓｔａｙ ｃｕｒｉｏｕｓ"
},
{
"style": "Small caps",
"text": "ꜱᴛᴀʏ ᴄᴜʀɪᴏᴜꜱ"
},
{
"style": "Superscript",
"text": "Sᵗᵃʸ ᶜᵘʳⁱᵒᵘˢ"
},
{
"style": "Upside down",
"text": "snoᴉɹnɔ ʎɐʇS"
},
{
"style": "Strikethrough",
"text": "S̶t̶a̶y̶ ̶c̶u̶r̶i̶o̶u̶s̶"
},
{
"style": "Underline",
"text": "S̲t̲a̲y̲ ̲c̲u̲r̲i̲o̲u̲s̲"
},
{
"style": "Double underline",
"text": "S̳t̳a̳y̳ ̳c̳u̳r̳i̳o̳u̳s̳"
},
{
"style": "Slashed",
"text": "S̸t̸a̸y̸ ̸c̸u̸r̸i̸o̸u̸s̸"
},
{
"style": "Overline",
"text": "S̅t̅a̅y̅ ̅c̅u̅r̅i̅o̅u̅s̅"
},
{
"style": "Wide spaced",
"text": "S t a y c u r i o u s"
}
]
}
```
### `text_layout_fix` — Keyboard layout fixer (EN ⇄ AR)
Fix text typed with the wrong keyboard layout between US English (QWERTY) and Arabic (101): "hgsghl ugd;l" becomes the Arabic greeting, and Arabic gibberish typed on English keys becomes "hello". Direction "auto" detects it; in mixed text only the words that look mistyped are converted (using small English/Arabic letter-pair models), so words that are already right stay as they are. Handles the shift layer (harakat, hamza forms), lam-alef keys and Caps Lock (all-caps Latin input is treated as lowercase). Web version: https://s3eidat.github.io/layout-fixer/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The mistyped text. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
| `direction` | "auto" \| "ar" \| "en" | no (default `"auto"`) | "auto" (default) detects; "ar" = typed on English keys, convert to Arabic; "en" = typed on Arabic keys, convert to English. |
| `capsLock` | boolean | no (default `false`) | Caps Lock was on: treat capital Latin letters as lowercase (detected automatically when all letters are capitals). |
**Output**
| Field | Type | Description |
|---|---|---|
| `text` | string | The fixed text. |
| `direction` | "ar" \| "en" \| "mixed" \| null | ar = converted to Arabic, en = converted to English, mixed = only mistyped words fixed, null = no letters. |
| `wordsChanged` | number | |
| `capsLockIgnored` | boolean | True when all-caps input was treated as Caps Lock. |
**Example**
```json
{
"text": ";dt phg;?"
}
```
Result:
```json
{
"text": "كيف حالك؟",
"direction": "ar",
"wordsChanged": 2,
"capsLockIgnored": false
}
```
**Example** — Mixed text: only the mistyped Arabic-looking word becomes "hello".
```json
{
"text": "Hi, ok اثممخ"
}
```
Result:
```json
{
"text": "Hi, ok hello",
"direction": "mixed",
"wordsChanged": 1,
"capsLockIgnored": false
}
```
### `text_lorem` — Lorem ipsum generator
Generate placeholder text: classic Lorem ipsum, readable English filler, or Arabic filler. Choose paragraphs (max 100), sentences (max 500) or words (max 10000); optionally start with the classic opener and wrap paragraphs in tags. Give a seed for repeatable output (the same seed gives the same text). Writes a .txt/.html file instead when "output" is given. Web version: https://s3eidat.github.io/lorem-gen/
Hints: readOnly
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `style` | "lorem" \| "english" \| "arabic" | no (default `"lorem"`) | Word list: lorem (Latin), english, or arabic. |
| `unit` | "paragraphs" \| "sentences" \| "words" | no (default `"paragraphs"`) | What "count" counts. |
| `count` | integer | no (default `3`) | How many paragraphs / sentences / words (clamped to the unit limit). |
| `opener` | boolean | no (default `true`) | Start with the classic opening line ("Lorem ipsum dolor sit amet…", "The quick brown fox…", or the Arabic one). Default true. |
| `html` | boolean | no (default `false`) | Wrap each paragraph in
…
. |
| `seed` | integer | no | Seed for repeatable output (default: random). |
| `output` | string | no | Optional: write the text to this file path (or folder ending in "/") instead of returning it. |
**Output**
| Field | Type | Description |
|---|---|---|
| `text` | string | The generated text (omitted when written to "output"). |
| `path` | string | |
| `bytes` | number | |
| `words` | number | |
| `characters` | number | |
| `paragraphs` | number | |
| `seed` | number | Seed used: pass it again to get the same text. |
**Example** — 25 words starting "Lorem ipsum dolor sit amet…"
```json
{
"unit": "words",
"count": 25,
"seed": 42
}
```
**Example**
```json
{
"style": "arabic",
"unit": "paragraphs",
"count": 2
}
```
### `text_morse` — Morse code translator
Translate text to International Morse code and back. Encoding: letters separated by spaces, words by " / "; accents are folded (é → E) and characters without a code are skipped and counted. Decoding accepts . and - plus look-alikes (• · – — _), with words split by /, | or 2+ spaces; unknown codes become #. Encoding also returns the playing time at a given speed (PARIS timing: dot = 1200/WPM ms). No audio. Web version: https://s3eidat.github.io/morse-code/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | yes | Text to encode, or Morse code to decode. |
| `mode` | "encode" \| "decode" \| "auto" | no (default `"auto"`) | "encode" text → Morse, "decode" Morse → text, or "auto" (default): decode if the input only has Morse symbols, spaces, / and \|. |
| `wpm` | number | no (default `18`) | Speed in words per minute for the duration estimate (default 18). |
**Output**
| Field | Type | Description |
|---|---|---|
| `mode` | "encode" \| "decode" | |
| `result` | string | |
| `skipped` | number | encode: characters with no Morse code (skipped). |
| `unrecognized` | number | decode: codes that were not recognised (shown as #). |
| `durationSeconds` | number | encode: time to play the Morse at the given WPM. |
**Example**
```json
{
"text": "SOS",
"mode": "encode"
}
```
Result:
```json
{
"mode": "encode",
"result": "... --- ...",
"skipped": 0,
"durationSeconds": 1.8
}
```
**Example**
```json
{
"text": ".... .. / - .... . .-. ."
}
```
Result:
```json
{
"mode": "decode",
"result": "HI THERE",
"unrecognized": 0
}
```
### `text_number_to_words` — Number to words (English & Arabic)
Spell a number in words in English and Arabic: English cardinal (with decimals, optional British "and"), ordinal (twenty-first), cheque wording for an amount in a currency (cents in words or as 25/100, optional "only"), Arabic cardinal, and Arabic tafqeet for amounts with correct gender/number agreement of the currency noun (optional "faqat … la ghayr" wrapper and the modern 100 spelling). Currencies: JOD, USD, SAR, AED, KWD, EGP, GBP (or none). Accepts Arabic-Indic digits and thousands separators. Up to 999 trillion (15 digits). Web version: https://s3eidat.github.io/number-words/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `number` | string \| number | yes | The number or amount, e.g. "1500.250", "1,234,567.89", -12.05 (Arabic-Indic digits work too). |
| `currency` | "none" \| "JOD" \| "USD" \| "SAR" \| "AED" \| "KWD" \| "EGP" \| "GBP" | no (default `"none"`) | Currency for cheque / tafqeet wording: none (default), JOD, USD, SAR, AED, KWD, EGP, GBP. |
| `only` | boolean | no (default `false`) | Add "only" (English) and the Arabic "faqat … la ghayr" wrapper to amounts. |
| `british` | boolean | no (default `false`) | British English "and": one hundred and five. |
| `subStyle` | "words" \| "fraction" | no (default `"words"`) | Cheque sub-units in words (twenty-five cents) or as a fraction (25/100). |
| `modernHundred` | boolean | no (default `false`) | Arabic: use the modern spelling of "hundred" (without the extra alif). |
**Output**
| Field | Type | Description |
|---|---|---|
| `digits` | string | The number as parsed, with thousands separators. |
| `english` | string | English cardinal words. |
| `ordinal` | string | English ordinal (whole non-negative numbers only). |
| `ordinalShort` | string | Ordinal in digits, e.g. 21st. |
| `arabic` | string | Arabic cardinal words. |
| `englishAmount` | string | Cheque wording in the currency (when a currency is set). |
| `arabicAmount` | string | Arabic tafqeet of the amount (when a currency is set). |
**Example**
```json
{
"number": "21"
}
```
Result:
```json
{
"digits": "21",
"english": "twenty-one",
"ordinal": "twenty-first",
"ordinalShort": "21st",
"arabic": "واحد وعشرون"
}
```
**Example** — englishAmount: "One thousand five hundred dollars and twenty-five cents", plus the Arabic tafqeet
```json
{
"number": "1500.25",
"currency": "USD"
}
```
Result:
```json
{
"digits": "1,500.25 USD",
"english": "one thousand five hundred point two five",
"arabic": "ألف وخمسمائة فاصلة خمسة وعشرون",
"englishAmount": "One thousand five hundred dollars and twenty-five cents",
"arabicAmount": "ألف وخمسمائة دولار وخمسة وعشرون سنتاً"
}
```
### `text_readability` — Readability score
Score how easy an English text is to read: Flesch Reading Ease, Flesch-Kincaid Grade, Gunning Fog, SMOG, Coleman-Liau and Automated Readability Index (same formulas, sentence splitter and syllable estimate as the website), plus a verdict, average grade level, and Hemingway-style hints: long sentences (over 20 / 30 words), passive voice and adverbs. The formulas are built for English; for Arabic text the result says so (arabicWarning). Give "text" or a text file "path". Web version: https://s3eidat.github.io/readability/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The text to score. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
**Output**
| Field | Type | Description |
|---|---|---|
| `readingEase` | number \| null | Flesch Reading Ease clamped to 0–100 and rounded (the big number on the website). |
| `verdict` | string \| null | |
| `verdictLevel` | "ok" \| "warn" \| "bad" \| null | |
| `advice` | string \| null | |
| `averageGrade` | number \| null | Mean of the five grade-level formulas. |
| `averageGradeText` | string | |
| `scores` | object \| null | |
| `words` | number | |
| `sentences` | number | |
| `syllablesPerWord` | number \| null | |
| `wordsPerSentence` | number \| null | |
| `longSentences` | object[] | Sentences over 20 (hard) or 30 (vhard) words. |
| `passive` | string[] | Passive-voice phrases found. |
| `adverbs` | string[] | Adverbs found (-ly words, with common non-adverbs excluded). |
| `tips` | string[] | |
| `smogNote` | string | |
| `arabicWarning` | string | |
**Example** — Returns all six scores, the verdict and hints.
```json
{
"text": "Keep it short. Use plain words. Readers scan, so put the main point first and cut what they don't need."
}
```
Result:
```json
{
"readingEase": 100,
"verdict": "Very easy",
"verdictLevel": "ok",
"advice": "Short sentences and everyday words. Almost anyone can follow it.",
"averageGrade": 1.7,
"averageGradeText": "grade 2 · age 7–8",
"scores": {
"fleschReadingEase": 111.2,
"fleschKincaidGrade": {
"score": -0.6,
"grade": "kindergarten"
},
"gunningFog": {
"score": 2.7,
"grade": "grade 3 · age 8–9"
},
"smog": {
"score": 3.1,
"grade": "grade 3 · age 8–9"
},
"colemanLiau": {
"score": 3,
"grade": "grade 3 · age 8–9"
},
"automatedReadability": {
"score": 0.5,
"grade": "grade 1 · age 6–7"
}
},
"words": 20,
"sentences": 3,
"syllablesPerWord": 1.05,
"wordsPerSentence": 6.7,
"longSentences": [],
"passive": [],
"adverbs": [],
"tips": [
"No long sentences, passive voice or extra adverbs found."
],
"smogNote": "SMOG is designed for 30+ sentences; with 3 it is a rough estimate."
}
```
### `text_slugify` — Slugify
Turn titles into clean URL slugs, one slug per non-empty line (bulk). Folds accents (é → e, ß → ss), transliterates Arabic to Latin (the article al- becomes its own word) or keeps Arabic letters, converts Arabic-Indic digits, drops tashkeel, turns & into "and", can remove stop words (English and Arabic) and cap the length at a word boundary. Web version: https://s3eidat.github.io/slugify/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | yes | Title(s) to slugify. Each non-empty line becomes one slug. |
| `separator` | "-" \| "_" \| "." | no (default `"-"`) | Word separator: dash (default), underscore or dot. |
| `lowercase` | boolean | no (default `true`) | Lowercase the slug (default true). |
| `foldAccents` | boolean | no (default `true`) | Transliterate accents: é → e, ß → ss, æ → ae (default true). |
| `removeStopWords` | boolean | no (default `false`) | Remove stop words in English and Arabic such as the, of, and (kept if nothing else is left). |
| `arabic` | "latin" \| "keep" | no (default `"latin"`) | "latin" transliterates Arabic letters (default); "keep" keeps them. |
| `maxLength` | integer | no (default `0`) | Maximum slug length in characters, cut at a word boundary (0 = no limit). |
**Output**
| Field | Type | Description |
|---|---|---|
| `slugs` | object[] | |
**Example**
```json
{
"text": "Crème Brûlée & Café au Lait: A Love Story"
}
```
Result:
```json
{
"slugs": [
{
"title": "Crème Brûlée & Café au Lait: A Love Story",
"slug": "creme-brulee-and-cafe-au-lait-a-love-story",
"length": 42,
"encodedLength": 42
}
]
}
```
**Example** — lord-rings
```json
{
"text": "The Lord of the Rings",
"removeStopWords": true
}
```
Result:
```json
{
"slugs": [
{
"title": "The Lord of the Rings",
"slug": "lord-rings",
"length": 10,
"encodedLength": 10
}
]
}
```
### `text_social_count` — Social media character counter
Check a post against platform limits the way the platforms count: X/Twitter weighted length (links = 23, emoji = 2, CJK = 2; limit 280), Threads 500, Bluesky 300, Instagram 2,200 (+ 30 hashtags), LinkedIn 3,000, Facebook 63,206, TikTok 4,000, YouTube title 100 / description 5,000, Pinterest 500, Google title ~60, meta description ~160. Characters are counted as user-perceived graphemes (one emoji = 1). Also: words, hashtags, mentions, links, emoji, and SMS encoding (GSM-7 vs Unicode) with the number of SMS parts and the characters that force Unicode. Give "text" or a text file "path". Web version: https://s3eidat.github.io/social-counter/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The post text. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
| `platforms` | ("x" \| "threads" \| "bsky" \| "ig" \| "li" \| "fb" \| "tt" \| "yt" \| "ytd" \| "pin" \| "gt" \| "gd")[] | no | Only these meters: x, threads, bsky, ig, li, fb, tt, yt, ytd, pin, gt (Google title), gd (meta description). Default: all. |
| `gsmLookalikes` | boolean | no (default `false`) | Also return the text with curly quotes, dashes, ellipses, odd spaces etc. replaced by GSM-7 look-alikes (cheaper SMS). |
**Output**
| Field | Type | Description |
|---|---|---|
| `characters` | number | |
| `words` | number | |
| `hashtags` | number | |
| `mentions` | number | |
| `links` | number | |
| `emoji` | number | |
| `lines` | number | |
| `utf16Units` | number | |
| `xWeightedLength` | number | |
| `platforms` | object[] | |
| `sms` | object | |
| `gsmText` | string | |
**Example** — xWeightedLength 48: the link counts 23 and the emoji 2.
```json
{
"text": "Read it here: https://example.com/blog/code-reviews 🚀 #coding",
"platforms": [
"x"
]
}
```
Result:
```json
{
"characters": 61,
"words": 9,
"hashtags": 1,
"mentions": 0,
"links": 1,
"emoji": 1,
"lines": 1,
"utf16Units": 62,
"xWeightedLength": 48,
"platforms": [
{
"id": "x",
"name": "X (Twitter) post",
"count": 48,
"limit": 280,
"softLimit": false,
"remaining": 232,
"over": 0,
"status": "ok",
"notes": [
"Weighted: links 23, emoji 2, CJK 2. Premium allows 25,000."
]
}
],
"sms": {
"encoding": "UCS-2",
"parts": 1,
"unitsUsed": 62,
"perPart": 70,
"leftInPart": 8,
"nonGsmCharacters": [
{
"char": "🚀",
"count": 1
}
]
}
}
```
### `text_word_count` — Word count
Count words, characters (with and without spaces), sentences, paragraphs, lines and unique words; estimate reading (238 wpm) and speaking (150 wpm) time; list the most used keywords with density. Works for English and Arabic (tashkeel ignored). Give "text" or a text file "path". Web version: https://s3eidat.github.io/word-count/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The text to analyse. |
| `path` | string | no | Or: a path to a UTF-8 text file. |
| `keywords` | integer | no (default `12`) | How many top keywords to return (0 = none). |
| `includeStopWords` | boolean | no (default `false`) | Count common words like "the"/"في" as keywords. |
**Output**
| Field | Type | Description |
|---|---|---|
| `words` | number | |
| `characters` | number | |
| `charactersNoSpaces` | number | |
| `sentences` | number | |
| `paragraphs` | number | |
| `lines` | number | |
| `uniqueWords` | number | |
| `averageWordLength` | number | |
| `longestWord` | string | |
| `readingTimeSeconds` | number | |
| `speakingTimeSeconds` | number | |
| `keywords` | object[] | |
**Example** — 11 words, 4 sentences, 2 paragraphs
```json
{
"text": "Hello world. This is a test! Is it?\n\nNew paragraph here."
}
```
Result:
```json
{
"words": 11,
"characters": 56,
"charactersNoSpaces": 45,
"sentences": 4,
"paragraphs": 2,
"lines": 3,
"uniqueWords": 10,
"averageWordLength": 3.73,
"longestWord": "paragraph",
"readingTimeSeconds": 3,
"speakingTimeSeconds": 4,
"keywords": [
{
"word": "hello",
"count": 1,
"density": 9.09
},
{
"word": "new",
"count": 1,
"density": 9.09
},
{
"word": "paragraph",
"count": 1,
"density": 9.09
},
{
"word": "test",
"count": 1,
"density": 9.09
},
{
"word": "world",
"count": 1,
"density": 9.09
}
]
}
```
## Developer: data formats
JSON, CSV, YAML, XML, SQL, HTML/CSS formatting and conversion, types from JSON, curl to code.
| Tool | What it does |
|---|---|
| [`css_format`](#css_format) | CSS beautify / minify |
| [`csv_to_json`](#csv_to_json) | CSV to JSON |
| [`curl_to_code`](#curl_to_code) | cURL to code |
| [`html_format`](#html_format) | HTML beautify / minify |
| [`json_format`](#json_format) | JSON format / minify / validate |
| [`json_query`](#json_query) | JSON query (JSONPath) |
| [`json_to_csv`](#json_to_csv) | JSON to CSV |
| [`json_to_types`](#json_to_types) | JSON to types (TypeScript, Go, Python, Zod) |
| [`json_to_yaml`](#json_to_yaml) | JSON to YAML |
| [`markdown_table`](#markdown_table) | Markdown table |
| [`markdown_table_parse`](#markdown_table_parse) | Markdown table to JSON / CSV |
| [`sql_format`](#sql_format) | SQL format / minify |
| [`xml_format`](#xml_format) | XML format / minify / validate / to JSON |
| [`xml_query`](#xml_query) | XML XPath query |
| [`yaml_to_json`](#yaml_to_json) | YAML to JSON |
### `css_format` — CSS beautify / minify
Beautify CSS (one declaration per line, one selector per line, blank line between top-level rules, nested @media blocks) or minify it. Strings, url(...) and escapes are kept intact; calc() spacing is preserved. Optional comment removal (/*! … */ kept). Give "text" or a file "path". Web version: https://s3eidat.github.io/html-css-format/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The CSS as inline text. |
| `path` | string | no | Or: a path to a CSS file (UTF-8; use this for big inputs). |
| `mode` | "beautify" \| "minify" | no (default `"beautify"`) | "beautify" (default) or "minify". |
| `indent` | "2" \| "4" \| "tab" \| integer | no (default `"2"`) | Indentation: 2, 4, "tab" (or any number of spaces 0-8). |
| `removeComments` | boolean | no (default `false`) | Drop comments (/*! … */ license comments are kept). |
| `output` | string | no | Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file. |
**Output**
| Field | Type | Description |
|---|---|---|
| `inputBytes` | number | |
| `outputBytes` | number | |
| `lines` | number | |
| `result` | string | The converted / formatted text (left out when written to a file). |
| `path` | string | Absolute path of the written file, when "output" was given or the result was too big to inline. |
| `bytes` | number | Size of the written file in bytes. |
**Example**
```json
{
"text": "a,b{color:red;margin:0 auto}"
}
```
Result:
```json
{
"result": "a,\nb {\n color: red;\n margin: 0 auto;\n}"
}
```
### `csv_to_json` — CSV to JSON
Convert CSV/TSV to JSON with an RFC 4180 parser (quoted fields, "" escapes, line breaks inside quotes, CR/LF/CRLF, BOM). Detects the delimiter (comma, semicolon, tab, pipe), uses the first row as headers (blank → column_N, duplicates → name_2), and can type values (numbers, true/false, null; long digit strings like IDs stay strings). Output: array of objects or array of arrays, pretty-printed. Give "text" or a file "path". Web version: https://s3eidat.github.io/csv-json/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `text` | string | no | The CSV as inline text. |
| `path` | string | no | Or: a path to a CSV/TSV file (UTF-8; use this for big inputs). |
| `delimiter` | "auto" \| "," \| ";" \| "tab" \| "\t" \| "\|" | no (default `"auto"`) | Delimiter: "auto" (detect), ",", ";", "tab" or "\|". |
| `header` | boolean | no (default `true`) | First row is a header (default true). |
| `types` | boolean | no (default `true`) | Turn numbers, true/false and empty/null into JSON types (default true). |
| `shape` | "objects" \| "arrays" | no (default `"objects"`) | "objects" (one object per row) or "arrays" (rows as arrays). |
| `output` | string | no | Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file. |
**Output**
| Field | Type | Description |
|---|---|---|
| `rows` | number | |
| `columns` | string[] | |
| `delimiter` | string | |
| `ragged` | boolean | Some rows have a different number of fields. |
| `result` | string | The converted / formatted text (left out when written to a file). |
| `path` | string | Absolute path of the written file, when "output" was given or the result was too big to inline. |
| `bytes` | number | Size of the written file in bytes. |
**Example**
```json
{
"text": "id,zip,ok\n1,007,true"
}
```
Result:
```json
{
"rows": 1,
"columns": [
"id",
"zip",
"ok"
],
"delimiter": "comma",
"ragged": false,
"result": "[\n {\n \"id\": 1,\n \"zip\": \"007\",\n \"ok\": true\n }\n]"
}
```
### `curl_to_code` — cURL to code
Convert a curl command (bash/zsh quoting incl. $'…', line continuations, "Copy as cURL" from browsers) into code for JavaScript fetch, axios, Python requests, PHP cURL, Go net/http or Node.js http/https: every target the website supports. Understands -X, -H, -d/--data-raw/--data-binary/--data-urlencode, --json, -F forms and files, -u, -b, -A, -e, -G, -I, -k, -L, -m, --connect-timeout, -x, -T, --compressed, --oauth2-bearer. Also returns the parsed request (secrets masked unless revealSecrets) and notes on what could not be converted. Only parses text; never sends the request. Web version: https://s3eidat.github.io/curl-convert/
Hints: readOnly, idempotent
**Inputs**
| Name | Type | Required | Description |
|---|---|---|---|
| `command` | string | yes | The curl command, e.g. "curl -X POST https://api.example.com -H 'Content-Type: application/json' -d '{"a":1}'". |
| `language` | "fetch" \| "axios" \| "python" \| "php" \| "go" \| "node" \| "all" | no (default `"fetch"`) | Target: fetch (browser/Node fetch), axios, python (requests), php (cURL), go (net/http), node (http/https), or "all". |
| `revealSecrets` | boolean | no (default `false`) | Show Authorization/Cookie/API-key header values and the basic-auth password in the parsed summary (the code always contains them). |
| `output` | string | no | Optional: write the code to this file (single language only). |
**Output**
| Field | Type | Description |
|---|---|---|
| `method` | string | |
| `url` | string | |
| `headers` | object[] | |
| `body` | string \| null | |
| `basicAuth` | object | |
| `warnings` | string[] | |
| `notConverted` | string[] | curl options with no equivalent in the generated code. |
| `code` | string | |
| `codes` | object | With language "all": code per target. |
| `path` | string | |
| `bytes` | number | |
**Example** — requests.get(url, auth=("user", "pass"))
```json
{
"command": "curl -u user:pass https://s3eidat.github.io",
"language": "python"
}
```
Result:
```json
{
"method": "GET",
"url": "https://s3eidat.github.io",
"headers": [],
"body": null,
"basicAuth": {
"user": "user",
"password": "••••••••"
},
"warnings": [],
"notConverted": [],
"code": "import requests\n\nurl = \"https://s3eidat.github.io\"\n\nresponse = requests.get(url, auth=(\"user\", \"pass\"))\nprint(response.status_code)\nprint(response.text)"
}
```
### `html_format` — HTML beautify / minify
Beautify (indent block elements, keep inline runs on one line) or minify HTML with a forgiving tokenizer: implied end tags (,
, …), void elements, and |