Highland Intel APIs

A, AAAA, MX, NS and TXT records for a domain over DNS-over-HTTPS. Returns { domain, records: { A, AAAA, MX, NS, TXT } }: each record type as a list of strings. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

SPF and DMARC presence and policy strength for a domain. Returns { domain, spf, dmarc, dmarcPolicy, findings, pass }: the SPF and DMARC records, the DMARC policy and finding codes. Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Which security headers a site's HTTPS front page sends, with a simple grade. Returns { domain, status, present, missing, grade, server }: security headers sent and missing, and a grade A, B, C or F. Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Whether plain HTTP redirects to HTTPS, and whether HSTS is set. Returns { domain, redirectsToHttps, hsts, hstsMaxAge, hstsStrong }: HTTP-to-HTTPS redirect and HSTS status. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Fetches /.well-known/security.txt and reports Contact and Expires (RFC 9116). Returns { domain, present, hasContact, expires, expired }: whether security.txt exists, has a Contact and has expired. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Three-bullet summary of up to 8,000 characters. Input is PII-redacted first. Returns { summary }: up to three short bullet points as one string. Price: 4 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to process, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted before the model sees it."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Picks one label from your list (2 to 20 labels) for a piece of text. Returns { label, labels }: the chosen label (one of yours, or null if none fit) and the labels sent. Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to process, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted before the model sees it."
    },
    "labels": {
      "type": "array",
      "minItems": 2,
      "maxItems": 20,
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 40
      },
      "description": "Candidate labels, 2 to 20, each 1 to 40 characters; the answer is always one of these or null."
    }
  },
  "required": [
    "text",
    "labels"
  ],
  "additionalProperties": false
}

Translates text between languages; defaults to English to French for NS/NB customers. Returns { translated, source, target }: the translated text and the language pair used. Price: 4 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to process, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted before the model sees it."
    },
    "source": {
      "type": "string",
      "pattern": "^[a-z]{2}$",
      "default": "en",
      "description": "ISO 639-1 two-letter lower-case language code of the input text."
    },
    "target": {
      "type": "string",
      "pattern": "^[a-z]{2}$",
      "default": "fr",
      "description": "ISO 639-1 two-letter lower-case language code to translate into."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Strips emails, phone numbers, card numbers, SINs and IPv4s. Runs locally, no model. Returns { text, counts }: the redacted text with [EMAIL]-style placeholders and a count per kind (email, card, sin, phone, ip). Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 32000,
      "description": "Text to redact, up to 32,000 characters."
    },
    "ip": {
      "type": "boolean",
      "default": true,
      "description": "Also redact IPv4 addresses."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Word, sentence and character counts, reading time and a Flesch reading-ease score. Returns { characters, words, sentences, readingMinutes, fleschReadingEase }. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 64000,
      "description": "Text to measure, up to 64,000 characters."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Validates a JSON value against a JSON-Schema subset and lists every error path. Returns { valid, errors }: true when the value matches, and one message per error path (up to 50). Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "schema": {
      "type": "object",
      "description": "JSON Schema subset to check against: type, required, properties, items, enum, minimum, maximum, minLength, maxLength."
    },
    "value": {
      "description": "Any JSON value to validate (object, array, string, number, boolean or null)."
    }
  },
  "required": [
    "schema",
    "value"
  ],
  "additionalProperties": false
}

Runs a JavaScript regex over sample text and returns matches and groups (capped sizes). Returns { count, matches }: up to 100 matches, each { match, index, groups }. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "maxLength": 200,
      "description": "JavaScript regular expression source, without slashes, up to 200 characters."
    },
    "flags": {
      "type": "string",
      "pattern": "^[gimsuy]*$",
      "maxLength": 6,
      "default": "g",
      "description": "Regex flags from g, i, m, s, u, y; g is always added."
    },
    "text": {
      "type": "string",
      "maxLength": 2000,
      "description": "Sample text to search, up to 2,000 characters."
    }
  },
  "required": [
    "pattern",
    "text"
  ],
  "additionalProperties": false
}

Explains a 5-field cron expression in plain English (UTC, as Cloudflare runs it). Returns { cron, explanation }: the expression and a plain-English reading of it. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "cron": {
      "type": "string",
      "minLength": 9,
      "maxLength": 100,
      "description": "Five-field cron expression (minute hour day-of-month month day-of-week), read as UTC like Cloudflare Cron Triggers."
    }
  },
  "required": [
    "cron"
  ],
  "additionalProperties": false
}

Line-by-line diff of two texts (up to 500 lines each). Returns { added, removed, diff }: line counts and the diff lines prefixed with space, - or +. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string",
      "maxLength": 32000,
      "description": "Original text, up to 32,000 characters and 500 lines."
    },
    "b": {
      "type": "string",
      "maxLength": 32000,
      "description": "Changed text, up to 32,000 characters and 500 lines."
    }
  },
  "required": [
    "a",
    "b"
  ],
  "additionalProperties": false
}

