All Services

Validates whether a string consists entirely of characters from the Bitcoin Base58 alphabet, locally and deterministically, with no live chain access.

Estimates the decoded byte size of a base64-encoded string without performing a full decode, returning a deterministic byte count in JSON

Decodes a Base64url-encoded string (with optional padding) into its original text, returning the decoded result and an ok status flag.

Converts a bit count integer into its equivalent byte representation, returning bytes, bits, and whole_bytes values.

Coerces common truthy/falsy string tokens (e.g. 'yes', 'true', '1', 'off', 'no') into a deterministic boolean JSON result

Encodes bounded UTF-8 text to its hexadecimal representation, or inspects the resulting hex byte length, entirely locally without any RPC calls.

Converts an integer byte count to its equivalent bit count, returning both bits and bytes as local JSON.

Converts a raw byte count integer into a human-readable binary unit string (e.g. 1024 → 1 KiB)

Converts camelCase identifiers to kebab-case strings, useful for mapping JavaScript property names to CSS custom properties or URL tokens.

Converts camelCase or PascalCase identifiers to snake_case format, returning the converted text and its length.

Converts an input string to lowerCamelCase format for use in JSON property naming and code generation

Computes character frequency distribution and top character histogram for a given text string

Splits an array into fixed-size batches, returning the chunked groups and total count.

Clamps an integer value into a specified inclusive min/max range, returning the bounded result as deterministic JSON

Normalizes a short-form #RGB or long-form #RRGGBB color hex string to its canonical lowercase #rrggbb representation.

Converts a probability (0–1) into its equivalent decimal odds representation for use in betting, forecasting, or risk modeling workflows.

Converts decimal betting odds to implied probability as a decimal fraction

Validates that specified fields within a JSON object contain valid URLs, returning a pass/fail result with a list of any invalid fields.

Checks whether a given string has a valid email address format (shape/syntax), returning true or false.

Analyzes an array of records to compute per-field null/missing value percentages and distributions

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

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

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

Normalizes a raw search query string into a clean, canonical form suitable for GDELT news event database queries

Classifies an HTTP method string as idempotent or non-idempotent and safe or unsafe, with cryptographic evidence of no data retention.

Validates whether a given EVM blob count is within a specified maximum limit, returning a bounded pass/fail result with verifiable evidence.

Computes the total gas cost in wei given gas used and gas price per unit

Checks whether array A is a subset of array B, returning a boolean result with element counts for both arrays.

Compares two Unix epoch timestamps to determine which is newer and by how many seconds

Computes the MD5 hash of an input string and returns it as a lowercase hexadecimal digest, paid per-result via USDC on Base or Solana.

Checks whether an observed latency measurement falls within a specified SLA threshold, returning overage details and a pass/fail result.

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

Returns the fiscal/calendar quarter number (Q1–Q4) and year for a given ISO-8601 date or timestamp.

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

Validates whether a given string is a properly shaped URL, returning a boolean validity result.

Computes the absolute profit and loss (PnL) value for a trade given entry price, exit price, and position size

Converts an array of JSON objects into a JSON Lines (NDJSON) formatted string, one object per line.

Validates whether a given string conforms to the standard UUID format (shape check only, not existence)

Computes the least common multiple (LCM) of two integers, paid per-result via USDC on Base or Solana using x402.

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

Computes a composite operational health score and band from latency, saturation, and success rate metrics.

Normalizes an HTTP version string (e.g. '2.0', 'HTTP/1.1') into a canonical short form and validates whether it is a recognized HTTP version.

Returns the current UTC time as a Unix timestamp (seconds and milliseconds) and ISO 8601 string, paid per-call via USDC over x402.

Parses a raw URL or query string into structured key-value pairs, with automatic redaction of sensitive tokens.

Analyzes an API response object to generate a structured pagination plan, including mode, next reference cursor, stop condition, and recommended max pages.

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

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

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

Splits an integer array into fixed-size chunks and returns them as a structured JSON result with verifiable evidence, billed at $0.001 USDC per call via x402.

Validates and classifies the shape/format of a public registry identifier string (e.g. LEI, ISIN, DUNS) without performing a live registry lookup

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

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

Computes the set difference between two integer arrays (elements in left but not in right), returning the count and items.

Filters an array of JSON objects to only include specified keys, returning the trimmed objects and a match count, paid per-call via USDC microtransaction.

Looks up Legal Entity Identifier (LEI) data for a given entity, paid per-result via USDC on Base or Solana using the x402 protocol.

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

Converts a raw byte count integer into a human-readable file size string (e.g. 1536 → '1.5 KB')

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

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

Escapes special characters in a string to produce valid JSON-safe text

Computes the statistical expectancy of a trading strategy given a list of profit/loss values

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

Computes the intersection of two integer arrays, returning shared elements and their count, with cryptographic evidence of no data retention.

Validates that specified array fields within a JSON object have lengths falling within a given minimum and maximum range, returning a pass/fail result with details on any invalid fields.

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

Validates that specified string fields within a JSON object fall within defined minimum and maximum character length bounds.

Extracts a specific field (by key) from an array of objects and returns all matching values as a flat list.

Sorts an array of JSON objects by a specified key, with optional descending order, returning verifiable sorted results with no data retention.

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

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.

Calculates whether a cached resource is still fresh given its age, max-age, and current timestamp, returning remaining freshness seconds.

Converts an integer basis points (bps) value to its equivalent percentage (pct) representation

Counts how many times a substring (needle) appears in a given text string, returning an exact occurrence count.

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.

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

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

Checks whether a given integer is a prime number, returning a boolean result via a pay-per-call API using USDC micropayments.

Adds a specified number of time units (days, hours, etc.) to a given date/timestamp and returns the resulting date

Extracts a URL slug (the last meaningful path segment) from a given URL string without fetching the destination

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

Computes a weighted composite quality score for agent-delivered data, combining latency, validity, freshness, and completeness metrics into a single verifiable score.

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

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

Validates an HTTP Age header value against a maximum age threshold to determine if cached content is still within its freshness window

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

Parses a hostname into its apex domain and constituent label segments

Computes the fair price for a binary outcome given a probability, returning the expected value as a price in USDC.

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.

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

Compares two ETag strings (strong or weak) and returns whether they match, using HTTP ETag comparison semantics.

Converts Markdown-formatted text to plain text by stripping all Markdown syntax and formatting

Converts color values between different color format representations (e.g. HEX, RGB, HSL) via a pay-per-call API using USDC micropayments.

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

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.

Normalizes a numeric quantity to both decimal and EVM-compatible hex (0x-prefixed) format for use in Ethereum transaction preflighting

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