{
  "openapi": "3.1.0",
  "info": {
    "title": "FreeToolBoxes Agent Tools API",
    "version": "1.0.0",
    "description": "Exactly 50 deterministic data-transformation and live-web-verification tools for AI agents. No account or API key is required.",
    "contact": {
      "name": "FreeToolBoxes",
      "url": "https://freetoolboxes.com/contact.html"
    },
    "license": {
      "name": "Free public API terms",
      "url": "https://freetoolboxes.com/terms.html"
    }
  },
  "servers": [
    {
      "url": "https://api.freetoolboxes.com"
    }
  ],
  "tags": [
    {
      "name": "Live Web Data"
    },
    {
      "name": "Structured Data"
    },
    {
      "name": "Exact Utilities"
    }
  ],
  "paths": {
    "/api/v1/tools/dns_lookup": {
      "post": {
        "operationId": "dns_lookup",
        "summary": "DNS Lookup",
        "description": "Use this when you need current public DNS records for a domain.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "domain": {
                    "type": "string",
                    "maxLength": 253
                  },
                  "type": {
                    "default": "A",
                    "type": "string",
                    "enum": [
                      "A",
                      "AAAA",
                      "CNAME",
                      "MX",
                      "NS",
                      "TXT",
                      "CAA",
                      "SOA"
                    ]
                  }
                },
                "required": [
                  "domain",
                  "type"
                ],
                "additionalProperties": false
              },
              "example": {
                "domain": "example.com",
                "type": "A"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/rdap_domain_lookup": {
      "post": {
        "operationId": "rdap_domain_lookup",
        "summary": "RDAP Domain Lookup",
        "description": "Use this when you need current domain registration data from the authoritative RDAP service.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "domain": {
                    "type": "string",
                    "minLength": 3,
                    "maxLength": 253
                  }
                },
                "required": [
                  "domain"
                ],
                "additionalProperties": false
              },
              "example": {
                "domain": "example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/redirect_trace": {
      "post": {
        "operationId": "redirect_trace",
        "summary": "Redirect Trace",
        "description": "Use this when you need the complete HTTPS redirect path and final response.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/http_status_check": {
      "post": {
        "operationId": "http_status_check",
        "summary": "HTTP Status Check",
        "description": "Use this when you need the live status and latency of a public HTTPS URL.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/response_headers_inspect": {
      "post": {
        "operationId": "response_headers_inspect",
        "summary": "Response Headers Inspect",
        "description": "Use this when you need normalized live response headers from a public HTTPS URL.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/page_metadata_extract": {
      "post": {
        "operationId": "page_metadata_extract",
        "summary": "Page Metadata Extract",
        "description": "Use this when you need title, description, canonical, robots, language, and social metadata from a live HTML page.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/page_links_extract": {
      "post": {
        "operationId": "page_links_extract",
        "summary": "Page Links Extract",
        "description": "Use this when you need deduplicated internal and external links from a live HTML page.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  },
                  "limit": {
                    "default": 200,
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 500
                  }
                },
                "required": [
                  "url",
                  "limit"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com",
                "limit": 100
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/structured_data_extract": {
      "post": {
        "operationId": "structured_data_extract",
        "summary": "Structured Data Extract",
        "description": "Use this when you need JSON-LD and supported microdata types from a live page.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/canonical_check": {
      "post": {
        "operationId": "canonical_check",
        "summary": "Canonical Check",
        "description": "Use this when you need to verify a page canonical against its final live URL.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/robots_fetch_analyze": {
      "post": {
        "operationId": "robots_fetch_analyze",
        "summary": "Robots Fetch Analyze",
        "description": "Use this when you need the live robots.txt rules and sitemap declarations for a site.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "origin": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  },
                  "user_agent": {
                    "default": "*",
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 100
                  }
                },
                "required": [
                  "origin",
                  "user_agent"
                ],
                "additionalProperties": false
              },
              "example": {
                "origin": "https://example.com",
                "user_agent": "*"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/sitemap_fetch_analyze": {
      "post": {
        "operationId": "sitemap_fetch_analyze",
        "summary": "Sitemap Fetch Analyze",
        "description": "Use this when you need to inspect a live XML sitemap or sitemap index.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  },
                  "limit": {
                    "default": 1000,
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 5000
                  }
                },
                "required": [
                  "url",
                  "limit"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://freetoolboxes.com/sitemap.xml",
                "limit": 1000
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/url_indexability_check": {
      "post": {
        "operationId": "url_indexability_check",
        "summary": "URL Indexability Check",
        "description": "Use this when you need a live technical assessment of whether a URL is crawlable and indexable.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/security_headers_audit": {
      "post": {
        "operationId": "security_headers_audit",
        "summary": "Security Headers Audit",
        "description": "Use this when you need a focused audit of important HTTP security headers on a live URL.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "url": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "url"
                ],
                "additionalProperties": false
              },
              "example": {
                "url": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/well_known_discover": {
      "post": {
        "operationId": "well_known_discover",
        "summary": "Well-Known Discover",
        "description": "Use this when you need to find standard machine-readable discovery documents on a public site.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "origin": {
                    "type": "string",
                    "maxLength": 2048,
                    "format": "uri"
                  }
                },
                "required": [
                  "origin"
                ],
                "additionalProperties": false
              },
              "example": {
                "origin": "https://example.com"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/currency_convert_current": {
      "post": {
        "operationId": "currency_convert_current",
        "summary": "Currency Convert Current",
        "description": "Use this when you need a current, source-attributed currency conversion using ECB reference rates.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "amount": {
                    "type": "number"
                  },
                  "from": {
                    "type": "string",
                    "minLength": 3,
                    "maxLength": 3
                  },
                  "to": {
                    "type": "string",
                    "minLength": 3,
                    "maxLength": 3
                  }
                },
                "required": [
                  "amount",
                  "from",
                  "to"
                ],
                "additionalProperties": false
              },
              "example": {
                "amount": 100,
                "from": "USD",
                "to": "EUR"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/exchange_rates_list": {
      "post": {
        "operationId": "exchange_rates_list",
        "summary": "Exchange Rates List",
        "description": "Use this when you need the current currencies and EUR reference rates published by the ECB.",
        "tags": [
          "Live Web Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {},
                "additionalProperties": false
              },
              "example": {}
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_validate": {
      "post": {
        "operationId": "json_validate",
        "summary": "JSON Validate",
        "description": "Use this when you need exact JSON syntax validation and the top-level value type.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  }
                },
                "required": [
                  "text"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "{\"ok\":true}"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_format": {
      "post": {
        "operationId": "json_format",
        "summary": "JSON Format",
        "description": "Use this when you need deterministic JSON formatting or minification.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "indent": {
                    "default": 2,
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 8
                  },
                  "sort_keys": {
                    "default": false,
                    "type": "boolean"
                  }
                },
                "required": [
                  "text",
                  "indent",
                  "sort_keys"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "{\"b\":2,\"a\":1}",
                "indent": 2,
                "sort_keys": true
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_pointer_get": {
      "post": {
        "operationId": "json_pointer_get",
        "summary": "JSON Pointer Get",
        "description": "Use this when you need the exact value addressed by an RFC 6901 JSON Pointer.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "document": {
                    "$ref": "#/$defs/__schema0"
                  },
                  "pointer": {
                    "type": "string",
                    "maxLength": 2000
                  }
                },
                "required": [
                  "document",
                  "pointer"
                ],
                "additionalProperties": false,
                "$defs": {
                  "__schema0": {
                    "anyOf": [
                      {
                        "type": "null"
                      },
                      {
                        "type": "boolean"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "string"
                      },
                      {
                        "type": "array",
                        "items": {
                          "$ref": "#/$defs/__schema0"
                        }
                      },
                      {
                        "type": "object",
                        "propertyNames": {
                          "type": "string"
                        },
                        "additionalProperties": {
                          "$ref": "#/$defs/__schema0"
                        }
                      }
                    ]
                  }
                }
              },
              "example": {
                "document": {
                  "users": [
                    {
                      "name": "Ada"
                    }
                  ]
                },
                "pointer": "/users/0/name"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_patch_apply": {
      "post": {
        "operationId": "json_patch_apply",
        "summary": "JSON Patch Apply",
        "description": "Use this when you need to safely apply RFC 6902 operations to a JSON document.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "document": {
                    "$ref": "#/$defs/__schema0"
                  },
                  "patch": {
                    "maxItems": 1000,
                    "type": "array",
                    "items": {
                      "type": "object",
                      "propertyNames": {
                        "type": "string"
                      },
                      "additionalProperties": {}
                    }
                  }
                },
                "required": [
                  "document",
                  "patch"
                ],
                "additionalProperties": false,
                "$defs": {
                  "__schema0": {
                    "anyOf": [
                      {
                        "type": "null"
                      },
                      {
                        "type": "boolean"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "string"
                      },
                      {
                        "type": "array",
                        "items": {
                          "$ref": "#/$defs/__schema0"
                        }
                      },
                      {
                        "type": "object",
                        "propertyNames": {
                          "type": "string"
                        },
                        "additionalProperties": {
                          "$ref": "#/$defs/__schema0"
                        }
                      }
                    ]
                  }
                }
              },
              "example": {
                "document": {
                  "name": "old"
                },
                "patch": [
                  {
                    "op": "replace",
                    "path": "/name",
                    "value": "new"
                  }
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_diff": {
      "post": {
        "operationId": "json_diff",
        "summary": "JSON Diff",
        "description": "Use this when you need deterministic RFC 6902 operations that transform one JSON value into another.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "before": {
                    "$ref": "#/$defs/__schema0"
                  },
                  "after": {
                    "$ref": "#/$defs/__schema0"
                  }
                },
                "required": [
                  "before",
                  "after"
                ],
                "additionalProperties": false,
                "$defs": {
                  "__schema0": {
                    "anyOf": [
                      {
                        "type": "null"
                      },
                      {
                        "type": "boolean"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "string"
                      },
                      {
                        "type": "array",
                        "items": {
                          "$ref": "#/$defs/__schema0"
                        }
                      },
                      {
                        "type": "object",
                        "propertyNames": {
                          "type": "string"
                        },
                        "additionalProperties": {
                          "$ref": "#/$defs/__schema0"
                        }
                      }
                    ]
                  }
                }
              },
              "example": {
                "before": {
                  "a": 1
                },
                "after": {
                  "a": 2
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_schema_validate": {
      "post": {
        "operationId": "json_schema_validate",
        "summary": "JSON Schema Validate",
        "description": "Use this when you need local JSON Schema validation without fetching remote references.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "schema": {
                    "type": "object",
                    "propertyNames": {
                      "type": "string"
                    },
                    "additionalProperties": {}
                  },
                  "data": {}
                },
                "required": [
                  "schema",
                  "data"
                ],
                "additionalProperties": false
              },
              "example": {
                "schema": {
                  "type": "object",
                  "required": [
                    "id"
                  ]
                },
                "data": {
                  "id": 1
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/openapi_validate": {
      "post": {
        "operationId": "openapi_validate",
        "summary": "OpenAPI Validate",
        "description": "Use this when you need structural validation of an OpenAPI 3.x document without resolving remote references.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "document": {
                    "anyOf": [
                      {
                        "type": "string",
                        "maxLength": 200000
                      },
                      {
                        "type": "object",
                        "propertyNames": {
                          "type": "string"
                        },
                        "additionalProperties": {}
                      }
                    ]
                  }
                },
                "required": [
                  "document"
                ],
                "additionalProperties": false
              },
              "example": {
                "document": {
                  "openapi": "3.1.0",
                  "info": {
                    "title": "Example",
                    "version": "1.0.0"
                  },
                  "paths": {}
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/yaml_to_json": {
      "post": {
        "operationId": "yaml_to_json",
        "summary": "YAML to JSON",
        "description": "Use this when you need safe YAML converted to structured JSON.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "yaml": {
                    "type": "string",
                    "maxLength": 200000
                  }
                },
                "required": [
                  "yaml"
                ],
                "additionalProperties": false
              },
              "example": {
                "yaml": "name: Ada\nactive: true"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_to_yaml": {
      "post": {
        "operationId": "json_to_yaml",
        "summary": "JSON to YAML",
        "description": "Use this when you need a JSON value serialized as deterministic YAML.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "value": {
                    "$ref": "#/$defs/__schema0"
                  }
                },
                "required": [
                  "value"
                ],
                "additionalProperties": false,
                "$defs": {
                  "__schema0": {
                    "anyOf": [
                      {
                        "type": "null"
                      },
                      {
                        "type": "boolean"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "string"
                      },
                      {
                        "type": "array",
                        "items": {
                          "$ref": "#/$defs/__schema0"
                        }
                      },
                      {
                        "type": "object",
                        "propertyNames": {
                          "type": "string"
                        },
                        "additionalProperties": {
                          "$ref": "#/$defs/__schema0"
                        }
                      }
                    ]
                  }
                }
              },
              "example": {
                "value": {
                  "name": "Ada",
                  "active": true
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/csv_to_json": {
      "post": {
        "operationId": "csv_to_json",
        "summary": "CSV to JSON",
        "description": "Use this when you need quoted CSV parsed into JSON rows with explicit size limits.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "csv": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "delimiter": {
                    "default": ",",
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 1
                  },
                  "headers": {
                    "default": true,
                    "type": "boolean"
                  }
                },
                "required": [
                  "csv",
                  "delimiter",
                  "headers"
                ],
                "additionalProperties": false
              },
              "example": {
                "csv": "name,age\nAda,36",
                "headers": true
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/json_to_csv": {
      "post": {
        "operationId": "json_to_csv",
        "summary": "JSON to CSV",
        "description": "Use this when you need an array of flat JSON objects serialized as standards-compatible CSV.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "rows": {
                    "maxItems": 10000,
                    "type": "array",
                    "items": {
                      "type": "object",
                      "propertyNames": {
                        "type": "string"
                      },
                      "additionalProperties": {}
                    }
                  },
                  "delimiter": {
                    "default": ",",
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 1
                  }
                },
                "required": [
                  "rows",
                  "delimiter"
                ],
                "additionalProperties": false
              },
              "example": {
                "rows": [
                  {
                    "name": "Ada",
                    "age": 36
                  }
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/xml_format": {
      "post": {
        "operationId": "xml_format",
        "summary": "XML Format",
        "description": "Use this when you need XML syntax checked and deterministically formatted without DTD or entities.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "xml": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "indent": {
                    "default": 2,
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 8
                  }
                },
                "required": [
                  "xml",
                  "indent"
                ],
                "additionalProperties": false
              },
              "example": {
                "xml": "<root><item>1</item></root>",
                "indent": 2
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/xml_to_json": {
      "post": {
        "operationId": "xml_to_json",
        "summary": "XML to JSON",
        "description": "Use this when you need XML converted to JSON while blocking DTD and entity expansion attacks.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "xml": {
                    "type": "string",
                    "maxLength": 200000
                  }
                },
                "required": [
                  "xml"
                ],
                "additionalProperties": false
              },
              "example": {
                "xml": "<root><item>1</item></root>"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/query_string_parse": {
      "post": {
        "operationId": "query_string_parse",
        "summary": "Query String Parse",
        "description": "Use this when you need a URL query string parsed with duplicate values preserved.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "query": {
                    "type": "string",
                    "maxLength": 20000
                  }
                },
                "required": [
                  "query"
                ],
                "additionalProperties": false
              },
              "example": {
                "query": "a=1&a=2&name=Ada"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/query_string_build": {
      "post": {
        "operationId": "query_string_build",
        "summary": "Query String Build",
        "description": "Use this when you need deterministic URL query encoding from scalar or array values.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "parameters": {
                    "type": "object",
                    "propertyNames": {
                      "type": "string"
                    },
                    "additionalProperties": {
                      "anyOf": [
                        {
                          "type": "string"
                        },
                        {
                          "type": "number"
                        },
                        {
                          "type": "boolean"
                        },
                        {
                          "maxItems": 100,
                          "type": "array",
                          "items": {
                            "anyOf": [
                              {
                                "type": "string"
                              },
                              {
                                "type": "number"
                              },
                              {
                                "type": "boolean"
                              }
                            ]
                          }
                        }
                      ]
                    }
                  }
                },
                "required": [
                  "parameters"
                ],
                "additionalProperties": false
              },
              "example": {
                "parameters": {
                  "a": [
                    1,
                    2
                  ],
                  "name": "Ada"
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/text_diff": {
      "post": {
        "operationId": "text_diff",
        "summary": "Text Diff",
        "description": "Use this when you need an exact line-level difference between two bounded text values.",
        "tags": [
          "Structured Data"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "before": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "after": {
                    "type": "string",
                    "maxLength": 200000
                  }
                },
                "required": [
                  "before",
                  "after"
                ],
                "additionalProperties": false
              },
              "example": {
                "before": "one\ntwo",
                "after": "one\nthree"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/regex_test": {
      "post": {
        "operationId": "regex_test",
        "summary": "Regex Test",
        "description": "Use this when you need safe RE2-compatible matching without catastrophic backtracking or backreferences.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "pattern": {
                    "type": "string",
                    "maxLength": 2000
                  },
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "flags": {
                    "default": "u",
                    "type": "string",
                    "pattern": "^[gimsu]*$"
                  },
                  "max_matches": {
                    "default": 100,
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 1000
                  }
                },
                "required": [
                  "pattern",
                  "text",
                  "flags",
                  "max_matches"
                ],
                "additionalProperties": false
              },
              "example": {
                "pattern": "[A-Z][a-z]+",
                "text": "Hello world",
                "flags": "gu"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/semver_compare": {
      "post": {
        "operationId": "semver_compare",
        "summary": "SemVer Compare",
        "description": "Use this when you need exact Semantic Version precedence comparison.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "a": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "b": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "loose": {
                    "default": false,
                    "type": "boolean"
                  }
                },
                "required": [
                  "a",
                  "b",
                  "loose"
                ],
                "additionalProperties": false
              },
              "example": {
                "a": "1.2.3",
                "b": "2.0.0"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/semver_satisfies": {
      "post": {
        "operationId": "semver_satisfies",
        "summary": "SemVer Satisfies",
        "description": "Use this when you need to test a Semantic Version against a range.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "version": {
                    "type": "string",
                    "maxLength": 100
                  },
                  "range": {
                    "type": "string",
                    "maxLength": 200
                  },
                  "include_prerelease": {
                    "default": false,
                    "type": "boolean"
                  }
                },
                "required": [
                  "version",
                  "range",
                  "include_prerelease"
                ],
                "additionalProperties": false
              },
              "example": {
                "version": "1.5.0",
                "range": "^1.2.0"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/cron_describe": {
      "post": {
        "operationId": "cron_describe",
        "summary": "Cron Describe",
        "description": "Use this when you need an exact field-by-field explanation of a cron expression.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "expression": {
                    "type": "string",
                    "minLength": 5,
                    "maxLength": 200
                  }
                },
                "required": [
                  "expression"
                ],
                "additionalProperties": false
              },
              "example": {
                "expression": "0 9 * * 1-5"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/cron_next_runs": {
      "post": {
        "operationId": "cron_next_runs",
        "summary": "Cron Next Runs",
        "description": "Use this when you need deterministic upcoming times for a cron expression in an IANA time zone.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "expression": {
                    "type": "string",
                    "minLength": 5,
                    "maxLength": 200
                  },
                  "timezone": {
                    "default": "UTC",
                    "type": "string",
                    "maxLength": 100
                  },
                  "count": {
                    "default": 5,
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 100
                  },
                  "after": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  }
                },
                "required": [
                  "expression",
                  "timezone",
                  "count"
                ],
                "additionalProperties": false
              },
              "example": {
                "expression": "0 9 * * 1-5",
                "timezone": "America/New_York",
                "count": 5
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/timestamp_convert": {
      "post": {
        "operationId": "timestamp_convert",
        "summary": "Timestamp Convert",
        "description": "Use this when you need an ISO date, Unix seconds, and Unix milliseconds for the same instant.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "value": {
                    "anyOf": [
                      {
                        "type": "string",
                        "maxLength": 100
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "unit": {
                    "default": "auto",
                    "type": "string",
                    "enum": [
                      "auto",
                      "seconds",
                      "milliseconds"
                    ]
                  }
                },
                "required": [
                  "value",
                  "unit"
                ],
                "additionalProperties": false
              },
              "example": {
                "value": 1704067200,
                "unit": "seconds"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/timezone_convert": {
      "post": {
        "operationId": "timezone_convert",
        "summary": "Timezone Convert",
        "description": "Use this when you need one instant represented in a specific IANA time zone.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "datetime": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  },
                  "timezone": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 100
                  }
                },
                "required": [
                  "datetime",
                  "timezone"
                ],
                "additionalProperties": false
              },
              "example": {
                "datetime": "2026-08-21T14:00:00Z",
                "timezone": "America/New_York"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/date_difference": {
      "post": {
        "operationId": "date_difference",
        "summary": "Date Difference",
        "description": "Use this when you need the exact elapsed duration between two instants.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "start": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  },
                  "end": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  }
                },
                "required": [
                  "start",
                  "end"
                ],
                "additionalProperties": false
              },
              "example": {
                "start": "2026-01-01T00:00:00Z",
                "end": "2026-01-02T12:00:00Z"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/duration_parse": {
      "post": {
        "operationId": "duration_parse",
        "summary": "Duration Parse",
        "description": "Use this when you need an ISO or human duration normalized to exact units.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "duration": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 500
                  }
                },
                "required": [
                  "duration"
                ],
                "additionalProperties": false
              },
              "example": {
                "duration": "2h 30m"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/unit_convert": {
      "post": {
        "operationId": "unit_convert",
        "summary": "Unit Convert",
        "description": "Use this when you need an exact conversion among supported length, mass, volume, data, speed, angle, or temperature units.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "value": {
                    "type": "number"
                  },
                  "from": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 20
                  },
                  "to": {
                    "type": "string",
                    "minLength": 1,
                    "maxLength": 20
                  }
                },
                "required": [
                  "value",
                  "from",
                  "to"
                ],
                "additionalProperties": false
              },
              "example": {
                "value": 10,
                "from": "km",
                "to": "mi"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/hash_digest": {
      "post": {
        "operationId": "hash_digest",
        "summary": "Hash Digest",
        "description": "Use this when you need a cryptographic digest of UTF-8 text using a Web Crypto algorithm.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "algorithm": {
                    "default": "SHA-256",
                    "type": "string",
                    "enum": [
                      "SHA-256",
                      "SHA-384",
                      "SHA-512"
                    ]
                  },
                  "encoding": {
                    "default": "hex",
                    "type": "string",
                    "enum": [
                      "hex",
                      "base64"
                    ]
                  }
                },
                "required": [
                  "text",
                  "algorithm",
                  "encoding"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "hello",
                "algorithm": "SHA-256",
                "encoding": "hex"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/uuid_generate": {
      "post": {
        "operationId": "uuid_generate",
        "summary": "UUID Generate",
        "description": "Use this when you need one or more cryptographically random UUID version 4 identifiers.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "count": {
                    "default": 1,
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 100
                  }
                },
                "required": [
                  "count"
                ],
                "additionalProperties": false
              },
              "example": {
                "count": 3
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/jwt_decode": {
      "post": {
        "operationId": "jwt_decode",
        "summary": "JWT Decode",
        "description": "Use this when you need to inspect JWT header and payload claims without verifying its signature.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "token": {
                    "type": "string",
                    "minLength": 3,
                    "maxLength": 100000
                  }
                },
                "required": [
                  "token"
                ],
                "additionalProperties": false
              },
              "example": {
                "token": "eyJhbGciOiJub25lIn0.eyJzdWIiOiIxMjMifQ."
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/jwt_expiry_check": {
      "post": {
        "operationId": "jwt_expiry_check",
        "summary": "JWT Expiry Check",
        "description": "Use this when you need to inspect exp, nbf, and iat timing without verifying the JWT signature.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "token": {
                    "type": "string",
                    "minLength": 3,
                    "maxLength": 100000
                  },
                  "at": {
                    "type": "string",
                    "format": "date-time",
                    "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
                  }
                },
                "required": [
                  "token"
                ],
                "additionalProperties": false
              },
              "example": {
                "token": "eyJhbGciOiJub25lIn0.eyJleHAiOjQxMDI0NDQ4MDB9."
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/base64_encode": {
      "post": {
        "operationId": "base64_encode",
        "summary": "Base64 Encode",
        "description": "Use this when you need UTF-8 text encoded as standard or URL-safe Base64.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "url_safe": {
                    "default": false,
                    "type": "boolean"
                  },
                  "padding": {
                    "default": true,
                    "type": "boolean"
                  }
                },
                "required": [
                  "text",
                  "url_safe",
                  "padding"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "hello",
                "url_safe": false
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/base64_decode": {
      "post": {
        "operationId": "base64_decode",
        "summary": "Base64 Decode",
        "description": "Use this when you need Base64 decoded to UTF-8 text with invalid UTF-8 reported.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "base64": {
                    "type": "string",
                    "maxLength": 300000
                  },
                  "url_safe": {
                    "default": false,
                    "type": "boolean"
                  }
                },
                "required": [
                  "base64",
                  "url_safe"
                ],
                "additionalProperties": false
              },
              "example": {
                "base64": "aGVsbG8="
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/text_chunk": {
      "post": {
        "operationId": "text_chunk",
        "summary": "Text Chunk",
        "description": "Use this when you need deterministic bounded text chunks with optional overlap for downstream AI processing.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "max_size": {
                    "type": "integer",
                    "minimum": 1,
                    "maximum": 50000
                  },
                  "overlap": {
                    "default": 0,
                    "type": "integer",
                    "minimum": 0,
                    "maximum": 10000
                  },
                  "unit": {
                    "default": "characters",
                    "type": "string",
                    "enum": [
                      "characters",
                      "words"
                    ]
                  }
                },
                "required": [
                  "text",
                  "max_size",
                  "overlap",
                  "unit"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "one two three four",
                "max_size": 2,
                "overlap": 1,
                "unit": "words"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    },
    "/api/v1/tools/redact_sensitive_data": {
      "post": {
        "operationId": "redact_sensitive_data",
        "summary": "Redact Sensitive Data",
        "description": "Use this when you need common secrets and personal identifiers replaced before further processing.",
        "tags": [
          "Exact Utilities"
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$schema": "https://json-schema.org/draft/2020-12/schema",
                "type": "object",
                "properties": {
                  "text": {
                    "type": "string",
                    "maxLength": 200000
                  },
                  "categories": {
                    "default": [
                      "email",
                      "phone",
                      "ipv4",
                      "credit_card",
                      "api_key",
                      "jwt"
                    ],
                    "minItems": 1,
                    "type": "array",
                    "items": {
                      "type": "string",
                      "enum": [
                        "email",
                        "phone",
                        "ipv4",
                        "credit_card",
                        "api_key",
                        "jwt"
                      ]
                    }
                  }
                },
                "required": [
                  "text",
                  "categories"
                ],
                "additionalProperties": false
              },
              "example": {
                "text": "Email ada@example.com and token sk-abcdefghijklmnopqrstuvwxyz",
                "categories": [
                  "email",
                  "api_key"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful structured result",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ToolResponse"
                }
              }
            }
          },
          "400": {
            "description": "Invalid input"
          },
          "429": {
            "description": "Rate limit exceeded"
          },
          "502": {
            "description": "Live upstream source failed"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "ToolResponse": {
        "type": "object",
        "required": [
          "ok",
          "tool",
          "result",
          "meta"
        ],
        "properties": {
          "ok": {
            "const": true
          },
          "tool": {
            "type": "string"
          },
          "result": {
            "type": "object",
            "additionalProperties": true
          },
          "meta": {
            "type": "object",
            "properties": {
              "provider": {
                "const": "FreeToolBoxes"
              },
              "provider_url": {
                "type": "string",
                "format": "uri"
              },
              "related_url": {
                "type": "string",
                "format": "uri"
              },
              "request_id": {
                "type": "string",
                "format": "uuid"
              }
            },
            "required": [
              "provider",
              "provider_url",
              "related_url",
              "request_id"
            ]
          }
        }
      }
    }
  }
}