SHA-1/256/384/512 hex digest of UTF-8 text. Returns { algorithm, hex }: the lower-case hex digest. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "maxLength": 64000,
      "description": "Text to hash as UTF-8, up to 64,000 characters."
    },
    "algorithm": {
      "type": "string",
      "enum": [
        "sha1",
        "sha256",
        "sha384",
        "sha512"
      ],
      "default": "sha256",
      "description": "Digest algorithm."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Adds 14% NS HST to a subtotal, or splits a tax-included total. Confirm the rate with CRA. Returns { subtotalCents, hstCents, totalCents, rate }. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "amountCents": {
      "type": "integer",
      "minimum": 0,
      "maximum": 100000000000,
      "description": "Pre-tax subtotal, or the tax-included total when included is true. Integer CAD cents."
    },
    "rate": {
      "type": "number",
      "minimum": 0,
      "maximum": 0.2,
      "default": 0.14,
      "description": "HST rate as a fraction (0.14 is the Nova Scotia rate)."
    },
    "included": {
      "type": "boolean",
      "default": false,
      "description": "amountCents already includes HST: split it instead of adding to it."
    }
  },
  "required": [
    "amountCents"
  ],
  "additionalProperties": false
}

Totals line items, applies a discount and HST, and computes a deposit. No customer details taken. Returns { lines, grossCents, discountCents, subtotalCents, hstCents, totalCents, rate, depositCents }. Price: 5 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "minItems": 1,
      "maxItems": 100,
      "description": "Line items, 1 to 100.",
      "items": {
        "type": "object",
        "properties": {
          "sku": {
            "type": "string",
            "maxLength": 200,
            "description": "Product code or short label; the first 40 characters are kept (default item-N)."
          },
          "qty": {
            "type": "integer",
            "minimum": 1,
            "maximum": 100000,
            "description": "Quantity, a whole number of at least 1."
          },
          "unitCents": {
            "type": "integer",
            "minimum": 0,
            "maximum": 100000000,
            "description": "Unit price in integer CAD cents, pre-tax."
          }
        },
        "required": [
          "qty",
          "unitCents"
        ],
        "additionalProperties": false
      }
    },
    "discountPct": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "default": 0,
      "description": "Discount on the gross total, in percent."
    },
    "depositPct": {
      "type": "number",
      "minimum": 0,
      "maximum": 100,
      "default": 0,
      "description": "Deposit as a percent of the tax-included total."
    }
  },
  "required": [
    "items"
  ],
  "additionalProperties": false
}

Formats PREFIX-YYYYMM-NNNNN-C with a Luhn check digit, or validates one. Returns { invoice } when formatting, or { valid } when validating. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "validate": {
      "type": "string",
      "maxLength": 40,
      "description": "An invoice number to check instead of formatting one; when given, the other fields are ignored."
    },
    "prefix": {
      "type": "string",
      "pattern": "^[A-Z]{2,6}$",
      "default": "HIC",
      "description": "Two to six upper-case letters."
    },
    "sequence": {
      "type": "integer",
      "minimum": 0,
      "maximum": 99999,
      "description": "Invoice sequence number. Required unless validate is given."
    },
    "yyyymm": {
      "type": "string",
      "pattern": "^\\d{6}$",
      "description": "Year and month as YYYYMM; defaults to the current UTC month."
    }
  },
  "required": [],
  "additionalProperties": false
}

One HTTPS probe of a public domain: status, latency and whether it looks up. Returns { domain, up, status, ms }: up is true for any status below 500; status is null when the host does not answer. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    },
    "path": {
      "type": "string",
      "pattern": "^/[\\w./-]*$",
      "maxLength": 200,
      "default": "/",
      "description": "Path to probe, starting with /, letters, digits, _ . / - only."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Neural or keyword web search with highlights, for agents. Up to 10 results, public URLs only. Returns { query, results: [{ title, url, publishedDate, score, highlights }] }: up to 10 results, each with up to 3 highlights of 500 characters. Price: 8 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500,
      "description": "Search query, 1 to 500 characters."
    },
    "numResults": {
      "type": "integer",
      "minimum": 1,
      "maximum": 10,
      "default": 5,
      "description": "Results to return, 1 to 10."
    },
    "type": {
      "type": "string",
      "enum": [
        "auto",
        "neural",
        "fast"
      ],
      "default": "auto",
      "description": "Search mode: auto (default), neural (semantic) or fast."
    },
    "includeDomains": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "minLength": 3,
        "maxLength": 253
      },
      "description": "Only return results from these domains (up to 20)."
    },
    "excludeDomains": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "minLength": 3,
        "maxLength": 253
      },
      "description": "Never return results from these domains (up to 20)."
    },
    "startPublishedDate": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
      "description": "Only pages published on or after this date (YYYY-MM-DD, UTC)."
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false
}

