1019 Services from api.delx.ai

Extracts bounded UTF-8 text from a caller-supplied base64-encoded PDF using local first-party parsing, with no document storage.

Performs OCR on up to 10 pages of a base64-encoded scanned PDF, returning extracted text, confidence scores, page counts, and a SHA-256 receipt for $0.01 USDC via x402.

Generates a public WebP image from a text prompt using FLUX Schnell, returning a URL, SHA-256 receipt, and support for 11 aspect ratios, paid per-call via x402 at $0.01 USDC.

Converts text to high-definition audio using the MiniMax speech-02-hd model with configurable voice, emotion, pitch, speed, and language.

Generates a self-contained PNG or SVG QR code from any text or URL, returned as a data URI with a SHA-256 receipt, for $0.001 USDC via x402.

Search recent GDELT Project news metadata and return attributed publisher headline links for a given query and timespan.

Generates a fast 4-second 720p AI video draft from a text prompt, returning a durable MP4 URL and SHA-256 receipt for $0.03 USDC via x402.

Computes the output token amount for a given input in a constant-product (x*y=k) AMM swap using caller-supplied reserves and fee, returning the result as deterministic JSON.

Computes the price impact in basis points for a swap against AMM reserves using deterministic constant-product math, returning mid-price vs execution price comparison.

Generates a controller-ready incident brief summarizing symptoms, actions taken, current status, and next decision points for a failing or drifting agent or system.

Computes Black-Scholes d1 and d2 intermediate values from spot price, strike price, volatility, time to expiry, and risk-free rate

Computes call and put delta for European options using the Black-Scholes closed-form formula given spot, strike, volatility, rate, and time to expiry.

Computes a compact set of Black-Scholes Greeks (delta, gamma, vega, theta) for a European call option using deterministic local math

Validates cookie security attributes (Secure, HttpOnly, SameSite) against a caller-defined policy and returns a deterministic pass/advisory verdict

Search recent attributed crypto news headlines (Bitcoin, Ethereum, DeFi, Web3) via the GDELT Project, returning publisher links and bounded headline metadata.

Produces or validates an EIP-55 checksummed EVM address locally and deterministically, with no network calls or live chain data.

Creates a durable, paid promise that waits for a time or webhook condition, then releases an opaque continuation envelope with an Ed25519 receipt upon capability authorization.

Calculates a bounded exponential backoff schedule given a number of retry attempts, base delay, and cap, returning a machine-readable list of wait intervals.

Converts a positive integer into its Roman numeral representation for display formatting, outlines, and labels.

Executes a bounded read-only eth_call on the Base blockchain for $0.002 USDC, with a 4KB data/response cap.

Aggregates a company's contact information from page contacts, forms, social profiles, registrar records, and security channels into a single structured pack.

Extracts email addresses, phone numbers, and social media profile links from a given web page URL for outreach, routing, and support use cases.

Measures how well a set of implemented governance controls covers a required set, returning deterministic JSON gap analysis.

Validates and describes a five-field cron expression, returning a human-readable schedule summary and upcoming run timestamps.

Audits a Content-Security-Policy header string for missing defaults and unsafe script directives, returning structured JSON findings.

Converts raw CSV data into structured JSON rows suitable for downstream AI agents, prompts, and ETL pipelines.

Classifies a list of field names to identify which likely contain sensitive data, without inspecting actual values, returning deterministic machine-readable JSON.

Checks whether an architecture decision record (ADR) contains the required accountable essentials, returning a machine-readable JSON assessment.

Runs a composite security and trust assessment on a domain, combining TLS, HTTP headers, security.txt, RDAP, DNS, and uptime signals into a single report.

Identifies duplicate record groups in a supplied dataset using canonical fingerprints, returning machine-readable JSON cluster results without exposing raw record values.

Validates an email address and its domain-level DNS delivery records (MX, SPF, DKIM) to confirm deliverability before outreach, signup, or routing.

Calculate remaining error budget and burn rate from total requests, failed requests, and an SLO target percentage

Discovers RSS, Atom, and JSON feeds for a given URL so agents can subscribe to content updates instead of scraping pages repeatedly.

Extracts HTML forms, their HTTP methods, action URLs, and input fields from a webpage for browser automation and workflow planning.

Calculates gross profit, gross margin percentage, and profitability from cost and price inputs

Fetches and audits the HTTP response headers of a given URL, surfacing security, cache, redirect, and server signals.

Derives a deterministic, namespaced idempotency key from canonical JSON to prevent duplicate operations in autonomous workflows.

Resize or convert a single base64-encoded PNG, JPEG, or WebP image to a specified max dimension and output format, returning a durable artifact with a SHA-256 receipt

Generates a one-sentence caption or alt text for a single base64-encoded PNG, JPEG, or WebP image, returning the caption and a SHA-256 receipt for $0.005 USDC.

Extracts machine-printed English text from a base64-encoded PNG, JPEG, or WebP image using local Tesseract OCR, returning the text, confidence score, and a SHA-256 receipt for $0.01 USDC via x402.

Revalues a dollar amount between two years using U.S. Bureau of Labor Statistics CPI data, priced at $0.002 USDC per call via x402.

Validates a JSON payload against a caller-supplied structural contract and returns path-level validation errors

Validates, normalizes, and pretty-prints a JSON payload, returning structured errors or a formatted result for $0.001 USDC per call.

Look up a Legal Entity Identifier (LEI) via GLEIF to retrieve its status and legal entity name for $0.002 USDC.

Computes Levenshtein edit distance and string similarity score between two input strings for $0.001 USDC per call.

Compares a list of requested OAuth scopes against the minimum required scopes and returns a deterministic JSON audit result for preflight validation in agent workflows.

Detects removed paths and methods between two OpenAPI specifications to identify client-breaking changes before deployment

Extracts Open Graph and Twitter Card metadata fields from a URL to preview how it will render in social feeds and AI agents.

Redacts common personally identifiable information (PII) from text, returning a sanitized version as machine-readable JSON

Counts likely personal-data classes in a text input without echoing detected values, returning a machine-readable JSON risk summary.

Extracts pricing signals including plans, trial offers, sales CTAs, and conversion routes from a given pricing page URL.

Screens untrusted text for prompt-injection and tool-coercion signals before an AI agent acts on it, returning a machine-readable JSON safety verdict.

Fetches registrar, registration status, and registration dates for a domain via RDAP for trust, compliance, and domain operations.

Tests a regular expression against input text and returns all matches, capture groups, and match counts.

Generates a deterministic bounded exponential backoff retry delay schedule with a configurable hard delay cap

Detects likely credentials and private keys in text without revealing their values, returning bounded machine-readable JSON

Scores the presence of five high-value browser security headers in a given set of HTTP response headers, returning a deterministic machine-readable JSON result.

Fetches and parses a domain's security.txt file to extract security contacts, disclosure policies, and trust links.

Scans untrusted text for SQL injection attack signals and returns a deterministic machine-readable JSON result

Screens a URL for SSRF risks including private/internal hosts, unsafe schemes, and embedded credentials, returning machine-readable JSON results.

Summarizes log severity and hashed error fingerprints from raw log text, returning bounded machine-readable JSON without exposing sensitive error lines

Detects gaps larger than an expected interval in a list of ISO-8601 timestamps and returns a machine-readable JSON report of where those gaps occur.

Inspects a domain's TLS certificate to retrieve issuer, subject, SANs, and expiry details for trust assessment and renewal risk evaluation.

Estimates GPT-style and Claude-style token counts for a given text payload, returning deterministic results without requiring an API key.

Compare a list of requested agent tools against an explicit least-privilege allowlist and return a deterministic JSON audit report of permitted and denied tools.

Converts values between units of measurement across length, mass, volume, time, data, and temperature — supporting up to 100 conversions per call.

Checks URL reachability, HTTP status code, response latency, and key headers for any given URL.

Splits a URL into its constituent parts: scheme, netloc, path, query, and fragment — no network access required.

Geocodes a single U.S., Puerto Rico, or U.S. Island Areas address to approximate latitude/longitude coordinates via the public Census Geocoder for $0.001 USDC.

Decodes a 17-character Vehicle Identification Number (VIN) via NHTSA vPIC to return make, model, year, and attribution data for $0.004 USDC.

