986 Services from commerce.delx.ai

Deduplicates a list of EVM addresses in-memory and returns the unique set with a count of removed duplicates

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

Parses a raw HTTP Set-Cookie header string and returns structured cookie attributes (name, value length, path, flags, SameSite) without retaining input data.

Generates a plain-text caption describing the visual content of a base64-encoded image, paid per-result via USDC

Scans arbitrary text for prompt injection attack signals and returns a risk score, severity level, and specific detected signals.

Resizes and re-encodes a base64-encoded image to a specified format (WebP, PNG, JPEG) and maximum dimension, returning a hosted URL and SHA256 hash, paid per-call via USDC on Base or Solana.

Normalizes and canonicalizes a raw trading ticker string into its constituent parts and standard form (e.g. 'ETHUSDC' → 'ETH/USDC')

Extracts text from a base64-encoded PNG, JPEG, or WebP image using Tesseract 5, with no image stored or forwarded to third parties.

Checks whether a given DKIM selector exists and has a valid shape in DNS for a specified domain

Fetches and analyzes HTTP response headers for a given URL, identifying present and missing security headers

Validates a JSON value against a bounded JSON Schema-like contract (type, required, properties, enum) and returns validation results with errors

Returns a multi-period US weather forecast for a given latitude/longitude coordinate using NOAA National Weather Service data, billed per call via USDC on Base or Solana.

Validates whether a set of DNS MX records indicate that a domain is ready and able to receive email.

Computes Black-Scholes delta (call and put) for an option given spot, strike, volatility, time to expiry, and risk-free rate

Compares two OpenAPI specifications and returns whether the new version introduces breaking changes, listing removed paths and methods.

Validates the structural shape and byte count of EVM calldata without retaining or executing it

Renames columns in a CSV string according to a provided old-to-new column name mapping, returning the transformed CSV with updated headers.

Extracts email addresses, phone numbers, social media links, and web manifest URL from a given website URL

Compares two sets of DNS records and returns a structured diff showing added, removed, and unchanged records

Detects the most likely delimiter character (comma, tab, semicolon, pipe, etc.) used in a CSV text sample by scoring each candidate.

Converts a U.S. street address into geographic coordinates (latitude/longitude) using the U.S. Census Bureau Geocoder, via a pay-per-call API requiring no signup.

Parses a DNS SPF record string and checks whether the number of DNS-lookup-triggering mechanisms stays within a configurable budget limit

Searches and retrieves recent cryptocurrency news headlines filtered by topic, timespan, and relevance using the GDELT Project as the data provider.

Removes the background from an image, returning a transparent PNG with verifiable delivery, paid per-result in USDC via x402.

Audits a list of requested tool permissions against an allowed set, returning which are permitted or denied and whether least-privilege principles are satisfied.

Computes a lightweight Sharpe ratio from an array of returns, returning mean, standard deviation, and annualized risk-adjusted performance score.

Replaces the background of an uploaded image with a studio fill color, returning a new image URL via a pay-per-result API using USDC on Base or Solana.

Parses and validates a raw DMARC DNS TXT record string, extracting all policy directives and reporting whether the record is valid.

Validates EVM transaction envelope fields for a given transaction type, returning required fields, missing fields, and pass/fail status.

Computes the population standard deviation (and mean, mode, count) for a supplied list of up to 10,000 numeric values, paid per-result in USDC via x402.

Generates a budget-tier image from a text prompt using a fast SDXL model, paid per-result in USDC via x402 with no signup required.

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

Checks whether a transaction included at a given EVM block height has reached finality based on a required confirmation depth

Converts text into high-definition audio (WAV) using AI voice synthesis with configurable voice, emotion, pitch, speed, and language options, billed per result in USDC via x402.

Audits a set of OAuth scopes, identifying missing required scopes, excess scopes, and whether the set satisfies least-privilege principles

Extracts the 4-byte function selector from raw EVM calldata and validates its basic structure

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

Transcribes a base64-encoded WAV audio clip (up to 2 MiB / 60 seconds) to text using Whisper, paid per-call in USDC via x402 with no signup required.

Extracts plain text from a base64-encoded PDF file, returning the full text content with metadata, for $0.003 USDC per call via x402.

Deterministically assigns a subject to one of N weighted variants using a seed, returning the selected variant and its index with cryptographic evidence of no data retention.

Extracts all HTML forms from a given webpage URL, returning structured data about each form's inputs, methods, and actions

Deterministically selects one candidate from a list using a seed string, producing a verifiable, reproducible tie-breaking decision with no data retention.

Removes null-valued keys from a JSON object and returns the pruned object along with the list of removed keys

Converts a text string into a specified naming case format (snake_case, camelCase, PascalCase, kebab-case, etc.)

Computes the Compound Annual Growth Rate (CAGR) given a start value, end value, and number of years

Searches recent news articles via the GDELT Project, returning headlines and URLs matching a query within a configurable time window

Computes the Expected Calibration Error (ECE) of a set of binary forecast probabilities against observed outcomes, returning a calibration quality score.

Audits a URL for SSRF (Server-Side Request Forgery) risk by checking if its hostname resolves to private, internal, or cloud metadata IP ranges

Parses a raw DNS SPF record string into structured components including mechanisms, terminal directive, and DNS lookup count

Generates a narrated MP4 video by composing an AI-generated still image with AI voiceover speech from a text prompt and narration script

Calculates the bookmaker's overround (vig) and returns fair no-vig implied probabilities from a pair of decimal odds.

Extracts structured pricing signals from a given URL, returning tier types, form counts, and pricing model indicators like free trial, enterprise, and usage-based.

Computes Black-Scholes options Greeks (delta, gamma, theta, vega) for a given option using spot price, strike, volatility, time to expiry, and risk-free rate

Analyzes a URL to report its login surface metrics, including auth link count, password form count, and security headers present.

Computes the Black-Scholes d1 and d2 intermediate values for an option given spot price, strike, volatility, time to expiry, and risk-free rate.

Audits a set of JWT claims object to check for expiry, standard claim presence, shape validity, and missing fields

Computes the Kelly Criterion fraction — the optimal bet size as a fraction of bankroll — given a win probability and net odds multiplier.

Compares the query parameters of two URLs and returns which parameters were added, changed, or removed between them.

Compares two sets of HTTP response headers and returns a structured diff showing added, removed, changed, and unchanged headers with security-sensitive changes highlighted.

Removes specified tracking parameters (e.g. UTM, gclid) from a URL, returning a clean URL without retaining input data

Scans arbitrary text for exposed secrets (API keys, tokens, credentials) and returns a risk rating, finding count, and finding types.

Normalizes a free-form phone number string into E.164 format (e.g. +14155550100) with digit-only and full E.164 representations

Extracts email addresses, phone numbers, and priority contact links from a company website URL

Scans arbitrary text for personally identifiable information (PII) and returns a risk level, finding count, and detected PII types

Scans a text string for XSS (cross-site scripting) attack signals and returns a risk level and signal count

Performs a reproducible weighted random selection of N items from a list using a deterministic seed, returning verifiable results with no data retention.

Fetches a URL and extracts structured content including title, headings, description, and text excerpt from the page

Validates an email address by checking syntax, DNS A records, MX records, and deliverability likelihood, returning normalized form and verification details.

Colorizes a black-and-white or desaturated photo by accepting a base64-encoded image and returning a URL to the colorized result, billed at $0.01 USDC per call via x402.

Performs a DNS lookup for a given domain, returning DNS records of a specified type (A, AAAA, CNAME, MX, NS, TXT) with TTL and answer data.

Generates images from text prompts using Flux models, paid per-call in USDC via x402 with no signup required.