Clean text of up to 5 public pages, capped per page, for agents to read. Returns { results: [{ url, title, publishedDate, text, characters }] }: one entry per page the provider could read. Price: 6 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "urls": {
      "type": "array",
      "minItems": 1,
      "maxItems": 5,
      "items": {
        "type": "string",
        "minLength": 8,
        "maxLength": 2048,
        "pattern": "^https?://",
        "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
      },
      "description": "1 to 5 public http(s) URLs."
    },
    "maxCharacters": {
      "type": "integer",
      "minimum": 500,
      "maximum": 10000,
      "default": 5000,
      "description": "Text kept per page, 500 to 10,000 characters."
    }
  },
  "required": [
    "urls"
  ],
  "additionalProperties": false
}

Pages similar in meaning to a given public URL, with highlights. Up to 10 results. Returns { url, results: [{ title, url, publishedDate, score, highlights }] }. Price: 8 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
    },
    "numResults": {
      "type": "integer",
      "minimum": 1,
      "maximum": 10,
      "default": 5,
      "description": "Results to return, 1 to 10."
    },
    "excludeSourceDomain": {
      "type": "boolean",
      "default": true,
      "description": "Leave out pages from the same domain as the URL (default true)."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Main content of one public page as Markdown (up to 50,000 characters), with title and status. Returns { url, finalUrl, title, description, statusCode, markdown, characters, truncated }. Price: 7 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
    },
    "maxChars": {
      "type": "integer",
      "minimum": 1000,
      "maximum": 50000,
      "default": 20000,
      "description": "Markdown kept, 1,000 to 50,000 characters."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Discovers the URLs of a public site (up to 200), optionally ranked by a search term. Returns { url, count, links }: up to 200 unique public URLs. Price: 6 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
    },
    "search": {
      "type": "string",
      "maxLength": 200,
      "description": "Optional term to rank and filter links by, up to 200 characters."
    },
    "limit": {
      "type": "integer",
      "minimum": 1,
      "maximum": 200,
      "default": 100,
      "description": "Links to return, 1 to 200."
    },
    "includeSubdomains": {
      "type": "boolean",
      "default": false,
      "description": "Also include links on subdomains of the site."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Scrapes a public page and fills your flat schema (up to 20 typed fields) from it. Values are type-checked. Returns { url, finalUrl, title, data, missing }: one value per field (typed, or null when the page does not say) and the required fields that came back null. Price: 10 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
    },
    "schema": {
      "type": "object",
      "description": "Flat JSON Schema of what to extract: { type: \"object\", properties: { <name>: { type: string|number|integer|boolean, description?, enum? } }, required? }. 1 to 20 fields; names match ^[A-Za-z_][A-Za-z0-9_]{0,39}$; descriptions up to 200 characters; enums up to 20 values."
    }
  },
  "required": [
    "url",
    "schema"
  ],
  "additionalProperties": false
}

Profiles one public page: title, summary, organisations and other entities, topics, sentiment and public contact points. Returns { url, finalUrl, title, summary, entities: [{ text, type }], topics, sentiment: { label, score }, contact_points: { emails, phones, pages, social } }. Only role mailboxes (info@, sales@ ...) are returned. Price: 12 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local and metadata addresses, internal hostnames and this service's own hosts are refused."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Company profile from public web sources: name, description, industry, recent signals and the sources used. Returns { name, domain, description, industry, signals, sources: [{ url, title }] }: up to 5 signals and 8 sources. Organisations only, never people. Price: 14 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}

Named entities of fixed types (person, organization, location, product, event, date, money, law, technology), each found verbatim in your text. Returns { entities: [{ text, type }], counts }: up to 50 entities, each present in the (redacted) text, and a count per type. Price: 10 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to analyse, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted first."
    },
    "types": {
      "type": "array",
      "minItems": 1,
      "maxItems": 9,
      "items": {
        "type": "string",
        "enum": [
          "person",
          "organization",
          "location",
          "product",
          "event",
          "date",
          "money",
          "law",
          "technology"
        ]
      },
      "description": "Entity types to return; default all nine."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Key phrases of your text, each found verbatim in it; falls back to a frequency ranking if the model answer is unusable. Returns { keywords, source }: up to `max` phrases and whether they came from the model or the frequency fallback. Price: 10 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to analyse, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted first."
    },
    "max": {
      "type": "integer",
      "minimum": 1,
      "maximum": 25,
      "default": 10,
      "description": "Keywords to return, 1 to 25."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Positive, negative or neutral, with a score from -1 to 1, from a sentiment classifier over up to 8,000 characters. Returns { label, score, positive, negative, chunks }: label is positive, negative or neutral (below 0.6 confidence); score is positive minus negative. Price: 10 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "Text to analyse, 1 to 8,000 characters. Emails, phone numbers, card numbers, SINs and IPv4s are redacted first."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Says whether an IPv4 or IPv6 address is in Cloudflare's published edge ranges, and which range. Returns { ip, version, cloudflare, range, rangesAsOf }: range is the matching CIDR or null. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string",
      "minLength": 2,
      "maxLength": 64,
      "description": "IPv4 (dotted quad) or IPv6 address, without a port or zone id."
    }
  },
  "required": [
    "ip"
  ],
  "additionalProperties": false
}

