SimplyUtils

Validate JSON and return it pretty-printed or minified, optionally with object keys sorted A-Z (recursively; array order is kept). Returns the formatted JSON as text. Invalid JSON returns an error naming the problem and its position. Input up to 100 KB.

{
  "type": "object",
  "properties": {
    "json": {
      "type": "string",
      "description": "The JSON text to validate and format"
    },
    "indent": {
      "default": "2",
      "description": "2 or 4 spaces, a tab, or minify to remove all whitespace",
      "type": "string",
      "enum": [
        "2",
        "4",
        "tab",
        "minify"
      ]
    },
    "sortKeys": {
      "default": false,
      "description": "Sort object keys alphabetically at every level",
      "type": "boolean"
    }
  },
  "required": [
    "json"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Make a static QR code for a link or any text, up to 800 UTF-8 bytes. Returns a 512 px PNG image plus the SVG markup. The data is stored in the code itself, so it never expires and needs no account. Light-on-dark colors are allowed, but some older scanners need dark on light. Errors are returned for empty text, content over 800 bytes, or colors that are not six-digit hex.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Link or text to encode"
    },
    "errorCorrection": {
      "default": "M",
      "description": "Error correction: L 7%, M 15%, Q 25%, H 30% of the code can be damaged and still scan; higher is denser",
      "type": "string",
      "enum": [
        "L",
        "M",
        "Q",
        "H"
      ]
    },
    "foreground": {
      "default": "#000000",
      "description": "Six-digit hex color for the modules",
      "type": "string"
    },
    "background": {
      "default": "#ffffff",
      "description": "Six-digit hex color for the background",
      "type": "string"
    }
  },
  "required": [
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Convert a number between two units of the same category and return a line such as "5 mi = 8.04672 km" (up to 10 significant digits). Units are matched by symbol or name, case-insensitive. Errors are returned for unknown units, units from another category, non-numeric values and temperatures below absolute zero. Months are 1/12 of a 365-day year. Units by category (symbols): length: m, km, mi, ft, in, cm, mm, yd, nmi; weight: kg, g, lb, oz, t, mg, st; temperature: °C, °F, K; volume: L, mL, gal, fl oz, cup, tbsp, m³; speed: km/h, mph, m/s, kn, ft/s; area: m², km², mi², ft², ac, ha; data: B, KB, MB, GB, TB, bit, KiB, MiB, GiB, TiB; time: s, min, h, d, wk, mo, yr, ms.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string",
      "description": "A plain number such as 12.5, -40 or 1e6 (no commas or unit text)"
    },
    "category": {
      "type": "string",
      "enum": [
        "length",
        "weight",
        "temperature",
        "volume",
        "speed",
        "area",
        "data",
        "time"
      ],
      "description": "The kind of quantity; both units must belong to it"
    },
    "from": {
      "type": "string",
      "description": "Unit symbol or name, e.g. km or kilometer"
    },
    "to": {
      "type": "string",
      "description": "Unit symbol or name, e.g. mi or mile"
    }
  },
  "required": [
    "value",
    "category",
    "from",
    "to"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Generate random passwords with Node's cryptographically secure generator. Each enabled character set appears at least once and the result is shuffled. Returns one password per line; every call gives new results. An error is returned if all character sets are turned off. Passwords are not stored or logged.

{
  "type": "object",
  "properties": {
    "length": {
      "default": 16,
      "description": "Characters per password, 8-128",
      "type": "integer",
      "minimum": 8,
      "maximum": 128
    },
    "count": {
      "default": 1,
      "description": "How many passwords to generate, 1-20",
      "type": "integer",
      "minimum": 1,
      "maximum": 20
    },
    "uppercase": {
      "default": true,
      "description": "Include A-Z",
      "type": "boolean"
    },
    "lowercase": {
      "default": true,
      "description": "Include a-z",
      "type": "boolean"
    },
    "numbers": {
      "default": true,
      "description": "Include 0-9",
      "type": "boolean"
    },
    "symbols": {
      "default": true,
      "description": "Include symbols such as !@#$%^&*",
      "type": "boolean"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Generate random version 4 UUIDs (RFC 9562) in lowercase 8-4-4-4-12 form, one per line. Every call gives new values.

{
  "type": "object",
  "properties": {
    "count": {
      "default": 1,
      "description": "How many UUIDs to generate, 1-50",
      "type": "integer",
      "minimum": 1,
      "maximum": 50
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Hash text (encoded as UTF-8) and return a line such as 'sha256: ba78...' with the lowercase hex digest. The same input always gives the same hash. MD5 and SHA-1 are only for checksums, not security; do not use plain hashes to store passwords. Input up to 100 KB.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The exact text to hash; spaces and line breaks change the result"
    },
    "algorithm": {
      "default": "sha256",
      "description": "Hash algorithm; sha256 is the usual choice",
      "type": "string",
      "enum": [
        "md5",
        "sha1",
        "sha256",
        "sha384",
        "sha512"
      ]
    }
  },
  "required": [
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Encode text (as UTF-8) to Base64, or decode Base64 back to text, and return the result. Decoding accepts standard and URL-safe alphabets and ignores whitespace; invalid Base64 returns an error. Bytes that are not valid UTF-8 are shown as replacement characters. Input up to 100 KB.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to encode, or Base64 to decode"
    },
    "mode": {
      "type": "string",
      "enum": [
        "encode",
        "decode"
      ],
      "description": "encode: text to Base64; decode: Base64 to text"
    },
    "urlSafe": {
      "default": false,
      "description": "When encoding, use - and _ and drop = padding (for URLs and JWTs)",
      "type": "boolean"
    }
  },
  "required": [
    "text",
    "mode"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Run a JavaScript (ECMAScript) regular expression against text. Returns the match count and, for each match, the matched text, its 0-based index, numbered capture groups and named groups. Returns 'No matches.' when nothing matches. All matches are listed (the g flag is added automatically), up to 200. Invalid patterns or flags return an error explaining why; patterns that run longer than 0.5 seconds are stopped with an error. Text up to 100 KB.

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "The pattern without surrounding slashes, for example (\\d+)-(?<unit>[a-z]+)"
    },
    "flags": {
      "default": "g",
      "description": "Any of d, g, i, m, s, u, v, y; for example gi for case-insensitive",
      "type": "string"
    },
    "text": {
      "type": "string",
      "description": "The text to search"
    }
  },
  "required": [
    "pattern",
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Convert a Unix timestamp or a date to Unix seconds, Unix milliseconds, ISO 8601 (UTC), an HTTP-style UTC string and a readable date in the chosen time zone. Numbers with 13 or more digits are read as milliseconds, shorter ones as seconds. Dates without a time zone are read as UTC. Errors are returned for unreadable dates and unknown time zones.

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string",
      "description": "e.g. 1767225600 or 2026-10-27T09:30:00Z"
    },
    "timeZone": {
      "default": "UTC",
      "description": "IANA time zone, e.g. Asia/Kolkata",
      "type": "string"
    }
  },
  "required": [
    "value"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Count words, characters (with and without spaces), sentences and paragraphs, and estimate reading time at 238 words per minute. Words are runs of letters or digits in any language; hyphenated words and contractions count once. Paragraphs are separated by blank lines. Input up to 100 KB.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "The text to analyze"
    }
  },
  "required": [
    "text"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}