Fetches a composite intelligence report for any URL, including page metadata, internal/external links, RSS/Atom feeds, forms, and contact signals.

Verifies a SHA-256 Digest header value against caller-supplied text bytes, returning a deterministic pass/fail result with computed hash evidence.

Compares two caller-supplied DNS record snapshots and returns a deterministic diff of added, removed, and unchanged records without making any live DNS requests.

Returns daily European Central Bank (ECB) reference exchange rates for a given date and optional set of currency pairs, using EUR or another currency as the base.

Converts an ETH amount (decimal) into its equivalent wei integer string for use in blockchain transaction value fields and allowances.

Deduplicates a list of EVM blockchain addresses, returning unique addresses and a count of removed duplicates.

Checks whether a given EVM address is the zero address (0x0000000000000000000000000000000000000000)

Computes the maximum base fee in wei that an EVM network could reach after a given number of blocks, given a fractional growth rate and starting base fee.

Checks whether a transaction has reached finality on an EVM chain by comparing current block height, inclusion block, and required confirmation depth.

Checks whether an EVM wallet's native token balance is sufficient to cover a transaction value plus a fee ceiling, returning sufficiency, required amount, available amount, and shortfall.

Checks whether the gap between a pending and proposed EVM nonce is within a specified maximum budget and whether a replacement is possible.

Checks whether a proposed EVM transaction nonce targets any pending nonces in a list, enabling pre-flight nonce replacement safety validation.

Checks whether a new EVM transaction fee (in wei) represents a sufficient bump over the old fee, given a minimum bump fraction threshold.

Validates whether the actual slippage on an EVM token swap falls within a specified maximum slippage policy, returning the computed slippage in basis points and a pass/fail result.

Extracts all numbers from free-form text and returns them as an ordered list, without regex maintenance or LLM overhead.

Calculates the structured time delta between two ISO-8601 timestamps, returning the difference in discrete units like days, hours, minutes, and seconds.

Computes the Kelly Criterion fraction for a binary bet given the true probability and market price

Computes the full Kelly criterion fraction from win probability and net payoff odds for optimal bankroll sizing

Converts text to speech audio using the Kokoro TTS model, returning a durable audio URL and SHA-256 receipt, paid per-clip via x402 micropayment at $0.001 USDC.

Computes a simplified Sharpe-like ratio (mean/stdev) from an array of returns, with no risk-free rate adjustment, for quick risk-adjusted ranking of strategies.

Computes a deterministic upper-bound price impact loss for a CPMM trade given trade size and pool reserves, without any blockchain or mempool access.

Generates a narrated still-image MP4 by composing a FLUX Schnell image and Kokoro voiceover into a single agent-ready video file for $0.02 USDC per call.

Returns a normalized multi-period National Weather Service (NOAA/NWS) weather forecast for a given US latitude/longitude coordinate

Search Wikidata-backed entity metadata (stable IDs, labels, descriptions, source links) for public places, companies, and concepts

Search English Wikipedia metadata via the Wikimedia API, returning attributed page links and short snippets for a given query at $0.001 USDC per call.

Computes L1 order book imbalance as (bid_size - ask_size) / (bid_size + ask_size), returning a normalized value in [-1, 1]

Fetches a URL and returns clean page metadata plus readable extracted text, ready for search, routing, or summarization.

Computes the OLS (ordinary least squares) hedge ratio beta of y on x (no intercept) for sizing the short leg in a pairs trade.

Normalizes a free-form phone number string into E.164 canonical format (e.g. +14155550100) given an optional default region code.

Calculates net profit and loss on a sized position after applying entry and exit fee rates, returning a deterministic JSON result.

Calculates the correct position size given account equity, risk percentage, entry price, and stop price using fixed-fractional sizing math.

Reformats serialized JSON text into indented, human-readable output; returns a structured error for invalid JSON.

Generates high-quality FLUX 1.1 Pro images via x402 micropayment at $0.06 USDC, returning a public WebP URL and SHA-256 hash — optimized for hero shots, campaign creatives, and brand-facing assets.

Selects a reproducible, deterministic random sample without replacement from a caller-supplied list using a seed string, returning sampled values, original indices, and a seed hash.

Computes the approximate liquidation price for a short leveraged position given entry price, leverage, and maintenance margin rate

Computes the Compound Annual Growth Rate (CAGR) from a start value, end value, and number of years using local deterministic math.

Computes volume-weighted average price (VWAP) and total volume from a list of price/size sample pairs using local deterministic math.

Calculates a stop-loss price given an entry price, a percentage risk, and trade side (long/short) using local deterministic math.

Calculates a take-profit price level given an entry price, a target percent move, and a trade side (long/short).

Converts a human-readable ERC-20 token amount into its on-chain raw integer representation by scaling by the token's decimal places.

Calculates expected profit or loss per trade given a list of PnL values, helping traders assess whether a system has a positive edge before scaling position size.

Validates a URL redirect target against caller-supplied allowed schemes and hosts, returning a deterministic pass/advisory finding as versioned JSON.

Converts a wei integer string to its equivalent ether float value for display in dashboards, receipts, and logs.

Validates and measures a third-party x402 payment endpoint by performing a live GET/402 handshake, checking contract fields, and returning a signed observation receipt — without making any payment.

Validates x402 HTTP 402 payment requirements against caller-defined constraints (max USDC amount, allowed networks, scheme, recipient, expiry) before a wallet signs, returning eligible accepts and any blockers.

Generates operator-ready root cause analysis for incidents, including evidence, corrective actions, and prevention steps.

Measures endpoint status, latency, redirects, content type, and reachability for any URL in a single call.

Fetches ERC-20 token name, symbol, and decimals for a given token contract on the Base blockchain via eth_call for $0.001 USDC per call.

Analyzes a set of dependency declarations to identify unbounded or risky version specifications before installation

Replaces an image background with studio gray or a custom hex color fill, returning an opaque PNG and SHA-256 receipt for $0.003 USDC per call.

Summarizes an OpenAPI document into its title, version, path counts, tags, and authentication hints

Fetches and parses a domain's robots.txt rules and sitemap declarations to reveal crawlability, disallow paths, and indexing directives before scraping or indexing.

Infers field types and nullability from a bounded array of JSON records, returning a deterministic machine-readable schema summary.

Resolves A, AAAA, CNAME, MX, TXT, and NS DNS records for a given domain to support delivery checks and domain intelligence.

Parses and indexes named GraphQL operations (queries, mutations, subscriptions) from a document string, returning a structured machine-readable JSON list of all operations found.

Computes profit factor (gross wins divided by gross losses) from a list of PnL values using local deterministic math.

Returns the native ETH balance for a single Ethereum address on Base mainnet via live JSON-RPC, charged at $0.001 USDC per call.

Calculate step-by-step and overall conversion rates from an ordered sequence of funnel stages

Colorizes a single grayscale photo (PNG, JPEG, or WebP) into a color PNG for $0.01 USDC, returning the colorized image and a SHA-256 receipt.

Extracts and maps all internal and external hyperlinks from a given webpage URL for crawling, routing, and site inspection.

Measures the distribution of null and missing fields across an array of JSON records, returning per-field null counts and rates.

Computes a stepped ladder of approximate liquidation prices across sequential leverage reductions for a leveraged position, using deterministic local math.

Computes spot-to-payoff data points for multi-leg options strategies using local closed-form math, suitable for drawing payoff diagrams offline.

Computes the absolute profit or loss in quote currency units from a closed trade given entry price, exit price, and position size.

Ranks offered media types against weighted HTTP Accept header ranges to determine the best match for content negotiation

Ranks a list of offered languages against a weighted Accept-Language HTTP header to determine the best language match for a web response.

Adds a specified amount of time (in a given unit) to an ISO 8601 date or timestamp and returns the shifted ISO timestamp

Computes a person's age in whole years from an ISO-8601 birthdate for eligibility checks and profile enrichment.

Calculates a weighted quality score for agent deliveries by combining completeness, validity, freshness, and latency metrics to produce an accept/reject decision.

Validates that all required output paths in an agent result object are non-null, returning acceptance/rejection status with mismatch reasons and normalized evidence.

Validates whether a declared agent result cost falls within a caller-supplied USDC budget, returning an explicit accept/reject status with mismatch reasons