Lints a wrangler.jsonc or wrangler.toml: name, entry point, compatibility date, secrets left in vars, routes. Returns { ok, format, findings[{ severity: error|warning|info, code, path, message }] and counts { error, warning, info } }. Values are never echoed, only paths. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "config": {
      "type": "string",
      "minLength": 2,
      "maxLength": 60000,
      "description": "The wrangler.jsonc, wrangler.json or wrangler.toml text, up to 60,000 characters."
    },
    "format": {
      "type": "string",
      "enum": [
        "auto",
        "jsonc",
        "toml"
      ],
      "default": "auto",
      "description": "Config format; auto treats text starting with { as JSONC, otherwise TOML."
    }
  },
  "required": [
    "config"
  ],
  "additionalProperties": false
}

Checks a cron expression against Cloudflare Cron Trigger syntax, explains it, lists the next runs and gives the wrangler snippet. Returns { valid, cron, errors, warnings, explanation, nextRuns (up to 5 ISO times, standard syntax only), snippets { jsonc, toml } }. Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "cron": {
      "type": "string",
      "minLength": 1,
      "maxLength": 120,
      "description": "Cron expression. Cloudflare uses 5 fields in UTC, weekdays 1 to 7 with 1 = Sunday (or SUN-SAT), and allows L, W and #."
    }
  },
  "required": [
    "cron"
  ],
  "additionalProperties": false
}

Validates a Claude Code .mcp.json: transports, commands, URLs, headers and env, and flags literal secrets by path. Returns { ok, servers[{ name, transport }], findings[{ severity: error|warning|info, code, path, message }] and counts { error, warning, info } }. Values are never echoed. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "config": {
      "description": "The config as a JSON string (comments and trailing commas allowed) or as an object, up to 60,000 characters."
    }
  },
  "required": [
    "config"
  ],
  "additionalProperties": false
}

Lints a CLAUDE.md: size, structure, @imports, and secrets, passwords or email addresses that should not be there. Returns { ok, stats { characters, lines, approxTokens, headings, imports }, findings[{ severity: error|warning|info, code, path, message }] and counts { error, warning, info } }. Paths are line numbers. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "The CLAUDE.md text, up to 60,000 characters."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Validates a Claude Code hooks block (or a whole settings.json): events, matchers, hook types, timeouts and risky commands. Returns { ok, events, hookCount, findings[{ severity: error|warning|info, code, path, message }] and counts { error, warning, info } }. Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "config": {
      "description": "The config as a JSON string (comments and trailing commas allowed) or as an object, up to 60,000 characters."
    }
  },
  "required": [
    "config"
  ],
  "additionalProperties": false
}

Writes a ready-to-save Claude Code slash command file with frontmatter, $ARGUMENTS and a step outline. Returns { path, content, usage }: save content at path (.claude/commands/<name>.md). Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9-]{0,39}$",
      "description": "Command name: lowercase letters, digits and -, up to 40 characters."
    },
    "description": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200,
      "description": "One-line description shown in the / menu."
    },
    "argumentHint": {
      "type": "string",
      "maxLength": 100,
      "description": "Optional hint for the arguments, e.g. [file] [focus]."
    },
    "allowedTools": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 220
      },
      "description": "Optional tool rules the command may use, e.g. Read or Bash(git diff:*)."
    }
  },
  "required": [
    "name",
    "description"
  ],
  "additionalProperties": false
}