Extracts text from scanned or machine-printed PDFs using Tesseract 5 + Poppler, returning recognized text with confidence score and cryptographic hashes for verifiable delivery

Analyzes a set of change signals and recommends the appropriate semantic version bump (major, minor, or patch) based on standard SemVer policy.

Computes the break-even unit quantity given a fixed cost and contribution margin per unit

Computes CVaR (Conditional Value at Risk) and VaR for a given return series at a specified tail probability

Searches Wikidata's open knowledge graph for structured entity records matching a text query, returning entity IDs, labels, descriptions, and source URLs.

Returns European Central Bank reference exchange rates for one or more currency pairs against a chosen base currency, for today or up to 31 days in the past.

Infers the schema (field names, types, nullability) from an array of input records

Computes the structural difference between two JSON objects, returning added, changed, and removed fields with before/after values.

Computes a sequence of liquidation price levels across multiple leverage steps for a leveraged trading position.

Validates whether the actual slippage on an EVM token swap falls within an acceptable policy threshold before execution

Scans an array of timestamps for gaps larger than an expected interval, returning each gap's start, end, and duration in seconds

Validates that an encoded EVM transfer recipient address matches the intended recipient before executing an on-chain transfer.

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

Traces the full redirect chain for one or more URLs, detecting hops, loops, HTTPS downgrades, and budget overruns

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

Generates a QR code image (PNG or SVG) encoding any text or URL, returned as a base64 data URI, for $0.001 USDC per call via x402.

Resolves and validates the full CNAME chain for one or more DNS hostnames, reporting hop count, loop detection, and chain members up to a configurable max-hop budget.

Inspects the TLS/SSL certificate of a given HTTPS URL, returning issuer, SAN DNS entries, subject, and days until expiry.

Analyzes a filesystem or URL path string for security risks such as traversal attacks, injection patterns, and unsafe characters, returning a risk level and signal count.

Validates and returns the ERC-55 keccak256 checksummed (mixed-case) version of an EVM address, confirming validity and whether it matches the input.

Fetches and parses the security.txt file for a given URL, returning contact info, expiry, and policy links

Discovers RSS/Atom feeds available at a given URL by inspecting the page and its web manifest

Calculates the liquidation price for a short position in a leveraged trading scenario given entry price, leverage, and maintenance margin rate.

Scans a text string for SQL injection patterns and returns a risk level with heuristic signal analysis

Parses an OpenAPI JSON document and returns a structured index of all operations (path, method, summary, operation ID, tags) contained within it.

Scans an array of numeric values and identifies statistical outliers using z-score thresholding, returning mean, standard deviation, and outlier indexes.

Computes descriptive lift metrics (absolute, relative, and rate-based) for an A/B experiment given control and treatment visitor/conversion counts.

Probes a given URL to discover and check the reachability of its XML sitemaps

Performs an RDAP lookup on a domain name to retrieve registration details including registrar, status, expiry, and handle

Joins two CSV datasets on a shared key column and returns the merged CSV result with row count.

Computes risk parity portfolio weights from one or more return series using equal-risk-contribution methodology

Sorts an array of DNS MX records by their priority values in ascending order, returning them ranked from highest to lowest preference.

Computes whether a service met its Service Level Objective (SLO) by comparing good vs total events against a target availability percentage

Checks whether a given domain name is a disposable/temporary email provider using heuristic detection

Validates and lints an image generation prompt for character count, word count, blocked tokens, and length compliance against a configurable character limit.

Checks the health of an API endpoint by fetching it and returning status, latency, content type, and response metadata

Performs a deterministic, seeded coin flip simulation for a given number of flips, returning heads/tails results with verifiable evidence and no data retention.

Computes gross PnL, trading fees, and net PnL for a trade given entry price, exit price, position size, and fee rate

Transforms wide-format CSV data into long/tidy format by unpivoting specified value columns into rows

Given a key, seed, and shard count, deterministically assigns the key to one shard number in a reproducible and verifiable way.

Generates a deterministic, seed-driven derangement (permutation where no element appears in its original position) of a list of items

Rolls one or more dice using a deterministic seed, returning reproducible results with a cryptographic evidence trail and no data retention.

Deterministically assigns a seed+subject pair to a numbered bucket out of N, enabling stable feature flagging and A/B experiment assignment.

Validates and normalizes a blockchain transaction hash, returning its canonical 0x-prefixed form and confirming it is a well-formed 32-byte hex string.

Calculates the fee fraction a liquidity provider needs to earn in order to break even against impermanent loss for a given price ratio change.

Scans input text and replaces all email addresses with a [REDACTED_EMAIL] placeholder, returning the sanitized text.

Deterministically assigns a subject to a treatment or holdout group based on a seed and holdout fraction, returning a verifiable group assignment with no data retention.

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

Splits a dataset of N items into K folds reproducibly using a provided seed, returning fold-to-index assignments.

Deterministically distributes a list of jobs across a list of workers using a seed value for reproducible, verifiable assignment

Deterministically draws a specified number of winners from a labeled list using a seed value, returning verifiable results with no data retention.

Computes the basis percentage (spread) between a spot price and a futures price for a given asset

Validates whether a Base chain USDC payment matches expected recipient and amount values, returning a verifiable pass/fail result.

Creates a Request-For-Quote (RFQ) on the Delx demand board, specifying a task, budget ceiling, and acceptance criteria so AI agents can procure verifiable results from suppliers

Deterministically pairs a list of participants into matched pairs (with optional bye) using a seed value, returning verifiable, reproducible results.

Generates a deterministic, human-readable passphrase (sequence of words) from a seed string and an optional word list, returning a reproducible label and array of words.

Deterministically decides whether a subject falls within a percentage rollout based on a seed and threshold, returning a boolean inclusion result and bucket percentage.

Computes the maximum possible EVM base fee after a given number of blocks using the EIP-1559 growth formula, given a current base fee and growth fraction.

Validates whether a given USDC price falls within a specified budget ceiling, optionally applying a buffer percentage, and returns headroom and allowance status.

Identifies the authentication scheme (e.g. Bearer, Basic, API Key) present in an HTTP Authorization header string

Checks whether an EVM token allowance is sufficient to cover a required spend amount, returning a pass/fail with shortfall details.

Deterministically selects one item from a list of queues using a seed string, returning the index and value of the chosen item with verifiable evidence.

Generates a deterministic hex string of random bytes from a user-supplied seed and byte count, with verifiable in-memory processing and no data retention.

Validates whether a given epoch timestamp falls within an acceptable lead-time window relative to a blockchain payment deadline on Base

Generates one or more deterministic pseudo-random floating-point numbers within a specified range using a user-supplied seed, with verifiable evidence of no data retention.

Deterministically ranks and selects a node from a list using a seeded rendezvous (HRW) hashing algorithm, returning a ranked list with cryptographic scores.

Calculates the estimated time remaining (in seconds) for a Base blockchain transaction to reach the required number of confirmations given current confirmation progress.

Parses an HTTP Range header string and resolves the concrete byte range (start, end, length, satisfiable) given a resource size

Generates a reproducible, seeded random sample of indices from a population without replacement, verifiably processed in memory without data retention.

Audits HTTP response headers for CORS policy risks, reporting findings like wildcard origins, credential exposure, and misconfiguration risk level

Returns a reproducible random sample (with replacement) from a list of items using a deterministic seed, verified without data retention.

Given an ISO-8601 date and an optional target weekday, returns the next occurrence of that weekday after the given date.

Computes an exponential-cap backoff schedule (delay list with jitter guidance) given base delay, cap, and attempt count

Deterministically shuffles a list of string items using a provided seed, returning a verifiable, reproducible ordering with no data retention.

Searches Wikipedia/Wikimedia open knowledge base and returns attributed snippets for a given query, billed per-result via x402/USDC.