Validates whether an agent-delivered result is within an acceptable age window by comparing observation timestamp against current time and a caller-supplied maximum age budget.

Estimates the output amount for a concentrated liquidity (V3) AMM swap using constant-product math, assuming price stays within a specified range, without any on-chain calls.

Generates a structured, controller-readable recovery plan with stabilize, diagnose, recover, and prevent phases for agents that are looping, drifting, or failing.

Returns a fleet-wide controller summary including top patterns, agent health status, active alerts, and recommended follow-up actions across all monitored agents.

Computes the arithmetic mean of a numeric array and returns the result as JSON, billed per call via x402.

Identifies the authorization scheme present in a caller-supplied HTTP header without validating credentials or contacting any external provider.

Computes the volume-weighted average entry price across multiple trade fills, returning the blended cost basis and total position size.

Encodes or decodes text using Base32, returning the transformed result along with the mode used

Computes a detailed breakdown of EVM transaction fee components (base, priority, ceiling) given gas limit and fee parameters in wei.

Validates a caller-supplied Base gas price and gas limit against an ETH transaction budget using exact Wei arithmetic, returning fee estimate, budget headroom, and optional USD estimate.

Validates whether a payment deadline epoch falls within an acceptable lead-time window relative to a given current epoch.

Validates that a Base chain USDC payment's recipient and amount match expected values for pre-flight payment verification.

Validates that a given Base USDC payment recipient address matches an expected address before executing a transaction.

Annualizes futures-spot basis percentage from raw premium, spot price, and days to delivery for carry trade analysis

Computes futures basis in basis points (bps) from a spot price and a future price using local deterministic math.

Computes the basis percentage between a futures price and spot price as (future − spot) / spot, enabling carry and premium/discount analysis.

Converts an integer basis points value to its unit-interval decimal fraction (bps / 10000) for use in fee, funding, or slippage calculations.

Computes an ordered list of bounded chunk offsets and counts given a total item count and a desired chunk size, returning a versioned deterministic JSON plan.

Validates whether a batch's failed item count and failure fraction are within caller-specified budget thresholds, returning bounded counts, normalized values, and a versioned deterministic result.

Validates whether a given BIC/SWIFT code is correctly formatted

Computes the edge (expected value advantage) for a binary outcome bet given a true probability and a market price

Computes the expected value of a 'No' position in a binary prediction market given stake, true probability, and current market price.

Estimates seconds until a target block height is reached given current block height offset and average block time, returning ETA and remaining block count.

Computes the break-even exit price for a trade position, accounting for a round-turn fee rate, so that profit targets actually clear all fees.

Computes the Brier score for a probabilistic forecast given a predicted probability and a binary outcome

Generates a low-cost commercial image via SDXL Lightning from a text prompt, returning a public WebP URL and SHA-256 hash for $0.005 USDC per call.

Compares two Cache-Control header strings and returns a structured diff of added, removed, and changed directives with a pass/advisory status.

Parses a Cache-Control HTTP header string into typed, normalized policy fields with a deterministic pass/advisory verdict

Calculates remaining HTTP cache freshness from caller-supplied response timing metadata (now, date, age, max-age) and returns a deterministic pass/advisory verdict

Applies a Caesar shift cipher to input text, shifting each alphabetic character by a specified integer amount, for use in puzzles, CTF challenges, or toy encoding scenarios.

Parses a CAIP-2 chain identifier string into its constituent namespace and reference components as deterministic JSON

Computes Expected Calibration Error (ECE) from forecast probabilities and binary outcomes to measure probabilistic model calibration quality.

Backs out an implied spot price from a futures/mark price and an annualized carry rate over a given number of days to delivery.

Splits a JSON array into fixed-size chunks to support batching, pagination, and payload-limit compliance

Compounds a list of period returns into a total growth factor and cumulative return via local deterministic math.

Computes blockchain confirmations observed vs. required given a transaction block, current head block, and target confirmation count.

Parses an HTTP Content-Disposition header to extract disposition type, filename, and safe parameters deterministically without external dependencies.

Parses a Content-Type header value into its media type and parameters, returning a normalized, deterministic result with a pass/advisory status.

Evaluates whether a cookie's Domain attribute matches a request host according to RFC host-only and Domain cookie matching rules, returning a deterministic pass/advisory verdict.

Parses a raw Set-Cookie HTTP header value into its name, value, and attributes, returning a normalized, deterministic JSON result with pass/advisory status.

Computes a CRC32 checksum (returned as hex) for any input text, enabling quick integrity fingerprinting of configs, prompts, or cached blobs.

Computes the next N fire timestamps for a cron expression starting from a given Unix timestamp

Parses a Content-Security-Policy header value into normalized source lists and returns a structured pass/advisory finding with deterministic versioned JSON

Detects duplicate composite keys in CSV data rows using caller-supplied column names, returning counts and normalized findings as versioned deterministic JSON.

Finds and counts duplicate normalized rows in a CSV text payload, returning structured deduplication results as versioned deterministic JSON.

Filters CSV rows in-memory, keeping only rows where a specified column's value matches one of a caller-supplied allowlist of values, returning counts and normalized results as versioned deterministic JSON.

Parses the first row of a UTF-8 CSV string and returns the column header names as a list

Inner-joins two CSV tables on a shared key column and returns the merged result as deterministic JSON with row counts and normalized values.

Performs a SQL-style left join of two CSV tables on a specified key column, returning the merged result as deterministic versioned JSON with row counts and normalized values.

Normalizes caller-specified null tokens (e.g. 'NA', 'NULL', 'N/A') to empty cells in a CSV text, returning counts and a versioned deterministic result.

Renames CSV header columns according to a caller-supplied mapping, returning the transformed CSV with counts and normalized values as deterministic JSON.

Counts the number of rows in a UTF-8 CSV string, including the header row, for import size estimation or upload validation.

Infers column names and data type hints from a CSV text sample, returning a deterministic JSON schema report.

Sorts CSV rows by a specified column, ascending or descending, and returns the reordered CSV with transformation metadata.

Trims surrounding whitespace from every cell in a caller-supplied CSV string, returning normalized values with counts and a versioned result contract.

Converts wide-format CSV columns into long-format name/value row pairs, returning normalized row counts and a versioned deterministic result.

Computes historical Conditional Value at Risk (CVaR/Expected Shortfall) at a given alpha from a return series using local math, returning var and cvar as deterministic JSON.

Classifies an HTTP status code and optional response body into a structured error taxonomy with retry and remediation guidance

Scores how integration-ready an API looks by combining health, OpenAPI spec availability, and authentication surface hints into a single readiness signal.

Routes an agent action to an appropriate human approval class (e.g. auto-approve, flag, escalate, block) based on risk level and transaction value

Removes null and empty values from an input array and returns the compacted list along with counts of remaining and removed items.

Deduplicate an array of items while preserving original order, returning unique items and their count

Normalizes audit event objects and hashes the actor identifier, returning deterministic machine-readable JSON for use as a preflight or analysis step in enterprise agent workflows.

Encodes or decodes Base64 strings deterministically and safely for $0.001 USDC per call

Base64url-encodes a text string without padding, suitable for JWT segments and URL-safe tokens

Fetches a Base blockchain block header by its hash using eth_getBlockByHash via a pay-per-call x402 API.

Checks whether a Base network address is a smart contract and returns its bytecode size via eth_getCode.

Returns the ERC-20 token balance of a holder address on Base mainnet by executing a balanceOf eth_call, charged at $0.001 USDC per call via x402.

Estimates the gas required for a bounded Ethereum call on the Base network via eth_estimateGas (max 4KB data payload).

Returns a real-time snapshot of Ethereum Base network gas price, base fee, and priority fee via live JSON-RPC for $0.001 USDC.

Returns the latest Base mainnet block header (number, hash, timestamp, gas) via live JSON-RPC for $0.001 USDC per call

Fetches Ethereum event logs from the Base blockchain within a bounded range (≤5 blocks, ≤50 logs) via eth_getLogs for $0.002 USDC per call.

Returns the transaction count (nonce) for a given Base network address via eth_getTransactionCount for $0.001 USDC.

Reads a single storage slot on the Base blockchain using eth_getStorageAt for $0.001 USDC per call.

Look up a Base blockchain transaction by hash via live JSON-RPC, optionally including the transaction receipt.