Estimated token counts for cl100k-like, o200k-like, Claude-like and Llama-like tokenizers plus a char/4 baseline. Deterministic estimates, not exact counts. Returns { estimates: { cl100k, o200k, claude, llama, char4 }, chars, bytes, pieces, method, exact: false } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "Text to count, up to 60,000 characters."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Splits text for retrieval by estimated tokens, sentences or markdown headings, with token overlap and stable SHA-256 chunk ids. Returns { chunks: [{ id (sha-256 hex of the chunk text), index, text, tokens, start, end, heading? }], count, mode, size, overlap, family, method } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "Text or markdown to chunk, up to 60,000 characters."
    },
    "mode": {
      "type": "string",
      "enum": [
        "tokens",
        "sentences",
        "headings"
      ],
      "default": "sentences",
      "description": "Split by estimated tokens, by sentence boundaries, or by markdown heading sections (each chunk carries its heading)."
    },
    "size": {
      "type": "integer",
      "minimum": 32,
      "maximum": 4000,
      "default": 400,
      "description": "Target maximum estimated tokens per chunk, 32 to 4000."
    },
    "overlap": {
      "type": "integer",
      "minimum": 0,
      "maximum": 1999,
      "default": 40,
      "description": "Estimated tokens repeated from the end of one chunk at the start of the next; must be under half of size."
    },
    "family": {
      "type": "string",
      "enum": [
        "cl100k",
        "o200k",
        "claude",
        "llama"
      ],
      "default": "cl100k",
      "description": "Tokenizer family used for counts: cl100k, o200k, claude or llama (all estimates)."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Checks chat (OpenAI-style), messages (Anthropic-style) or Alpaca JSONL: per-line errors, role order, empty turns, duplicates, token estimates and a training-cost estimate from your price. Returns { format, lines, valid, invalid, ok, errors: [{ line, code, message }] (first 100), errorCount, errorsTruncated, duplicates: [{ line, firstLine }], duplicateCount, tokens: { total, mean, max }, costEstimate } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "jsonl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "JSONL: one JSON object per line, up to 60,000 characters and 5,000 lines. Blank lines are ignored."
    },
    "format": {
      "type": "string",
      "enum": [
        "auto",
        "openai",
        "anthropic",
        "alpaca"
      ],
      "default": "auto",
      "description": "openai (messages with system/user/assistant/tool), anthropic (top-level system + user/assistant messages), alpaca (instruction/input/output), or auto to detect from the first parseable row."
    },
    "pricePerMillionTokens": {
      "type": "number",
      "minimum": 0,
      "maximum": 10000,
      "description": "Optional: your training price per million tokens, used only for costEstimate (any currency)."
    },
    "epochs": {
      "type": "integer",
      "minimum": 1,
      "maximum": 50,
      "default": 3,
      "description": "Training epochs for the cost estimate, 1 to 50."
    }
  },
  "required": [
    "jsonl"
  ],
  "additionalProperties": false
}

Converts JSONL between OpenAI-style chat, Anthropic-style messages and Alpaca rows. System prompts move between the system message and the top-level field; rows that cannot convert are listed. Returns { from, to, converted, skippedCount, skipped: [{ line, reason }], jsonl } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "jsonl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "JSONL: one JSON object per line, up to 60,000 characters and 5,000 lines. Blank lines are ignored."
    },
    "from": {
      "type": "string",
      "enum": [
        "auto",
        "openai",
        "anthropic",
        "alpaca"
      ],
      "default": "auto",
      "description": "openai (messages with system/user/assistant/tool), anthropic (top-level system + user/assistant messages), alpaca (instruction/input/output), or auto to detect from the first parseable row."
    },
    "to": {
      "type": "string",
      "enum": [
        "openai",
        "anthropic",
        "alpaca"
      ],
      "description": "Target format: openai, anthropic or alpaca (alpaca takes single user/assistant exchanges only)."
    }
  },
  "required": [
    "jsonl",
    "to"
  ],
  "additionalProperties": false
}

Deterministic seeded shuffle and train/val/test split of JSONL rows. The same seed and input always give the same split. Returns { seed, ratios, counts: { train, val, test, skipped }, train, val, test } (each split as JSONL) Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "jsonl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "JSONL: one JSON object per line, up to 60,000 characters and 5,000 lines. Blank lines are ignored."
    },
    "seed": {
      "type": "string",
      "minLength": 1,
      "maxLength": 128,
      "default": "highland",
      "description": "Shuffle seed; any string."
    },
    "train": {
      "type": "number",
      "minimum": 0,
      "maximum": 1,
      "default": 0.8,
      "description": "Share of rows for train. train + val + test must equal 1."
    },
    "val": {
      "type": "number",
      "minimum": 0,
      "maximum": 1,
      "default": 0.1,
      "description": "Share of rows for validation."
    },
    "test": {
      "type": "number",
      "minimum": 0,
      "maximum": 1,
      "default": 0.1,
      "description": "Share of rows for test."
    }
  },
  "required": [
    "jsonl"
  ],
  "additionalProperties": false
}

Embeds 1 to 16 short texts with the fixed Workers AI model @cf/baai/bge-base-en-v1.5 (768 dimensions) for search and clustering. Returns { model, dimensions, count, vectors: number[][] } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "inputs": {
      "type": "array",
      "minItems": 1,
      "maxItems": 16,
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 2000
      },
      "description": "1 to 16 texts, each up to 2000 characters."
    }
  },
  "required": [
    "inputs"
  ],
  "additionalProperties": false
}

