{
  "openapi": "3.0.3",
  "info": {
    "title": "Security and Developer Utilities API",
    "version": "1.5.1",
    "description": "Hashes, UUIDs, JWT decode, passwords, Base64, URL and HTML encoding, regex, JSON, QR and barcodes. Small, exact developer helpers as JSON endpoints: hash text (MD5 and the SHA family), generate UUIDs, random numbers and passwords and score password strength, decode a JWT without verifying it, encode and decode Base64, URLs, HTML entities and binary, test a regex, format JSON, minify code, diff two texts, look up HTTP status codes, parse a user agent, and make QR codes and Code 128 barcodes. Everything runs in memory and nothing is stored. One X-API-Key header authenticates every call, and the same key works across every FreeDailyPro API. Every 4xx response is documented and none of them is billed.",
    "contact": {
      "name": "FreeDailyPro",
      "url": "https://www.freedailypro.com/developers",
      "email": "support@freedailypro.com"
    },
    "termsOfService": "https://www.freedailypro.com/terms",
    "x-logo": {
      "url": "https://www.freedailypro.com/favicon.ico"
    }
  },
  "servers": [
    {
      "url": "https://api.freedailypro.com",
      "description": "Production"
    }
  ],
  "externalDocs": {
    "description": "Developer hub, plans and MCP setup",
    "url": "https://www.freedailypro.com/developers"
  },
  "components": {
    "securitySchemes": {
      "ApiKeyAuth": {
        "type": "apiKey",
        "in": "header",
        "name": "X-API-Key"
      }
    }
  },
  "tags": [
    {
      "name": "Security & Developer Utilities",
      "description": "Hashes, UUIDs, JWT decode, passwords, Base64, URL and HTML encoding, regex, JSON, QR and barcodes."
    }
  ],
  "paths": {
    "/v1/text/password": {
      "post": {
        "summary": "Generate a random password with the length and character sets you choose",
        "operationId": "textPassword",
        "description": "Send 'length' (4 to 128, default 16) and which types to use ('uppercase', 'lowercase', 'numbers', 'symbols', all on by default). The first version's response fields 'password' and 'strength' are unchanged; 'strength' is the original rule of thumb from length and the number of types on. The same code as the website now draws the password, so every selected type is present and every password that meets your settings is equally likely (the first version could leave a type out). Additive request fields: 'excludeSimilar' (leave out I l 1 O 0 o |), 'symbolSet' (the symbols to use; remove any a site rejects) and 'count' (1 to 10; the first is 'password', and with more than one they are all in 'passwords'). Additive response fields: 'entropyBits' (exact: log2 of the number of passwords your settings allow), 'alphabetSize', 'entropyWorking' (the arithmetic in plain lines, length x log2(alphabet size), then the correction for requiring every type), 'strengthByEntropy' (Weak under 45 bits, Medium from 45, Strong from 70, Very Strong from 100), 'crackTimeAtTenBillionGuessesPerSecond' with 'crackTimeAssumption' (an offline attack on a fast-hashed copy, average case; a slow hash is far slower, a leaked plain-text password makes it meaningless, and it holds only for a password drawn at random like this one) and 'generator'. Where the passwords are made: on the website they are made in the browser with crypto.getRandomValues and are never sent or stored; through this API a password has to be returned in the response, over HTTPS, and the API's usage log records the operation name, not the password. If the password will protect something that matters, make it on the device that will use it. Passphrases (random words) are on the website only. Who calls it: onboarding and IT tools issuing temporary passwords, test-data builders, internal admin panels and MCP agents. Worked example: {\"length\":20,\"uppercase\":true,\"lowercase\":true,\"numbers\":true,\"symbols\":false} returns a 20-character letters-and-digits password with entropyBits 119.04 and strengthByEntropy Very Strong. Integration scenario: an admin panel issues a temporary password for a new hire with excludeSimilar true so it can be read aloud, and forces a change at first sign-in. Stateless: the request is processed in memory and nothing is stored. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "length": {
                    "type": "number",
                    "minimum": 4,
                    "maximum": 128
                  },
                  "uppercase": {
                    "type": "boolean"
                  },
                  "lowercase": {
                    "type": "boolean"
                  },
                  "numbers": {
                    "type": "boolean"
                  },
                  "symbols": {
                    "type": "boolean"
                  },
                  "excludeSimilar": {
                    "description": "Leave out look-alike characters (I l 1 O 0 o |).",
                    "type": "boolean"
                  },
                  "symbolSet": {
                    "description": "The symbols to use when symbols is on (default !@#$%^&*()_+-=[]{}|;:,.<>?). Remove any character a website rejects.",
                    "type": "string",
                    "maxLength": 64
                  },
                  "count": {
                    "description": "How many passwords, 1 to 10. The first is 'password'; with more than one they are all in 'passwords'.",
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 10
                  }
                },
                "additionalProperties": false
              },
              "example": {
                "length": 20,
                "uppercase": true,
                "lowercase": true,
                "numbers": true,
                "symbols": false
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "password": {
                      "type": "string",
                      "description": "The generated password (the first one when count > 1)"
                    },
                    "passwords": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "description": "A generated password"
                      },
                      "description": "All passwords, when count is more than 1"
                    },
                    "strength": {
                      "type": "string",
                      "description": "Strength label"
                    },
                    "entropyBits": {
                      "type": "number",
                      "description": "Estimated entropy in bits"
                    },
                    "alphabetSize": {
                      "type": "number",
                      "description": "Number of distinct characters the generator draws from"
                    },
                    "strengthByEntropy": {
                      "type": "string",
                      "description": "Strength label from the entropy"
                    },
                    "entropyWorking": {
                      "type": "array",
                      "items": {
                        "type": "string",
                        "description": "One line of the entropy working"
                      },
                      "description": "How entropyBits was worked out"
                    },
                    "crackTimeAtTenBillionGuessesPerSecond": {
                      "type": "string",
                      "description": "Time to guess by brute force at the stated rate"
                    },
                    "crackTimeAssumption": {
                      "type": "string",
                      "description": "What the crack time assumes"
                    },
                    "generator": {
                      "type": "string",
                      "description": "Which random generator was used"
                    }
                  },
                  "required": [
                    "password",
                    "strength"
                  ]
                },
                "example": {
                  "tool": "Password generator client and server side from freedailypro",
                  "password": "6OYIZX4DACfWCZrSZTKB",
                  "strength": "Strong"
                }
              }
            }
          },
          "400": {
            "description": "No character type selected, a length outside 4 to 128 or shorter than the number of selected types, a count outside 1 to 10, or settings that leave fewer than 2 possible characters; the body says which Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/hash": {
      "post": {
        "summary": "Hash text with MD5, SHA-1, SHA-256, SHA-384 or SHA-512",
        "operationId": "securityHash",
        "description": "Hash text with MD5, SHA-1, SHA-256, SHA-384 or SHA-512. Send JSON with text (required); optional: algorithm. Returns JSON with the answer as a string in result. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "algorithm": {
                    "type": "string",
                    "enum": [
                      "md5",
                      "sha1",
                      "sha256",
                      "sha384",
                      "sha512"
                    ]
                  }
                },
                "required": [
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "hello world",
                "algorithm": "sha256"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Hash generator client and server side from freedailypro",
                  "algorithm": "sha256",
                  "result": "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/uuid": {
      "post": {
        "summary": "Generate one or more random version 4 UUIDs",
        "operationId": "securityUuid",
        "description": "Generate one or more random version 4 UUIDs. Send JSON with no required fields; optional: count. Returns JSON: a list. Limits: count: at most 1000, at least 1. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "count": {
                    "description": "How many random version 4 UUIDs, a whole number from 1 to 1000 (default 1). A fraction such as 2.5 or a value outside 1-1000 is a 400. count 1 (or omitted) returns 'result' as a single string; 2 or more returns an array of strings.",
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 1000
                  }
                },
                "additionalProperties": false
              },
              "example": {
                "count": 3
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Uuid generator client and server side from freedailypro",
                  "result": [
                    "d16bc9ea-bbe9-4255-a727-4c2ba81d14a1",
                    "e65b9b37-e1e3-42bf-b3a9-24b382c2ac26",
                    "c4ce58d7-46c7-45b6-8d79-b78b971c2112"
                  ]
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/base64": {
      "post": {
        "summary": "Encode text to Base64 or decode Base64 back to text",
        "operationId": "securityBase64",
        "description": "Encode text to Base64 or decode Base64 back to text. Send JSON with text, action (required). Returns JSON with the answer as a string in result. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "description": "For 'encode': any text (encoded as UTF-8). For 'decode': Base64, standard (+ /) or URL-safe (- _), with or without '=' padding; line breaks and spaces are ignored. Text with characters outside the Base64 alphabet, wrong padding, an impossible length, or bytes that are not UTF-8 text is a 400 ({error, code: 'invalid_base64'})."
                  },
                  "action": {
                    "type": "string",
                    "enum": [
                      "encode",
                      "decode"
                    ],
                    "description": "encode: text to Base64. decode: Base64 to text."
                  }
                },
                "required": [
                  "text",
                  "action"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "FreeDailyPro",
                "action": "encode"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Base64 tool client and server side from freedailypro",
                  "action": "encode",
                  "result": "RnJlZURhaWx5UHJv"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/json-format": {
      "post": {
        "summary": "Validate JSON and return it pretty-printed with the indent you choose",
        "operationId": "securityJsonFormat",
        "description": "Validate JSON and return it pretty-printed with the indent you choose. Send JSON with text (required); optional: indent. Returns JSON with valid, formatted, stats. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string"
                  },
                  "indent": {
                    "anyOf": [
                      {
                        "type": "number",
                        "minimum": 0,
                        "maximum": 8
                      },
                      {
                        "type": "string",
                        "enum": [
                          "minify"
                        ]
                      }
                    ]
                  }
                },
                "required": [
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "{\"name\":\"Ada\",\"skills\":[\"math\",\"code\"],\"active\":true}",
                "indent": 2
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Json formatter client and server side from freedailypro",
                  "valid": true,
                  "formatted": "{\n  \"name\": \"Ada\",\n  \"skills\": [\n    \"math\",\n    \"code\"\n  ],\n  \"active\": true\n}",
                  "stats": {
                    "keys": 3,
                    "depth": 3
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/regex": {
      "post": {
        "summary": "Test a regular expression against text and return the matches and groups",
        "operationId": "securityRegex",
        "description": "Test a regular expression against text and return the matches and groups. Send JSON with pattern, text (required); optional: flags. Returns JSON with valid, matches, matchCount, groups. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "pattern": {
                    "type": "string",
                    "minLength": 1,
                    "description": "The regular expression (JavaScript syntax), up to 2,000 characters (longer is a 422 Unprocessable Content, not billed). A pattern that does not compile is a 400 with {error, code: 'invalid_regex', valid: false}."
                  },
                  "text": {
                    "type": "string",
                    "description": "The text to search, up to 1,000,000 characters (longer is a 422 Unprocessable Content, not billed). At most 100,000 matches are returned; when the limit is hit the response has truncated: true and matchLimit."
                  },
                  "flags": {
                    "description": "Optional flags, each at most once: g (all matches), i (ignore case), m (multiline), s (dot matches newline), u (unicode), y (sticky). Default 'g'. An unknown or repeated flag is a 400 ({error, code: 'invalid_flags'}); send an empty string for no flags (first match only).",
                    "type": "string"
                  }
                },
                "required": [
                  "pattern",
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "pattern": "(\\d{4})-(\\d{2})-(\\d{2})",
                "text": "Invoice dated 2026-10-30, due 2026-11-29.",
                "flags": "g"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Regex tester client and server side from freedailypro",
                  "valid": true,
                  "matches": [
                    "2026-10-30",
                    "2026-11-29"
                  ],
                  "matchCount": 2,
                  "groups": [
                    [
                      "2026",
                      "10",
                      "30"
                    ],
                    [
                      "2026",
                      "11",
                      "29"
                    ]
                  ]
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/url": {
      "post": {
        "summary": "URL-encode or decode text",
        "operationId": "securityUrl",
        "description": "URL-encode or decode text. Send JSON with text, action (required); optional: component. Returns JSON with the answer as a string in result. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "description": "The text to percent-encode, or the percent-encoded text to decode. Decoding text with a malformed sequence (a lone % or %zz) or bytes that are not UTF-8 is a 400 ({error, code: 'invalid_url_encoding'})."
                  },
                  "action": {
                    "type": "string",
                    "enum": [
                      "encode",
                      "decode"
                    ],
                    "description": "encode: text to percent-encoding. decode: percent-encoding back to text."
                  },
                  "component": {
                    "description": "true (default): treat the text as one URL part (encodeURIComponent / decodeURIComponent), so / ? & = # are encoded. false: treat it as a whole URL (encodeURI / decodeURI), keeping those characters.",
                    "type": "boolean"
                  }
                },
                "required": [
                  "text",
                  "action"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "name=Ana María&city=São Paulo",
                "action": "encode",
                "component": true
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Url encoder client and server side from freedailypro",
                  "action": "encode",
                  "result": "name%3DAna%20Mar%C3%ADa%26city%3DS%C3%A3o%20Paulo"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/diff": {
      "post": {
        "summary": "Compare two texts line by line and return the added and removed lines",
        "operationId": "securityDiff",
        "description": "Compare two texts line by line and return the added and removed lines. Send JSON with textA, textB (required). Returns JSON with lines, added, removed, equal, changes, identical (inside result). Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "textA": {
                    "type": "string"
                  },
                  "textB": {
                    "type": "string"
                  }
                },
                "required": [
                  "textA",
                  "textB"
                ],
                "additionalProperties": false
              },
              "example": {
                "textA": "The cat sat on the mat.\nIt was warm.",
                "textB": "The cat sat on the rug.\nIt was warm.\nThe end."
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Diff checker client and server side from freedailypro",
                  "result": {
                    "lines": [
                      {
                        "type": "remove",
                        "line": "The cat sat on the mat.",
                        "lineNumberA": 1
                      },
                      {
                        "type": "add",
                        "line": "The cat sat on the rug.",
                        "lineNumberB": 1
                      },
                      {
                        "type": "equal",
                        "line": "It was warm.",
                        "lineNumberA": 2,
                        "lineNumberB": 2
                      },
                      "..."
                    ],
                    "added": 2,
                    "removed": 1,
                    "equal": 1,
                    "changes": 3,
                    "identical": false
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/password-strength": {
      "post": {
        "summary": "Rate the strength of a password and return entropy and improvement tips",
        "operationId": "securityPasswordStrength",
        "description": "Rate the strength of a password and return entropy and improvement tips. Send JSON with password (required). Returns JSON with score, label, entropyBitsApprox, feedback (inside result). Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "password": {
                    "type": "string",
                    "description": "The password to rate. It is rated in memory and never stored or logged. The estimate is character-pool entropy minus penalties for repetition (aaaa, abcabc), sequences and keyboard runs (1234, qwerty) and common passwords (including look-alike swaps such as P@ssw0rd and a trailing 1 or !). Labels by estimated bits: under 28 Very Weak, under 36 Weak, under 60 Fair, under 80 Strong, otherwise Very Strong. It cannot know passwords leaked in breaches."
                  }
                },
                "required": [
                  "password"
                ],
                "additionalProperties": false
              },
              "example": {
                "password": "correct-horse-battery-staple"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Password strength client and server side from freedailypro",
                  "result": {
                    "score": 3,
                    "label": "Strong",
                    "entropyBitsApprox": 164,
                    "feedback": [
                      "Add uppercase letters",
                      "Add numbers"
                    ]
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/converters/random": {
      "post": {
        "summary": "Generate random numbers in a range, optionally without repeats",
        "operationId": "convertersRandom",
        "description": "The first version's request ('min', 'max', 'count' up to 1000, 'unique') is unchanged and still returns 'result', an array of whole numbers; every response now also names the 'generator' and says whether it is 'secure'. Without a seed the numbers come from Node's crypto (a cryptographically secure generator): whole numbers use crypto.randomInt, and decimals and the presets use crypto.getRandomValues with rejection sampling so every value is equally likely. Additive fields: 'decimals' (0 to 10) draws from every number with that many decimal places between min and max, both ends included (the limits are rounded inward onto that grid), and returns 'result' as numbers plus 'resultText' with the exact text of each (1.100, not 1.1) and a 'steps' array that shows the working; 'sort' returns ascending order; 'seed' makes the draw repeatable (the same seed and request give the same numbers) but switches to sfc32, which is NOT cryptographically secure, and the response says so with secure false: never use a seed for a raffle, a secret or a password. 'mode' picks a preset: dice with 'dice' as NdM or NdM+K (2d6, d20, 3d8+2) returns each roll, the sum and the total; coin with 'count' flips returns each flip and the heads and tails counts; lottery with 'pick' and 'of' returns that many different numbers from 1 to 'of', sorted, with 'oddsOneIn' (the exact 1 in C(of, pick)); list with 'items' (and 'pick', omitted to shuffle all) returns the picked items, each line its own entry. Who calls it: teachers picking students, giveaway and raffle tools (secure mode, no seed), tabletop and game apps, test-data builders, lottery quick-pick apps and MCP agents. Worked example: {\"min\":0.5,\"max\":1.5,\"count\":5,\"decimals\":3,\"seed\":\"demo\"} returns 1.354, 0.863, 1.100, 0.806 and 0.998 every time. Integration scenario: a classroom app draws a seeded order of presentations so a teacher can reproduce it, while a giveaway app calls the same endpoint with no seed and keeps the unrepeatable, secure result. A random pick does not predict a real lottery draw. Stateless: the request is processed in memory and nothing is stored. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "min": {
                    "description": "Smallest value, included. Default 1.",
                    "type": "number"
                  },
                  "max": {
                    "description": "Largest value, included. Default 100.",
                    "type": "number"
                  },
                  "count": {
                    "description": "How many numbers (or coin flips). 1 to 1000. Default 1.",
                    "type": "number",
                    "minimum": 1,
                    "maximum": 1000
                  },
                  "unique": {
                    "description": "No repeated numbers.",
                    "type": "boolean"
                  },
                  "decimals": {
                    "description": "Decimal places, 0 to 10. With more than 0 the result is the list of numbers and resultText holds the exact text of each. Default 0 (whole numbers).",
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 10
                  },
                  "sort": {
                    "description": "Return the numbers in ascending order.",
                    "type": "boolean"
                  },
                  "seed": {
                    "description": "Repeatable draws: the same seed gives the same numbers. A seed switches from the secure generator to sfc32, which is NOT cryptographically secure; never use it for secrets or raffles.",
                    "type": "string",
                    "maxLength": 200
                  },
                  "mode": {
                    "description": "numbers (default), dice, coin, lottery or list.",
                    "type": "string",
                    "enum": [
                      "numbers",
                      "dice",
                      "coin",
                      "lottery",
                      "list"
                    ]
                  },
                  "dice": {
                    "description": "mode dice: NdM with an optional modifier, such as 2d6, d20 or 3d8+2.",
                    "type": "string",
                    "maxLength": 40
                  },
                  "pick": {
                    "description": "mode lottery: how many different numbers to pick. mode list: how many items to pick (omit to shuffle all).",
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 100000
                  },
                  "of": {
                    "description": "mode lottery: the pool, numbers 1 to this.",
                    "type": "integer",
                    "minimum": 2,
                    "maximum": 100000
                  },
                  "items": {
                    "description": "mode list: the items to pick from or shuffle.",
                    "maxItems": 10000,
                    "type": "array",
                    "items": {
                      "type": "string",
                      "maxLength": 500
                    }
                  }
                },
                "additionalProperties": false
              },
              "example": {
                "min": 1,
                "max": 50,
                "count": 6,
                "unique": true
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Random number generator client and server side from freedailypro",
                  "result": [
                    29,
                    30,
                    28,
                    "..."
                  ]
                }
              }
            }
          },
          "400": {
            "description": "min above max, count outside 1 to 1000, more unique numbers than the range holds (the body says how many values exist), a range with no number at that many decimal places, a bad dice expression, a lottery pick larger than its pool, or a list pick larger than the list; the body says which Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/http-status/{code}": {
      "get": {
        "summary": "Look up one HTTP status code and return its phrase and category",
        "operationId": "securityHttpStatusCode",
        "description": "Look up one HTTP status code and return its phrase and category. Put the status code in the URL, for example /v1/security/http-status/404. Returns JSON with code, phrase, category, known (inside result). Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "parameters": [
          {
            "name": "code",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Http status reference client and server side from freedailypro",
                  "result": {
                    "code": 404,
                    "phrase": "Not Found",
                    "category": "Client Error",
                    "known": true
                  }
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/http-status": {
      "get": {
        "summary": "List every HTTP status code with its phrase and category",
        "operationId": "securityHttpStatus",
        "description": "List every HTTP status code with its phrase and category. No input needed. Returns JSON: a list. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Http status reference client and server side from freedailypro",
                  "result": [
                    {
                      "code": 100,
                      "phrase": "Continue",
                      "category": "Informational"
                    },
                    {
                      "code": 101,
                      "phrase": "Switching Protocols",
                      "category": "Informational"
                    },
                    {
                      "code": 102,
                      "phrase": "Processing",
                      "category": "Informational"
                    },
                    "..."
                  ]
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/html-entities": {
      "post": {
        "summary": "Encode or decode HTML entities",
        "operationId": "securityHtmlEntities",
        "description": "Encode or decode HTML entities. Send JSON with text, action (required). Returns JSON with the answer as a string in result. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "description": "For 'encode': text in which & < > \" ' become &amp; &lt; &gt; &quot; &#39;. For 'decode': text containing character references. Decoding happens once (&amp;lt; becomes &lt;, not <) and understands all 2,125 named references of the HTML standard (&eacute; &copy; &nbsp; &euro; &apos; ...), legacy names without a semicolon (&copy), and decimal or hex numbers including characters above U+FFFF (&#x1F600;). Unknown names are left as written; numbers that are not characters become U+FFFD."
                  },
                  "action": {
                    "type": "string",
                    "enum": [
                      "encode",
                      "decode"
                    ],
                    "description": "encode: escape the five HTML-significant characters. decode: turn character references into characters."
                  }
                },
                "required": [
                  "text",
                  "action"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "<a href=\"/pay?a=1&b=2\">Tom & Jerry's</a>",
                "action": "encode"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Html entity converter client and server side from freedailypro",
                  "action": "encode",
                  "result": "&lt;a href=&quot;/pay?a=1&amp;b=2&quot;&gt;Tom &amp; Jerry&#39;s&lt;/a&gt;"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/binary-ascii": {
      "post": {
        "summary": "Convert text to binary or hex and back",
        "operationId": "securityBinaryAscii",
        "description": "Convert text to binary or hex and back. Send JSON with text, action (required); optional: separator. Returns JSON with the answer as a string in result. Limits: separator: up to 3 characters. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "description": "For toBinary / toHex: any text, converted as UTF-8 bytes (so 'é' is c3 a9, 11000011 10101001). For fromBinary: 8-bit groups separated by spaces or commas, an optional 0b prefix per group, or one unbroken run whose length is a multiple of 8. For fromHex: pairs such as '48 69', '4869', '0x48 0x69', '\\x48\\x69' or '48:69'. Malformed input (a character that is not 0/1 or a hex digit, an odd number of hex digits, a bit run that is not whole bytes, or bytes that are not valid UTF-8) is a 400 ({error, code: 'invalid_input_bytes'})."
                  },
                  "action": {
                    "type": "string",
                    "enum": [
                      "toBinary",
                      "fromBinary",
                      "toHex",
                      "fromHex"
                    ],
                    "description": "toBinary / toHex: text to UTF-8 bytes. fromBinary / fromHex: bytes back to text."
                  },
                  "separator": {
                    "description": "Text placed between bytes by toBinary and toHex (up to 3 characters, default a space). Ignored by fromBinary and fromHex.",
                    "type": "string",
                    "maxLength": 3
                  }
                },
                "required": [
                  "text",
                  "action"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "Hi!",
                "action": "toBinary",
                "separator": " "
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Binary ascii converter client and server side from freedailypro",
                  "action": "toBinary",
                  "result": "01001000 01101001 00100001"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/user-agent": {
      "post": {
        "summary": "Parse a User-Agent string into browser, operating system and device",
        "operationId": "securityUserAgent",
        "description": "Send 'ua' (the user-agent string). Returns 'browser', 'browserVersion', 'os', 'device' and 'isBot' as before, plus 'recognised' (false when the text does not look like a user-agent string at all, in which case a 'note' explains what a real one looks like, instead of returning Unknown fields with no explanation). Optional 'clientHints': paste the Sec-CH-UA request headers (Sec-CH-UA, Sec-CH-UA-Platform, Sec-CH-UA-Platform-Version, Sec-CH-UA-Full-Version-List, Sec-CH-UA-Model, Sec-CH-UA-Mobile, Sec-CH-UA-Arch, Sec-CH-UA-Bitness) and the response adds a 'clientHints' object with the full browser version, the model and, for Windows, 11 or 10, which the user-agent string cannot tell (Sec-CH-UA-Platform-Version 13.0.0 or higher is Windows 11). Who calls it: log analysers, analytics pipelines, support tools that triage bug reports, and agents. Worked example: {\"ua\":\"hello world\"} returns recognised false and a note. Integration scenario: a server that logs request headers sends the User-Agent value as 'ua' and the Sec-CH-UA lines as 'clientHints' to tell Windows 11 users from Windows 10 users. The text you send is parsed in memory and not stored. Client Hints are only sent by Chromium-based browsers, and a user-agent string can be spoofed, so never use the result as a security control. Stateless: the request is processed in memory and nothing is stored. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "ua": {
                    "type": "string",
                    "minLength": 1,
                    "description": "The User-Agent string. Recognises Chrome, Edge, Firefox, Safari, Opera, Samsung Internet, Vivaldi, Chrome and Firefox on iOS, UC and Yandex browsers; Windows, macOS, iOS, Android, ChromeOS, Linux, Tizen and webOS; and flags crawlers, link-preview fetchers, headless browsers and scripted clients (Googlebot, curl, python-requests, Go-http-client ...) with isBot true. device is desktop, mobile, tablet, tv (smart TVs, Tizen, webOS, Fire TV, Chromecast), bot or unknown. recognised is false when the text does not look like a user-agent string."
                  },
                  "clientHints": {
                    "description": "Optional: pasted Sec-CH-UA request headers (Sec-CH-UA, -Platform, -Platform-Version, -Full-Version-List, -Model, -Mobile, -Arch, -Bitness); adds a 'clientHints' object, e.g. Windows 11, which the user-agent string cannot tell",
                    "type": "string"
                  }
                },
                "required": [
                  "ua"
                ],
                "additionalProperties": false
              },
              "example": {
                "ua": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "User agent parser client and server side from freedailypro",
                  "result": {
                    "raw": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1",
                    "browser": "Safari",
                    "browserVersion": "17.5",
                    "os": "iOS 17.5",
                    "device": "mobile",
                    "isBot": false
                  }
                }
              }
            }
          },
          "400": {
            "description": "A missing or non-string 'ua' Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/minify": {
      "post": {
        "summary": "Minify CSS or JavaScript and return the smaller code",
        "operationId": "securityMinify",
        "description": "Minify CSS or JavaScript and return the smaller code. Send JSON with code, type (required). Returns JSON with the answer as a string in result. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "code": {
                    "type": "string",
                    "description": "The CSS or JavaScript source. Comments and unneeded whitespace are removed with a tokenizer, so strings, template literals, regular expression literals and CSS url(...) are never touched. Nothing is renamed or rewritten. JavaScript newlines that automatic semicolon insertion could depend on are kept (for example before a line starting with ++ or after return), so the output behaves like the input. Unterminated strings, comments or template literals are a 400 ({error, code: 'invalid_code'})."
                  },
                  "type": {
                    "type": "string",
                    "enum": [
                      "css",
                      "js"
                    ],
                    "description": "css or js: which language the code is written in."
                  }
                },
                "required": [
                  "code",
                  "type"
                ],
                "additionalProperties": false
              },
              "example": {
                "code": "body {\n  margin: 0;\n  padding: 0;\n}\n/* header */\nh1 { color: #ff0000; }",
                "type": "css"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Css js minifier client and server side from freedailypro",
                  "type": "css",
                  "result": "body{margin:0;padding:0}h1{color:#ff0000}"
                }
              }
            }
          },
          "400": {
            "description": "Missing or invalid input; the body explains what to fix Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/jwt-decode": {
      "post": {
        "summary": "Decode a JWT and check its time claims (signature NOT verified)",
        "operationId": "securityJwtDecode",
        "description": "Decodes the header and payload of a JSON Web Token and tells you, in plain words, whether its own time claims make it usable right now. IMPORTANT: this endpoint DECODES ONLY. It never verifies the signature (that needs the issuer's secret or public key), so a token that decodes cleanly is not proof the token is genuine. A leading 'Bearer ' (any case) is removed, so you can paste an Authorization header value. 'valid' is true only when ALL of these hold: the token is well formed; the header has an 'alg' that is not 'none'; 'exp' (if present) is in the future; 'nbf' (if present) is not in the future. Otherwise 'valid' is false and 'status' says why: 'expired', 'not_yet_valid', 'unsigned' (alg none, or an empty signature) or 'malformed' (HTTP 400). 'expired', 'notYetValid' and 'unsigned' are also returned as separate flags, 'issues' lists the reasons in plain words, and 'signatureVerified' is always false. Optional 'now' checks the claims as of another time and 'clockToleranceSeconds' allows for clock drift. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "token": {
                    "type": "string",
                    "minLength": 1,
                    "description": "The JWT. A leading 'Bearer ' (as copied from an Authorization header) is removed for you."
                  },
                  "now": {
                    "description": "Optional. Check exp/nbf as of this time instead of now: epoch seconds or an ISO date.",
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "clockToleranceSeconds": {
                    "description": "Optional. Seconds of clock difference allowed when checking exp and nbf (default 0).",
                    "type": "number",
                    "minimum": 0,
                    "maximum": 86400
                  }
                },
                "required": [
                  "token"
                ],
                "additionalProperties": false
              },
              "example": {
                "token": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwiZXhwIjoxNTc3ODM2ODAwfQ.c2lnbmF0dXJl"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Jwt decoder",
                  "valid": false,
                  "wellFormed": true,
                  "status": "expired",
                  "signatureVerified": false,
                  "issues": [
                    "The token expired at 2020-01-01T00:00:00.000Z (exp), 215534435 seconds before the time checked."
                  ],
                  "header": {
                    "alg": "HS256",
                    "typ": "JWT"
                  },
                  "payload": {
                    "sub": "1234567890",
                    "exp": 1577836800
                  },
                  "signature": "c2lnbmF0dXJl",
                  "evaluatedAt": "2026-10-30T14:40:35.000Z",
                  "algorithm": "HS256",
                  "expiresAt": "2020-01-01T00:00:00.000Z",
                  "secondsUntilExpiry": -215534435,
                  "expired": true
                }
              }
            }
          },
          "400": {
            "description": "Missing token, or the token is malformed (not three parts, or the header/payload is not base64url JSON); the body has valid:false and a plain-words error Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/barcode-code128": {
      "post": {
        "summary": "Generate a Code 128 barcode as valid SVG",
        "operationId": "securityBarcodeCode128",
        "description": "Encodes 'text' as a Code 128 (subset B) barcode. 'text' must be 1 to 80 printable ASCII characters (codes 32 to 126); anything else is rejected with a 400. 'height' is the bar height in px (default 80). The JSON response holds 'svg' (a complete, valid SVG with width and height and single-quoted attributes, no escaped quotes, no trailing newline), 'dataUrl' (data:image/svg+xml URL), 'width' and 'height'. Send 'format': 'svg' to get the raw image/svg+xml document as the response body instead of JSON. Stateless: the request is processed in memory and nothing is stored.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 80,
                    "pattern": "^[\\x20-\\x7E]+$"
                  },
                  "height": {
                    "type": "number",
                    "minimum": 10,
                    "maximum": 400
                  },
                  "format": {
                    "type": "string",
                    "enum": [
                      "json",
                      "svg"
                    ]
                  }
                },
                "required": [
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "FDP-2026-0042",
                "height": 60,
                "format": "svg"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "Code 128 barcode",
                  "result": {
                    "svg": "<svg xmlns='http://www.w3.org/2000/svg' width='203' height='108' viewBox='0 0 203 108'>...</svg>",
                    "dataUrl": "data:image/svg+xml;charset=utf-8,%3Csvg...",
                    "width": 203,
                    "height": 108
                  }
                }
              }
            }
          },
          "400": {
            "description": "Text empty, longer than 80 characters or containing non-ASCII characters; height out of range; or an unsupported 'format' Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    },
    "/v1/security/qr": {
      "post": {
        "summary": "Generate a QR code as valid SVG",
        "operationId": "securityQr",
        "description": "Encodes 'text' (any text or URL) as a QR code (error correction level M, version chosen automatically). The JSON response holds 'svg' (a complete, valid SVG with width and height of 256 px and single-quoted attributes, so it contains no escaped quotes and can be saved straight to a .svg file, with no trailing newline), 'dataUrl' (the same SVG as a data:image/svg+xml URL for an <img src>), 'width' and 'height'. Send 'format': 'svg' to get the raw image/svg+xml document as the response body instead of JSON. Stateless: the request is processed in memory and nothing is stored. Errors: 400 when a field is missing or invalid (the body says which), 401 without a valid X-API-Key header, 429 when the plan's call limit is reached.",
        "tags": [
          "Security & Developer Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "minLength": 1
                  },
                  "format": {
                    "type": "string",
                    "enum": [
                      "json",
                      "svg"
                    ]
                  }
                },
                "required": [
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "https://www.freedailypro.com/developers",
                "format": "svg"
              }
            }
          }
        },
        "security": [
          {
            "ApiKeyAuth": []
          }
        ],
        "responses": {
          "200": {
            "description": "Success",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                },
                "example": {
                  "tool": "QR code generator",
                  "result": {
                    "svg": "<svg xmlns='http://www.w3.org/2000/svg' width='256' height='256' viewBox='0 0 29 29' shape-rendering='crispEdges'>...</svg>",
                    "dataUrl": "data:image/svg+xml;charset=utf-8,%3Csvg...",
                    "width": 256,
                    "height": 256
                  }
                }
              }
            }
          },
          "400": {
            "description": "Empty text, text too long for a QR code, or an unsupported 'format' Not billed: a failed call does not count against your plan's calls."
          },
          "401": {
            "description": "Missing or invalid API key Not billed: a failed call does not count against your plan's calls."
          },
          "429": {
            "description": "Rate limit exceeded for your plan Not billed: a failed call does not count against your plan's calls."
          }
        }
      }
    }
  }
}