Splits a labeled dataset into reproducible train/test index sets using a seed and stratified sampling, with verifiable in-memory processing and no data retention.

Deterministically selects a time slot from a provided list using a seed value, returning a reproducible, verifiable pick with no data retention.

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 any shortfall — all computed in-memory without data retention.

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

Generates a deterministic, reproducible UUID from a name, seed, and namespace triple, with verifiable evidence that no data was retained.

Deterministically selects one item from a weighted list using a seed, returning the chosen item's index and value with verifiable evidence.

Computes the optimal wave structure (number of waves, concurrency per wave, and last wave size) for processing a batch of items at a given concurrency level.

Deterministically selects a specified number of winners from a candidate list using a seed, with no replacement, and returns verifiable evidence of the selection.

Extracts the 4-byte ABI function selector and remaining calldata byte count from raw EVM transaction calldata hex.

Compares two semantic version strings and returns a numeric comparison result (-1, 0, or 1) indicating their relative order.

Creates a pay-per-result asynchronous promise that waits for a scheduled time or inbound webhook event, then delivers a stored continuation envelope via claim or webhook

Calculates whether a proposed EVM transaction replacement fee is sufficient compared to the original fee, given a minimum bump fraction requirement.

Analyzes a given API URL and returns a readiness score and hints indicating how suitable and easy it is for AI agent integration (e.g., x402 support, OpenAPI availability).

Computes descriptive latency statistics (min, max, mean, p50, p95, p99) from an array of millisecond latency values

Audits a URL to check how well it implements the x402 pay-per-result payment protocol, returning a score and gap analysis

Normalizes raw data into valid, prefixed EVM hex format and returns byte count, with no data retention.

Computes the difference in days and seconds between two ISO-8601 timestamps

Parses an HTTP Server-Timing header string into structured entries with names, durations, and descriptions

Computes the set difference (elements in array A that are not in array B) and returns the unique items and count

Analyzes an array of records and returns per-field presence counts and coverage percentages

Computes the SHA-1 hash of a given text string and returns it as a lowercase hexadecimal digest, paid per-result via USDC on Base or Solana.

Compares two numeric fields within a JSON object using a specified relational operator and returns whether the comparison passed, with verifiable evidence.

Computes the mid price, absolute spread, and spread in basis points from a best bid and best ask price pair

Parses an SPF TXT record string and returns boolean flags indicating which mechanisms are present (a, mx, include, all).

Validates a single XML sitemap entry object, checking structural correctness and returning a validity verdict with evidence

Counts the number of data rows in a UTF-8 CSV string and guesses whether a header row is present

Predicts whether Ethereum's price will be up or down over the next 5 minutes, given caller-supplied historical price observations

Counts how many latency samples exceed a given SLA threshold and returns the breach count and percentage.

Calculates slippage in basis points (bps) given a mid price and a fill price for a trade.

Sorts the rows of a CSV string by a specified column, optionally in descending order, and returns the sorted CSV with row count.

Computes the slippage percentage between a mid price and a fill price for a trade

Renames the keys of a JSON object according to a provided key mapping, returning the transformed object with collision tracking.

Converts a text string into a URL-safe slug (lowercase, hyphen-separated) via a pay-per-result API with no signup required.

Converts snake_case text strings to camelCase format via a pay-per-call API using USDC on Base or Solana

Computes the Sortino ratio and downside standard deviation for a given array of periodic returns

Computes the prime factorization of an integer, returning all prime factors as a list, paid per-result via USDC micropayment.

Computes the half-Kelly bet sizing fraction given a win probability and odds multiplier (b), useful for optimal position sizing in trading or betting scenarios.

Calculates the bid-ask spread in basis points (BPS) given a bid and ask price, returning mid price and spread metrics.

Calculates the bid-ask spread percentage and midpoint price given a bid and ask price

Classifies an HTTP status code into its family, class label, success flag, and retryability hint

Fetches and extracts Open Graph metadata (title, description, image, site name) from any given URL

Calculates the stop-loss price for a trading position given an entry price, position side, and stop-loss percentage

Computes the funding rate premium in basis points between a perpetual futures mark price and its underlying index price

Calculates the expected value (EV) of buying 'No' shares in a binary prediction market given stake, true probability, and market price.

Removes diacritical marks and accent characters from text, returning plain ASCII-friendly output

Computes the USD cost of an Ethereum transaction given gas used, gas price in wei, and current ETH/USD price

Strips HTML tags from a string of text and returns the cleaned plain-text content with character count.

Analyzes raw log text and returns a structured summary including log level counts, line count, top error fingerprints, and a deduplication-friendly error digest.

Checks the byte and character size of a JSON payload against configurable hard and soft size limits, returning size metrics and truncation recommendations.

Computes the combined probability of a parlay (multi-leg) bet assuming all legs are statistically independent

Computes a weighted priority score (P0–P3) for a task given effort, impact, and urgency inputs

Computes the greatest common divisor (GCD) of two integers, paid per-result via USDC on Base or Solana using x402.

Splits a UTF-8 text string into overlapping character-based chunks and returns the index plan (start, end, char count) for each chunk without performing embedding or storage.

Audits a password policy object and returns a risk rating, findings, and security recommendations.

Converts a Roman numeral string (e.g. 'XLII') into its corresponding integer value (e.g. 42), paid per-result via USDC on Base or Solana.

Checks a batch of up to 256 EVM nonces for duplicates, returning which nonces appear more than once — useful as a pre-flight validation before submitting EVM transactions.

Computes the next N daily recurrence fire timestamps starting from a given Unix timestamp, using a configurable day interval.

Parses and normalizes an HTTP Origin header value into structured components (host, scheme, effective port), verifiably and without data retention.

Computes OHLC (Open, High, Low, Close) statistics from an ordered array of price samples

Transforms all keys of a JSON object to lowercase, returning the modified object and any collision metadata, with verifiable in-memory processing and no data retention.

Computes how to split a model's context window into system, input, and output token budgets given total and reserved token counts

Compares two DNS SOA serial numbers using RFC 1982 modular arithmetic to determine which is newer and by how much

Converts an implied probability (0–1) into American moneyline odds format

Deterministically assigns a list of items to named partitions using a seed string, returning verifiable, reproducible partition assignments.

Computes the maximum possible gas cost (fee ceiling) for an EVM transaction given a gas limit and max fee per gas in wei

Converts a probability value into its corresponding odds ratio

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

Computes the effective number of concurrent workers an agent should use, capping at a hard limit and signaling saturation based on queue depth

Converts a UTC offset in minutes to a fixed, formatted timezone offset string (e.g. '-03:00')

Computes the order book imbalance ratio from displayed bid and ask sizes at the best quotes

Classifies an incident's severity level (e.g. sev1–sev4) and returns a numeric score and detected signals based on impact context

Extracts a deduplicated list of unique words from a given text and returns them along with their count

Generates a cryptographically random nonce of a specified byte length, returned as a hexadecimal string.

Projects (selects/filters) a specified set of keys from each object in a JSON array, returning only those key-value pairs.

Calculates the minimum sell price for an API call given a base cost and desired profit margin percentage.

Converts a Unix epoch integer timestamp to an ISO 8601 formatted datetime string

Calculates the unrealized profit and loss for a trading position given mark price, position size, and entry price.

Converts a URL slug or hyphenated/underscored text string into a human-readable title-cased display name

Sums an array of EVM transaction values expressed in Wei and returns the total Wei and transaction count, processed in-memory without data retention.

Checks whether a given date is a US stock market holiday and returns the holiday name if applicable

Compares two URLs to determine if they canonically refer to the same resource, returning a match result with verifiable evidence.