Ranks up to 15 candidate texts by cosine similarity to a query, using @cf/baai/bge-base-en-v1.5 embeddings. Returns { model, ranked: [{ index, score }] (highest first), scores: number[] (input order) } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2000,
      "description": "Query text, up to 2000 characters."
    },
    "candidates": {
      "type": "array",
      "minItems": 1,
      "maxItems": 15,
      "items": {
        "type": "string",
        "minLength": 1,
        "maxLength": 2000
      },
      "description": "1 to 15 candidate texts, each up to 2000 characters."
    }
  },
  "required": [
    "query",
    "candidates"
  ],
  "additionalProperties": false
}

Flags prompt-injection phrasing, chat-template tokens, hidden characters, PII and secrets per line, and lists {{variables}}. Rule-based, no model call; flagged text is never echoed. Returns { ok, findings: [{ kind, severity, line, detail }], counts: { high, medium, low }, variables } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "prompt": {
      "type": "string",
      "minLength": 1,
      "maxLength": 60000,
      "description": "Prompt or template text to check, up to 60,000 characters."
    }
  },
  "required": [
    "prompt"
  ],
  "additionalProperties": false
}

Decodes a JWT header and payload without verifying it, with warnings for alg none, missing or past exp, future nbf/iat and risky header fields. Returns { header, payload, signatureBytes, times: { exp, nbf, iat, expired }, verified: false, warnings, note } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "minLength": 5,
      "maxLength": 16000,
      "description": "Compact JWS (header.payload.signature). It is decoded only; do not send production tokens you cannot rotate."
    }
  },
  "required": [
    "token"
  ],
  "additionalProperties": false
}

Splits a URL into scheme, host, port, path segments, query (repeated keys as arrays) and fragment, with warnings for credentials, plain http and punycode. Passwords are never echoed. Returns { href, protocol, username, hasPassword, hostname, port, pathname, pathSegments, query, hash, origin, isIp, warnings } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8192,
      "description": "Absolute URL to parse. It is not fetched."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Encodes UTF-8 text to standard or url-safe base64, or decodes either form; binary results that are not valid UTF-8 come back as hex. Returns encode: { base64, variant, bytes } · decode: { text | null, hex | null, utf8, bytes } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "mode": {
      "type": "string",
      "enum": [
        "encode",
        "decode"
      ],
      "description": "encode turns text into base64; decode turns base64 into text (or hex)."
    },
    "data": {
      "type": "string",
      "maxLength": 48000,
      "description": "Text to encode, or base64 (standard or url-safe, padding optional) to decode."
    },
    "variant": {
      "type": "string",
      "enum": [
        "standard",
        "url"
      ],
      "default": "standard",
      "description": "Output alphabet when encoding: standard (+/ and padding) or url (-_ without padding)."
    }
  },
  "required": [
    "mode",
    "data"
  ],
  "additionalProperties": false
}

Generates 1 to 100 random v4 or time-ordered v7 UUIDs (RFC 9562) from Web Crypto. Returns { version, uuids: string[] } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "version": {
      "type": "integer",
      "enum": [
        4,
        7
      ],
      "default": 4,
      "description": "4 for random, 7 for Unix-ms time-ordered (sortable, good for database keys)."
    },
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 100,
      "default": 1,
      "description": "How many UUIDs, 1 to 100."
    }
  },
  "required": [],
  "additionalProperties": false
}

Identifies browser, engine, OS, device class and known crawlers, AI bots and HTTP clients from a User-Agent string. Rule-based; user agents can be spoofed. Returns { browser: { name, version }, engine, os: { name, version }, device, isBot, bot } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "userAgent": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2000,
      "description": "The User-Agent header value."
    }
  },
  "required": [
    "userAgent"
  ],
  "additionalProperties": false
}

Sends a GET with an Origin header (and an OPTIONS preflight for non-simple methods, custom headers or credentials) to a public URL and reports the Access-Control-* headers with an allowed/blocked verdict. Returns { url, finalUrl, origin, status, preflight: { status } | null, headers: { acao, acac, acam, acah, vary }, allowed, issues } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local, metadata and our own hosts are refused."
    },
    "origin": {
      "type": "string",
      "maxLength": 512,
      "pattern": "^https?://",
      "default": "https://example.com",
      "description": "Origin the browser would send, e.g. https://app.example.com."
    },
    "method": {
      "type": "string",
      "pattern": "^[A-Za-z]{3,10}$",
      "default": "GET",
      "description": "Method the browser call would use; non-simple methods trigger a preflight."
    },
    "requestHeaders": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "pattern": "^[A-Za-z0-9-]{1,64}$"
      },
      "description": "Request header names the call would send (triggers a preflight when non-empty)."
    },
    "credentials": {
      "type": "boolean",
      "default": false,
      "description": "Whether the call sends cookies or auth (credentials: include)."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Checks an OpenAPI 3.0/3.1 document (as JSON): version, info, paths, responses, unique operationIds, declared path parameters and unresolved local $refs. Returns { valid, version, operations, refs, unresolvedRefs, errors: [{ path, message }], warnings: [{ path, message }] } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "spec": {
      "type": "object",
      "description": "The OpenAPI document as a JSON object (convert YAML first). Request bodies are capped at 64 KiB."
    }
  },
  "required": [
    "spec"
  ],
  "additionalProperties": false
}