Fetches a Base blockchain transaction receipt by hash using eth_getTransactionReceipt, returning full on-chain receipt data for $0.001 USDC per call.

Recommends an optimal batch size given item count, hard item cap, hard byte cap, and average item bytes

Calculates the break-even unit quantity from a fixed cost and contribution margin per unit

Counts business days between two dates, accounting for weekdays and US federal holidays, without relying on any third-party calendar API.

Audits HTTP cache headers to detect missing cache policies and sensitive data exposed via public caching

Masks a digit string (e.g. a card number) keeping only the last 4 digits visible, returning both the masked string and last4.

Converts a text string between common programming case formats such as snake_case, kebab-case, camelCase, and PascalCase.

Converts an input string to snake_case format, returning deterministic machine-readable JSON

Builds a bounded frequency distribution (counts and proportions) for an array of categorical values, returning deterministic JSON analytics.

Looks up a static mapping from a numeric chain ID or network slug to its canonical network name, with no live RPC call required.

Scores the deployment risk of a production change based on explicit change signals, returning a deterministic machine-readable risk assessment.

Computes a hash digest and byte size for caller-supplied content, returning deterministic checksum metadata as JSON

Deterministically maps a seed string into an integer index within [0, length) for stable, stateless A/B or bucket assignment

Check whether a given IP address falls within a specified CIDR network range.

Derives closed, open, or half-open circuit breaker state from failure counters and cooldown timing inputs

Extracts URL and DOI citation patterns from caller-supplied text without any network access, returning structured JSON results

Calculates per-cohort and weighted aggregate retention rates from a bounded list of cohort data

Converts hex or RGB color values into all three formats: hex, RGB, and HSL

Validates whether a webhook timestamp is within acceptable age and future-skew bounds before signature verification proceeds

Converts fractional odds (numerator/denominator) into implied probability and decimal odds

Estimates the probability that Ethereum's price will be up or down in a 30-minute window using caller-supplied historical observations and optional market share pricing context.

Converts American (moneyline) odds to implied probability

Converts a Roman numeral string (e.g. 'XIV') into its integer equivalent

Maps an EVM chain_id integer to a short network name and known-chain flag using deterministic local lookup

Estimates probability that BTC price will be up or down at the close of a 5-minute window, given caller-supplied price observations and window parameters

Estimates the probability that ETH will be up or down over a 15-minute window given caller-supplied price observations, opening price, and close timestamp

Estimates the probability that ETH price will be up or down at the close of a 5-minute window, given caller-supplied price observations and window parameters.

Estimates the probability that Bitcoin's price will be up or down over a 15-minute window, given caller-supplied price observations and window parameters.

Deterministically select a fixed number of winners from a candidate list using a seed, ensuring no duplicate selections and reproducible results.

Parses a URL locally and returns a clean slug derived from its path component, suitable for route keys or cache identifiers.

Counts characters, words, lines, and bytes in a given text string, returning all metrics in a single JSON object.

Computes payout amounts for each outcome in a prediction market or structured settlement given share holdings and a winning outcome index.

Estimates the probability that Bitcoin will be up or down in a 30-minute window using caller-supplied BTC price observations and venue context

Converts a raw transaction value field (in wei) to its ether equivalent for human-readable display, using local deterministic math with no RPC or external calls.

Extracts and returns the domain portion of a given email address.

Converts a decimal probability value to American (moneyline) odds format

Extracts the host/domain component from a given URL without fetching the destination, useful for allowlists, branding, and outbound policy checks.

Validates whether a delivered agent result meets a minimum fraction threshold relative to expected items, returning acceptance or rejection with mismatch reasons.

Converts free text or identifiers into CONST_CASE (UPPER_SNAKE_CASE) format for use in environment variable names, enum labels, and agent configuration.

Checks whether a given string contains a specified needle substring, with optional case-insensitive matching, returning a boolean result.

Analyzes and summarizes how a website distributes content across Open Graph, RSS/Atom feeds, social channels, and blog surfaces.

Guesses the MIME type for a given filename, file path, or URL based solely on its extension

Heuristically detects the MIME content-type of data given a sample of bytes and/or a filename, returning a deterministic machine-readable JSON result.

Audits a Set-Cookie header value for the presence and correctness of Secure, HttpOnly, and SameSite security controls, returning deterministic machine-readable JSON results.

Audits CORS response headers for wildcard origins, credential exposure, and cache-variance risks, returning machine-readable JSON findings.

Evaluates whether a given data age meets a caller-supplied maximum freshness requirement, returning a deterministic pass/fail assessment

Returns a paginated live feed of open buyer RFQs (requests for quotes) for agent services, including task contracts, USDC price ceilings, deadlines, and acceptance criteria, optionally filtered by capability family.

Computes a stable topological sort order for a set of workflow nodes given directed edges, and detects structural cycles in the dependency graph.

Runs a preflight checklist covering tests, rollback, observability, ownership, and security review before a deployment reaches production, returning structured JSON results.

Computes a line-level text diff between two strings, returning structured change information for $0.001 USDC per call.

Maps a documentation website surface by extracting docs links, sitemap signals, robots rules, and feed hints from a given URL.

Splits a hostname string into its DNS labels, guesses the registrable apex domain, and returns the label count.

Checks whether a given EVM address already matches its EIP-55 mixed-case checksum form, returning a deterministic boolean result without any live RPC call

Checks whether a given text string ends with a specified suffix, returning a boolean result and the matched suffix.

Converts an SLO percentage and a request window size into the maximum number of allowed failures (error budget) for that window

Calculates descriptive conversion lift metrics (absolute and relative) for control vs. treatment groups in an A/B experiment

Returns the canonical file extension for a given MIME type using a local, first-party JSON lookup.

Extracts email-like addresses from a block of text, returning all identified email patterns found within it.

Extracts all signed integers from free-form text and returns them as a list with a count

Extracts all HTTP/HTTPS URLs from a given block of text

Measures per-field presence rates across a bounded array of JSON records, returning deterministic coverage statistics for each field.

Hashes a text string using SHA-256, SHA-1, or MD5 and returns a compact deterministic receipt for $0.001 USDC per call.

Validates and canonicalizes even-length hex strings, normalizing 0x prefix presence and confirming validity — stateless, local, no live chain RPC.

Computes an HMAC-SHA256 hex digest of a given text using a caller-supplied secret, without storing or transmitting the secret.

Returns the list of observed US federal holidays for a given year

HTML-escapes a text string so it can be safely embedded in HTML without XSS risk

Strips HTML tags from markup, returning clean plain text for $0.001 USDC per call.

Look up the meaning of an HTTP status code or retrieve a full reference list of common HTTP status codes.

Canonicalizes an HTTP request object by removing credentials and deriving a stable, deterministic fingerprint for use in preflight analysis, security review, or policy workflows.

Evaluates an HTTP status code and request method to return a machine-readable, idempotency-aware retry policy indicating whether a failed request is safe to retry.

Generates a deterministic SHA-256 idempotency fingerprint from a caller-supplied scope and JSON payload without storing any state.

Validates a text-to-image prompt for character length and policy token violations before submitting it to a generative image API

Classifies operational incident severity from explicit impact signals, returning a deterministic machine-readable JSON result for use in enterprise agent workflows.

Normalize and chronologically sort a list of incident events into a structured, machine-readable JSON timeline

Transcribes a single WAV audio clip (up to 60 seconds, 2 MiB) to text for $0.02 USDC per call, returning the transcript and a SHA-256 receipt with no API key or audio retention.

Quality-upscales a single still image up to 4 megapixels for $0.01 USDC, returning the enlarged image and a SHA-256 receipt.

Classifies an IP address as private, loopback, or global (public) without performing geolocation.

Detects whether an IPv4 address is private or loopback, returning validity and private-range flags.

Validates ISBN-10 and ISBN-13 checksum correctness for a given ISBN string

Validates whether a string has a valid email address shape (syntax only, no network checks)

Converts an ISO-8601 datetime string to its Unix epoch timestamp in seconds

Validates whether a given string is a well-formed HTTP or HTTPS URL, locally without any network requests or external lookups.

Lists all top-level keys from a caller-supplied JSON-LD or plain JSON object without any network access

Applies bounded top-level JSON Merge Patch (RFC 7396) semantics to a target object using a patch object, returning the merged result as deterministic machine-readable JSON.