Generates a cryptographically random NanoID string of configurable length (4–64 characters), billed per-call at $0.001 USDC with no signup required.

Masks the middle characters of a string, preserving the first and last few characters for safe display of sensitive values

Validates whether a numeric string passes the Luhn algorithm checksum, returning validity status and digit count

Parses and normalizes raw log text into a structured log event object with level, message, service, trace ID, and timestamp fields.

Parses a Content-Security-Policy header string and returns a structured breakdown of all directives and their values

Calculates the liquidation price for a leveraged long position given entry price, leverage, and maintenance margin rate (MMR).

Computes the Levenshtein (edit) distance between two strings, paid per-result via USDC on Base or Solana using the x402 protocol.

Detects and quantifies Unicode writing scripts (Latin, Japanese, Cyrillic, etc.) present in a UTF-8 text string, returning per-script character counts, percentages, and the dominant script.

Parses a JWT token and returns its expiration time, seconds remaining, and whether it is expired — without verifying the signature

Checks whether a given IPv4 address falls within a private (RFC 1918) address range

Indexes an array of JSON objects by a specified key field, returning a dictionary keyed by each object's key value, with duplicate key detection.

Decodes a JWT string and returns its claims with human-readable timestamps

Validates whether a URL redirect target is allowed by checking its host, scheme, and resolved URL against a configurable allowlist

Converts a raw USDC integer (in base units) to a human-readable decimal USDC amount by dividing by 10^6 decimals

Checks whether a list of JSON objects are unique across specified fields, returning duplicate indices and a pass/fail result

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

Validates that specified fields within a JSON object contain timestamp values falling within a given epoch range, returning a pass/fail result with details on any invalid fields.

Checks whether a JSON object's serialized byte size falls within a specified maximum budget and returns the exact byte count.

Calculates the market impact price for a trade given a mid price, side (buy/sell), and slippage tolerance in basis points

Computes the Nth percentile of a provided numeric dataset, returning the percentile value and sample count.

Computes how many tokens have vested and how many remain unvested given a vesting schedule and evaluation timestamp

Validates that a given JSON object contains all specified required fields, returning a list of any missing ones.

Computes sample volatility (standard deviation and annualized volatility) from a caller-supplied array of period returns

Validates whether specified fields in a JSON object match a given pattern, returning pass/fail results and a list of any invalid fields.

Applies a sequence of RFC 6902 JSON Patch operations to a document in-memory and returns the patched result with verifiable evidence, without persisting any data.

Removes specified keys from a JSON object and returns the filtered result with verifiable evidence of in-memory-only processing.

Validates whether a webhook signature timestamp falls within an acceptable age and future-skew window, returning pass/fail with computed age in seconds.

Fetches and analyzes a given URL to produce a structured intelligence summary including page title, feeds, forms, and contact presence

Fetches and parses a website's robots.txt file, returning allowed paths, disallowed paths, and sitemap URLs

Validates that fields in a JSON object match their expected enum values as defined by a supplied enums schema

Calculates loyalty points earned and estimated reward value for a purchase, returning a ledger-ready credit instruction.

Removes keys with empty or null values from a JSON object and returns the pruned result with evidence of what was removed.

Converts a wei amount (as a string) to its equivalent ETH value as a decimal number

Groups an array of JSON objects by a specified key field, returning bucketed items and group count

Converts a Wei value (smallest Ethereum unit) to Gwei by dividing by 1,000,000,000

Computes a categorical frequency distribution from an array of values, returning counts, percentages, and unique category stats.

Removes duplicate integers from a JSON array and returns the deduplicated list with a count of removed items, processed in-memory without data retention.

Returns the ISO week number, year, and weekday for a given date or timestamp

Applies a JSON Merge Patch (RFC 7396) to a target JSON object, returning the merged result and a list of changed fields.

Converts an ISO 8601 datetime string to a Unix timestamp (epoch seconds) for $0.001 USDC per call via x402.

Validates that specified fields in a JSON object contain valid UUID values, returning pass/fail status and a list of any invalid fields.

Calculates the compound return factor and total return from an array of periodic returns

Randomly selects one item from a list using weighted probabilities, returning the chosen item, its index, weight, and probability

Parses an ISO 8601 duration string (e.g. PT1H30M) into its component parts: days, hours, minutes, seconds, and total seconds.

Validates whether an X402 payment nonce is fresh (not reused) and meets minimum length requirements, returning acceptance status with verifiable evidence.

Computes the win rate (percentage of profitable trades) from an array of PnL values

Transforms a list of raw incident events into a structured, chronologically ordered incident timeline with start/end times and event count.

Computes a reliability curve (calibration curve) from forecast probabilities and binary outcomes, grouped into bins, to evaluate forecast calibration quality.

Calculates the impermanent loss percentage and fraction for a constant-product AMM position given a price ratio change

Computes the SHA-256 hash of an arbitrary UTF-8 text string, paid per-call via USDC on Base or Solana

Counts word frequencies in a text and returns the top words with their counts, total token count, and unique word count.

Parses a WWW-Authenticate HTTP header string into structured scheme and parameter components, returning verifiable results with no data retention.

Escapes special HTML characters in a string (e.g. <, >, &, quotes) to produce safe HTML-encoded text.

Estimates the byte size and token count of a UTF-8 text payload, useful for planning agent handoffs and data transfers.

Validates whether a partial delivery of items meets a minimum coverage fraction threshold, returning an acceptance decision and coverage metrics.

Ranks and selects the best payment option from an array of x402 'accepts' objects based on preferred assets and networks

Analyzes a URL to report its content distribution signals, including RSS/feed count, Open Graph presence, and active social channels.