Name, meaning, class, retryability and default cacheability of an HTTP status code, including Cloudflare's 52x codes. Returns { code, name, meaning, class, known, retryable, cacheableByDefault } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "code": {
      "type": "integer",
      "minimum": 100,
      "maximum": 599,
      "description": "Status code, 100 to 599."
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}

Fetches a public page (first 512 KB) and returns its link-preview metadata: title, description, image, Open Graph and Twitter tags, canonical URL, icons and missing tags. Returns { url, finalUrl, status, title, description, image, siteName, canonical, icons, lang, og, twitter, missing, truncated } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 8,
      "maxLength": 2048,
      "pattern": "^https?://",
      "description": "Public http(s) URL. Private, loopback, link-local, metadata and our own hosts are refused."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Reviews a code snippet and returns concrete issues (bugs, security, performance, style) with severity and a fix for each. Returns { language, summary, issues: [{ severity, line, issue, fix }] } Price: 4 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "minLength": 1,
      "maxLength": 6000,
      "description": "Source code to review, up to 6,000 characters."
    },
    "language": {
      "type": "string",
      "minLength": 1,
      "maxLength": 40,
      "description": "Language name, or omit to auto-detect."
    }
  },
  "required": [
    "code"
  ],
  "additionalProperties": false
}

Turns a unified diff into a Conventional Commits message: type, scope, subject and body. Returns { message, type, scope, subject, body } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "diff": {
      "type": "string",
      "minLength": 1,
      "maxLength": 7000,
      "description": "Unified diff (git diff output), up to 7,000 characters."
    }
  },
  "required": [
    "diff"
  ],
  "additionalProperties": false
}

Writes a JavaScript regex from a plain-English description, compiles it, and tests it against your sample strings. Returns { pattern, flags, literal, explanation, tests: [{ input, expected, got }], passed, total } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "description": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500,
      "description": "What the regex should match, in plain English."
    },
    "should_match": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "maxLength": 500
      },
      "description": "Strings that must match."
    },
    "should_not_match": {
      "type": "array",
      "maxItems": 20,
      "items": {
        "type": "string",
        "maxLength": 500
      },
      "description": "Strings that must not match."
    }
  },
  "required": [
    "description"
  ],
  "additionalProperties": false
}

Explains a SQL query step by step and flags performance and safety risks, with index suggestions. Returns { summary, steps, risks, index_suggestions } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "sql": {
      "type": "string",
      "minLength": 1,
      "maxLength": 5000,
      "description": "One SQL statement, up to 5,000 characters. It is not executed."
    }
  },
  "required": [
    "sql"
  ],
  "additionalProperties": false
}

Sorts versions by SemVer 2.0 precedence, returns the latest stable and pre-release, and the next major, minor and patch. Returns { sorted, latest_stable, latest, invalid, next: { major, minor, patch, from } } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "versions": {
      "type": "array",
      "minItems": 1,
      "maxItems": 500,
      "items": {
        "type": "string",
        "maxLength": 100
      },
      "description": "Version strings, optionally v-prefixed."
    }
  },
  "required": [
    "versions"
  ],
  "additionalProperties": false
}

Fetches a public page and returns clean, LLM-ready Markdown of the main content, with title, word and link counts. No third-party scraper. Returns { url, title, words, links, truncated, markdown } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "Public http(s) URL to fetch. Private and internal hosts are refused."
    },
    "max_chars": {
      "type": "integer",
      "minimum": 500,
      "maximum": 50000,
      "description": "Markdown kept, default 20,000."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Pulls the fields you name out of free text (emails, invoices, tickets) and returns strict JSON, null when a field is absent. Returns { data: { <field>: value | null }, found, total } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 6000,
      "description": "Source text, up to 6,000 characters."
    },
    "fields": {
      "type": "array",
      "minItems": 1,
      "maxItems": 30,
      "items": {
        "type": "string",
        "pattern": "^[\\w .-]{1,40}$"
      },
      "description": "Field names to extract."
    }
  },
  "required": [
    "text",
    "fields"
  ],
  "additionalProperties": false
}

Builds ready-to-paste tool definitions for Anthropic, OpenAI and MCP from a compact parameter spec. Returns { anthropic, openai, mcp } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_-]{1,64}$",
      "description": "Tool name."
    },
    "description": {
      "type": "string",
      "minLength": 1,
      "maxLength": 1000,
      "description": "What the tool does."
    },
    "params": {
      "type": "object",
      "description": "Map of parameter name to \"type[:extra][!] description\"; types string, number, integer, boolean, object, enum:a,b, array:itemtype; ! marks required."
    }
  },
  "required": [
    "name",
    "description"
  ],
  "additionalProperties": false
}