Extracts a value from a nested JSON object using a dotted path expression, returning the value, whether it was found, and the resolved path.

Performs a lightweight type, required-field, and property check on a caller-supplied JSON instance against a caller-supplied JSON schema without full draft validation.

Profiles the top-level shape, fields, size, and cardinality of a JSON value for preflight analysis before downstream decisions

Converts structured JSON row data into CSV format for exports, spreadsheets, and data handoff.

Audits JWT claim names, expiry, and identifiers at a specified reference time without exposing claim values, returning deterministic machine-readable JSON.

Decodes a JWT token and extracts its claims, headers, and metadata for auth debugging, routing, and token inspection.

Converts free text or identifiers to kebab-case slugs suitable for URL paths, CSS classes, or route segments.

Measures the density of specified keywords or phrases within caller-supplied text, returning machine-readable JSON results.

Detects the dominant Unicode script families (e.g. Latin, Cyrillic, Arabic, Han) present in a caller-supplied text sample

Compares a single observed latency measurement against an SLA threshold in milliseconds and returns a deterministic pass/fail result

Computes p50, p95, p99, mean, min, and max latency statistics from an array of millisecond samples

Normalizes JSON or common text logs into a single stable, machine-readable event envelope for downstream agent workflows.

Inspects a website's login and authentication surface, detecting forms, reset flows, signup links, and security headers.

Calculates loyalty points earned, reward value, effective rebate, and generates a ledger-ready idempotent credit instruction for a given purchase event

Calculates the LTV-to-CAC ratio and returns a bounded health heuristic as deterministic machine-readable JSON

Validates whether a digit string passes the Luhn checksum algorithm, used to verify credit card numbers and other numeric identifiers.

Validates a digit string (e.g. a credit card number) using the Luhn checksum algorithm, returning whether it passes and its digit count.