Computes the relative luminance of a hex color code (#RRGGBB) and returns it as a float value.

Checks whether a given DMARC policy, SPF alignment, and DKIM alignment result in a triggered enforcement disposition

Parses HTTP rate-limit headers from an API response and returns structured rate limit information including limit, remaining, reset, and retry-after values.

Calculates gross profit and gross margin percentage given a cost and price value

Revalues a notional amount from one FX rate to another, returning the converted value

Computes trade execution slippage in basis points relative to a VWAP benchmark for a given trade side and average fill price

Computes the periodic funding payment amount for a leveraged position given notional size, funding rate, and holding period in hours.

Validates an X402 delivery receipt to confirm a pay-per-result API delivery was completed, structurally sound, and contains all required fields.

Validates that a result object contains all required fields specified in an X402 delivery contract, returning a pass/fail verdict with evidence of non-retention.

Converts a radian angle value to degrees with high precision

Parses the HTTP Forwarded header string (RFC 7239) into structured entries with client IPs, host, and protocol fields.

Validates whether the r and s components of an EVM ECDSA signature have valid cryptographic shape (within the secp256k1 curve bounds)

Escapes a text string for safe inclusion in a CSV field, quoting and doubling any internal double-quotes per RFC 4180.

Checks whether a given data retention period complies with a specified maximum allowed retention policy, returning compliance status and excess days.

Verifies that a Base USDC recipient address matches an expected address before executing a payment transaction

Generates a compact 16-character SHA-256 fingerprint (hash) of an input text string for lightweight deduplication or identity checks.

Returns static registry metadata for blockchain networks by name or EVM chain ID, including CAIP-2 identifier, chain family, and display name.

Computes the log-loss (cross-entropy loss) for a binary prediction given a predicted probability and the actual binary outcome.

Validates whether a given payment timestamp falls within an acceptable lead-time window relative to a deadline, returning pass/fail and the computed lead seconds.

Extracts all numbers from a given text string, returning a count and list of the found numeric values.

Computes the total required Wei amount by adding a transaction value (in Wei) and its associated fee ceiling, useful for EVM preflight budget checks before executing on-chain transactions.

Resolves a blockchain chain ID integer to its canonical human-readable chain name (e.g. 8453 → 'base')

Classifies a numeric value against optional lower and upper thresholds, returning whether the value is below, within, or above the defined range.

Computes a deterministic SHA-256 fingerprint of a JSON record using sorted keys and compact separators for verifiable, canonical hashing.

Validates an HTTP Strict-Transport-Security (HSTS) response header against configurable policy requirements, returning pass/fail with parsed max-age and subdomain details.

Checks the nesting depth of a JSON object and verifies whether it falls within a specified maximum depth budget

Classifies an EVM transaction type integer (e.g. 0, 1, 2) into a human-readable category such as 'legacy', 'access_list', or 'dynamic_fee'.

Checks whether a proposed EVM transaction nonce targets any pending (stuck) nonces, enabling safe nonce replacement decisions before transaction submission.

Verifies whether an actual X402 resource URL matches an expected resource URL, returning a verifiable pass/fail result with cryptographic evidence.

Scans a block of text and replaces all email addresses with redacted placeholders, returning the sanitized text and a count of redacted emails.

Computes the bounded lower and upper range (in wei) for the next EVM block's base fee given a current base fee and a maximum change fraction

Escapes special XML characters in a text string, returning a safely encoded version suitable for embedding in XML documents.

Computes the intersection of two arrays, returning the common elements and their count

Validates that a list of EVM log topics does not exceed a specified maximum count, returning the topic count and a pass/fail result.

Parses an HTTP Permissions-Policy header string and returns a structured breakdown of all directives and their allowed origins.

Checks whether an estimated Ethereum Base network gas fee falls within a specified ETH budget, returning fee breakdown and headroom in ETH, wei, and USD.

Normalizes null/empty values in CSV text by replacing custom null tokens with standard empty fields, returning a cleaned CSV string.

Validates whether an EVM (Ethereum) address conforms to EIP-55 mixed-case checksum encoding and returns the correctly checksummed form

Computes the OLS hedge ratio (beta) between two price series for pairs trading strategies.

Converts American-format sports betting odds (e.g. -150) to implied probability (e.g. 0.6)

Extracts all hyperlinks from a given URL, classifying them as internal or external, with configurable limit and timeout.

Counts occurrences in a CSV by pivoting rows and columns to produce a cross-tabulation frequency table

Normalizes phone-like text into a clean string of digits, returning the digit sequence and its length

Validates whether a legacy EVM transaction's gas fee falls within a specified budget ceiling, returning a pass/fail result with verifiable evidence.

Converts decimal betting odds into implied probability

Computes the number of EVM block confirmations for a transaction given its inclusion block and current block, returning finality status.

Parses a single CSV row string and returns its field count, individual field values, and whether a quoted field is still open (unterminated quote).

Converts raw yes/no vote or bet counts into implied probabilities, removing the overround to produce fair market probabilities.

Converts a periodic funding rate and funding period length into an annualized percentage rate (APR) for derivatives/perpetuals markets

Converts a MIME type string to its canonical file extension and metadata

Computes the total gas and fee ceiling for a batch of EVM transactions without retaining input data or making external calls.

Given a cron expression and a start timestamp, returns the next N scheduled fire times as Unix timestamps

Probes a single x402-enabled HTTPS endpoint to confirm it is live and returns a 402 payment-required response, without sending any payment.

Validates whether a proposed EVM token approval amount is within policy bounds relative to a required minimum and maximum cap

Given a series of caller-supplied ETH price observations, returns a probabilistic up/down prediction for the next 15 minutes

Validates the structural shape of an EVM access list array, confirming addresses and storage keys conform to expected format before transaction submission.

Looks up the full country name for a given ISO 3166-1 alpha-2 country code, paid per-call via USDC on Base or Solana.

Decodes a Vehicle Identification Number (VIN) to return structured vehicle details such as make, model, year, and specifications

Verifies that a list of delivered item IDs matches and is in the correct order compared to an expected list of IDs, returning a pass/fail result with mismatch indices.

Computes option strategy payoff diagram points across a range of spot prices for one or more option legs

Detects and reports duplicate records in a dataset by analyzing specified key fields, returning group counts and duplicate statistics.

Checks whether a given payment asset (e.g. USDC) is supported by a list of accepted assets for x402 protocol payments

Returns a trust score and trust level for a given domain URL, indicating how reputable or safe the domain is.

Joins an array of DNS TXT record chunks into a single concatenated string value, returning the assembled record along with verifiable evidence of in-memory-only processing.

Predicts whether Bitcoin price will go up or down over the next 15 minutes, given caller-supplied price observations.

Computes a cryptographic checksum (hash) of input content and returns the hex digest, byte length, and emptiness status.

Computes the byte length of an EVM calldata hex string and validates its format, returning the byte count and shape validity.

Validates that the values in a JSON object match expected types as defined by a caller-supplied type map, returning pass/fail and detailed failure list.

Infers column names and data types from a raw CSV text sample, returning a structured schema description.

Parses a raw DNS HTTPS resource record string and extracts structured fields such as priority, target, and parameters like ALPN and port.

Returns a reproducible random sample of items from an array, deterministically driven by a seed string, with verifiable delivery paid per-call in USDC.

Compares two OpenAPI paths maps and returns which paths were added, removed, and held in common

Verifies whether a document URL and its declared canonical URL match, returning a pass/fail result with evidence of the check.

Checks whether an EVM token approval amount is infinite or near-infinite by comparing a raw approval value against a threshold

Parses a GraphQL document and returns a structured index of all operations (queries, mutations, subscriptions) defined within it, including their names and types.

Parses a caller-supplied robots.txt and determines whether a given path is allowed for a specified user-agent, without fetching any URLs.

Computes the LTV-to-CAC ratio from two numeric inputs and returns a health assessment with advisory guidance

Analyzes a proposed change (e.g. deployment, config update, migration) and returns a risk score with category and contributing signals

Counts characters, words, lines, and UTF-8 bytes in a given text string, returning precise metrics for pay-per-result via x402.

Computes the ETH and wei cost of an Ethereum transaction given gas used and gas price in wei

Validates whether a given Unix epoch timestamp meets a minimum lead-time window before a deadline, used for EVM transaction preflight checks.

Calculates the combined decimal parlay odds from an array of individual decimal odds values

Computes the SHA-256 hash of base64-encoded bytes and returns the hex digest along with the byte count.

Converts CSV text into structured JSON with rows, columns, and row count, supporting custom delimiters, paid per-call via USDC.

Counts occurrences and calculates density percentages of specified keywords within a supplied text block

Computes a structured diff between two Cache-Control header directive strings, returning added, changed, and removed directives.

Validates a JSON instance against a provided JSON schema and returns a lightweight list of validation errors.

Computes the upper-bound loss and price impact fraction a trade would suffer from a MEV sandwich attack given pool reserves and trade size

Computes the deviation of an observed price from a target peg price, expressed in basis points (BPS).

Computes the maximum blob fee ceiling in wei given blob gas and max fee per blob gas, for EVM transaction preflight estimation.

Converts a value in Gwei to its equivalent in Wei (Ethereum gas unit conversion)

Returns a reproducible random sample of integers from a list using a seed, with cryptographic evidence of no data retention or external calls.

Extracts DOI identifiers and URLs from arbitrary text using pattern matching, returning structured lists without fetching the links

Validates whether a given origin is allowed by a CORS policy, checking against a list of permitted origins and credential requirements.

Estimates the number of Base blockchain blocks that will elapse over a given duration in seconds, using a configurable assumed block time.

Computes the CRC32 checksum of a given text string, returning both hexadecimal and integer representations.

Calculates the annualized basis (APR) between a spot price and a futures/mark price over a given number of days

Calculates whether a given gas limit provides sufficient headroom over an estimated gas cost for an EVM transaction, returning the headroom amount and fraction.

Computes the mid-market price from a bid and ask value pair, returning the arithmetic midpoint

Validates the structural format of a DNS TLSA record string, returning field decomposition and a pass/fail shape validity result.

Predicts whether Bitcoin's price will be higher or lower in the next 5 minutes, given a caller-supplied sequence of recent price observations

Converts a monetary amount from one currency to another using a caller-supplied exchange rate, returning the converted value with 6-decimal precision.

Validates and normalizes a USDC amount string to 6-decimal Base USDC precision, returning the rounded value and conformance result.

Parses robots meta tag directives from HTML content and returns structured indexing/follow rules

Checks whether a given source URL is permitted by a Content Security Policy (CSP) header for a specified directive

Computes the expected value (EV) and number of shares for a binary prediction market position given stake, true probability, and market price

Checks whether the From domain and MAIL FROM domain are SPF-aligned (relaxed or strict) for DMARC compliance purposes

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

Converts a raw byte count integer into a human-readable file size string (e.g. '1.46 MiB') with unit, scaled value, and exact bytes.

Fetches open Requests for Quotes (RFQs) from the Delx agent demand board, optionally filtered by capability family

Checks a JSON object against an allowlist of permitted keys, returning pass/fail and any unexpected keys found

Validates whether a given BIC/SWIFT code is correctly formatted, returning a boolean result

Parses a robots.txt body and returns a structured summary of allowed/disallowed path counts and sitemap URLs

Audits a URL target for open redirect vulnerabilities by checking whether its host is in an allowed hosts list

Checks whether the gap between a pending nonce and a proposed nonce on an EVM chain is within an acceptable maximum, and whether a nonce replacement is possible.

Extracts a subset of keys from a JSON object, returning only the specified fields and a key count.

Deterministically assigns a list of items to named partitions according to provided weights, using a seed for reproducible results.

Returns a deterministic contiguous sub-window of an integer array derived from a seed string, with verifiable evidence of no data retention.

Checks whether a batch operation's failure count and failure fraction fall within an acceptable error budget, returning a pass/fail result with computed failure fraction.

Validates a Base blockchain settlement receipt by checking chain, amount, recipient, and status fields against expected values

Checks whether an actual HTTP Content-Type value matches an expected media type pattern or range, returning a pass/fail result with verifiable evidence.

Computes the basis points (bps) spread between a spot price and a futures price for a financial instrument

Validates whether a given string conforms to the Bitcoin Base58 alphabet and returns its length and validity status.

Upscales a base64-encoded image to higher resolution (up to 4 MP) using AI, returning a URL to the enhanced image for $0.01 USDC per call via x402.

Extracts all hyperlinks from raw HTML using regex, returning a deduplicated list of URLs up to an optional limit.

Converts between Ethereum wei and ether denominations in either direction, returning both unit representations.

Given a sequence of Ethereum price observations, returns a probabilistic up/down prediction for the next 30 minutes using a local model.

Classifies an EVM transaction signature's V value as legacy, EIP-155, or other type given a chain ID, enabling preflight validation of Ethereum signature recovery parameters.

Calculates how many months a startup can operate given its current cash balance and monthly burn rate

Computes a breakdown of EVM transaction fee components (ceiling, base, priority) from gas limit and fee parameters on the Base network

Computes the volume-weighted average entry price across a list of trade fills

Parses a raw DMARC TXT record body and extracts structured policy fields such as reporting address and policy mode

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

Checks whether a single API call cost and projected daily spend fall within a configured per-call and per-day USDC budget

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

Computes a person's current age in whole years given their ISO-8601 birth date

Parses a raw DNS SRV record string and returns its structured fields: priority, weight, port, and target hostname.

Validates an image generation result object against size and dimension constraints, returning a normalized receipt with metadata and any detected gaps.

Computes the arithmetic mean (average) of a list of up to 10,000 numeric values, returning the result with count metadata.

Validates a JSON instance object against a lite JSON schema, returning pass/fail and any validation errors.

Computes maker and taker trading fees in currency units given a notional amount and basis-point rates for each side

Validates HTTP Set-Cookie headers against configurable security policies (Secure, HttpOnly, SameSite attributes) and returns a structured pass/fail result.

Parses an HTTP Link header string into structured entries with values and parameters (e.g. rel, type)

Computes funnel conversion rates and dropoffs across sequential stages (e.g. visited → challenged → paid → delivered)

Heuristically detects the MIME content type of a file or data sample based on filename and/or byte sample

Computes cohort-based user retention metrics, returning retention percentages and weighted retention across cohorts.

Detects and redacts personally identifiable information (PII) from arbitrary text, returning the sanitized text with counts and types of redacted items

Validates that specified fields within a JSON object contain properly formatted email addresses, returning pass/fail results with a list of invalid fields.

Validates the structural shape of an EVM event log object, confirming it has the expected fields and format without retaining any input data.

Performs a deep merge of two JSON objects, combining nested properties recursively and returning the merged result with verifiable evidence.

Coerces an array of string values into JSON booleans, returning converted results and rejecting unparseable inputs.

Ranks a list of language/locale offer strings against an HTTP Accept-Language header and returns them sorted by quality score with the best match selected

Ranks a list of MIME type offers against an HTTP Accept header and returns the best match according to quality weighting

Extracts a specified subset of keys from a JSON object, returning only the requested fields and reporting any missing ones.

Parses HTML content to extract meta-refresh redirect targets and delay durations from HTTP-equiv refresh tags

Validates the syntax of an email address and parses it into local and domain parts

Computes optimal bet stakes and fractions across multiple outcomes using the Kelly Criterion given outcome probabilities, market prices, and a bankroll size.

Returns the MIME type corresponding to a given file extension, with a flag indicating whether the extension is recognized.

Parses and validates the Content-Security-Policy `frame-ancestors` directive from a given HTTP header string, checking whether a required source is present.

Verifies an HTTP Digest header by checking whether a given algorithm and base64-encoded digest match the provided text, returning a match result and the computed digest.

Validates whether a given request host matches a specified cookie domain according to browser cookie-scoping rules

Classifies a list of data fields to detect sensitive or restricted data types such as PII and credentials

Validates and computes the fee ceiling for an EVM EIP-1559 transaction given gas limit, max fee per gas, and max priority fee per gas in wei.

Validates whether an EVM block timestamp is within a specified maximum age threshold, returning freshness status and age in seconds.

Determines whether a given EVM transaction `to` address indicates a contract creation (null/empty `to` field pattern)

Converts an EVM chain ID (in any format) to its canonical hex and decimal representations in a single in-memory, stateless computation.

Converts camelCase text strings to snake_case format via a pay-per-call API with no signup required.

Validates whether an EVM token amount (in raw units) meets a specified minimum threshold, returning sufficiency status and shortfall details.

Validates the structural format of a DNS DS (Delegation Signer) record string, returning field decomposition and a pass/fail shape verdict.

Analyzes a set of HTTP response headers and returns a security score with details on which headers are present, missing, and advisory notes.

Deterministically assigns a subject to an A/B test variant (A or B) based on a seed and optional weight, returning a verifiable bucket value and variant label.

Derives the implied spot price from a futures/mark price by backing out the carry (funding) over a given delivery horizon.

Counts lines, characters, non-empty lines, and detects newline endings in a given text string

Computes a deterministic, jitter-seeded exponential backoff delay schedule given a seed, factor, base interval, and attempt count

Calculates the overround (bookmaker margin) from an array of probability values

Deterministically splits a list of integers into balanced groups using a seed for reproducible, verifiable partitioning.

Calculates the output token amount for a given input amount in a constant-product AMM (automated market maker) swap, accounting for a specified fee

Computes the expected logarithmic portfolio growth (Kelly criterion-style) given a bet fraction, true probability, and market price.

Generates a reproducible bootstrap sample of indices given a seed, item count, and sample count, returning the sampled indices with verifiable evidence of no data retention.

Deterministically selects a reproducible subset of items from a candidate list using a seed value, returning chosen items and their indices.

Returns an optimal HTTP retry strategy (backoff algorithm, max attempts, jitter, idempotency) for a given HTTP method and response status code

Detects and identifies duplicate rows in CSV-formatted text, returning the row indices of duplicates without retaining the input data.

Converts a USDC decimal amount into its raw on-chain integer representation (base units with 6 decimals)

Detects duplicate rows in CSV text based on one or more specified key columns, returning which rows are duplicates.

Validates that every row in a CSV text has the expected number of columns, returning a pass/fail result with details on any invalid rows.

Computes SLO error budget status given total requests, failed requests, and a target availability percentage, returning burn rate and remaining failure allowance.

Audits a Content Security Policy (CSP) header string and returns a risk rating, detected directives, and security findings.

Computes the time-weighted absolute deviation of a set of market prices from a target peg value (e.g., 1.0 for stablecoins)

Analyzes a documentation website URL to extract its sitemap structure, feed availability, and documentation link count

Generates a reproducible, verifiably seeded sequence of random integers within a specified range, with cryptographic evidence of non-retention and no external calls.

Audits a browser cookie string for security properties including risk level, HttpOnly flag, SameSite attribute, and security flag.

Classifies the decoded text of a QR code or barcode payload into a typed category (e.g. URL, contact, etc.) and returns a normalized value.

Determines whether a given HTTP cookie path matches a given HTTP request path, following standard cookie path-matching rules.

Accepts an array of operation results and returns aggregated counts by status (success, failed, pending, unknown) with a verifiable in-memory summary.

Infers the MIME content type and file extension from a filename, file path, or URL string

Sorts the keys of a JSON object alphabetically and returns the reordered object with verifiable evidence of in-memory processing.

Computes slippage in basis points by comparing an average fill price against a TWAP benchmark for a given trade side.

Computes the profit factor from a list of PnL values, returning gross wins, gross losses, and the win/loss ratio

Parses an HTTP Content-Disposition header string and returns the disposition type and its parameters (e.g. filename) as structured data.

Computes the risk, reward, and risk/reward ratio for a trade given entry, stop-loss, and take-profit price levels

Computes the median value of a submitted array of up to 10,000 numeric samples, returning the result with count and schema identifier.

Calculates how many additional block confirmations are needed before a blockchain transaction is considered final, given a target confirmation count and current block heights.

Decodes and validates a JWT token, returning its header, payload claims, and expiry information

Parses Markdown text and returns a structured index of all headings with their levels and titles

Extracts and lists the column headers from a UTF-8 CSV text string, returning the header names and count.

Compares an actual API response object against an expected response schema to identify missing fields, type mismatches, and unexpected fields.

Generates a deterministic SHA-256 fingerprint from a scoped JSON payload to enable idempotency checking across agent operations

Discovers and lists all pay-per-result x402 API resources available at a given URL, returning their endpoints, tool names, and supported blockchain networks

Checks whether a raw EVM token balance is sufficient to cover a required raw amount, returning a pass/fail result with shortfall details.

Classifies whether an HTTP request is safe to retry based on method, status code, mutation behavior, and idempotency key presence

Detects whether a base64-encoded file prefix represents a valid PDF by inspecting its binary header bytes.

Checks a JSON object against a list of denied key names and returns which forbidden keys are present

Masks a credit/debit card number, returning only the last 4 digits with the rest replaced by asterisks

Checks whether a given certificate issuer is permitted by a domain's DNS CAA (Certification Authority Authorization) records

Removes the bookmaker overround from two-way market odds to return fair (true) implied probabilities for each outcome

Normalizes a blockchain address string to a canonical checksummed format

Calculates the appropriate position size for a trade given entry price, stop loss, account equity, and risk percentage.

Validates a set of deployment readiness checks and returns a pass/fail report identifying missing or failed requirements before production deployment.

Performs a left join on two CSV datasets using a specified key column, returning merged rows in-memory without data retention.

Analyzes a map of software dependencies and flags those with unbounded or risky version ranges that could introduce security or stability vulnerabilities.

Converts a JSON text payload into CSV format, returning the CSV string, column names, and row count — paid per call with USDC on Base or Solana via x402.

Removes duplicate items from an array and returns the unique set with a count of removed entries

Computes the price impact in basis points for a trade on an Automated Market Maker (AMM), given input amount, reserves, and fee.

Evaluates a RFC 6901 JSON Pointer expression against a supplied JSON document and returns the value at that path, with verifiable delivery proof.

Checks whether a given EVM address is the zero address (0x0000000000000000000000000000000000000000) — a common preflight validation before executing on-chain transactions.

Validates a decision record object and returns which required fields are missing and an overall completeness percentage

Normalizes an array of raw price tick samples to a specified decimal precision, returning min, max, last, and count statistics.

Performs topological sorting on a directed graph of workflow nodes, returning execution order and cycle detection results.

Computes the Soundex phonetic code for a given text string, returning a 4-character alphanumeric code representing its English phonetic signature.

Filters a CSV text to retain only the specified columns, returning the trimmed CSV and a list of any missing columns.

Calculates the maximum possible loss for a trade given position size, entry price, and stop-loss level

Converts an ETH amount (as a decimal number) to its equivalent Wei value (as a string integer).

Calculates the required margin for a leveraged position given a notional value and leverage multiplier

Returns a probabilistic up/down prediction for Bitcoin price movement over the next 30 minutes, based on caller-supplied price observations.

Ranks a list of candidate texts against a multilingual query using semantic similarity scoring, returning candidates ordered by relevance score.

Validates that a CSV text contains all specified required column headers, returning pass/fail status and a list of any missing columns.

Validates whether an agent's result object contains all required fields/paths, returning a pass/fail verdict with a list of any missing paths and a cryptographic evidence hash.

Validates whether a transaction's chain ID matches an expected chain ID during EVM preflight checks

Parses an HTTP ETag header value into its structured components (weak flag and opaque tag string), in-memory with no data retention.

Extracts all email addresses found in a given text string, returning a deduplicated list and count.

Ranks a list of candidate tool names by relevance to a natural language intent query, returning scored results in order of match quality.

Computes statistical profiles (count, parsed count, max, min) for numeric values in CSV columns

Filters rows in a CSV by checking whether values in a specified column match an allowed list of values

Calculates the exact number of days between two date strings, returning a verified integer result for $0.001 USDC per call with no signup required.

Trims whitespace from all cells in a CSV-formatted text string, returning a cleaned CSV without storing the input data.

Validates and canonicalizes a hex string, returning its normalized form with optional 0x prefix, byte length, and validity status.

Computes how many seconds remain before an SLA deadline and whether the deadline has already been breached, given a current timestamp and a deadline timestamp.

Validates a card or ID number using the Luhn algorithm to detect if it is structurally valid

Determines the appropriate approval route (e.g., security_and_finance) for a transaction or action based on risk level and amount, indicating whether human review is required.

Validates whether a string conforms to slug format rules (lowercase alphanumeric with hyphens), returning validity status and any issues found

Checks whether a given IP address falls within a specified CIDR block/subnet range

Extracts HTML meta tags (title, description, and other metadata) from a raw HTML string without browser rendering

Calculates the output token amount for a given input amount using AMM V3 constant-product market maker (CPMM) pool reserve data

Strips HTML tags from content, returning clean plain text via a pay-per-result micro-payment API using USDC on Base or Solana.

Computes revenue concentration metrics (HHI-style) across a set of accounts, returning concentration level, top account share, and top-three share.

Classifies an HTTP error response body and status code into a structured error taxonomy, returning category, retryability, and a content hash.

Computes the total notional value (in USD or quote currency) across an array of order book price/size ladder levels

Computes per-step timeout allocation by splitting a total timeout budget across sequential steps after reserving overhead milliseconds.

Checks whether a previously quoted Base network gas price is still fresh (within a maximum age threshold) given two epoch timestamps and a staleness limit.

Validates that a list of citations meets a minimum count threshold, returning a pass/fail result with verifiable proof of execution.

Validates and selects an eligible x402 payment option from a set of requirements before executing a micropayment

Reconciles and verifies x402 payment lifecycle artifacts (settlement reference, delivery receipt, payment response, and payment requirement) to produce a cryptographic verdict on whether a pay-per-result transaction was correctly completed.

Determines whether a sitemap entry is still fresh by comparing its lastmod timestamp to the current time against a configurable maximum age threshold.

Calculates the allowed failure count and error budget percentage for a given SLO target and request window

Computes an HMAC-SHA256 hex digest of an input text using a provided secret key, payable per-call via USDC.

Validates that an agent's result object conforms to a standard delivery envelope schema, confirming presence of required fields and data integrity without retaining input.

Compares two semantic version strings and returns their ordering relationship (greater, lesser, or equal)

Checks whether a purchase is eligible for a refund given a specific refund policy, returning eligibility status and reasons.

Validates that an X402 payment challenge object has the correct structure and required fields, returning a shape-validity report with field diagnostics.

Decodes a World Manufacturer Identifier (WMI) code to retrieve vehicle manufacturer information

Parses a JSON Lines (JSONL) text blob into individual JSON objects and returns the count and parsed items, with verifiable no-retention evidence.

Validates that max_fee_per_gas_wei is correctly ordered relative to max_priority_fee_per_gas_wei for an EVM transaction preflight check

Returns the correctly pluralized form of an English word given an optional count, via a pay-per-call API using x402/USDC.

Estimates the wait time for a job entering a queue given the number of workers, mean service time, and current queue depth.

Computes realized profit and loss for a trade position using FIFO (first-in, first-out) accounting given entry price, exit price, and close size.

Replaces digit sequences in text with # characters, masking sensitive numeric data like credit card numbers

Validates whether an HTTP Referrer-Policy header value is accepted against a list of allowed policy values

Strips all punctuation characters from a text string, returning clean alphanumeric output

Parses an HTTP Retry-After header value and computes the delay in seconds and the absolute retry timestamp epoch.

Computes an exponential backoff retry schedule given base delay, growth factor, max attempts, and an optional delay ceiling.

Converts RGB integer color values (red, green, blue) into a CSS-compatible hexadecimal color string

Merges generic and agent-specific robots.txt directives to produce a unified set of crawling permissions (index/follow/noindex/nofollow)

Computes return on investment (ROI) as a ratio and percentage given a profit/loss (PnL) and margin (capital deployed).

Extracts the file extension and basename from a given file path string

Parses DNS CAA records and extracts the list of authorized certificate authority hostnames from them

Computes the saturation ratio of a system by dividing current in-flight work units by maximum capacity, returning a normalized load metric.

Ranks and selects the best HTTP Accept-Encoding compression format from a list of offers given an Accept-Encoding header value

Deterministically reorders a list of batch IDs using a seed string, returning a shuffled order that is reproducible and verifiable without external calls or data retention.

Deterministically generates a hex color code from a seed string, with no data retention and verifiable delivery via x402 micropayment

Deterministically maps a seed string to a (row, column) coordinate within a grid of specified width and height

Extracts initials from a given text string, returning the abbreviated capital-letter form of a name or phrase

Computes the factorial of a non-negative integer, returning the exact result, paid per-call via USDC microtransaction.

Given a seed string and a count, deterministically computes a bounded permutation index using a seeded algorithm, with verifiable evidence of no data retention.

Deterministically reorders a list of tasks using a seed string, producing a reproducible priority ranking with verifiable delivery proof

Deterministically selects a starting index for round-robin distribution given a seed string and a member count, with verifiable no-retention processing.

Generates a deterministic token of specified length from a seed string and character alphabet, with verifiable evidence of no data retention

Parses a semantic version string into its major, minor, and patch components with validity confirmation

Probes a URL to check whether it is a reachable and valid x402-compliant API server, returning discovery health checks, tool counts, and resource counts.

Computes the mathematical union of two arrays, returning a deduplicated set of all unique elements from both inputs.

Computes the SHA-256 hash of an input text string and returns it as a hexadecimal digest, paid per-call via USDC on Base or Solana using the x402 protocol.

Audits HTTP response headers to identify missing or misconfigured caching directives and returns a structured risk assessment with specific findings

Computes the absolute spread (ask minus bid) given an ask price and a bid price for a financial instrument

Checks whether a payment settlement falls within the allowable refund window by comparing timestamps against a specified window duration.

Computes a canonical SHA-256 hash of input text, returning a deterministic hex digest via a pay-per-call API

Classifies whether an HTTP request with a given method and status code is retryable, given a set of retry-eligible status codes

Splits a total millisecond time budget proportionally across ordered workflow steps using optional weights

Calculates the take-profit price level for a trade given an entry price, position side, and target profit percentage

Converts a Celsius temperature value to its Fahrenheit equivalent, paid per-call via USDC on Base or Solana.

Converts a temperature value from Fahrenheit to Celsius, returning both values in a structured response, paid per-call via USDC on Base or Solana.

Aligns a list of ISO-8601 UTC timestamps to fixed-width time buckets given a specified interval in seconds

Returns the timezone for a given location or identifier, paid per-result via USDC micropayment on Base or Solana using the x402 protocol.

Converts a human-readable token amount and decimal precision into the raw integer representation used in on-chain transactions.

Converts a raw blockchain token integer value to a human-readable decimal amount given the token's decimal precision.

Trims leading/trailing whitespace and collapses internal whitespace runs in a text string, returning the cleaned result.

Truncates a string to a maximum character length by removing characters from the middle and inserting an ellipsis, preserving the start and end.

Computes a simple time-weighted average price (TWAP) from an array of price inputs

Computes unit economics (gross profit, gross margin) given a cost and price, returning a profitability verdict

Checks whether a given URL matches any pattern in a provided allowlist, returning host, path, and match details.

Encodes an input text string into Base64URL format and returns the encoded result for $0.001 USDC per call via x402.

Parses a URL string into its constituent components (scheme, host, path, port, query, fragment) without fetching the destination

Parses a URL string into its component parts: scheme, netloc, path, query, and fragment

Checks whether a URL's port is allowed according to a specified list of permitted ports and returns the effective port used

Fetches and summarizes the OpenAPI specification of a given URL, returning title, version, auth hints, and path counts

Parses and normalizes an HTTP Vary header string into a canonical, sorted list of header field tokens

Normalizes an array of non-negative weights so that they sum to 1, returning normalized values along with count and sum metadata.

Evaluates a set of named boolean preflight checks and returns whether an agentic workflow is allowed to proceed, based on which required conditions are met.

Calculates the estimated time in seconds for a given number of blockchain blocks to be produced, given a seconds-per-block rate

Validates whether a given route object conforms to the x402 catalog specification, checking for required fields, valid HTTP method, path format, and positive pricing.

Converts an integer to its Roman numeral representation, paid per-result via USDC on Base or Solana.

Converts a wei amount (smallest Ethereum unit) to its equivalent ETH value

Checks whether a given x402 protocol version is supported among a list of supported versions, returning a verifiable result with cryptographic evidence.