Scans untrusted text (web pages, emails, tool output) for prompt-injection patterns before it reaches your agent; returns a risk score and the hits. Returns { risk: none|low|medium|high, score, hits: [{ rule, weight, match, index }] } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100000,
      "description": "Untrusted text, up to 100,000 characters."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false
}

Audits a live page: title and description length, H1s, canonical, robots, lang, viewport, image alts, structured data and links, scored 0-100. Returns { url, status, score, title, description, h1_count, images, images_missing_alt, links, checks: [{ id, pass, weight }] } Price: 3 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "Public http(s) URL to fetch. Private and internal hosts are refused."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Computes the WCAG 2.2 contrast ratio of two colours, pass/fail for AA and AAA, and the nearest passing foreground when it fails. Returns { ratio, aa_normal, aa_large, aaa_normal, aaa_large, ui_components, suggested_foreground } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "foreground": {
      "type": "string",
      "pattern": "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$",
      "description": "Text colour, hex."
    },
    "background": {
      "type": "string",
      "pattern": "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$",
      "description": "Background colour, hex."
    }
  },
  "required": [
    "foreground",
    "background"
  ],
  "additionalProperties": false
}

Reads a site's robots.txt and says whether a crawler may fetch a path, with the matching rule, the major AI crawlers' access and the sitemaps. Returns { robots_url, robots_status, agent, path, allowed, rule, ai_crawlers, sitemaps } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2048,
      "description": "Public http(s) URL to fetch. Private and internal hosts are refused."
    },
    "agent": {
      "type": "string",
      "minLength": 1,
      "maxLength": 100,
      "description": "Crawler user agent, default *."
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false
}

Verifies Stripe, GitHub, Slack, Shopify or generic HMAC-SHA256 webhook signatures exactly as the provider computes them, with timestamp tolerance. Returns { provider, valid, timestamp?, age_s?, within_tolerance? } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "provider": {
      "type": "string",
      "enum": [
        "stripe",
        "github",
        "slack",
        "shopify",
        "hmac-sha256"
      ],
      "description": "Signature scheme."
    },
    "secret": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500,
      "description": "Webhook signing secret. Use a test secret; it is not stored."
    },
    "payload": {
      "type": "string",
      "minLength": 0,
      "maxLength": 500000,
      "description": "Raw request body exactly as received."
    },
    "signature": {
      "type": "string",
      "minLength": 1,
      "maxLength": 2000,
      "description": "Signature header value (Stripe-Signature, X-Hub-Signature-256, X-Slack-Signature, X-Shopify-Hmac-Sha256, or hex/base64)."
    },
    "timestamp": {
      "type": "string",
      "minLength": 1,
      "maxLength": 20,
      "description": "Slack only: X-Slack-Request-Timestamp."
    },
    "tolerance_s": {
      "type": "integer",
      "minimum": 1,
      "maximum": 86400,
      "description": "Allowed clock skew for Stripe and Slack, default 300."
    }
  },
  "required": [
    "provider",
    "secret",
    "payload",
    "signature"
  ],
  "additionalProperties": false
}

Converts a curl command into JavaScript fetch, Python requests, Go net/http or PHP code. Returns { language, request: { url, method, headers, data }, code } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "curl": {
      "type": "string",
      "minLength": 1,
      "maxLength": 8000,
      "description": "A curl command line."
    },
    "language": {
      "type": "string",
      "enum": [
        "javascript",
        "python",
        "go",
        "php"
      ],
      "description": "Target language, default javascript."
    }
  },
  "required": [
    "curl"
  ],
  "additionalProperties": false
}

Generates realistic sample JSON from a JSON Schema or OpenAPI schema object, with field-aware values (emails, UUIDs, dates, URLs). Returns { data } or { data: [...], count } Price: 1 credit (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "schema": {
      "type": "object",
      "description": "JSON Schema (or OpenAPI schema object) of one response item."
    },
    "count": {
      "type": "integer",
      "minimum": 1,
      "maximum": 20,
      "description": "Items to generate, default 1."
    }
  },
  "required": [
    "schema"
  ],
  "additionalProperties": false
}

Modern WHOIS over RDAP: registrar, creation and expiry dates, days to expiry, status codes, nameservers and DNSSEC. Returns { domain, registrar, created, updated, expires, days_to_expiry, status, nameservers, dnssec } Price: 2 credits (1 credit = 1 CAD cent) per successful call; input that does not match the schema is rejected before billing.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "minLength": 4,
      "maxLength": 253,
      "description": "Public domain name, e.g. example.com; IP literals and private suffixes (.local, .internal, .lan, .corp) are refused."
    }
  },
  "required": [
    "domain"
  ],
  "additionalProperties": false
}