Parses and indexes ATX-style markdown headings (# H1, ## H2, etc.) from caller-supplied text, returning a structured JSON list of headings with levels and positions

Strips markdown formatting from text and returns clean plain text for $0.001 USDC per call.

Masks the middle characters of a string while preserving both ends, useful for redacting secrets in logs or displays.

Audits an MCP server for tools/list compliance, schema validity, manifest correctness, discovery readiness, and integration fitness before publishing or connecting a client.

Guesses the MIME type for a given file extension using a local JSON lookup, returning mime type, extension, and a known flag.

Returns the canonical MIME type for a given file extension or filename for $0.001 USDC per call.

Returns the minimum value and count from a numeric list supplied by the caller

Generates a cryptographically random hex-encoded nonce of a specified byte length for use as idempotency keys or request identifiers.

Converts a number from one base to another, supporting any base between 2 and 36.

Identifies statistical outlier indexes in a bounded numeric array using z-score thresholding, returning machine-readable JSON results.

Filters an object to only the keys from a provided whitelist that actually exist on the object, returning the filtered object, missing keys, and count.

Aggregates an ordered list of price samples into open, high, low, and close (OHLC) values

Converts an OpenAPI JSON document into a compact, machine-readable operation index for agent planning and tool selection

Validates a redirect target URL against an exact hostname allowlist and returns a deterministic pass/fail JSON result

Combines success rate, latency score, and saturation percentage into a single composite ops health band for SRE and observability workflows.

Estimates the 95th percentile (p95) latency from a bounded numeric sample array, returning a deterministic JSON result.

Extracts and summarizes all href links from caller-supplied HTML without making any network requests

Extracts the title and common meta tags from caller-supplied HTML and returns them as structured JSON

Infers a bounded cursor, link, or page pagination plan from a response envelope, returning a deterministic machine-readable JSON plan

Audits a password policy object for length requirements, breached-secret exposure, and MFA enforcement, returning machine-readable JSON results.

Screens an untrusted file or URL path string for path traversal attack signals and returns a deterministic machine-readable JSON result

Extracts all values for a specified key from an array of JSON objects, returning a flat list of those values.

Post a task with a USDC budget ceiling and deadline so that live x402-enabled services can competitively bid to fulfil it, returning a signed receipt and a private claim capability.

Checks whether a given USDC price falls within a buyer-specified ceiling, optionally with a buffer percentage, and returns a deterministic pass/fail result.

Calculate the minimum selling price required to achieve a specified gross margin percentage given an input cost.

Extracts specified named query parameters from a URL or raw query string and returns their values as deterministic JSON

Parses query string pairs from a raw URL or query string and redacts credential-like keys, returning structured JSON

Converts a radian value to its equivalent in degrees, returning both the input in radians and the converted result in degrees.

Picks one or more random items from a provided list without replacement, returning the selected item(s).

Generates a cryptographically secure random integer within a specified range for $0.001 USDC per call.

Generates a random RFC 4122 UUID v4 and returns it in multiple formats (uuid, hyphenated, hex, URN) as machine-readable JSON

Normalizes common HTTP rate-limit and retry headers into deterministic machine-readable JSON for use in agent workflows

Generates a deterministic SHA-256 fingerprint from a canonical JSON record for use as a preflight or analysis step in enterprise agent workflows.

Replaces all email addresses in a text string with the [REDACTED_EMAIL] marker, locally and without retention.

Compares expected and actual top-level response fields and value types, returning a machine-readable JSON diff for contract validation.

Compares a declared data retention period (in days) against a maximum allowed policy window to determine compliance

Classifies whether a failed HTTP-style call is safe to automatically retry, returning a deterministic machine-readable JSON verdict.

Computes the percent return between a starting value and an ending value, returning deterministic JSON

Measures top-account and top-three revenue concentration ratios from a caller-supplied accounts map, returning machine-readable JSON without exposing individual account values.

Converts red, green, and blue integer channel values (0–255) into a CSS #rrggbb hex color string

Checks whether a given URL path is allowed or disallowed for a specified user-agent against caller-supplied robots.txt rules, returning a deterministic JSON result

Calculate static cash runway in months from a given cash balance and monthly burn rate

Computes capacity saturation ratio from in-flight work units and maximum capacity, returning a deterministic machine-readable JSON result

Clips a numeric score into a caller-specified inclusive [min, max] range, returning a deterministic clamped value as JSON

Converts an integer number of seconds into a human-readable HH:MM:SS string format

Extracts the 4-byte function selector from Ethereum transaction calldata hex, returning deterministic results with no live RPC required.

Recommends a semantic version bump (major, minor, or patch) based on explicit change signals provided by the caller

Compares two semantic version strings (a vs b) and returns a comparison result (-1, 0, or 1) indicating which version is older, equal, or newer.

Parses a semantic version string into its constituent major, minor, and patch components, returning validity and numeric parts.

Computes the intersection of two arrays, returning only the elements present in both lists along with the count.

Computes the SHA-1 hex digest of an input text string, locally and without retention.

Classifies a numeric signal value against optional upper and/or lower thresholds, returning a deterministic machine-readable JSON result

Computes normalized Levenshtein string similarity between two input strings, returning a score between 0 and 1.

Quickly checks a website's sitemap and robots.txt to reveal its crawlable structure and indexing hints.

Calculates whether a service meets its SLO target by comparing good events to total events and returning a compliance verdict in machine-readable JSON.

Converts arbitrary text into a URL-safe slug string for $0.001 USDC per call.

Converts free-form text into a lowercase, hyphen-separated URL slug suitable for use in paths, product IDs, or identifiers.

Converts snake_case text identifiers to lowerCamelCase format, returning the converted string and its length.

Computes the mid price and bid-ask spread in basis points from caller-supplied bid and ask prices

Computes a canonical SHA-256 hex digest of a JSON-stable serialization of the input payload, independent of key ordering.

Strips HTML tags from a caller-supplied markup string and returns the plain text along with its character length.

Computes success rate and failure rate as percentages from a success count and total count

Scores task priority from urgency, impact, and effort inputs into a deterministic ordered band, returning machine-readable JSON

Converts a Celsius temperature value to Fahrenheit, returning both unit representations as a local JSON computation with no external network calls.

Converts a Fahrenheit temperature value to its Celsius equivalent, returning both values as JSON.

Plans overlapping character-based chunks for RAG ingestion from caller-supplied text, returning deterministic chunk boundary metadata without storing the input

Canonicalizes a raw ticker symbol string and splits it into its base and quote components using common separator conventions

Aligns an array of ISO-8601 timestamps down to fixed-width UTC interval buckets, returning deterministic bucket-aligned timestamps as JSON

Converts Unix timestamps, ISO 8601 strings, and human-readable date strings into a single normalized timestamp response

Returns IANA timezone info including UTC offset, abbreviation, DST status, and current local time for a given timezone identifier

Deduplicates and sorts a JSON array, returning unique items in stable sorted order with a count

Calculates gross profit and gross margin percentage from a per-unit selling price and cost, returning deterministic JSON results.

Converts a Unix timestamp (integer seconds) to an ISO-8601 UTC string, returning both iso and unix fields.

Converts URL/path slugs (e.g. 'my-product-name') into Title Case display labels (e.g. 'My Product Name')

Checks whether a given URL matches any host/path pattern in a caller-supplied allowlist, returning a deterministic JSON result for use in agent preflight egress checks

Percent-decodes (URL-decodes) a string, safely reversing percent-encoding from query parameters or path segments

Generates one to ten UUIDv4 identifiers in a single call for $0.001 USDC, no API key required.

Estimates descriptive sample volatility (annualized standard deviation) from caller-supplied period returns

Normalizes heterogeneous webhook event payloads and derives a stable fingerprint for deduplication, replay detection, and safe autonomous workflow gating.

Converts a numeric amount between wei and ether units using fixed 1e18 scaling, locally and without any RPC call

Picks one item from a list using non-negative weights, returning a single sampled selection as deterministic JSON

Normalizes an array of non-negative weights so they sum to 1.0, returning a probability simplex representation suitable for ensemble models and signal preparation.

Decodes a 3-character World Manufacturer Identifier (WMI) using the NHTSA vPIC database to return manufacturer name and vehicle type.

Counts words, characters, lines, and paragraphs in submitted text for $0.001 USDC per call.

Summarizes a server's .well-known/x402 resources, pricing surface, supported networks, and available paths from its x402 discovery endpoint.

Audits an x402-enabled server for discovery quality, documentation completeness, pricing surface clarity, and readiness gaps.

Performs an end-to-end probe of an x402-enabled server, testing discovery, status, available tools, reliability, and OpenAPI spec retrieval.

XML-escapes a text string so it can be safely embedded in XML fragments without breaking document structure

Scans untrusted text for cross-site scripting (XSS) signals and returns a deterministic, machine-readable JSON result without echoing or retaining the input.

Zips two parallel arrays (keys and values) into a single JSON object, returning the merged object and an entry count.

Checks whether a given domain name is a known disposable or temporary email domain.

Parses a raw DMARC TXT record string and extracts structured fields such as policy, reporting URI, and schema version.

Validates a caller-supplied DNS CNAME chain for loops and hop-count budget violations, returning a deterministic pass/advisory verdict without any external DNS lookups.

Compares two DNS SOA serial numbers using RFC 1982 32-bit wraparound ordering to determine which is newer or equal

Parses an SPF DNS record string into its version, mechanisms, modifiers, and terminal policy as structured, normalized JSON.

Computes the drawdown percentage from a peak price to a trough price for use in risk reports and path risk analysis.

Validates the structural shape of an EVM transaction access list (EIP-2930), confirming addresses and storage keys conform to the expected format.

Validates whether a proposed EVM token approval amount falls within policy bounds defined by a maximum and satisfies a minimum required amount.

Computes the total gas and fee ceiling for a batch of EVM transactions in a single preflight calculation.

Computes the total blob fee ceiling in wei given blob gas and max fee per blob gas, enabling EVM preflight cost checks without external calls.

Checks whether an EVM blockchain block is fresh by computing its age in seconds and comparing it against a maximum allowed age threshold.

Extracts the 4-byte function selector from raw EVM transaction calldata and validates its shape.

Validates the structural shape and byte count of EVM calldata hex strings without retaining or executing them.

Computes the byte length of EVM calldata hex strings for preflight validation before on-chain submission.

Counts the 32-byte words in EVM calldata and validates its structure, returning byte count, complete word count, and partial-word bytes.

Validates whether a transaction's chain ID matches an expected EVM chain ID, returning a boolean match result and audit evidence.

Calculates the number of block confirmations between a current block and an inclusion block on an EVM-compatible blockchain.

Validates whether an EVM transaction deadline is still actionable given a current timestamp and minimum lead-time requirement.

Validates EIP-1559 transaction fee parameters (gas limit, max fee per gas, max priority fee per gas) and computes ceiling values for EVM preflight checks.

Computes the maximum possible gas cost (fee ceiling) in wei for an EVM transaction given a gas limit and max fee per gas, without retaining any input data.

Computes whether a given gas limit provides sufficient headroom over an estimated gas usage, returning the surplus gas amount and fraction.

Normalizes arbitrary input data into a well-formed EVM hex string, returning the normalized hex value and its byte count.

Checks whether an EVM token approval value is infinite (or near-infinite) by comparing it against a configurable threshold

Validates that the number of EVM log topics in a list does not exceed a specified maximum, returning a pass/fail result with evidence metadata.

Validates a list of EVM recipient addresses against an allowed list, detecting duplicates, unexpected addresses, and zero-address presence before a multisend transaction.

Computes the lower and upper bound (in wei) of the next EVM block's base fee given the current base fee and a maximum change fraction.

Computes the ratio of max priority fee per gas to max fee per gas for an EVM transaction, returning the proportion as a decimal and percentage.

Computes the delta, direction, and fractional variance between actual gas used and estimated gas for an EVM transaction receipt.

Validates that EVM ECDSA signature components R and S are correctly shaped (well-formed hex values of expected length/format) without any external calls or data retention.

Classifies an EVM transaction signature V value as legacy, EIP-155, or other type, given the V integer and chain ID.

Checks whether a raw EVM token balance is sufficient to cover a required raw token amount, returning surplus or shortfall details.

Validates that an encoded EVM recipient address matches the intended recipient address before executing a transfer, as a preflight safety check.

Validates an EVM transaction envelope by checking that all required fields are present for a given transaction type and returns missing or required field lists.

Classifies an EVM transaction type integer into its named category (e.g. legacy, access list, dynamic fee)

Calculates the total Wei required to cover a given transaction value plus a capped fee, for EVM preflight budget checks.

Compares an average fill price against a caller-supplied TWAP benchmark and returns the slippage in basis points

Compares an average fill price against a caller-supplied VWAP benchmark and returns slippage in basis points for post-trade quality analysis.

Computes n! (factorial) for integer n up to 20, returning the exact result or a structured error for out-of-range inputs, billed at $0.001 USDC per successful call via x402 on Base.

Computes the Nth Fibonacci number for integer n up to 78, returning a structured JSON receipt for a micropayment of $0.001 USDC.

Parses and validates RFC 7239 Forwarded HTTP header values, returning normalized evidence and a pass/advisory status as deterministic versioned JSON.

Converts a fractional rate (0–1) to basis points by multiplying by 10,000, returning the result as deterministic JSON.

Validates whether a CSP frame-ancestors directive header contains a required source, returning a deterministic pass/advisory finding as versioned JSON.

Calculates perpetual futures funding payment (notional × funding_rate × hours) and returns the result as deterministic JSON for a $0.001 USDC micropayment.

Converts a periodic funding rate (e.g. 8-hour) into an annualized APR for cross-venue funding rate comparison.

Revalues a notional amount by comparing a historical (source) FX rate against a current (target) FX rate, returning the revalued amount as deterministic JSON.

Computes total Ethereum transaction gas cost in ETH from gas used and gas price in wei using deterministic local math.

Estimates the USD cost of an Ethereum transaction given gas used, gas price in wei, and a caller-supplied ETH/USD price, using pure local arithmetic with no external calls.

Computes total gas cost in wei by multiplying gas_used by gas_price_wei using pure local arithmetic, no RPC or node required.

Computes the greatest common divisor (GCD) of two integers and returns the result as structured JSON

Converts a gas price value from gwei to its equivalent wei integer string for use in EVM transaction builders and eth_gasPrice-style fields.

Computes the half-Kelly bet sizing fraction given win probability and net odds ratio, returning a conservative Kelly criterion stake for lower-variance bankroll growth.

Converts a 0x-prefixed hexadecimal string into its decimal integer string representation using local deterministic math

Validates an HTTP Strict-Transport-Security header value against caller-specified minimum max-age and subdomain inclusion requirements, returning a deterministic pass/advisory result.

Compares and validates a document URL against its canonical URL using deterministic normalization, returning a pass or advisory status.

Parses the delay and target URL from an HTML meta-refresh tag in a supplied web response, returning normalized evidence, the computed finding, and a pass/advisory status.

Compares two HTTP header maps case-insensitively, redacting sensitive values, and returns a structured diff of added, removed, and changed headers.

Converts a raw byte count integer into a human-readable size string like '1.5 KB' or '2.3 MB'

Validates an IBAN string by verifying its checksum, returning a boolean validity result.

Computes the fee fraction needed to exactly offset impermanent loss at a given price ratio, returning a deterministic break-even value as JSON.

Computes the expected execution price after slippage given a mid price, trade side, and slippage in basis points

Calculates impermanent loss fraction and percentage for a constant-product market maker (CPMM/x*y=k) LP position given a price ratio change

Converts a non-negative integer into a 0x-prefixed hexadecimal string for use in hex fields or debug payloads.

Determines whether a given IPv4 address falls within RFC1918 private address ranges using local computation only.

Looks up a country name from a static ISO 3166-1 alpha-2 country code table and returns the name and code as deterministic JSON.

Computes the set difference of two integer arrays, returning elements present in the left array but absent from the right array.

Groups an array of JSON objects by a specified top-level key, returning counts and grouped results as deterministic versioned JSON.

Indexes an array of JSON objects by a specified top-level key, returning a keyed map with duplicate detection and counts

Returns the set of values shared by two integer arrays, preserving left-side order, with counts and normalized values as deterministic versioned JSON.

Sorts an array of JSON objects by a specified top-level key, ascending or descending, returning the reordered array with counts and a versioned result contract.

Removes empty string, array, and object top-level values from a caller-supplied JSON object and returns counts and normalized results

Validates a JSON object's top-level keys against a caller-supplied allowlist, returning counts and details of any disallowed keys found.

Compares two JSON objects and reports added, removed, and changed top-level keys with counts and normalized values

Removes specified top-level keys from a JSON object and returns the filtered result with transformation metadata

Filters a JSON object to retain only the specified top-level keys, returning a clean subset of the original object

Renames top-level keys of a JSON object using a caller-supplied mapping and detects/reports key collisions deterministically.

Previews the result of JSON Patch add, remove, and replace operations on a document without mutating the source, returning counts, normalized values, and a versioned result contract.

Inspects serialized JSON text and returns its root type (object, array, etc.) and a size signal as a cheap preflight check.

Validates a JSON instance object against a lightweight schema, checking required keys and types, returning deterministic ok/errors output.

Computes the least common multiple of two integers, useful for cadence alignment, tile sizing, and schedule math in agent workflows.

Returns a boolean indicating whether a given Gregorian calendar year is a leap year

Parses and validates Link header values, extracting targets and relation parameters with deterministic pass/advisory status.

Computes a Sortino-like ratio using downside standard deviation of negative returns, returning the ratio and sample count as deterministic JSON.

Calculates the approximate liquidation price for a leveraged long position given entry price, leverage, and maintenance margin rate

Splits total trading fee drag into maker and taker fee components for a given notional amount and basis point rates, returning deterministic JSON results.

Computes the margin required for a given notional amount at a specified leverage, using pure local math with no exchange API calls.

Computes the dollar value of an equity position by marking it to a specified price using local arithmetic, returning deterministic JSON.

Calculates maximum potential loss in dollars given a position size, entry price, and stop distance using deterministic local math.

Computes the median of a list of numbers, providing a robust central tendency measure that is unaffected by outliers.

Computes the mid price as (bid + ask) / 2 from a supplied best bid and offer (BBO) pair, returning a single deterministic mark price.

Strips whitespace and formatting from JSON text to produce a compact, value-preserving minified string.

Ranks 2–16 multilingual candidate texts (passages, tools, routes, or answers) against a query by cosine similarity, returning ordered indexes and a SHA-256 receipt for $0.003 USDC.

Computes optimal Kelly criterion stake sizes and fractions across multiple outcomes given their probabilities, market prices, and a bankroll amount.

Generates a random URL-safe NanoID string of configurable length (4–64 chars, default 21) for use as job IDs, draft keys, or idempotency tokens

Returns the next calendar date that falls on a specified weekday, given a starting date.

Converts decimal odds into American, fractional, and implied probability formats in a single call

Strips the bookmaker's overround (vig) from a pair of decimal odds to return fair implied probabilities and the overround percentage.

Diffs path keys between two OpenAPI path maps, returning added, removed, and common route counts as deterministic JSON.

Computes the total notional value (price × size sum) available within N levels of an order book side ladder

Computes mid price, absolute spread, and spread in basis points from L1 bid and ask prices using deterministic local math.

Normalizes the scheme, host, and effective port from a caller-supplied HTTP Origin header value into a canonical, validated form with pass/advisory status.

Computes the z-score, mean, and standard deviation of a price-spread series for pairs trading mean-reversion analysis.

Computes the combined probability of multiple independent events all occurring (parlay probability) given an array of individual probabilities.

Parses truthy/falsey strings like yes/no/1/0/true/false into a normalized boolean value with interpretation

Parses human-readable size strings (e.g. '1.5MB', '512KB') into integer byte counts

Parses a URL string into its constituent parts (scheme, host, path, query, fragment) without performing any network I/O

Computes a requested percentile (e.g. p50, p95) of a numeric array without requiring a statistics stack

Calculates percent profit/loss from entry and exit prices as deterministic local math, returning a JSON result for $0.001 USDC.

Converts a percent value to basis points (pct × 100) and returns the result as deterministic JSON.

Parses a Permissions-Policy HTTP header value into normalized feature allowlist entries and returns a structured pass/advisory finding

Computes the perpetual futures basis premium as (mark - index) / index in basis points from caller-supplied prices

Strips all non-digit characters from a phone number string, returning only the raw digit sequence.

Computes the notional (exposure) value of a position as mark price × size, returning a deterministic JSON result for risk sizing and leverage calculations.

Checks whether a given integer is prime and returns a boolean result for $0.001 USDC per call.

Returns the prime factorization of an integer as a structured JSON list of factors

Validates the structural shape of common registry identifiers (LEI, WMI, EIN-like) and returns a kind guess and validity flag without external lookups.

Calculates FIFO-style realized profit and loss from sequential buy/sell fills using local deterministic math, returning a PnL summary as JSON.

Replaces email address patterns in a text string with a safe placeholder, returning the sanitized text.

Validates a supplied list of URLs as a redirect chain, detecting loops, protocol downgrades, and hop-count budget violations — returning a deterministic pass/advisory verdict.

Evaluates refund eligibility flags by checking purchase facts against a policy JSON definition, returning a deterministic eligible/reasons result.

Computes a calibration reliability curve by binning forecast probabilities against observed binary outcomes to assess forecast accuracy.

Strips all punctuation characters from a text string and returns the cleaned text plus a compact processing receipt.

Normalizes an HTTP Retry-After header value (seconds or HTTP-date) into a delay in seconds using a caller-supplied current epoch, returning a deterministic pass/advisory finding.

Computes inverse-volatility risk parity portfolio weights from a return series, returning weights that sum to 1 as deterministic JSON.

Computes the risk-reward ratio (reward divided by risk) for a given trade setup defined by entry, stop-loss, and take-profit levels.

Parses robots meta tag directives from HTML content into normalized index/follow decisions, returning a deterministic pass/advisory status.

Computes return on margin (ROI%) for a realized or mark PnL relative to posted margin, enabling capital efficiency comparison across leveraged trades.

Deterministically assigns a subject to an A/B variant (A or B) using a seed and configurable weight, returning a stable bucket value and variant label.

Generates a deterministic, seeded exponential backoff delay schedule with configurable jitter for a given number of retry attempts.

Deterministically partitions a list of integers into balanced groups using a reproducible seed string

Deterministically selects a reproducible subset of candidate items from a list using a seed string and a count, returning the selected items and their original indices.

Performs a deterministic, seeded sequence of coin flips returning heads/tails outcomes with a cryptographic audit trail.

Shuffle a list into a guaranteed derangement (no element remains in its original position) using a deterministic seed string.

Rolls a configurable number of dice with a given number of sides using a deterministic seed, returning reproducible random results.

Deterministically assigns a seed+subject pair to a numbered bucket for feature flagging and A/B test bucketing.

Deterministically assigns a subject to a treatment or holdout group using a seed, returning a stable group label and bucket value based on a configurable holdout fraction.

Reproducibly splits a set of N items into K folds using a deterministic seed, returning fold-to-index assignments for cross-validation workflows.

Deterministically assigns a list of jobs to a list of workers using a seed value for reproducible, balanced load distribution.

Performs a deterministic, reproducible lottery draw from a labeled list using a caller-supplied seed, returning a fixed count of winners.

Deterministically assigns a variant from a weighted list using a seed and subject, enabling reproducible A/B or multivariate test bucketing.

Generates a deterministic decimal nonce within a specified integer range using a seed string, returning the same value for the same inputs every time.

Generates a deterministic passphrase by selecting words from a provided word list using a seed, returning a hyphen-joined label and constituent word array.

Deterministically decides whether a subject is included in a percentage rollout based on a seed and percentage threshold, returning a boolean result and bucket value.

Generates one or more deterministic pseudo-random floats within a specified range from a given seed string.

Generates a deterministic sequence of random integers within a specified range using a seed string, returning the same values every time for the same inputs.

Ranks a list of nodes by deterministic seeded rendezvous hashing to consistently select and order nodes given a key and seed.

Performs a reproducible reservoir sampling of an integer array using a seed string, returning a fixed-count random subset with the original indices.

Generates a reproducible list of random sample indices from a population using a deterministic seed string, count, and population size.

Draws a reproducible random sample with replacement from a list of items using a fixed seed, returning exactly the requested count of items.

Deterministically computes a time offset in seconds from a seed string and a window duration, using a reproducible hash-based calculation with no external calls or data retention.

Splits a list of integer items into reproducible train and test sets using a deterministic seed and a specified test fraction.

Generates a deterministic UUID v5-style value from a name, seed, and namespace, returning the same UUID every time the same inputs are supplied.

Deterministically selects one item from a weighted list using a seed string, returning the chosen item and its index.

Deterministically partitions a list of items into named buckets according to per-item weights and a seed, producing reproducible weighted assignments.

Randomly samples a specified count of items from a weighted list using a deterministic seed, returning reproducible results without retaining input data.

Converts an input string to sentence case (first letter of first word capitalized, rest lowercase) for $0.001 USDC per call

Computes a simple (equal-weight) average of an array of price samples as a lightweight TWAP mark for benchmarking trade fills.

Computes remaining seconds until an SLA deadline and whether the deadline has already been breached, given two unix timestamps.

Computes trade slippage in basis points versus the mid price from a fill price and mid price, returning a deterministic JSON result.

Calculates the slippage percent between an expected mid price and an actual fill/impact price for pre- and post-trade quality checks.

Computes the American Soundex phonetic code for a surname-like string, enabling fuzzy name matching, deduplication, and genealogy-style search keys.

Computes the bid-ask spread as a percentage of the mid-price for cross-asset liquidity comparison

Calculates the deviation in basis points between an observed stablecoin price and its target peg (typically 1.0), returning a deterministic JSON result.

Computes the time-weighted absolute peg deviation across a window of price samples to summarize depeg severity.

Computes population and/or sample standard deviation for a list of numeric values

Removes diacritical marks (accents) from text, returning ASCII-safe normalized output without network calls or language models.

Generates a compact, time-sortable unique ID (KSUID-inspired) suitable for log entries, event streams, and ordered records without requiring a database sequence.

Converts a string to title case formatting via a pay-per-use API, returning structured JSON output for $0.001 USDC per call.

Converts raw integer token units (e.g. wei, satoshi) into human-readable decimal amounts by scaling with the token's decimal places.

Calculates how many tokens remain unvested at a given point in time given a linear vesting schedule with optional cliff

Validates the order and placement of transfer-coding values in an HTTP Transfer-Encoding header, ensuring 'chunked' appears only as the last encoding

Removes the overround (vig) from a two-outcome market, converting raw bookmaker probabilities into fair implied probabilities.

Tokenizes input text and returns each unique word along with its occurrence count, without any external NLP service.

Computes unrealized profit and loss for an open position given entry price, mark price, and position size using local deterministic math.

Normalizes and compares two URLs across scheme, host, port, path, and query components to determine if they are canonically equivalent.

URL-encodes a text string using encodeURIComponent-style encoding, suitable for safe query string values and URL path segments

Validates a URL's effective port against a caller-supplied allowlist and returns a deterministic pass/advisory verdict as versioned JSON

Compares two URLs and returns added, removed, and changed query parameters between them as deterministic JSON.

Removes caller-selected tracking parameters from a URL while preserving all other query parameters, returning a normalized clean URL with a deterministic pass/advisory status.

Converts a raw USDC integer (6-decimal units) into a human-readable USDC amount using deterministic local math.

Converts a human-readable USDC amount into its 6-decimal raw on-chain integer representation (e.g. 1.5 USDC → 1500000).

Checks whether a given YYYY-MM-DD date falls on a known US stock market holiday, returning a boolean flag and the holiday name if applicable.

Returns the current UTC time as unix seconds, unix milliseconds, and ISO 8601 string from the server clock

Returns whether a given ISO-8601 date or timestamp falls on a Saturday or Sunday.

Converts a wei integer string to a human-readable gwei float value using pure local arithmetic, no RPC call required.

Computes win rate fraction and percentage from a list of trade PnLs, classifying wins vs total closed trades.

Counts and returns the top words by frequency from a given text as structured JSON

Hard-wraps a text string to a specified column width, returning structured JSON output for $0.001 USDC per call.

Parses and normalizes the WWW-Authenticate HTTP challenge header, extracting the authentication scheme and parameters for validation or downstream use.

Validates a raw payment amount against a caller-supplied maximum budget, returning an explicit accept/reject decision with mismatch reasoning for x402 payment challenges.

Verifies delivered text against a caller-supplied SHA-256 digest to accept or reject an x402 agent delivery before payment or acceptance

Validates an X402 payment delivery receipt to confirm it is well-formed, contains required fields, and represents a successfully delivered payment.

Validates delivered x402/agent result objects against a caller-specified required field list, returning acceptance or rejection status with mismatch reasons and normalized evidence.

Reconciles an x402 payment lifecycle end-to-end by comparing payment requirement, payment response, delivery receipt, and settlement reference metadata to produce a deterministic field-by-field verdict of proven, conflicting, or missing.

Validates whether a payment authorization deadline falls within acceptable time bounds relative to a caller-supplied current time and lead-second constraints.

Validates the shape and encoding of an x402 payment header, returning acceptance/rejection status, normalized evidence, and mismatch reasons.

Validates a payment nonce for presence, minimum length, and caller-known reuse against a bounded list of previously seen nonces, returning acceptance or rejection status with mismatch reasons.

Validates that an x402 payment settlement recipient matches the expected pay-to address, returning acceptance/rejection status and mismatch reasons.

Detects whether an EVM address is the zero address (0x0000...0000), returning a boolean and normalized address for validation use cases.

Computes the next N fire timestamps for a daily recurring rule (RRULE) starting from a given unix timestamp with a configurable day interval.

Compares a declared Content-Length header value against an observed byte count and returns a deterministic pass/advisory verdict with normalized evidence.

Projects and reorders selected columns from a CSV text input, returning only the specified columns in caller-defined order as deterministic JSON with counts and normalized values.

Look up blockchain network metadata and EVM chain IDs from a static first-party registry by network name or chain ID.

Computes the absolute bid–ask spread (ask minus bid) from caller-supplied bid and ask prices using local deterministic math.

Validates whether a request origin is in an explicit list of allowed origins and returns a deterministic pass/advisory finding for CORS policy enforcement.

Indexes ABI type strings by frequency to assist with encoding planning, running locally and statically without any live RPC or blockchain call.

Convert a monetary amount between two currencies using a caller-supplied exchange rate, returning deterministic conversion results as JSON

Converts a CSS hex color string (#rrggbb) into its individual red, green, and blue numeric channel values.