ScorpTech x402 API

The nth Bell number, the number of partitions of a set of n objects. B(0) and B(1) are 1, and B(5) is 52. n runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bell

The sum of Bell numbers from lo through hi inclusive. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the sum is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bell-sum

The nth Bernoulli number as a reduced fraction, from the Akiyama-Tanigawa algorithm. B0 is 1, B1 is 1/2, B2 is 1/6, and B4 is -1/30. Odd indices after 1 are 0. n runs from 0 to 40. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bernoulli

The von Staudt denominator of B(m) for even m at least 2: the product of primes p such that p-1 divides m. The denominator of B2 is 6, and of B4 is 30. An odd m is rejected. m runs from 2 to 40. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bernoulli-denom

The sum of Bernoulli numbers B0 through Bn, as a reduced fraction. The sum through B1 is 3/2, and through B2 is 5/3. n runs from 0 to 40. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bernoulli-sum

Point on a cubic Bezier at t, as an exact fraction. t is between 0 and 1. The arch (0,0), (0,1), (1,1), (1,0) at one half is (1/2, 3/4). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bezier-cubic

Control points of the derivative of a quadratic or cubic Bezier. A cubic derivative is a quadratic, and each control is the degree times the step to the next point. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bezier-derivative

Point on a quadratic Bezier at t, as an exact fraction. (0,0), (1,1), (2,0) at one half is (1, 1/2). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bezier-quadratic

Split a quadratic or cubic Bezier at t by de Casteljau. Left and right are the two new control polygons, and they meet at the point on the curve. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bezier-split

Tangent vector of a quadratic or cubic Bezier at t. It is the derivative curve evaluated at t. The arch (0,0), (0,1), (1,1), (1,0) at one half has tangent (3/2, 0). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/bezier-tangent

The number of prime factors of n counted with multiplicity. Omega(1) is 0, Omega(4) is 2, and Omega(12) is 3. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/big-omega

The number of binary partitions of n, partitions into powers of two. b(0) is 1. Odd n copies b(n-1). Even n is b(n-1) plus b(n/2). b(1) is 1, b(4) is 4, and b(10) is 14. n runs from 0 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/binary-partition

The binomial coefficient C(n, k). k must not exceed n, and both indexes run up to 4096. An optional modulus reduces the coefficient; zero is rejected. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/binom

European option pricing (Black-Scholes-Merton with continuous dividend yield): call and put prices, delta, gamma, vega, theta per day, rho, d1/d2 and probability of finishing in the money; with a market price it solves implied volatility. Works for equity, index and crypto options (set the yield to 0). Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/black-scholes

Any BLS time series by id (CPI, payrolls, unemployment, state/metro LAUS, PPI, JOLTS, ECI ...) for a year range: observations newest first with preliminary flags and footnotes, latest value, MoM / YoY change. Up to 25 series per call. Includes BLS retrieval date and disclaimer. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/bls-series

Fixed-coupon bond math: price from yield or yield to maturity from price (clean and dirty, with accrued interest for fractional periods), current yield, Macaulay and modified duration, convexity and DV01, plus the cash-flow schedule. Treasury, corporate or zero-coupon bonds; any coupon frequency. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/bond-calc

The two historic Unix sums, matching GNU sum. bsd rotates the 16-bit sum right and counts 1024-byte blocks. sysv reduces modulo 65535, keeps 65535 when the total is a positive multiple of it, and counts 512-byte blocks. "123456789" is bsd 53615 and sysv 477. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/byte-sum

The Calkin-Wilf tree. Give n to get the nth positive rational, starting at 1/1, or give a reduced num and den to get its index. The two answers must agree when both are sent. An unreduced fraction is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/calkin-wilf

The Cantor bit of n. It is 1 when every base-3 digit of n is 0 or 1, and 0 when a digit is 2. Bit 0 is 1, bit 2 is 0, and bit 4 is 1. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cantor-bit

How many integers from 0 through n have only the digits 0 and 1 in base 3. The count through 0 is 1, through 2 is 2, and through 8 is 4. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cantor-count

Payment card number checks without storing anything: Luhn checksum, brand / network from the IIN (Visa, Mastercard incl. 2-series, Amex, Discover, Diners, JCB, UnionPay, Maestro, Mir, Elo, Hipercard, Verve, RuPay, Dankort, Troy, UATP), allowed lengths, CVV length, card-number spacing, known public test numbers (Stripe, Braintree, Adyen) and expiry validity. Returns only the PCI-safe first 6 / last 4 — never the full number. Up to 100 numbers per call. POST so numbers stay out of URLs and logs. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.i…

Carmichael's lambda of n, the exponent of the multiplicative group mod n. lambda(1) is 1, lambda(8) is 2, lambda(p) is p-1, and lambda(15) is 4. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael

CAS Registry Number check digit. Two to seven digits, a hyphen, two digits, a hyphen and a check digit. No leading zero. From the right, digits are weighted 1, 2, 3 and the total mod 10 is the check. A number typed without hyphens is split the same way. This does not look the substance up. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cas-validate

The nth Catalan number. C0 and C1 are 1, C2 is 2, C3 is 5, and C_n = binom(2n, n) / (n+1). n runs from 0 to 2048. An optional modulus reduces the term; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/catalan

US Census Bureau geocoder: a one-line US street address (or a lat/lon) to matched address and coordinates plus Census geographies: state and county with FIPS codes, census tract, block group and block GEOID, place/city, congressional district, state legislative districts, ZCTA, metro/micro area and urban area where available. Public-domain US government data; useful for district lookups, data joins and address normalisation. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/census-geographies

Best rational approximation with a denominator up to maxDen. It searches the convergents and the intermediate fractions. 355/113 with maxDen 7 is 22/7. With maxDen 100 it is 311/99. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cf-best

One convergent of a continued fraction. Index 0 is a0/1. The last index is the value itself. 13/8 at index 3 is 5/3. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cf-convergent

Continued fraction of a non-negative rational, by the Euclidean algorithm. 13/8 is [1; 1, 1, 1, 2]. 355/113 is [3; 7, 16]. A trailing 1 is folded into the previous term, so this is the short form. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cf-expand

Continued fraction of a square root. sqrt(2) is [1; 2, 2, 2, ...] and the period is 1. sqrt(3) has period 2. A perfect square is one term and period 0. The period is the repeating length, even when fewer terms are requested. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cf-sqrt

Exact value of a continued fraction [a0; a1, a2, ...]. Later terms are at least 1. [3; 7, 15, 1] and [3; 7, 16] are both 355/113. The canonical field is the short Euclidean form. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cf-value

Render a chart to a standalone SVG (plus base64 data URI) for reports, dashboards, emails and agent answers: bar, horizontal bar, stacked bar, line, area, scatter, pie and donut. Multiple series with legend, "nice" axis ticks, compact number labels (1.2k, 3.4M), optional value labels, gaps for null values, rotated category labels when crowded, light / dark theme, custom colours and size. Accessible (title + aria-label). Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chart-svg

The Chebyshev discriminant identity T(n,x)^2 - (x^2-1)*U(n-1,x)^2 = 1. gap is that difference. n runs from 1 to 64. Past 15 digits t or u is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chebyshev-disc

The product identity 2*T(a,x)*T(b,x) = T(a+b,x) + T(|a-b|,x). twice is the left side and sum is the right side. a+b must be at most 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chebyshev-prod

One step of the Chebyshev recurrence. kind is t or u. prev is degree n-1, older is degree n-2, and value is 2*x*prev - older. n runs from 2 to 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chebyshev-rec

The Chebyshev polynomial of the first kind T(n,x) at an integer x. T(0,x) is 1, T(1,x) is x, and T(2,3) is 17. n runs from 0 to 64 and x from -1000 to 1000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chebyshev-t

The Chebyshev polynomial of the second kind U(n,x) at an integer x. U(0,x) is 1, U(1,x) is 2*x, and U(3,2) is 56. n runs from 0 to 64 and x from -1000 to 1000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chebyshev-u

Apply a chmod mode to a starting mode. The grammar is GNU chmod: symbolic [ugoa]*([-+=][rwxXst]* or one of ugo), comma separated, or =644 / +1, or a bare octal. No spaces. If who is omitted, bits set in umask are not changed; the default umask is 0. Explicit who ignores umask. X adds execute only on a directory, or when an execute bit is already set. On a directory, bare octal shorter than five digits keeps set-user-ID and set-group-ID; =755, 00755, or a symbolic s clears them. The sticky bit is not kept across = or bare octal. Price: $0.001 USDC per successful call (x402, Solana). Same tool o…

IPv4 / IPv6 subnet calculator: network and broadcast/last address, netmask, wildcard, first/last usable host, address and host counts, address type (private, CGNAT, documentation, ULA, link-local...), reverse-DNS zone, expanded/compressed IPv6; check whether IPs fall inside, and split the block into smaller subnets. Accepts CIDR, "ip netmask" or a single IP. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cidr-calc

Look up TLS cipher suites by IANA name, OpenSSL name, GnuTLS name or hex code (0x13,0x01 / 0xC02F) — one or a whole list from a scanner, server config or ClientHello — and get key exchange, authentication, cipher, MAC / PRF hash, AEAD and forward-secrecy flags, minimum protocol, the IANA Recommended flag (Y / N / Discouraged) and a security rating (recommended, secure, weak, insecure) with reasons: no forward secrecy, CBC, SHA-1, RC4, 3DES, EXPORT, NULL or anonymous. Lists get a summary and their worst suite. Without a suite, browse the 356-entry IANA registry filtered by protocol or rating. O…

CISA Known Exploited Vulnerabilities check: is a CVE (or up to 100) in CISA's KEV catalog, with date added, federal remediation due date, past-due flag, known ransomware use, required action and CWEs. Or search the catalog by vendor/product, recently added (?days=) or ransomware use. Complements /v1/cve-lookup (NVD). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cisa-kev

Search ClinicalTrials.gov (API v2) by condition, keyword, location, sponsor, recruitment status (or open/closed) and phase. Returns NCT id, title, status, phases, study type, conditions, interventions, lead sponsor, start and completion dates, enrollment, results flag, a short summary and up to 5 sites (ranked by your location), with total count and a page token. Informational only, not medical advice. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/clinical-trials

Whether n can be made with non-negative counts of coins a and b. 10 can be made with 2 and 5. 3 cannot. 0 can. a and b run from 1 to 10000, and n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/coin-check

How many positive integers cannot be made with coprime denominations a and b. The count is (a-1)*(b-1)/2. For 2 and 5 it is 2. For 4 and 7 it is 9. A pair that is not coprime is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/coin-count

The fewest coins of denominations a and b that sum to n. Making 10 with 2 and 5 takes 2 coins. An amount that cannot be made is rejected. a and b run from 1 to 10000, and n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/coin-min

The number of non-negative integer solutions of a*x + b*y = n. Order of summands does not matter. There are 2 ways to make 10 with 2 and 5, and 0 ways to make 3. a and b run from 1 to 10000, and n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/coin-ways

The Collatz glide of n, the number of steps until a value strictly below n. The glide of 1 is 0, the glide of 6 is 1, and the glide of 7 is 11. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/collatz-glide

The number of Collatz steps from n until 1. The length of 1 is 0, the length of 6 is 8, and the length of 27 is 111. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/collatz-length

The parity of each term on the Collatz trajectory from n through 1. 0 is even and 1 is odd. The parity of 6 is 010100001. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/collatz-parity

The largest value on the Collatz trajectory from n through 1, including n. The peak of 1 is 1, the peak of 6 is 16, and the peak of 27 is 9232. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/collatz-peak

One Collatz step. An even n is halved and an odd n becomes 3n+1. 6 goes to 3, and 1 goes to 4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/collatz-step

Convert a colour between HEX, RGB(A), HSL, HSV, CMYK, CIE Lab and OKLCH (any CSS colour syntax or one of the 148 CSS names in), with relative luminance, contrast against white and black, the readable text colour and the nearest CSS named colour (CIE76 delta-E). With a second colour it returns the WCAG 2.x contrast ratio and AA / AAA pass/fail for normal and large text and UI components. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/color-convert

Generate colour palettes from one base colour: complementary, analogous, triadic, split-complementary, tetradic and monochromatic schemes plus an 11-step 50-950 shade scale (Tailwind-style, perceptually even in OKLCH), each swatch with HEX, HSL, readable text colour and contrast ratios. Ready for design tokens and UI theming. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/color-palette

Company profile from its own website: name, description, logo, social profiles, contact emails/phones, postal address, schema.org Organization JSON-LD, OpenGraph/Twitter cards, plus RDAP domain registration basics (registered, expires, registrar). SSRF-safe fetch of the public page. Price: $0.03 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/company-profile

Compound growth / savings calculator: future value of a principal plus monthly contributions at any compounding frequency (incl. continuous), contributions at start or end of month, inflation-adjusted value, APR <-> APY conversion, doubling time, months to reach a target and a yearly breakdown. Works for savings, staking yields and DCA projections. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/compound-interest

Extract public business contact details from a website: email addresses (mailto, visible text incl. [at]/[dot] obfuscation, Cloudflare-protected, JSON-LD) tagged role/personal and same-domain, phone numbers (tel: links, JSON-LD, text), social profiles (LinkedIn, X/Twitter, Facebook, Instagram, YouTube, GitHub, TikTok, Mastodon, ...; share links ignored), JSON-LD organization name/address and contact-form URLs. Follows up to 3 same-site contact/impressum/about pages. SSRF-safe fetching; respect GDPR/CAN-SPAM when using results. Price: $0.02 USDC per successful call (x402, Solana). Same tool ove…

ISO 6346 container check digit. Four letters (the fourth is U, J, Z or R), six serial digits and a check digit. Letter values skip every multiple of 11, then each value is multiplied by 2 to the power of its position. The total mod 11 mod 10 is the check digit. Spaces are ignored. This does not look the owner up at BIC. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/container-check

Convert a location between coordinate formats in one call: decimal degrees, DMS, degrees-decimal-minutes, UTM (Krüger series, WGS-84, Norway / Svalbard zones), MGRS military grid, geohash (with cell size), Maidenhead ham-radio locator and Open Location Code (plus code). Auto-detects the input format, including free-form DMS like 40°26'46"N 79°58'56"W. Offline, deterministic. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/coord-convert

The cosine of the angle opposite side c, as a reduced rational (a^2+b^2-c^2)/(2ab). The sides must form a strict triangle. A right angle returns 0. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cosine-law

CRC-16 over text or hex bytes. Algorithms are CCITT-FALSE, ARC, XMODEM, KERMIT and MODBUS. The check string 123456789 is 29b1 in CCITT-FALSE. This is not CRC-32. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/crc16

Credit-card and revolving-balance payoff in exact cents. Give a balance, an annual percentage rate, and a fixed payment (or a minimum that is the greater of a percent of the new balance and a floor). Returns the months to zero, total interest, total paid, and a yearly rollup. Interest each month is round-half-up of balance × APR / 12. The last payment is the remaining balance plus that month's interest. Refuses a payment that does not cover the interest. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/credit-payoff

ISO 11649 creditor reference. RF, two check digits, then up to 21 letters or digits. Spaces, hyphens, dots, commas, slashes and colons are ignored. The check moves RF and the two digits to the end and requires ISO 7064 mod 97-10 to be 1. This does not look the creditor up. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/creditor-ref

Explain a standard 5-field cron expression in plain English and list its next N run times (default 5, max 20) in any IANA zone, DST-correct. Supports lists, ranges, steps (*/n, a-b/n), month/weekday names, 0 or 7 = Sunday and @yearly/@monthly/@weekly/@daily/@hourly/@reboot; applies cron's day-of-month OR day-of-week rule and notes it. Rejects invalid and never-firing expressions with a precise reason. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cron-explain

Solve simultaneous congruences x ≡ a_i (mod m_i). Shared factors are allowed when the system is consistent; an inconsistent system is rejected. The result is the smallest non-negative solution and the lcm of the moduli. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/crt

Offline validator and chain detector for up to 50 crypto addresses: EVM (EIP-55 checksum, returns the checksummed form), Bitcoin (P2PKH, P2SH, SegWit v0 bech32, Taproot bech32m, testnet), Solana (32-byte base58, wallet vs program-derived/off-curve), Tron, XRP, Litecoin, Dogecoin, Dash and Cosmos-SDK bech32 chains. Catches typos via checksums before an agent sends funds. No network calls. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/crypto-address-validate

Evaluate a Content-Security-Policy string the way CSP Evaluator does, before you ship it: parses directives, catches typos, unquoted keywords and deprecated directives, then checks script execution (unsafe-inline without nonce/hash, unsafe-eval, wildcards, http:/https:/data: sources, 40+ known allowlist-bypass hosts with JSONP / AngularJS / user content), object-src, base-uri, frame-ancestors, form-action, reporting and Trusted Types. Returns findings with severity and fixes, a 0-100 score and A-F grade, and a strict nonce-based policy template. Price: $0.002 USDC per successful call (x402, So…

Convert a CSS angle among deg, grad, turn and pirad. A degree is 1/360 turn, a gradian is 1/400 turn, and one pirad is π radians, which is half a turn. A raw radian value is rejected because π is not rational. Exact rationals. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/css-angle

Convert one CSS absolute length. An inch is 96px and 2.54 cm, so a centimetre is 4800/127 px, a millimetre is 480/127 px, and Q (a quarter-millimetre) is 120/127 px. A point is 4/3 px and a pica is 16px. Units: px, in, cm, mm, Q, pt, pc. em, rem, percent and viewport units are rejected. Exact rationals, 12 decimal places. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/css-length

Convert a CSS resolution among dppx, dpi and dpcm. The alias x means dppx. One dppx is 96 dpi, and one inch is 2.54 cm, so one dpcm is 127/4800 dppx. Exact rationals. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/css-resolution

Convert a CSS time between seconds and milliseconds. One millisecond is 1/1000 s. Minutes are not a CSS time unit. Exact rationals. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/css-time

Profile a CSV/TSV dataset: delimiter detection, row and column counts, per-column inferred type (integer, decimal, boolean, date, datetime, string), null/empty counts, distinct values, min/max/mean/median/std and percentiles for numbers, length stats and detected patterns (email, URL, phone) for text, top values, duplicate rows and data-quality warnings. Up to 50,000 rows. POST JSON body {csv}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/csv-profile

Turn CSV/TSV into SQL: CREATE TABLE with inferred column types (integer/bigint, numeric, boolean, date, timestamp, varchar/text, NOT NULL where never empty, optional primary key) and batched INSERT statements with correct quoting and escaping for PostgreSQL, MySQL, SQLite or SQL Server. Up to 20,000 rows. POST JSON body {csv, table, dialect}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/csv-to-sql

Certificate Transparency subdomain enumeration via crt.sh JSON API. Returns unique hostnames (capped) issued under the domain. Price: $0.008 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ct-subdomains

Whether n is cubefull: 1, or every prime factor's exponent is at least 3. 1 and 8 are cubefull. 36 is powerful but not cubefull. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cubefull

Convert a curl command (copied from browser dev tools, API docs or a terminal) into ready-to-run code: Python requests, JavaScript fetch, Node axios, Go net/http, PHP curl, Rust reqwest, HTTPie and PowerShell. Handles quoting ($'…', "…", line continuations), -X / -H / -d / --data-raw / --data-binary / --data-urlencode / --json / -F multipart / -u basic auth / -b cookies / -A / -e / -G / -I / -L / -k / --max-time / -x proxy / --oauth2-bearer and combined short flags. Also returns the parsed request (method, URL, headers, body) and warnings for options that cannot be expressed. Price: $0.002 USD…

Money formatting and math with CLDR data (ICU 78 / CLDR 48, matches Intl.NumberFormat): format an amount for any of 60 locales and 154 active ISO 4217 currencies (symbol, narrow symbol or code; standard or accounting negatives; Indian lakh grouping, Swiss apostrophes, RTL marks), round with 9 modes or cash rounding (CHF 0.05), parse a formatted string such as "1.234,56 €" or "(US$1,234.50)" back to an exact amount and currency, split an amount by ratios without losing a cent (largest remainder) and look up currency or country info (digits, symbols, cash rounding, countries). Exact decimal arit…

CUSIP check digit. Nine characters from digits, letters, and * @ #. Spaces are ignored and hyphens are not. From the left, values are weighted 1, 2, 1, 2 and the digits of those products sum to the check digit. A CUSIP made only of letters and digits is also returned as a US ISIN. This does not look the issuer up. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cusip-validate

Search NIST NVD CVE API 2.0 by product/keyword with optional CVSSv3 severity filter. Returns CVE ids, scores, vectors, descriptions and reference URLs. Public NVD data. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cve-lookup

Score and explain any CVSS vector: v4.0 (official FIRST macrovector algorithm, CVSS-B/BT/BE/BTE nomenclature, macrovector and severity breakdown), v3.1 and v3.0 (base, impact / exploitability subscores, temporal and environmental scores) and v2 (base and temporal). Validates the vector, rejects duplicates / unknown metrics, labels every metric in plain words and returns the qualitative severity. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cvss-calc

Calendar-correct date arithmetic in any IANA zone: add or subtract durations (ISO 8601 or plain English, months clamp to month end so Jan 31 + 1 month = Feb 28/29), exact difference between two dates (years / months / days breakdown plus total days / weeks / hours / seconds and ISO 8601), start / end of day / week / month / quarter / year, the Nth weekday of a month ("4th Thursday of November") and age / countdown. DST-aware. Offline. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/date-calc

Day-count conventions and accrued interest for bonds, loans and swaps: days and year fraction between two dates under ACT/360, ACT/365F, ACT/ACT ISDA, NL/365, 30/360 (ISDA bond basis), 30/360 US (SIA end-of-February rules), 30E/360 and 30E/360 ISDA, with simple interest on a principal; or, for a fixed-coupon bond, the coupon schedule around a settlement date (previous / next coupon, end-of-month rule), accrued days and accrued interest per face amount, including ACT/ACT ICMA (Treasuries). Matches QuantLib. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https:/…

Dedekind's psi function, n times the product of (1+1/p) over the distinct prime factors of n. psi(1) is 1, psi(2) is 3, and psi(6) is 12. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dedekind-psi

Find and remove duplicate records (CRM contacts, leads, customers, products) in a JSON array. Modes: exact, normalized (emails: case, Gmail dots and +tags; phones: punctuation and country prefix; URLs: scheme, www, tracking params; names: accents, honorifics, word order; companies: Inc / Ltd / GmbH suffixes) and fuzzy (Jaro-Winkler / token similarity with weighted fields, blocking + sorted neighbourhood so 5,000 records stay fast). Groups transitive matches, keeps the first / last / most complete record, optionally merges missing fields from the duplicates, and returns the unique records plus …

The deficiency 2n - sigma(n). A deficient number is positive, a perfect number is 0, and an abundant number is negative. 4 is 1, 6 is 0, and 12 is -4. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/deficiency

The Delannoy number D(m,n), the number of paths from (0,0) to (m,n) using steps (1,0), (0,1), and (1,1). D(3,5) is 231. m and n run from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/delannoy

The central Delannoy number D(n,n). D(0,0) is 1 and D(3,3) is 63. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/delannoy-central

The sum of Delannoy numbers D(m,0) through D(m,hi). The sum through D(4,4) is 501. m and hi run from 0 to 64. Past 15 digits the sum is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/delannoy-sum

Depreciation schedules: straight-line, declining balance (any factor, optional switch to straight-line), double-declining, sum-of-the-years-digits and US MACRS GDS (3/5/7/10/15/20-year, half-year convention, computed from the IRS rules: 200% or 150% DB switching to straight-line). Year-by-year depreciation, accumulated depreciation and book value. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/depreciation

Reverse the decimal digits of an integer. Leading zeros of the reversal are dropped, so 1200 becomes 21. The sign is kept. A malformed integer is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/digit-rev

The sum of the decimal digits of an integer, ignoring the sign. 199 sums to 19. The decimal has no leading zeros. A malformed integer is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/digit-sum

The digital root of a decimal integer. Zero stays zero, and any other magnitude is 1 + (n-1) mod 9, so multiples of 9 have root 9. The sign is ignored. A malformed integer is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/digital-root

The number of positive divisors of n. A prime has 2, and d(1) is 1. n = 0 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/divisor-count

The sum of the positive divisors of n. sigma(6) is 12 and sigma(28) is 56. n = 0 is rejected. A value past 15 digits is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/divisor-sum

Parse DMARC aggregate (RUA) reports and SMTP TLS reports (TLS-RPT, RFC 8460) into an actionable summary. Accepts the raw XML / JSON or the email attachment as base64 (.xml, .xml.gz, .zip). DMARC: reporter, date range, published policy, message totals, DMARC / DKIM-aligned / SPF-aligned pass rates, dispositions, every sending source IP with its auth results and a verdict (authorized, forwarded / third-party, spoofing), top failing sources and concrete next steps (e.g. when it is safe to move from p=none to quarantine). TLS-RPT: per-policy success / failure counts and failure details. No DNS or …

All common DNS records for a domain via Cloudflare DNS-over-HTTPS: A, AAAA, NS, MX, TXT, CAA. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/dns-dump

DNS propagation check: resolves one record type for a domain across Cloudflare 1.1.1.1, Google 8.8.8.8 and Quad9 9.9.9.9 (DNS-over-HTTPS, in parallel) and reports consensus, per-resolver answers, TTLs, rcodes and differences. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/dns-propagation

DNSSEC status of a domain over DNS-over-HTTPS: secure / insecure / bogus (validation failure) / island (signed but no DS at the parent), the zone apex, DS records (key tag, algorithm, digest type) and DNSKEYs (KSK / ZSK, algorithm, computed key tag), whether each DS digest really matches a published DNSKEY (recomputed locally), and warnings for deprecated algorithms or SHA-1 digests (RFC 8624). Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/dnssec-check

Offline Dockerfile linter: parses stages/continuations and runs 20+ best-practice and security rules (latest tag, curl|bash, secrets in ENV/ARG, runs-as-root, chmod 777, ADD-vs-COPY, apt cache, no HEALTHCHECK, multi-stage hints). Returns 0-100 score, letter grade and actionable fixes. Does not build or pull images. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dockerfile-lint

Bulk domain availability: for up to 20 domains, asks the authoritative registry over RDAP (server chosen from the IANA RDAP bootstrap). RDAP 404 = available; registered names return registrar, IANA id, creation/expiry dates, status and nameservers. TLDs without RDAP fall back to a DNS NS check; subdomains are flagged. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/domain-availability

One-call domain due-diligence: RDAP registration age/expiry/registrar, A/AAAA/NS/MX/CAA, live TLS certificate (issuer, expiry, SANs, trust), Certificate-Transparency subdomain enumeration, and risk flags (new domain, expiring cert, no CAA). Good for phishing/scam triage of links before an agent visits or pays them. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/domain-intel

The double factorial n!!. Even n uses the even factors down to 2, and odd n uses the odd factors down to 1. 0!! is 1, 6!! is 48, and 7!! is 105. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/double-factorial

Parse any duration into seconds and every common format: ISO 8601 (P1DT2H30M, PT1.5S, P2W), clock (1:02:03.5, 02:30), Go / compact (1h30m, 2d4h), and plain English ("an hour and a half", "2.5 days", "3 weeks ago", "90 secs"). Returns total seconds / milliseconds / minutes / hours / days, normalised ISO 8601, H:MM:SS, compact and human text, and flags month / year approximations. Up to 50 inputs per call. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/duration-parse

Check a Dyck word of parentheses and report its semilength and height. The empty word is valid. A prefix that goes negative, or a word that does not close, is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dyck-word

GTIN check digit for EAN-8, UPC-A (12 digits), EAN-13 and GTIN-14. The weight alternates 3 and 1 from the right, starting with 3 on the digit beside the check. Spaces and hyphens are ignored. This does not check that the GS1 prefix was assigned. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ean-validate

Recent earthquakes from the USGS: filter by bounding box or center point + radius, minimum magnitude and time window (last N days or start/end dates). Returns magnitude, place, time, coordinates, depth, tsunami flag, PAGER alert, felt reports and USGS event links. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/earthquakes

Extended gcd of a and b. Returns g, x, and y with g = a*x + b*y and g >= 0. gcd(0, 0) is rejected. Decimals have no leading zeros. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egcd

Check that a sum of unit fractions equals the fraction a/b. A match returns the reduced sum. A sum that differs, or a non-positive denominator, is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egypt-check

The greedy Egyptian fraction for a proper positive fraction a/b. 5/6 is 1/2 + 1/3. A fraction that is not strictly between 0 and 1 is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egypt-greedy

EIP-712 typed-data hashing and signature check: returns encodeType, typeHash, domain separator, struct hash and the final digest a wallet signs (eth_signTypedData_v4), and with a signature recovers the signer and compares it to an expected address. Summarises common payloads (ERC-2612 Permit, EIP-3009 TransferWithAuthorization used by x402 EVM payments, Permit2) so an agent can see what it is about to sign. POST JSON body. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/eip712-hash

Email authentication & deliverability posture for a domain: SPF (qualifier, lookup count, duplicates), DMARC policy/rua/pct, DKIM probe across common selectors, MTA-STS, TLS-RPT, BIMI, MX; scored with actionable issues. Useful for spoofing-risk and vendor checks. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/email-auth

Parse a raw email (.eml / RFC 5322 + MIME) for triage: decoded headers (RFC 2047), addresses, Received hop chain with relays, IPs, timestamps and delays, originating IP, Authentication-Results (SPF / DKIM / DMARC / ARC), DKIM-Signature domains and selectors, MIME part tree, attachments (name, type, size, SHA-256, risky extensions), text body and links (with anchor-text vs href domain mismatch). Adds phishing / spoofing indicators (From vs Return-Path / Reply-To misalignment, display-name spoofing, brand impersonation, auth failures, urgency language) and a 0-100 risk score. Price: $0.003 USDC …

Validate an email address without sending mail: RFC 5321/5322 syntax, MX/A lookup (null-MX aware), disposable-domain detection (~10k domains), role-account and free-provider flags, typo suggestion (gmial.com -> gmail.com), overall verdict. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/email-validate

Resolve an ENS name to its Ethereum address (plus optional text records like avatar, url, com.twitter), or reverse-resolve an address to its forward-verified primary ENS name. Read-only, public RPC. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ens-resolve

Rule-based entity and value extraction with normalised values: dates (ISO, numeric with dmy/mdy, month names, relative "next Friday" / "in 3 days" resolved against a reference date), times with time zones, money (symbols, ISO codes, crypto tickers, k/m/bn scales), percentages and basis points, quantities with units, durations in seconds, URLs, emails, hashtags, @mentions, $cashtags, organisations (legal suffixes) and titled persons. Code-point offsets, overlap resolution, type filter. Offline, deterministic, English. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: …

The Entringer number E(n, k). E(1, 1) is 1, and E(n, k) = E(n, k-1) + E(n-1, n-k). E(5, 2) is 10, and E(6, 3) is 46. The last entry E(n, n) is the zigzag number a(n). n and k run from 1 to 40, and k must not pass n. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/entringer

The smallest ISO C envelope that holds a sheet flat, and whether a DL envelope holds it flat or folded in exact thirds. C4 holds A4. DL does not hold A4 flat; it holds A4 folded in thirds. A sheet bigger than C0 has no C envelope. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/envelope-fit

Is this software version still supported? End-of-life status from endoflife.date for 400+ products (languages, frameworks, databases, OSes, runtimes, cloud services): status (supported, security-only, eol, unmaintained), release, active-support and EOL dates, days until/since EOL, LTS flag, latest patch for the cycle and whether you are on it, the recommended upgrade cycle, and plain advice. Fuzzy product matching with suggestions; batch up to 10 product@version items. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/eol-chec…

FIRST EPSS exploit-prediction scores for up to 100 CVEs: probability of exploitation in the next 30 days, percentile rank and a simple band, for the latest model run or a past date. Complements /v1/cve-lookup and /v1/cisa-kev for vulnerability prioritisation. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/epss-score

Solve equations exactly where possible. Polynomials of any degree up to 100: exact rational roots, exact surd forms for quadratic factors ("(3 + √5)/2", complex "(-1 + i√3)/2"), multiplicities via square-free factorisation, and high-precision numeric roots (Aberth–Ehrlich + Newton polishing) for the rest. Any other single-variable equation ("cos(x) = x", "2^x = x^2 + 1", "ln(x) + x = 5") is solved numerically over a range with sign scanning + Brent's method, rejecting poles. Systems of linear equations ("2x + 3y = 7", "x - y = 1") are solved with exact rational Gaussian elimination, reporting …

Validate an EU VAT number live against the European Commission VIES service: valid/invalid, plus registered trader name and address where the member state discloses them. Accepts IE6388047V style input or ?country= + number; GR is mapped to EL, XI = Northern Ireland. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/eu-vat-validate

Modified EUI-64 from RFC 4291. A 48-bit MAC is expanded by flipping the U/L bit and inserting FF-FE in the middle. A 64-bit value with FF-FE in the middle is folded back to the MAC. Any other 64-bit value is returned as-is with mac null. The bits, local and multicast fields describe the 64-bit result. Flipping the bit makes a universal MAC look local in the interface id. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/eui64

The nth secant number, the signed Euler number E(2n) = (-1)^n * a(2n). E(0) is 1, E(2) is -1, E(4) is 5, and E(6) is -61. n runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euler-secant

The nth Euler zigzag number, the number of up-down permutations of n. a(0) is 1, a(3) is 2, a(4) is 5, and a(5) is 16. For n at least 1 it is the Entringer number E(n, n). n runs from 0 to 40. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euler-zigzag

The sum of Euler zigzag numbers a(0) through a(n). The sum through a(5) is 26, and the sum through a(10) is 60201. n runs from 0 to 40. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euler-zigzag-sum

Where is this address used? One call checks an EVM address on Ethereum, Base, Arbitrum, OP Mainnet, Polygon and BNB Chain: native balance, nonce (transactions sent), contract or EOA, EIP-7702 delegation, code size, and a per-chain active flag plus a summary of chains with activity. Useful before sending funds, for wallet screening and for picking the right chain. Keyless public RPC, read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-address-activity

ERC-20 allowance matrix for an owner across up to 10 tokens × 10 spenders (defaults: major stables/WETH × Uniswap Permit2, 1inch, CoW, 0x, OpenSea Seaport — verified deployed on-chain). Also reports ERC-721/1155 setApprovalForAll. Flags unlimited (max-uint) approvals. Read-only; no log scan. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-allowance

Native ETH and ERC-20 token balances for an address on Ethereum, Base or Arbitrum via public RPC. Defaults to major tokens (USDC, USDT, WETH, DAI/ARB) or pass up to 20 token contracts. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-balance

One EVM block by number, tag (latest, safe, finalized, earliest, pending) or hash on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain: timestamp and age, transaction count, gas used/limit and fill %, base fee (gwei), blob gas, fee recipient, size, withdrawals, parent hash, optional transaction hash list. Keyless public RPC, read-only. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-block

EVM contract introspection on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain via public RPC: bytecode size/hash, EIP-1167 / EIP-1967 / ZeppelinOS / EIP-7702 proxy detection, ERC-165/20/721/1155(/2981) standards, name/symbol/decimals/supply, owner()/paused(), and a bytecode selector scan against 145 known signatures that surfaces capabilities (mint, blacklist, fee setters, trading switches, upgrade) and a 0-100 risk score. Static analysis only — not a honeypot simulation. Read-only. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.…

Predict EVM contract addresses before deployment: CREATE (deployer + nonce, RLP-encoded; up to 50 consecutive nonces) or CREATE2 (deployer + salt + init code or its keccak256 hash, EIP-1014). Works for every EVM chain; returns EIP-55 checksummed addresses. No network calls. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-create-address

Live gas tracker across Ethereum, Base, Arbitrum, OP Mainnet, Polygon and BNB Chain: head block age, base fee, 10th/50th/90th percentile priority fees from eth_feeHistory, suggested maxFeePerGas tiers, and estimated cost of a native transfer and an ERC-20 transfer. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-gas

Decoded event logs for any contract and event on Ethereum, Base, Arbitrum, OP Mainnet, Polygon or BNB Chain: give the event as a human signature (e.g. "Transfer(address indexed from, address indexed to, uint256 value)"), optional indexed-topic filters, and get the newest matching logs with named, ABI-decoded arguments (exact integers as strings, checksummed addresses). Scans backwards from the head with an adaptive block window. Keyless public RPC. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-logs

Read-only eth_call of any view/pure function from a human signature (e.g. balanceOf(address)(uint256) or `function name() view returns (string)`). ABI-encodes args, decodes outputs (address/uint/int/bool/string/bytes/arrays), and surfaces Error(string) / Panic(uint256) revert reasons. Six chains. No state change. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-read

Decode EVM function selectors, calldata and event topics: looks up 4-byte selectors (or 32-byte event topics) in 4byte.directory plus a built-in table of well-known signatures, re-hashes every candidate with Keccak-256 to drop bad entries, and for full calldata ABI-decodes the arguments (address with EIP-55 checksum, uint/int as exact decimal strings, bool, bytes, string, arrays, tuples), ranking candidates that decode cleanly first. Also computes the selector/topic for a given signature. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/…

Latest ERC-20 or ERC-721 Transfer events for a token contract (optionally filtered to one wallet, in/out/both) on six EVM chains. Adaptive eth_getLogs window with automatic shrink on provider range caps. Returns decoded from/to/value or tokenId, approx age, mint/burn tags. Read-only. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-token-transfers

Decode an EVM transaction (Ethereum, Base, Arbitrum): status, block, timestamp, confirmations, from/to, value, gas used, effective gas price, fee, method selector name, and decoded ERC-20 Transfer/Approval events. Read-only, public RPC. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-tx-info

Verify an Ethereum signature offline: recovers the signer address (secp256k1 ecrecover) from an EIP-191 personal_sign message (UTF-8 or hex) or a raw 32-byte digest (e.g. an EIP-712 hash), compares it with an expected address, flags malleable high-s signatures, accepts 65-byte r,s,v and 64-byte EIP-2098 compact signatures, and parses Sign-In with Ethereum (EIP-4361) messages (domain, nonce, chain, expiry). For smart-contract wallets (EIP-1271) recovery does not apply. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/evm-verif…

n! mod m. 0! is 1, so 0! mod 5 is 1. 10! mod 97 is 30. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/factorial-mod

Generate realistic, reproducible fake test data from a field schema: up to 1,000 records with 44 field types (names, usernames, emails consistent with the name, phones, companies, job titles, US addresses, countries, coordinates, dates, numbers, prices, UUIDs, IPs, URLs, lorem text, enums with weights, sequences, templates referencing other fields, test card numbers), per-field null rate and uniqueness, as JSON, CSV or NDJSON. Seeded (the seed is returned) so the same request gives the same data. Safe by design: only example.* domains, 555-01xx phone numbers, documentation IP ranges and public…

The falling factorial (n)_k = n*(n-1)*...*(n-k+1). (5)_3 is 60, (5)_0 is 1, and (5)_6 is 0. n runs from 0 to 100000 and k runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/falling

Whether a/b and c/d are Farey neighbors. They are adjacent when the determinant ad-bc is 1 or -1. A non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/farey-adjacent

The mediant child of a Farey-neighbor pair. a/b and c/d must satisfy |ad-bc| = 1. A pair that is not adjacent is rejected, as is a non-positive denominator. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/farey-child

FDA adverse-event reports (openFDA): drug FAERS, device MAUDE, food/supplement CAERS. Filter by drug, product, reaction, dates or raw openFDA search; compact reports or counts on any field (e.g. top reactions for a drug). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fda-adverse-events

FDA device records (openFDA): 510(k) clearances, PMA approvals, device classification (product code, class, regulation) and GUDID device identifiers. Search by name, product code, applicant, K/PMA number or raw search; count by any field. GMDN removed. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fda-device

FDA recalls (openFDA): drug, device and food enforcement reports (class, status, firm, reason, distribution, lots) plus the device recall database (root cause). Filter by firm, product, class, status, state, dates; count by any field. Newest first. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fda-recalls

Search the U.S. Federal Register (federalregister.gov) for rules, proposed rules, notices, presidential documents and executive orders by keyword, agency (name, short name such as EPA, or slug), type, publication date range and significance. Returns document number, title, type, agencies, action, abstract, citation, effective and comment-close dates, EO number and signing date, docket ids, RINs and HTML/PDF links. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/federal-register

Find a website's RSS/Atom/JSON feeds and read the latest items: parses <link rel="alternate"> tags, likely feed links and (if none) probes common feed paths, then parses the feed (RSS 2.0, RSS 1.0/RDF, Atom 1.0, JSON Feed) into clean JSON items with title, link, published date (ISO), author, summary, categories and enclosure. Also accepts a feed URL directly. SSRF-safe fetches. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/feed-discover

The nth bit of the infinite Fibonacci word, starting at n = 0. The word is the fixed point of 0 to 01 and 1 to 0, and it starts 01001010. n runs from 0 to 99999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fibword

The first n bits of the Fibonacci word. The first 8 bits are 01001010, and the first 16 bits are 0100101001001010. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fibword-prefix

FIGI check digit. Twelve characters with no vowels. The first two are letters and are not BS, BM, GG, GB or VG, and the third character is G. The check uses the full A–Z alphabet, weights 1 and 2 from the left. Spaces are ignored. This does not call OpenFIGI. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/figi-validate

Explain a POSIX file mode. Accepts octal (755, 0755, 4755) or the 9-character ls form, with an optional leading type character. s and t mean the execute bit is also set; S and T mean the special bit without execute. setuid, setgid and sticky are the high octal digit. value is the mode as a decimal integer. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/file-mode

Identify what a file really is from its bytes (not its name): 80+ signatures (images, audio, video, archives, PDF / Office / OpenDocument / EPUB, executables ELF / PE / Mach-O / WASM, fonts, SQLite / Parquet / pcap, ML model files GGUF / safetensors / PyTorch / pickle), container sniffing (DOCX vs XLSX vs JAR vs APK, tar.gz, MP4 vs HEIC vs AVIF, WebP / WAV / AVI), text sniffing (JSON, XML, SVG, HTML, CSV, PEM, scripts) and image dimensions. Flags risky content (executables, macros, pickles, shortcuts) and mismatches with the declared file name or MIME type. Base64 input (up to ~140 KB) or a UR…

The nth Fine number. F(0) is 1, F(1) is 0, F(2) is 1, and F(6) is 57. For n at least 1, F(n) = C(n) - sum of C(i)*F(n-1-i) over i from 0 to n-1, with C the Catalan numbers. n runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fine

The sum of Fine numbers from lo through hi inclusive. The sum from F(0) through F(6) is 85. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fine-sum

Body and training calculator in one call, metric or imperial: BMI with WHO category and healthy-weight range, BMR (Mifflin-St Jeor, revised Harris-Benedict, Katch-McArdle), TDEE by activity level, calorie target and protein / fat / carb grams for lose / maintain / gain, US Navy body-fat %, ideal weight (Devine, Robinson, Miller, Hamwi), max heart rate and 5 training zones (Karvonen when resting HR is given), daily water, one-rep max (Epley, Brzycki, Lombardi, O'Conner) and running pace / speed with Riegel race-time predictions. Informational, not medical advice. Price: $0.001 USDC per successf…

Fletcher-16 checksum, modulus 255. The two sums are packed with the second sum in the high byte. "abcde" is c8f0. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fletcher16

Fletcher-32 checksum, modulus 65535. Bytes are big-endian 16-bit words. An odd final byte is padded with zero. "abcde" is 4ff029c7. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fletcher32

Explain an IEEE 754 binary32 or binary64 value. Pass bits as hex, or a decimal or fraction, which is rounded ties-to-even. Returns the class, sign, unbiased exponent, fraction bits, and the exact value. Negative zero stays negative. The word nan is the quiet NaN; snan is the signaling NaN with payload 1. The top fraction bit is the quiet bit. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/float-bits

The next binary32 or binary64 value up or down. Positive zero and negative zero both step up to the smallest positive subnormal, and both step down to the smallest negative one. Infinity stays put at its end. A NaN is returned with its payload unchanged. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/float-next

IEEE 754 totalOrder on two binary32 or binary64 values. Negative zero is below positive zero. Negative NaNs are below minus infinity and positive NaNs are above plus infinity. A larger NaN payload is farther from zero. sameBits is true only when every bit matches. form bits reads both sides as hex; the default reads them as numbers rounded ties-to-even. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/float-order

Round an exact decimal or fraction to binary32 or binary64. Modes are nearestEven, towardZero, towardPositive, and towardNegative. Ties in nearestEven go to an even fraction bit. Overflow becomes infinity, or the largest finite value when the mode points toward zero. underflow is set only when the result is subnormal or zero and not exact. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/float-round

Unit in the last place of a binary32 or binary64 value. A power of two uses the spacing of its own binade. Zero uses the smallest subnormal. Infinity uses positive infinity. A NaN is returned with its payload unchanged. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/float-ulp

Food product facts by barcode (EAN-13, EAN-8, UPC-A, UPC-E; GTIN check digit validated) from Open Food Facts (ODbL): name, brand, quantity, categories, ingredients text, allergens and traces, additives, Nutri-Score grade, NOVA processing group, Green-Score, nutrients per 100 g (energy, fat, saturates, carbohydrates, sugars, fibre, protein, salt), labels, origin and image URL. Community data: always check the packaging for allergens. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/food-barcode

Convert data between CSV, TSV, JSON, YAML and XML in one call (auto-detects the input format). CSV header handling and delimiter detection, type inference (numbers, booleans, null), nested objects flattened to dotted CSV columns, XML attributes as @keys and repeated elements as arrays, safe YAML subset (no anchors/tags), optional spreadsheet formula-injection guard. Body: {input, from, to, options}; 256 KB limit, clear errors with line numbers on malformed input. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/format-conver…

Four nonnegative integers w <= x <= y <= z with w^2 + x^2 + y^2 + z^2 = n. Every nonnegative integer has one. 7 is 1, 1, 1, 2. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/four-squares

Write a frame count since midnight as SMPTE timecode. Set drop for 30 fps drop-frame. The count has to land inside one day. 30 frames at 30 fps is 00:00:01:00. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/frames-timecode

The Frobenius number of two coprime integers a and b, each at least 2. It is ab-a-b, the largest integer that cannot be made with non-negative combinations. For 2 and 5 it is 3. For 4 and 7 it is 17. A pair that is not coprime is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/frobenius

The nth Fubini number, the ordered partitions of an n-element set. a(0) is 1, a(2) is 3, a(3) is 13, and a(5) is 541. n runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fubini

The nth Fubini number mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 20. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fubini-mod

The sum of Fubini numbers from lo through hi inclusive. The sum from a(0) through a(5) is 634. lo must not pass hi. Each index runs from 0 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fubini-sum

Mutual fund / ETF portfolio from its latest public SEC Form N-PORT: top holdings by value (name, CUSIP, ISIN, LEI, shares, USD value, % of net assets, asset and issuer category, country, maturity/coupon for debt), asset-class / country / issuer / currency mix, top-10 concentration, net assets and monthly returns per share class. Look up by fund ticker (VOO, QQQ, BND), series id or class id. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fund-holdings

The Fuss-Catalan number C(p*n+1, n) / (p*n+1). FC(2,n) is the Catalan number, so FC(2,5) is 42. p runs from 1 to 8 and n from 0 to 30. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fuss-catalan

The Fuss-Catalan division. num is C(p*n+1, n), den is p*n+1, and value is the exact quotient. p runs from 1 to 8 and n from 0 to 30. Past 15 digits a part is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fuss-check

Fuzzy string matching for entity resolution, dedupe and "did you mean": match one or many queries against up to 5,000 choices with RapidFuzz-style scorers (WRatio weighted blend, ratio / InDel similarity, partial_ratio, token_sort, token_set, Jaro-Winkler, normalised Levenshtein, Damerau / OSA). Default preprocessing lowercases, folds accents and strips punctuation. Returns top matches with 0-100 scores and choice index, optional per-scorer breakdown. Offline, deterministic. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/f…

Fiat currency exchange rate (ECB reference rates via Frankfurter, with ExchangeRate-API fallback for 150+ currencies), optional amount conversion and historical date. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fx-rate

The nth Genocchi number |G(2n)|, from G(2n) = 2*(1-4^n)*B(2n) with B(1) = +1/2. The first four absolute values are 1, 1, 3, and 17. signed is (-1)^n times that value. n runs from 1 to 20. Past 15 digits a value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/genocchi

Geodesic distance and bearings on the WGS-84 ellipsoid: Vincenty (millimetre accuracy) plus great-circle haversine, initial / final bearing with 16-point compass, midpoint, multi-point path length with per-segment legs, and the destination point from a start, bearing and distance. Units km, m, mi, nautical miles or feet. Offline, deterministic. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/geo-distance

Analyse GeoJSON polygons (Polygon, MultiPolygon, Feature or FeatureCollection): geodesic area (m², km², ha, acres; same spherical formula as Turf.js), perimeter, area-weighted centroid, bounding box, validity report (unclosed or short rings, self-intersections, RFC 7946 winding order), point-in-polygon tests for up to 1,000 points honouring holes and edges, convex hull and optional Douglas-Peucker simplification to a tolerance in metres. Offline. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/geo-polygon

Geocode an address or place name to latitude/longitude (US Census Geocoder for US street addresses, Photon/OpenStreetMap worldwide), or reverse-geocode lat/lon to an address (with US county/tract). Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/geocode

Security audit of a GitHub Actions workflow YAML (zizmor / actionlint style): pwn-request checkouts under pull_request_target / workflow_run, script injection from attacker-controlled ${{ github.event.* }} contexts in run: and github-script, actions not pinned to a commit SHA, missing or write-all permissions, toJSON(secrets), secrets in workflow-wide env, self-hosted runners on PR triggers, persisted checkout credentials, disabled ::set-env / ::add-path commands, curl | bash, cache poisoning in release workflows, artifact poisoning, spoofable bot-actor conditions and hard-coded credentials. F…

GitHub repository health summary via public API: stars/forks/issues, license, languages, last push age, latest release & commit, heuristic healthScore and notes. Unauthenticated rate limits apply. Price: $0.008 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/github-health

Trending new GitHub repositories: repos created in the last day, week or month ranked by stars (GitHub REST search API), filterable by language, topic and minimum stars. Returns full name, URL, description, language, topics, stars, forks, open issues, licence, created/pushed dates, owner type and a stars-per-day velocity. Cached 30 minutes. Uses the public API (not HTML scraping). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/github-trending

The Golay-Rudin-Shapiro partial sum. Each term is +1 or -1 as the Rudin-Shapiro sign of k, and the value is the sum from k = 0 through n. The sum through n = 3 is 2. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/golay-rudin

The nth Golomb term, 1-based. a(1) is 1, a(n) counts how often n will appear, and a(6) is 4. The sequence starts 1, 2, 2, 3, 3, 4. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/golomb

The smallest index n with Golomb a(n) equal to k. Index 1 holds 1, index 4 holds 3, and index 6 holds 4. k runs from 1 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/golomb-inverse

The sum of the first n Golomb terms, from a(1) through a(n). The sum of the first 5 terms is 11. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/golomb-sum

The binary reflected Gray code of n, written in exactly width bits. Bit 0 is on the right. n must be smaller than 2^width. A width that cannot hold n is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gray-bits

Decode a binary reflected Gray code back to its index. The walk xors the code with each of its right shifts. A negative code is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gray-decode

Encode a non-negative integer as a binary reflected Gray code. The code is n xor (n shifted right by one). Zero stays zero, and a negative integer is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gray-encode

The single bit that flips in the binary reflected Gray code when the index goes from n to n+1. Bit 0 is the least significant bit. A negative index is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gray-flip

The next binary reflected Gray code after g. It is the code of the index one past the index of g. A negative code is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gray-next

Follow the happy-number map: replace n by the sum of the squares of its decimal digits. 1 is already happy. 7 reaches 1 in 5 steps. 4 is unhappy and the repeat is 4. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/happy

The nth harmonic number as a reduced fraction. H1 is 1/1, H2 is 3/2, and H6 is 49/20. n < 1 is rejected. n runs up to 200. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/harmonic

Whether n is a base-10 Harshad number: n is divisible by the sum of its decimal digits. 18 is Harshad, and 11 is not. n runs from 1 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/harshad

Whether n is a Harshad number in base b: n is divisible by the sum of its base-b digits. 10 is Harshad in base 2. 13 is not Harshad in base 10. n runs from 1 to 999999999999999, and b runs from 2 to 36. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/harshad-base

Hashing, HMAC and encoding toolkit: digests (MD5, SHA-1/2/3, Keccak-256 as used by Ethereum, RIPEMD-160, Whirlpool, CRC32/CRC32C, Adler-32, FNV-1a, xxHash32/64/3/128, MurmurHash3), HMAC (SHA-1/2/3, MD5) with hex or base64 output, encode/decode between UTF-8, hex, base64, base64url, base32, base58 and URL encoding, identification of what a string is (hash type by length, UUID version, JWT, bcrypt/argon2, EVM address with EIP-55 checksum, Bitcoin/Solana address, base64, timestamps) and UUID v4/v7 or random-bytes generation. Offline. Price: $0.005 USDC per successful call (x402, Solana). Same too…

Graded HTTP security-header audit of a URL: HSTS, CSP quality, XFO, nosniff, Referrer/Permissions/COOP/CORP/COEP, cookie flags, redirect chain, server info leaks, with fix recommendations. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/headers-audit

The physicist Hermite polynomial H(n, x) at an integer x. H(0, x) is 1, H(1, x) is 2x, H(2, 1) is 2, and H(3, 1) is -4. n runs from 0 to 32 and x from -1000 to 1000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hermite

The derivative of the physicist Hermite polynomial, H'(n, x) = 2*n*H(n-1, x). At n = 3 and x = 1 the derivative is 12. n runs from 1 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hermite-deriv

The probabilist Hermite polynomial He(n, x) at an integer x. He(0, x) is 1, He(1, x) is x, and He(2, 1) is 0. n runs from 0 to 32 and x from -1000 to 1000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hermite-prob

Exact area data for a strict integer triangle. sixteen is 16 times the squared area. When sixteen is a perfect square, area is the reduced value of its square root over 4. A degenerate triple is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/heron-area

Search Hacker News stories and comments (Algolia HN index): by relevance or newest first, with date range, story/comment/Ask HN/Show HN filter, author and minimum points. Returns title, URL, points, comment count, author, time, comment text and HN links. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/hn-search

The hockey-stick sum of binomial coefficients C(i, r) from i = r through n. It equals C(n+1, r+1). The sum for r = 2 and n = 5 is 20. r must not pass n. Both run from 0 to 1024. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hockey-stick

The nth Hofstadter-Conway term. a(1) and a(2) are 1, and a(n) = a(a(n-1)) + a(n-a(n-1)). a(5) is 3, and a(10) is 6. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-conway

The sum of Hofstadter-Conway terms a(1) through a(n). The sum through a(10) is 32, and the sum through a(30) is 266. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-conway-sum

The nth Hofstadter female term. F(0) is 1, M(0) is 0, F(n) = n - M(F(n-1)), and M(n) = n - F(M(n-1)). F(1) is 1, and F(5) is 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-female

The nth Hofstadter G term. G(0) is 0, and G(n) = n - G(G(n-1)). G(1) is 1, and G(10) is 6. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-g

The nth Hofstadter H term. H(0) is 0, and H(n) = n - H(H(H(n-1))). H(1) is 1, and H(10) is 7. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-h

The nth Hofstadter male term. M(0) is 0, F(0) is 1, M(n) = n - F(M(n-1)), and F(n) = n - M(F(n-1)). M(2) is 1, and M(5) is 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-male

The Hofstadter male and female terms at the same index. M(0) is 0 and F(0) is 1. At n = 5 both terms are 3. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-pair

The nth Hofstadter Q term. Q(1) and Q(2) are 1, and Q(n) = Q(n-Q(n-1)) + Q(n-Q(n-2)). Q(10) is 6, and Q(16) is 9. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-q

The first n Hofstadter Q terms, from Q(1) through Q(n), written as comma-separated integers. The first 10 terms are 1,1,2,3,3,4,5,5,6,6. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-q-prefix

The sum of Hofstadter Q terms Q(1) through Q(n). The sum through Q(10) is 36, and the sum through Q(20) is 129. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hof-q-sum

Public holidays for 100+ countries (optionally one state/region) and business-day math in one call: list holidays for a year, add or subtract N business days, check if a date is a business day, or count business days between two dates, skipping weekends (configurable, e.g. fri,sat) and public holidays. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/holidays-business-days

HSTS preload check for a domain: current status on the Chromium preload list (hstspreload.org), the official preloadable errors/warnings, and our own live checks of the site's HSTS header (max-age >= 1 year, includeSubDomains, preload, single header) and HTTP->HTTPS same-host redirect, fetched SSRF-safely. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/hsts-preload

Sanitize untrusted HTML (LLM output, user comments, scraped pages, email bodies) with a strict allowlist before rendering it: three profiles (strict inline formatting, basic with links and lists, rich with images and tables) or a custom tag list; drops scripts, styles, iframes, forms, SVG/MathML, event handlers, javascript:/vbscript:/data: URLs and comments; adds rel="noopener noreferrer nofollow" (+ optional target=_blank) to links; returns clean HTML, a plain-text version and a report of everything removed. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST htt…

Scrape a public page (SSRF-safe fetch) or an HTML string with a CSS selector (CSS3 plus :has, :contains, :nth-child(an+b), attribute operators) or raw XPath: returns each match's text, attributes and optionally outer HTML, or just one attribute (href / src resolved to absolute URLs). Also returns the XPath the selector compiled to. Like querySelectorAll without a browser. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/html-select

Extract HTML tables from a public URL (SSRF-safe fetch) or an HTML string into clean JSON: header detection (thead or leading th rows, multi-row headers joined), rowspan / colspan expansion, captions, rows as objects keyed by header or as arrays, optional number parsing ("$1,234.50", "45%"), and table choice by index or CSS selector (e.g. table.wikitable). Layout tables with too few rows are skipped. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/html-tables

Convert an HTML string to clean Markdown (GFM tables, fenced code, nested lists). No fetch. Body: { "html": "...", "base_url"?: "https://...", "extract_main"?: false }. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/html-to-markdown

Fast HTTP GET probe: final URL, status, timing, response bytes, and a subset of interesting headers (server, cache, HSTS, CDN). Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/http-probe

Run a statistical significance test and get the statistic, p-value, effect size, confidence interval and a plain-English verdict — results match scipy.stats. Tests: Welch / Student two-sample t, paired t, one-sample t, one-proportion z, A/B test of two conversion rates (pooled z, lift, CI of the difference), chi-square goodness of fit and independence (Yates for 2×2, Cramér's V), one-way ANOVA (η²), Kruskal–Wallis, Mann–Whitney U (exact for small samples, rank-biserial r), Wilcoxon signed-rank (exact / permutation / normal), Pearson and Spearman correlation (Fisher-z CI) and Fisher's exact tes…

Validate an IBAN offline: ISO 7064 mod-97 checksum, per-country length and BBAN structure from the SWIFT IBAN registry (100+ countries plus national/experimental ones), national check digits for BE, ES, FR (+territories), IT/SM and NO; returns country, SEPA membership, bank code, branch code and account number, and the expected check digits on a typo. Optional BIC/SWIFT structure check (ISO 9362) and BIC-vs-IBAN country match. No data leaves the server. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/iban-validate

The integer cube root of a non-negative decimal integer, the greatest r with r^3 not exceeding n. icbrt(26) is 2 and icbrt(27) is 3. A leading zero is rejected. n has at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/icbrt

Generate a standards-compliant iCalendar (.ics, RFC 5545) file from JSON events — ready for Google Calendar, Outlook and Apple Calendar invites or "add to calendar" links. Time zones with a generated VTIMEZONE (DST rules from the IANA database), all-day and multi-day events, recurrence (RRULE validated, EXDATE), reminders (VALARM), organizer / attendees with RSVP, location, URL, geo, categories and status. Proper escaping and 75-octet line folding; deterministic UIDs. Returns the .ics text and a data: URI. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:…

Parse an iCalendar (.ics) feed from a URL (SSRF-safe; Google / Outlook / Apple calendar exports) or inline text into JSON: calendar name and zone, events with start / end in any IANA zone, all-day flag, location, organizer, attendee count, status and recurrence rule in English. Give a from / to window to expand recurring events (RRULE, EXDATE, RDATE, RECURRENCE-ID overrides) into concrete occurrences. Windows time-zone names are mapped to IANA. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ics-parse

Generate unique IDs: UUID v4 (random), v7 (time-ordered, monotonic within a batch), v5 (deterministic from namespace + name), ULID, nanoid (custom size / alphabet), KSUID and MongoDB ObjectId, up to 100 at once. Or inspect an existing ID: detects UUID (version, variant, embedded v1 / v6 / v7 time), ULID, KSUID, ObjectId and Snowflake (Twitter / Discord) and decodes the timestamp. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/id-generate

Deterministic avatar SVG for any user id, email, wallet address or name — the same input always gives the same image, with no storage or external service. Styles: identicon (GitHub-style symmetric 5×5 grid), pixel (8×8 symmetric sprite), initials (coloured badge with up to two initials, readable text colour chosen by WCAG contrast) and gradient (two-tone ring). Returns the SVG markup, a data: URI ready for <img src>, the palette, and the Gravatar MD5 hash for emails. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/identicon-…

Inspect an image without decoding pixels: format, dimensions (EXIF-orientation aware), megapixels, animation, sha256, EXIF summary (camera, exposure, GPS). Body: { "image": "<base64>" }. Max ~190KB input image (the service caps POST bodies at 256KB, base64 included). Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/image-info

Resize / convert an image (GD): width/height up to 4096, fit contain|cover|fill|inside, output png|jpeg|webp|gif, quality, EXIF auto-orient, metadata stripped. Body: { "image": "<base64>", "width": 256 }. Max ~190KB input image (the service caps POST bodies at 256KB, base64 included). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/image-resize

IMEI and IMEISV. A 15-digit IMEI must pass the Luhn check. A 14-digit IMEI has no check digit, and a 16-digit IMEISV has none either. Spaces and hyphens are ignored. This does not look the number up with a manufacturer. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/imei-validate

Impermanent loss calculator for AMM liquidity positions: full-range constant-product pools (Uniswap v2, Raydium, Orca classic) or concentrated ranges (Uniswap v3/v4, Orca Whirlpools, Raydium CLMM, Meteora) from entry price, current price and an optional price range. Returns LP value vs simply holding, the loss in percent and money, token amounts at entry and now, in-range status and, with a fee APR, the fees earned and break-even. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/impermanent-loss

RFC 1071 internet checksum. Big-endian 16-bit words are added with end-around carry, then inverted. An odd final byte is padded with zero. The RFC example 0001 F203 F4F5 F6F7 is 220d. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/inet-checksum

Invoice math in exact cents. Each line is quantity × unit price, then an optional line discount, rounded half away from zero to the cent. An invoice-level discount comes off the subtotal, then tax is that percent of the discounted subtotal, rounded the same way. Returns every line, the subtotal, discount, tax, and total. A discount larger than the amount it applies to is rejected. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/invoice-total

The number of involutions of n objects. I(0) and I(1) are 1, and I(n) = I(n-1) + (n-1)*I(n-2). I(5) is 26, and I(10) is 9496. n runs from 0 to 100. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/involution

The number of involutions of n objects with exactly k fixed points. It is 0 when n-k is odd. For n = 5 and k = 1 the count is 15, and for n = 5 and k = 5 it is 1. n runs from 0 to 100, and k runs from 0 to n. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/involution-fixed

I(n) mod m, the involution number reduced by a positive modulus. Zero is rejected. n runs from 0 to 100. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/involution-mod

The sum of involution numbers from lo through hi inclusive. The sum from I(0) through I(10) is 13232. lo must not pass hi. Each index runs from 0 to 100. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/involution-sum

Extract indicators of compromise from threat reports, alerts, logs or emails: IPv4/IPv6 (private ranges optional), domains (TLD-validated, file-name false positives suppressed), URLs, email addresses, MD5/SHA-1/SHA-256/SHA-512 hashes, CVE IDs, MITRE ATT&CK technique IDs, ASNs, Bitcoin (checksum-validated) / Ethereum / Monero addresses, Windows registry keys and suspicious file names. Defanged input (hxxp, [.], (dot), [at]) is refanged automatically; output can be defanged for safe sharing. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.co…

IP ASN + geolocation from free public sources (ipapi.co + RIPE Stat prefix-overview). Country/city/coords, ASN/org, announced prefix. Public IPs only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ip-intel

Aggregate IP allow/deny lists: merges any mix of IPv4/IPv6 addresses, CIDRs, "a-b" ranges and "ip netmask" entries into the minimal set of CIDR blocks, optionally subtracts an exclude list, reports address counts and tests IPs for membership. For firewall rules, WAF / CDN allowlists and cloud security groups. POST JSON body {items, exclude?, check?}. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ip-range-merge

IP blocklist reputation for up to 50 IPv4/IPv6 addresses: membership in the Tor exit list, Spamhaus DROP/DROPv6, abuse.ch Feodo Tracker botnet C2 and FireHOL level1 (cached published lists), with matched range/SBL reference, categories and a simple 0-100 risk score. Blocklist membership only; complements /v1/ip-intel (geo/ASN). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ip-reputation

The integer power base^exp. 2^10 is 1024, and (-2)^5 is -32. 0^0 is 1. exp runs from 0 to 256. The base has at most 80 digits. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ipow

ISBN-10 and ISBN-13 check digit. Spaces and hyphens are ignored, and a 9-digit number is read as an ISBN-10 with a leading zero. ISBN-13 must use the 978 or 979 prefix. A valid ISBN-10 is also returned as ISBN-13, and a 978 ISBN-13 is also returned as ISBN-10. This does not check that the publisher prefix was ever assigned. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/isbn-validate

ISIN check digit (ISO 6166). Two letters, nine letters or digits, one check digit. Letters expand to their alphabet position (A = 10) and the Luhn sum of that digit string must be 0. The prefix must be an ISO country code or one of the substitute prefixes EU, QS, QT, XA, XB, XC, XD, XF, XK, XS. Spaces are ignored. The national security id inside is not looked up. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/isin-validate

The integer square root of a non-negative decimal integer, the greatest r with r^2 not exceeding n. isqrt(0) is 0 and isqrt(10) is 3. A leading zero is rejected. n has at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/isqrt

Whether a non-negative decimal integer is a perfect square, and the root when it is. 16 is 4 squared. 15 is not a square. A leading zero is rejected. n has at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/isquare

ISSN check digit (8 characters, the last may be X). Spaces and hyphens are ignored. The formatted form is the two groups of four. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/issn-validate

The Jacobi symbol (a/n). n must be odd and positive. The value is -1, 0, or 1. An even or non-positive n is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobi

The nth Jacobsthal number. J0 is 0, J1 is 1, and each later term is the previous one plus twice the one before that. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobsthal

The Jacobsthal addition rule. (L(a)*J(b) + J(a)*L(b)) / 2 is J(a+b). a+b must be at most 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobsthal-add

The nth Jacobsthal-Lucas number. L0 is 2, L1 is 1, and later terms use the Jacobsthal recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobsthal-lucas

The power identity J(n) + J(n+1) = 2^n. left is J(n), right is J(n+1), and value is their sum. n runs from 0 to 8191 so that n+1 stays in range. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobsthal-power

The sum of Jacobsthal numbers, or Jacobsthal-Lucas numbers, from lo through hi inclusive. seq is j or l. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jacobsthal-sum

The Jordan totient J(k, n). J(1, n) is Euler's totient. J(1, 6) is 2 and J(2, 6) is 24. k runs from 1 to 12 and n runs from 1 to 1000000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jordan-totient

RFC 8785 JSON Canonicalization Scheme (JCS): deterministic serialization with keys sorted by UTF-16 code units and ECMAScript number formatting, plus SHA-256 / SHA-512 digests of the canonical bytes for signing, caching and deduplication. Also returns sorted pretty JSON and document stats (depth, keys, values, bytes). POST JSON body {json}. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/json-canonicalize

Structural diff of two JSON documents: list of added / removed / changed values with JSON Pointer paths and old/new values, an RFC 6902 JSON Patch that turns a into b, and counts. Arrays are aligned by longest common subsequence (inserted items show as inserts, not a cascade of changes) or matched by an id field. POST JSON body {a, b}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/json-diff

Apply a JSON Patch (RFC 6902: add, remove, replace, move, copy, test) or a JSON Merge Patch (RFC 7386) to a JSON document and return the result. Atomic: any failing operation or test returns 422 with the operation index and nothing is applied. POST JSON body {document, patch}. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/json-patch

Repair broken or LLM-style JSON into valid JSON: strips markdown fences and surrounding prose, comments, trailing/missing commas, single or smart quotes, unquoted keys and values, Python/JS literals (True/None/undefined), NaN/Infinity, unescaped inner quotes and control characters, truncated output (closes open strings/arrays/objects) and mismatched brackets. Reports every fix applied, the original parse error, type and size stats, and optionally runs a JSONPath query ($.a.b[0], [*], .., slices, unions, filters) on the result. Offline; 200 KB. Price: $0.005 USDC per successful call (x402, Sola…

Infer a JSON Schema (draft 2020-12) from one JSON document or many samples: types (integer vs number), nested objects and arrays, required keys (present in every sample), nullable fields, string formats (date-time, date, email, uri, uuid, ipv4/6) and optionally enums and numeric bounds. Turns API responses into a contract for validation or tool definitions. POST JSON body. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/json-schema-infer

Generate typed models from sample JSON: TypeScript interfaces, Zod schemas, Python Pydantic models, Go structs (json tags) or Rust serde structs. Nested objects become named types, optional and nullable fields are detected across samples, arrays are typed by their merged items. POST JSON body {json or samples, language, rootName}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/json-to-types

Query JSON with JSONPath (RFC 9535): dot and bracket names, indexes, slices, wildcards, recursive descent (..) and filters with comparisons, && || !, and length() / count() / match() / search() / value() functions, e.g. $.store.book[?@.price < 10].title. Returns matched values with their normalized paths. Several queries per call. POST JSON body {json, query}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/jsonpath

Convert public keys between PEM, JWK and OpenSSH formats and compute their identifiers — what an agent needs to publish a JWKS, configure an OIDC / JWT verifier or pin a key. Accepts SPKI or PKCS#1 PEM, X.509 certificates (PEM or base64 DER), OpenSSH public keys, a JWK or a whole JWKS. Returns the public JWK (RSA, EC P-256 / P-384 / P-521 / secp256k1, OKP Ed25519 / Ed448 / X25519 / X448), RFC 7638 thumbprint (and RFC 9278 thumbprint URI), SPKI PEM, OpenSSH line with its SHA256 fingerprint, the pin-sha256 SPKI hash, x5t / x5t#S256 for certificates, suggested JWS algorithms and weak-key warnings…

Decode a JWT (JWS or JWE header), POST only (token in the JSON body, never in a URL): header, claims, alg/kid, exp/nbf/iat status with leeway, aud/iss checks, and security findings (alg none, HMAC alg-confusion risk, jku/x5u/jwk header keys, missing exp, odd kid). Optionally verifies the signature against a JWKS URL you supply, or one discovered from the token's https iss via OpenID discovery (fetched SSRF-safely): RS256/384/512, PS256/384/512, ES256/384/512, ES256K and EdDSA. Never trusts alg none. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorp…

Create or verify HMAC-signed JWTs (HS256 / HS384 / HS512) — for test fixtures, service-to-service tokens, webhook auth and debugging "invalid signature" errors. sign: builds header + claims with iat / exp / nbf from durations ("15m", "1h", "7d"), iss / sub / aud shortcuts and an optional random jti, and returns the compact token. verify: checks the signature in constant time plus exp / nbf / iat with leeway and optional issuer / audience expectations, and explains exactly why a token fails. The secret can be UTF-8, base64, base64url or hex; it is never echoed or stored. Warns when the secret i…

Security and reliability audit of Kubernetes YAML (multi-document, List kinds; kubesec / kube-score style): privileged containers, root users, privilege escalation, dangerous capabilities, host namespaces / hostPath / docker.sock mounts, writable root filesystems, seccomp, :latest or untagged images, missing resource limits and probes, literal secrets in env, hostPorts, automounted service-account tokens, risky Services (externalIPs, NodePort), Ingress without TLS, RBAC wildcards / escalate / bind / impersonate / secrets access, cluster-admin and anonymous bindings and committed Secret data. P…

Keyphrase extraction for tagging, SEO and RAG metadata: RAKE (rapid automatic keyword extraction: candidate phrases split at stopwords/punctuation, scored by word degree / frequency) or TextRank (co-occurrence graph + PageRank, adjacent top words merged into phrases). Returns ranked multi-word phrases with score, relative relevance, occurrence count and first offset. Offline, deterministic, English stopword list (add your own); 200 KB input. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/keyword-extract

The nth Kolakoski term, using a 1-based index. The sequence is 1s and 2s, and it starts 1, 2, 2, 1, 1. Term 7 is 1. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kolakoski

Whether a string of the digits 1 and 2 is a prefix of the Kolakoski sequence. 122112 is a prefix. An empty string, or any other character, is rejected. The string stops at 512 characters. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kolakoski-check

The first n Kolakoski terms as a string of the digits 1 and 2. The first 10 terms are 1221121221. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kolakoski-prefix

The Kolakoski run that contains the 1-based index n. A run has length 1 or 2. Index 1 is a single 1. Index 2 starts two 2s. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kolakoski-run

The sum of the first n Kolakoski terms. The sum of the first 10 terms is 15. n runs from 1 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kolakoski-sum

The number of carries when a and b are added in prime base p. By Kummer, that is the exponent of p in C(a+b, a). Adding 5 and 3 in base 2 makes 3 carries. A composite base is rejected. a and b run from 0 to 1000000000000, and p runs from 2 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/kummer

The Laguerre polynomial L(n, x) at an integer x, as a reduced fraction. L(n, 0) is 1, L(1, 1) is 0, and L(2, 1) is -1/2. n runs from 0 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/laguerre

The unsigned Lah number L(n, k). L(0, 0) is 1, L(n, 0) is 0 for n > 0, and L(n, 1) is n!. L(5, 2) is 240, and L(6, 3) is 1200. n and k run from 0 to 20, and k must not pass n. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lah

Row n of the unsigned Lah numbers, from L(n, 0) through L(n, n), written as comma-separated integers. Row 5 is 0,120,240,120,20,1. n runs from 0 to 12. Past 15 digits a term inside the row is still written in decimal. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lah-row

Series resistor for LEDs on one supply. Resistance is (supply − series × forward) / current, with volts and amperes. The part chosen is the next IEC 60063 E24 value at or above that resistance, so the LED current does not go over the request. The forward drop of the string must be under the supply. Exact rationals. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/led-resistor

The Legendre polynomial P(n, x) at an integer x, as a reduced fraction. P(n, 1) is 1, and P(2, 2) is 11/2. n runs from 0 to 32 and x from -1000 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/legendre-pol

LEI check digits, ISO 17442 with ISO 7064 mod 97-10. Twenty letters or digits, and the whole number is 1 mod 97. Spaces and hyphens are ignored. This does not look the entity up at GLEIF. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/lei-validate

The nth Leonardo number. L(0) and L(1) are 1, and L(n) = L(n-1) + L(n-2) + 1. L(4) is 9, and L(10) is 177. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/leonardo

The Leonardo identity L(n) = 2*F(n+1) - 1. F is the Fibonacci sequence with F(0) = 0 and F(1) = 1. For n = 10, L is 177 and F(11) is 89, so the difference is 0. n runs from 0 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/leonardo-fib

The smallest index n with L(n) equal to value. 1 is index 0, and 9 is index 4. A number that is not a Leonardo number, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/leonardo-index

L(n) mod m for the Leonardo sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/leonardo-mod

The sum of Leonardo numbers from lo through hi inclusive. The sum from L(0) through L(5) is 34. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/leonardo-sum

Identify a software / content licence from a LICENSE file, source header or SPDX expression and explain what it allows: 40 licences incl. MIT, Apache-2.0, BSD-2/3/4, ISC, 0BSD, GPL/LGPL/AGPL v2/v3, MPL-2.0, EPL, EUPL, Unlicense, CC0, Creative Commons BY/SA/NC/ND, and source-available BUSL / SSPL / Elastic / PolyForm / Commons Clause. Returns SPDX id, confidence, category (permissive, weak / strong / network copyleft, non-commercial, source-available), OSI approval, permissions / conditions / limitations, "or later" detection, SPDX-License-Identifier tags and copyright holders. Offline; not leg…

Find broken links on a public web page (or in supplied HTML, e.g. a draft before publishing): fetches the page (SSRF-safe), extracts links (optionally images / scripts / stylesheets too), then checks up to 50 of them in parallel with HEAD (falling back to GET), every target re-validated against private / internal addresses and pinned to its checked IP. Reports status, category (ok / redirect / broken / error / blocked), redirect location, response time and anchor text, broken first. Price: $0.006 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x…

Liouville's function lambda(n) = (-1) to the number of prime factors of n, counted with multiplicity. lambda(1) is 1, lambda(2) is -1, and lambda(4) is 1. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/liouville

The sum of Liouville's lambda(k) from 1 through n. The sum through 10 is 0, and the sum through 30 is -4. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/liouville-sum

Liquidation calculator. mode=perp: isolated-margin long/short liquidation and bankruptcy price from entry price, leverage and maintenance margin rate (optionally size and fees), with distance to liquidation. mode=lending: health factor, liquidation price of the collateral and safe borrow headroom for Aave/Compound/Kamino/Morpho-style loans from collateral, debt and liquidation threshold. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/liquidation-price

The number of distinct prime factors of n. omega(1) is 0, omega(4) is 1, and omega(30) is 3. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/little-omega

Read a site's llms.txt (the llmstxt.org convention that tells AI agents where the useful docs are), SSRF-safe: title, summary, details and every section's links (title, absolute URL, notes; "Optional" section flagged), whether llms-full.txt exists, size / token estimate and format issues. Accepts a domain or a direct URL to an llms.txt file. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/llms-txt

Loan / mortgage amortization: periodic payment, total interest, payoff date and a yearly or full payment schedule (principal, interest, balance) for any rate, term and payment frequency (monthly, bi-weekly, weekly, quarterly, annual). Extra payments per period show months and interest saved. Fixed-rate, level-payment loans. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/loan-amortization

True cost of a loan including fees: the US Truth in Lending APR (Regulation Z actuarial method) and the EU APRC (Consumer Credit Directive annual effective rate), plus the payment, amount financed, finance charge and total of payments for a level-payment loan. Handles origination fees and points paid upfront or rolled into the loan, a balloon payment, and weekly to annual payments. Compares the note rate with the real borrowing rate so offers can be ranked. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/loan-apr

The nth look-and-say term, starting from 1. Term 1 is 1, term 4 is 1211, and term 5 is 111221. Each run of k copies of a digit d becomes the digits of k followed by d. n runs from 1 to 25. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/look-say

How many times a digit occurs in the nth look-and-say term. Term 5 is 111221, so it has four 1s and two 2s. A digit from 4 through 9 occurs zero times in the classic sequence. n runs from 1 to 25, and the digit runs from 0 to 9. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/look-say-count

One digit of the nth look-and-say term. The index starts at 0. Term 5 is 111221, so index 3 is 2. An index past the end is rejected. n runs from 1 to 25. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/look-say-digit

The number of digits in the nth look-and-say term, starting from 1. Term 1 has length 1, term 5 has length 6, and term 8 has length 10. n runs from 1 to 25. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/look-say-len

One look-and-say step on a digit string. 1 becomes 11, and 1211 becomes 111221. Two 2s become 22. An empty string, or a character that is not a digit, is rejected. The string stops at 4096 characters. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/look-say-step

The nth Lucas number. L0 is 2, L1 is 1, and each later term is the sum of the previous two. L5 is 11 and L10 is 123. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lucas

The Lucas discriminant L(n)^2 - 5*F(n)^2, which equals 4*(-1)^n. F is the Fibonacci sequence with F0 = 0 and F1 = 1. For n = 5 the value is -4. n runs from 0 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lucas-disc

The smallest index n with L(n) equal to value. 2 is index 0, and 1 is index 1. A number that is not a Lucas number, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lucas-index

L(n) mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lucas-mod

The sum of Lucas numbers from lo through hi inclusive. The sum from L0 through L5 is 28. The sum equals L(hi+2) - L(lo+1). lo must not pass hi. Each index runs from 0 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/lucas-sum

Normalize a MAC-48 or EUI-64. Accepts colon, hyphen, Cisco dotted (groups of four) or plain hex, any case. Returns lowercase colon, hyphen, dotted and compact forms. multicast is the I/G bit, the low bit of the first octet. local is the U/L bit, the next bit. oui is the first three octets as hex, not a vendor name. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/mac-address

A stable locally administered unicast MAC from a seed. SHA-256 of the seed, first six bytes, multicast bit cleared and the U/L bit set. The same seed always returns the same MAC. This is not a random draw and not a real assignment. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/mac-local

Macro indicators by country and year: GDP, real GDP growth, GDP per capita, inflation, unemployment, population, government debt and current account, side by side from the World Bank (WDI actuals) and the IMF World Economic Outlook (DataMapper, incl. projections). Up to 10 countries (ISO2/ISO3) and 8 indicators per call. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/macro-indicators

Build or parse Markdown (GitHub-flavoured) tables. Build: from an array of objects, an array of arrays or CSV, with column selection / order / renaming, alignment (numeric columns right-aligned automatically), pipe / newline escaping, cell truncation and padding that respects wide CJK / emoji characters; also returns an HTML table. Parse: extract every table from Markdown into headers, alignment and typed rows (JSON). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/markdown-table

Render Markdown to safe HTML: CommonMark-style blocks (ATX / setext headings, paragraphs, block quotes, nested ordered / bullet lists, fenced and indented code with language classes, thematic breaks) and inlines (emphasis, strong, code spans, links, images, reference links, autolinks, hard breaks, escapes, entities) plus GitHub extensions (tables with alignment, task lists, strikethrough, bare URL autolinks). Raw HTML is escaped by default or allowlist-sanitized; javascript: and other unsafe URLs are dropped. Returns HTML, heading ids and a table of contents. Offline, deterministic. Price: $0.…

Price, margin and markup in exact cents. Analyze a cost and a price (margin is profit / price, markup is profit / cost). Or set a price from a cost and a margin percent (price = cost / (1 − margin)), or from a markup percent (price = cost × (1 + markup)). Or walk a list of successive discounts off a price, rounding each step half away from zero to the cent. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/markup-margin

Evaluate math expressions safely and exactly — the calculator agents should call instead of doing arithmetic in their heads. Exact rational arithmetic by default (0.1 + 0.2 = 3/10, 1/3 + 1/6 = 1/2, 2^200 and 1000! in full), with repeating-decimal notation, plus floating point for transcendental functions: sqrt, cbrt, root, exp, ln, log (base 10, or log(x, b)), log2, trig and hyperbolic functions (radians or degrees), gamma, erf, factorial, nCr / nPr, gcd / lcm, mod, min / max / sum / mean / median, round(x, digits), comparisons. Implicit multiplication (2pi, 3(x+1)), variables, and multi-state…

Linear algebra on matrices, exactly where it matters. Determinant, inverse, RREF, rank, null space, linear solve (Ax = b), multiply, add / subtract, integer powers, trace and LU are computed with exact rational arithmetic (entries may be integers, decimals or "p/q" strings — 0.1 stays 1/10), returned as exact values plus decimals. Floating-point eigenvalues (Jacobi for symmetric matrices with eigenvectors; Hessenberg + shifted QR for general matrices including complex eigenvalues, with eigenvectors for real eigenvalues), singular values (one-sided Jacobi SVD), QR, norms and condition number. o…

The mediant of a/b and c/d, which is (a+c)/(b+d) reduced by their gcd. Numerators may be zero. A non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mediant

Find the best meeting times across time zones: give 2-20 IANA zones (optionally with per-person hours like Asia/Tokyo@08:00-18:00) and a date; returns the windows where everyone is inside working hours, the top-ranked slots (everyone in hours first, then fewest people outside, then least early / late), each with every participant's local time and weekday, plus UTC offsets. DST-correct, weekends flagged. Offline. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/meeting-planner

MEID, the CDMA equipment id. Hex is 14 digits with an optional Luhn check in base 16. Decimal is 18 digits (manufacturer and serial) with an optional decimal Luhn check, and it converts to the hex form. A 14-digit hex number that is only decimal digits is an IMEI, not a MEID. Spaces and hyphens are ignored. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/meid-validate

The Mertens function M(n), the sum of the Mobius function mu(k) from 1 through n. M(1) is 1, M(10) is -1, and M(100) is 1. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mertens

The largest absolute value of the Mertens function M(k) for k from 1 through n, and the smallest k where it occurs. Through 10 the maximum is 2 at k = 5. Through 100 it is 4 at k = 31. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mertens-max

A written note or a MIDI number. Middle C is C4, which is 60. C-1 is 0 and G9 is 127. The name you pass keeps its spelling, so B#3 stays B#3 even though it is the same key as C4. sharp and flat are the two usual names of that key. x is a double sharp. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/midi-note

The Mobius function mu(n). It is 0 when n has a squared prime factor, and otherwise (-1)^k for k distinct primes. mu(1) is 1. n = 0 is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mobius

The modular inverse of a modulo m, as a residue from 0 up to m-1. The modulus must be at least 1. A value that is not coprime to m is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mod-inv

base^exp mod m, exact, for a non-negative exponent. The modulus must be at least 1. A negative exponent is rejected. Decimals have no leading zeros and at most 200 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/mod-pow

Bits that differ between two POSIX modes. added and removed run from the special bits down through owner, group and other. same is true when nothing differs. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/mode-diff

Moon phase for any moment: phase name and emoji, illuminated fraction, phase angle, age in days since new moon, waxing / waning, Earth-Moon distance and apparent size, the next new moon / first quarter / full moon / last quarter (to a few minutes), and moonrise / moonset for a location and local date (topocentric, parallax and refraction aware). Meeus lunar theory, offline. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/moon-phase

Decode international Morse. Letters are separated by one space and words by " / ". The result is capitals. ... --- ... is SOS. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/morse-decode

Encode text as international Morse (ITU-R M.1677). Letters are separated by one space and words by " / ". SOS is ... --- ... Digits and the recommendation punctuation are included. Other characters are rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/morse-encode

The Thue-Morse run that contains n. The bit is the parity of the 1-bits of n. A run has length 1 or 2. Index 0 is a run of one 0, and index 1 starts a run of two 1s. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/morse-run

How long a Morse message takes at a given speed. The dit is 1200/wpm milliseconds. PARIS is 43 units, or 50 units once the trailing 7-unit word gap of a stream is added. SOS is 27 units. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/morse-timing

How much house can I afford: maximum home price and loan from income, monthly debts, down payment and rate under front-end / back-end debt-to-income limits (default 28/36), with a full monthly PITI breakdown (principal & interest, property tax, insurance, HOA, PMI below 20% down). Give homePrice instead to get the monthly cost and the income needed. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/mortgage-affordability

The nth Motzkin number. M0 and M1 are 1, M2 is 2, M4 is 9, from M_n = sum binom(n, 2k) C_k. n runs from 0 to 512. An optional modulus reduces the term; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/motzkin

The number of ways to choose k elements from n types with repetition, which is C(n+k-1, k). Choosing 2 from 3 types can be done in 6 ways. Choosing nothing can be done in 1 way. n and k run from 0 to 1024. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/multichoose

Multiplicative persistence: how many times the decimal digits of n must be multiplied to reach a single digit, and that digit. 39 takes 3 steps and ends at 4. 10 ends at 0 in 1 step. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/multiplicative-persistence

Spell a chord up from a root: major, minor, diminished, augmented, sus2, sus4, dom7, maj7, min7, dim7, half-dim7, and sixth. Letters stay in thirds except the suspensions and the sixth. A diminished seventh uses a double flat when the spelling needs it. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/music-chord

The interval between two written notes. The number comes from the letters and the quality from the semitones, so C to E is a major third and C to Fb is a diminished fourth. Direction follows the written notes. Semitones is negative when the second note is lower. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/music-interval

Spell a scale on letters from a tonic. Major, minor, harmonic minor, melodic minor (the ascending form), the church modes, pentatonic, minor pentatonic, and blues. G# major is written with E# and F##, not with flats. signature lists the accidentals in scale order. The octave does not repeat the tonic. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/music-scale

Move a written note by a named interval. The letter moves with the interval number, then the accidental is chosen to hit the semitones. A perfect third is rejected, and so is a quality that would need more than a double accidental. Up and down are the two directions. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/music-transpose

MX / mail-routing check: sorted MX with inferred provider (Google, M365, Proofpoint, etc.), A/AAAA, SPF presence, null-MX detection. Complements /v1/email-auth. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/mx-check

The Narayana number N(n,k). N(5,3) is 20. A k outside 1..n yields 0. n runs from 1 to 60 and k from 0 to 60. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/narayana

The Narayana product C(n,k)*C(n,k-1). It is exactly n times N(n,k). product is that binomial product and value is the Narayana number. n runs from 1 to 60. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/narayana-check

Narayana numbers N(n,1) through N(n,n). Their sum is the Catalan number C(n). The row for n = 4 is 1, 6, 6, 1 and sums to 14. n runs from 1 to 60. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/narayana-row

ERC-721 / ERC-1155 token metadata: tokenURI/uri (ipfs/arweave/data/https), ownerOf, collection name/symbol/supply, EIP-2981 royalty. Metadata JSON is fetched SSRF-safe via target_fetch (public-IP pinned). Returns name, description, image (+ http gateway URL), attributes. Read-only. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/nft-metadata

Investment appraisal for a cash-flow series: NPV at a discount rate, IRR (all roots for non-conventional flows), MIRR, profitability index, simple and discounted payback; with dates gives Excel-compatible XNPV and XIRR. POST JSON body {cashFlows, ratePct, dates?}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/npv-irr

Spell out numbers in words — cardinal, ordinal, currency amounts, cheque wording, years and Roman numerals — in English, Spanish, French, German, Italian, Portuguese (PT) and Brazilian Portuguese, with each language's real grammar (French "quatre-vingts" / "et un", Spanish "veintiún mil" / "un millón", German compounds, Italian elision, long and short scales). Integers up to 36 digits, decimals ("twelve point five"), negatives. Also converts Roman numerals back to numbers. For invoices, cheques, contracts, accessibility and voice output. Price: $0.001 USDC per successful call (x402, Solana). S…

OAuth 2.0 PKCE helper (RFC 7636 / OAuth 2.1): generate a code_verifier with its S256 code_challenge plus random state and OIDC nonce, verify that a verifier matches a challenge, or build a complete authorization URL (response_type=code, client_id, redirect_uri, scope, state, nonce, code_challenge, extra parameters such as prompt or audience) and return the verifier / state to keep for the token exchange. Validates verifier length and characters and redirect URIs. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/oauth-pkce

Ohm's law for one passive resistor. Give any two of voltage (volts), current (amperes), resistance (ohms) and power (watts). The other two come back as exact rationals. A third or fourth value is checked and rejected when it disagrees. Zero volts across a positive resistance is a dead circuit. Voltage across zero ohms, or voltage with zero current, is rejected. Power and resistance are accepted only when both square roots are rational. SI units, no prefixes. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ohm-law

Scholarly search over OpenAlex (250M+ works): works with title, authors + ORCID + institutions, year, venue, DOI, citation count, open-access status + OA URL and reconstructed abstract; or authors (works, citations, h-index, institution, topics) or institutions (country, ROR, works, citations). Year range, open-access filter, sort by relevance/citations/date. Falls back to Crossref for works if OpenAlex is unavailable. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/openalex-search

Summarise an OpenAPI 3.x or Swagger 2.0 API from a URL (SSRF-safe) or an inline JSON / YAML spec, so an agent can learn an API fast: title, version, servers / base URLs, auth schemes (API key, bearer, OAuth flows), and every operation with method, path, operationId, summary, tags, parameters (with $ref resolved), request body types, response codes and per-operation security. Filter by tag or search text. Price: $0.004 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/openapi-summary

FDA drug facts by brand/generic name or NDC from openFDA: label sections (boxed warning, indications, dosage, contraindications, warnings, adverse reactions, interactions, or any SPL field), FAERS adverse-event report totals with serious count and top reported reactions, and the latest enforcement recalls with class and reason. Not for clinical use; the response carries FDA's disclaimer. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/openfda-drug

Extract Open Graph, Twitter Card, title/description, canonical, icons and JSON-LD @types from a public URL. Ideal for link unfurling agents. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/opengraph

Known vulnerabilities for ONE package version from OSV.dev (GitHub Advisory DB, PyPA, Go, RustSec, OSS-Fuzz, distro feeds): advisory id + CVE aliases, severity (GHSA label or computed CVSS v3 base score), CVSS vectors, CWEs, fixed versions, a heuristic minimal safe upgrade, and links. npm, PyPI, Go, crates.io, Maven, Packagist, RubyGems, NuGet, Pub, Hex, distros. Use POST for a whole dependency list or lockfile. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/osv-scan

Dependency vulnerability scan (SCA) via OSV.dev querybatch: send up to 500 packages, or paste a lockfile (package-lock.json, yarn.lock, composer.lock, requirements.txt, Pipfile.lock, poetry.lock, uv.lock, Cargo.lock, go.mod, go.sum, Gemfile.lock; auto-detected). Returns a severity summary plus, per vulnerable package, advisories with CVE aliases, CVSS, fixed versions and a heuristic safe upgrade. 256 KB body limit. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/osv-scan

npm or PyPI package risk/typosquat check: registry metadata, weekly downloads (npm), deprecation, license/repo presence, edit-distance to popular packages, and whether close-name variants already exist. Heuristic — not a malware scanner. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/package-risk

The nth Padovan number. P0, P1, and P2 are 1, and each later term is the sum of the term two back and the term three back. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/padovan

The Padovan step identity P(n) = P(n-1) + P(n-5). left is P(n-1) and right is P(n-5). n runs from 5 to 8192. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/padovan-step

The sum of Padovan numbers, or Perrin numbers, from lo through hi inclusive. seq is p or r. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/padovan-sum

How many copies of one sheet fit on another at full size. The copy may be turned. Two A4 pages fill an A3 and the waste is zero. count is 0 when it does not fit. orientation is how the copy sits, or none. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/paper-fit

The next larger and smaller sheet in the same ISO series. A4 sits between A3 and A5. A0 has no larger size and A10 has no smaller one. DL is not in a series. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/paper-next

The largest scale that places one sheet on another, turning it when that lets it be larger. The scale is an exact ratio of the millimeter sides. Below one, the sheet has to shrink. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/paper-scale

ISO 216 A, B and C sizes, plus the DL envelope, in millimeters. Portrait, so the width is the shorter side. Inches are exact millimeters divided by 25.4. A4 is 210 by 297. Set landscape to swap the sides. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/paper-size

The regular paperfolding bit of n. Write n = m * 2^k with m odd. The bit is 1 when m is 1 mod 4, and 0 when m is 3 mod 4. The first three bits, from n = 1, are 1, 1, 0. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/paperfold

The number of integer partitions p(n), from the pentagonal recurrence. p(0) is 1, p(5) is 7, and p(10) is 42. n runs from 0 to 2000. An optional modulus reduces the count; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/partition

The conjugate of an integer partition, read down the columns of its Ferrers diagram. Parts must be positive and nonincreasing. The empty partition is its own conjugate. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/partition-conjugate

The number of partitions of n into distinct positive parts. This equals the number of partitions into odd parts. q(0) is 1 and q(5) is 3. n runs from 0 to 2000. An optional modulus reduces the count; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/partition-distinct

Check an integer partition and return its sum and length. Parts must be positive and nonincreasing. The empty list is the partition of zero. A rise or a zero part is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/partition-parts

Generate strong secrets with a CSPRNG (never stored or logged): random passwords (length, character classes, custom symbols, exclude look-alike characters, guarantee one of each class), diceware-style passphrases from a ~9,000-word common-English list (about 13 bits per word) (separator, capitalisation, optional digit) and PINs (weak / sequential PINs rejected). Up to 50 at once, with entropy bits, strength and offline crack-time estimate. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/password-generate

Hash, verify and identify password hashes — for seeding users, migrating auth systems, writing htpasswd files and auditing leaked hash formats. hash: bcrypt, Argon2id / Argon2i (where the server has libargon2), PBKDF2-SHA256 / SHA512 (Django format), SHA-512 / SHA-256 crypt (Linux shadow) and Apache APR1 (htpasswd). verify: checks a password against bcrypt, Argon2, crypt ($1$ $5$ $6$, DES), APR1, Django / Werkzeug / passlib PBKDF2, phpass ($P$ $H$, WordPress), Drupal 7 ($S$), LDAP {SSHA} / {SHA} / {SSHA256} / {SSHA512} / {SMD5}, MySQL 4.1+ and unsalted MD5 / SHA / NTLM hex. identify: algorithm…

Offline password strength audit (POST only, so the password never appears in a URL or access log; never echoed or stored): zxcvbn-style score 0-4, estimated guesses and entropy, crack-time estimates, weak patterns (common/breached passwords incl. l33t and reversed, keyboard walks, sequences, repeats, dates, personal info) and NIST SP 800-63B checks. Body: { "password": "...", "user_inputs"?: ["alice", "alice@example.com"] }. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/password-strength

The nth Pell number. P0 is 0, P1 is 1, and each later term is twice the previous one plus the one before that. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pell

Compose two solutions of x^2 - 2y^2 = ±1. The unit for index a multiplied by the unit for index b is the unit for a+b. a+b must be at most 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pell-compose

The nth solution of the Pell equation x^2 - 2y^2 = (-1)^n. x is half the companion Pell-Lucas number and y is the Pell number. A supplied norm must equal that sign. n runs from 0 to 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pell-equation

The nth companion Pell-Lucas number. Q0 and Q1 are both 2, and later terms use the Pell recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pell-lucas

The sum of Pell numbers, or companion Pell-Lucas numbers, from lo through hi inclusive. seq is p or q. lo must not pass hi. Each index runs from 0 to 8192. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pell-sum

The generalized pentagonal number n(3n-1)/2. n may be negative. n = 1 gives 1, n = -1 gives 2, and n = 0 is rejected. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentagonal

The nth Pentanacci number. P0 through P3 are 0, P4 is 1, and each later term is the sum of the previous five. P(10) is 31. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentanacci

The smallest index n with P(n) equal to value. 0 is index 0, and 1 is index 4. A number that is not a Pentanacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentanacci-index

P(n) mod m for the Pentanacci sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentanacci-mod

The Pentanacci step P(n) = P(n-1) + P(n-2) + P(n-3) + P(n-4) + P(n-5). a is P(n-5), b is P(n-4), c is P(n-3), d is P(n-2), and e is P(n-1). n runs from 5 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentanacci-step

The sum of Pentanacci numbers from lo through hi inclusive. The sum from P0 through P12 is 244. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pentanacci-sum

Classify n from its divisor sum. 6 and 28 are perfect. 12 is abundant. 8 is deficient. The class is perfect, abundant, or deficient. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perfect-check

Whether n is a perfect power a^k with k at least 2. The base is the smallest such a, so the exponent is the largest. 16 is 2^4, 36 is 6^2, and 7 is not a perfect power. 0 and 1 use exponent 2. A leading zero is rejected. n has at most 80 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perfect-power

The period-doubling bit at index n, starting at 0. It is the parity of the exponent of 2 in n+1. Bit 0 is 0, bit 1 is 1, and the first 8 bits are 01000101. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/period-double

The first n period-doubling bits, as a string of the digits 0 and 1. The first 8 bits are 01000101. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/period-double-prefix

The number of 1s in the first n period-doubling bits, from index 0 through n-1. The first 8 bits have three 1s, and the first 100 bits have 33. n runs from 0 to 999999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/period-double-sum

Compose two permutations of the same length. a is applied first, then b, so the result at i is b[a[i]]. Both must use 0..n-1 once each. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perm-compose

Inverse of a permutation of 0..n-1. The inverse of [1, 2, 0] is [2, 0, 1]. Applying both is the identity. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perm-inverse

The next permutation in lexicographic order. After [0, 1, 2] comes [0, 2, 1]. The reverse, [2, 1, 0], is the last and has no successor. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perm-next

Lexicographic rank of a permutation, or the permutation at a rank. [0, 1, 2] is rank 0 and [2, 0, 1] is rank 4. Give the permutation, or n and a rank, not both. n is at most 10. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perm-rank

Sign of a permutation of 0..n-1, from the number of inversions. [2, 1, 0] has three inversions and sign -1. The identity has sign 1. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perm-sign

Whether one class may read, write, or execute under a mode. Pass the class that applies: on a real system the owner class is used for the owner even when the group bits differ. setuid, setgid and sticky do not grant the bit. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/permission-check

The nth Perrin number. R0 is 3, R1 is 0, R2 is 2, and later terms use the Padovan recurrence. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 8192. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perrin

The remainder of the nth Perrin number divided by n. A prime n divides R(n), so the remainder is 0. n runs from 1 to 8192. Past 15 digits the Perrin number is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/perrin-divide

Inspect an OpenPGP public key (ASCII-armored or base64 binary) the way gpg --show-keys does, offline: primary key and subkey fingerprints and key IDs (v4, v5 and RFC 9580 v6 keys), algorithm and size / curve (RSA, DSA, ElGamal, ECDSA, ECDH, EdDSA, Ed25519 / Ed448, X25519 / X448), creation and expiry from the self-signatures, revocations, capabilities (certify / sign / encrypt / authenticate), user IDs split into name / email / comment, preferred algorithms and features, the armor CRC-24 check and Web Key Directory (WKD) URLs for each email. Flags weak or deprecated keys, SHA-1 self-signatures,…

Heuristic phishing-likelihood score for a URL/domain: brand typosquat distance, subdomain depth, punycode, RDAP age, HTTPS reachability. Returns scored signals — not a verdict. Low Bazaar crowding. Price: $0.008 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/phishing-score

Detect and redact PII in text: emails, phone numbers (E.164, NANP, keyword-anchored national), credit cards (Luhn + issuer prefix/length, brand), US SSNs (SSA validity rules) and IBANs (registry length + mod-97). Returns counts per type, findings with code-point offsets, confidence and masked values, and a redacted copy using stable labels ([EMAIL_1]) or inline masks. Raw values are only echoed with reveal:true. Offline; 200 KB text limit. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pii-detect

Paid x402 test route for agents and client developers: the cheapest way to prove your x402 client signs a Solana USDC payment and the facilitator settles it before you call anything expensive. Returns pong, server time, your optional echo string and the payment terms; the settlement transaction comes back in the PAYMENT-RESPONSE header. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ping

Add two integer polynomials, lowest degree first. Trailing zeros are dropped, and the zero polynomial is an empty list. An optional modulus reduces each coefficient; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/poly-add

Differentiate an integer polynomial. The derivative of a constant is the zero polynomial, which is an empty list. An optional modulus reduces each coefficient; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/poly-deriv

Exact quotient of two integer polynomials. The divisor must be non-zero, and every leading step must divide in the integers. A zero divisor or a non-integral quotient is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/poly-div

Evaluate an integer polynomial at an integer point, by Horner. The zero polynomial evaluates to 0. An optional modulus reduces the result; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/poly-eval

Multiply two integer polynomials, lowest degree first. The zero polynomial is an empty list. An optional modulus reduces each coefficient; zero is rejected. A coefficient past 15 digits is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/poly-mul

Portfolio and asset risk/return analytics from price or return series you supply: annualised return (CAGR) and volatility, Sharpe and Sortino ratios, max drawdown, historical and parametric 95% VaR, beta/alpha against a benchmark series and a correlation matrix, for each asset and the weighted (periodically rebalanced) portfolio. Up to 20 assets. POST JSON body. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/portfolio-metrics

Risk-based position sizing for trading agents: from account balance, risk per trade (percent or fixed amount), entry and stop price returns units to buy/sell, notional, leverage needed, stop distance, and with a target the reward:risk ratio, profit at target and break-even win rate. Optional fees and lot-size rounding. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/position-size

Whether n is powerful: 1, or every prime factor's exponent is at least 2. 1, 8, and 36 are powerful. 12 is not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/powerful

Whether n is prime, by trial division. 1 is not prime. n < 1 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/prime-check

If n is a prime power p^k with k at least 1, return that prime and the exponent. Otherwise the prime and the exponent are 0. 8 is 2^3, 49 is 7^2, and 12 is not a prime power. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/prime-power

The primorial of n, the product of the primes less than or equal to n. The primorial of 1 is 1, of 10 is 210, and of 11 is 2310. n runs from 1 to 5000. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/primorial

Profanity, sexual-language and slur filter for chat, usernames, reviews and LLM output: token-level matching (no Scunthorpe false positives) with obfuscation handling (leetspeak f4ck / sh1t, masked letters f*ck, repeated letters fuuuck, separators f.u.c.k / f u c k, accents), inflections and compounds (bullshit, motherf...). Severity mild / moderate / severe and category per hit, masked output in four styles, custom block / allow words. Matched words are never echoed unless reveal is set. Offline, English. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https:…

Offline prompt-injection / jailbreak / exfiltration scanner: 10 rule families (ignore-instructions, reveal-system, role-hijack, delimiter-escape, tool/secret dump, encoding smuggle, policy bypass, authority claim, continuation trap, multilingual) plus hidden-Unicode and long-base64 heuristics. Returns verdict (clean|suspicious|critical), 0-100 score and match spans. Batch up to 20 texts. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/prompt-injection-scan

Prorate a money amount across a date range, in exact cents. The window is half-open: from the start date up to but not including the end date. The charge is amount × days used / days in the period, rounded half away from zero. The used range has to sit inside the period. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/prorate

Search PubMed biomedical literature via NCBI E-utilities (esearch + esummary + efetch): PMID, title, authors, journal, publication date, volume/issue/pages, DOI, PMCID, publication types; abstracts only on request (abstracts=true, off by default since they may be publisher-copyrighted; structured sections kept). Full PubMed query syntax ([MeSH], [Author], AND/OR), relevance or newest-first, publication-date range. Server-wide 3 req/s NCBI limit respected. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/pubmed-search

Check a^2 + b^2 = c^2 for positive integers, with c the hypotenuse. primitive is true when the three sides are coprime. A side triple that fails the equation is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pythag-check

The Pythagorean triple from m > n >= 1 and scale k >= 1. a is k(m^2-n^2), b is k(2mn), and c is k(m^2+n^2). primitive is true when k is 1, m and n are coprime, and they have opposite parity. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/pythag-gen

Generate a QR code (PNG or SVG, base64 + data URI) for any UTF-8 text up to 2953 bytes. Options: ecc L|M|Q|H, size (px/module), margin, format png|svg, fg/bg hex colours. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/qr-generate

Inverse of a quaternion, the conjugate divided by the squared length. (1, 2, 3, 4) inverts to (1/30, -1/15, -1/10, -2/15). Zero has no inverse. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/quat-inv

Hamilton product of two quaternions, scalar first. i times j is k, and j times i is minus k. Components are exact fractions. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/quat-mul

Conjugate and squared length of a quaternion. (1, 2, 3, 4) has squared length 30 and conjugate (1, -2, -3, -4). Unit means the squared length is 1. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/quat-norm

Integer power of a quaternion. i squared is -1, and i to the fourth is 1. Exponent 0 is 1, including zero to the 0. A negative power inverts first. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/quat-pow

Rotate a vector by a quaternion, q v q inverse. k sends (1, 0, 0) to (-1, 0, 0), a half turn about z. Scaling q does not change the turn. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/quat-rotate

The radical of n, the product of its distinct prime factors. rad(1) is 1, rad(12) is 6, and rad(36) is 6. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/radical

Provably fair random draws for giveaways, raffles, games and A/B assignment. Pick winners from a list (unique or with replacement, optional weights), shuffle a list, split people into balanced teams, draw integers in a range, or roll dice ("3d6+2", "4d6kh3"). Randomness is HMAC-SHA256(serverSeed, clientSeed:nonce:counter) with unbiased rejection sampling and Fisher–Yates; the response publishes the server seed, its SHA-256 commitment and the algorithm so anyone can re-run and verify the draw. Supply serverSeed + clientSeed to reproduce a previous draw exactly. Price: $0.002 USDC per successful…

Lightweight RDAP registration age lookup: registered/expiry dates, ageDays, daysToExpiry, registrar, status flags via rdap.org bootstrap. Faster/cheaper than full domain-intel when you only need age. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/rdap-age

Extract the main article from a web page (Readability-style content scoring, no headless browser): clean body text with paragraph breaks plus title, byline, site name, published/modified dates, language, excerpt, lead image, word count and reading time. Navigation, ads, share bars, comments and related-links blocks are stripped; JSON-LD articleBody is used when it is fuller. SSRF-safe fetch. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/readability-extract

The nth Recamán term. a(0) is 0. Each later term steps back by n when that value is positive and new, and otherwise steps forward by n. a(4) is 2 and a(6) is 13. n runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/recaman

Whether value appears in Recamán's sequence from a(0) through a(limit), and the smallest index if it does. 2 appears at index 4. 4 does not appear by index 20. limit runs from 0 to 100000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/recaman-seen

Follow HTTP redirects (max 10) with SSRF protections; report each hop status, Location, Server and Content-Type. Detect open-redirect chains and tracking bounces. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/redirect-chain

Explain, lint and test a regular expression before an agent ships it. Parses the pattern (PCRE, JavaScript, Python, Go/RE2, Java or .NET syntax) into a token-by-token plain-English explanation with capture groups; flags ReDoS risks (nested quantifiers, overlapping alternation in repeats, adjacent overlapping quantifiers) and confirms them with a crafted input against a backtracking limit; warns about common bugs (unescaped dots in domains, [A-z], empty alternatives, unanchored validators); reports which features each regex flavour does not support (lookbehind, possessive / atomic, \A \z, named…

Offline PCRE2 regex tester (JS-compatible i/m/s/u flags): match (with offsets + capture groups), replace, or split. Hard caps on backtracking/recursion and a structural ReDoS warning. Pattern max 2 KB, subject max 200 KB. Returns count, matches/result/parts and engine notes. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/regex-test

Fit a regression model and get the full statistical table, like R's summary(lm) or statsmodels. Linear, polynomial (degree 2–6), exponential (y = a·e^(bx)), logarithmic, power (y = a·x^b), multiple linear (many named predictors) and binary logistic regression (IRLS, odds ratios, McFadden pseudo-R², accuracy). Returns coefficients with standard errors, t / z statistics, p-values and confidence intervals, R² and adjusted R², residual standard error, F-test, AIC / BIC, a residual summary, the fitted equation, and predictions with confidence and prediction intervals. model=best ranks the single-pr…

The rencontres number D(n, k), the permutations of n objects with k fixed points. D(n, k) = C(n, k) * !(n-k). D(5, 0) is 44, and D(5, 2) is 20. n runs from 0 to 100, and k runs from 0 to n. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/rencontres

Security posture of a public GitHub repository from the OpenSSF Scorecard API: aggregate 0-10 score and rating, every check (Code-Review, Branch-Protection, Dangerous-Workflow, Token-Permissions, Pinned-Dependencies, Signed-Releases, Vulnerabilities, SAST, Fuzzing, Security-Policy, ...) with score, risk level, status and reason, a list of failing important checks, plus GitHub signals: SECURITY.md location, license, archived, stars, last push. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/repo-posture

The repunit of length n, (10^n - 1)/9. R1 is 1 and R2 is 11. n = 0 is rejected. n runs up to 500. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/repunit

IEC 60062 resistor color code. Decode 3 to 6 bands, or encode a resistance that lands exactly on a digit-and-multiplier value. Digits run black=0 through white=9. Multipliers run from silver (×0.01) and gold (×0.1) through white (×1e9). Tolerances: brown 1%, red 2%, green 0.5%, blue 0.25%, violet 0.1%, grey 0.05%, gold 5%, silver 10%. Three bands mean 20% and have no tolerance band. The sixth band is the temperature coefficient in ppm/K: black 250, brown 100, red 50, orange 15, yellow 25, green 20, blue 10, violet 5, grey 1. Grey may be spelled gray. This does not measure a part. Price: $0.001…

Series or parallel equivalent of 2 to 24 resistances. Series adds them. Parallel is the reciprocal of the sum of the reciprocals. Exact rationals. Every value must be positive. One block only: a mixed ladder is not a mode. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/resistor-network

Reverse DNS (PTR) for up to 20 IPv4 / IPv6 addresses with forward-confirmed reverse DNS (FCrDNS: does the PTR hostname resolve back to the same IP?), PTR name, TTL and NXDOMAIN / SERVFAIL status, over DNS-over-HTTPS. Useful for mail-server checks, log enrichment and bot verification (e.g. is this really Googlebot). Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/reverse-dns

The nth Riordan number. R(0) is 1, R(1) is 0, and (n+1)*R(n) = (n-1)*(2*R(n-1) + 3*R(n-2)) for n at least 2. R(4) is 3, and R(6) is 15. n runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/riordan

R(n) mod m for the Riordan numbers. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 80. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/riordan-mod

The sum of Riordan numbers from lo through hi inclusive. The sum from R(0) through R(10) is 989. lo must not pass hi. Each index runs from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/riordan-sum

The rising factorial n^(k) = n*(n+1)*...*(n+k-1). 5^(3) is 210, and 5^(0) is 1. n runs from 0 to 100000 and k runs from 0 to 512. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/rising

Fetch and parse robots.txt plus discovered sitemaps for a domain: user-agents, allow/disallow samples, sitemap index vs urlset, URL counts and sample locs. Useful for crawl planning and AI agent politeness checks. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/robots-sitemap

Expand an iCalendar RFC 5545 RRULE (recurring event rule, as used by Google Calendar, Outlook, CalDAV) into concrete occurrences in any IANA zone, DST-correct, with an English description. Supports FREQ (yearly … secondly), INTERVAL, COUNT, UNTIL, BYMONTH, BYWEEKNO, BYYEARDAY, BYMONTHDAY, BYDAY with ordinals (2MO, -1FR), BYHOUR / BYMINUTE / BYSECOND, BYSETPOS, WKST, plus EXDATE / RDATE and an after / before window. Accepts a bare rule or full DTSTART + RRULE lines. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/rrule-expand

The Rudin-Shapiro bit of n, the parity of the number of overlapping 11 blocks in its binary expansion. n = 3 is 11, so the bit is 1 and the sign is -1. n = 0 is 0. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/rudin-shapiro

The ruler value of n, the exponent of 2 in n. v2(1) is 0, v2(8) is 3, and v2(12) is 2. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ruler

The largest ruler value on 1 through n, and the smallest index where it occurs. That index is the greatest power of 2 that does not exceed n. On 1 through 20 the maximum is 4, at 16. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ruler-max

Remove every factor of 2 from n. The odd part of 12 is 3 and the valuation is 2. The odd part of 7 is 7. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ruler-odd

The ruler values v2(1) through v2(n), written as comma-separated integers. The first 8 values are 0,1,0,2,0,1,0,3. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ruler-prefix

The sum of the ruler values v2(1) through v2(n). It equals n minus the number of 1-bits in n. The sum through 15 is 11. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ruler-sum

Decode and inspect SAML 2.0 messages for SSO debugging: paste a SAMLResponse / SAMLRequest (base64 from an HTTP-POST form, deflated + URL-encoded from an HTTP-Redirect URL, the whole redirect URL, or raw XML) or IdP / SP metadata. Returns the message type, issuer, destination, status, every assertion (NameID and format, subject confirmation, conditions with NotBefore / NotOnOrAfter checked against now, audiences, AuthnContext, session index, attributes), signature placement and algorithms, embedded certificates (subject, expiry, SHA-256 fingerprint) and metadata endpoints. Flags unsigned respo…

Sanctions screening of a person or company NAME against the official consolidated lists: US OFAC SDN + non-SDN, UK Sanctions List (FCDO/OFSI), EU Financial Sanctions Files and the UN Security Council Consolidated List, loaded from the official files (no third-party aggregator). Transliteration-aware fuzzy matching; returns scored matches with list source, programmes/regimes, aliases, dates of birth, countries and listing date, plus each list's publication date. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sanctions-screen

Scam / fraud likelihood for messages, DMs, emails, posts and listings: 16 pattern families (crypto doubling giveaways, seed-phrase and private-key solicitation, wallet-connect / airdrop lures, fake support, guaranteed-return and pig-butchering investment pitches, advance-fee, gift-card / wire / crypto-ATM payment, off-platform WhatsApp / Telegram pushes, job-task scams, credential and OTP requests, recovery scams, urgency and account threats) plus link and text signals (URL shorteners, IP and punycode links, crypto addresses, homoglyph words, invisible characters, shouting). Returns 0-100 scor…

Extract all schema.org structured data from a public page (SSRF-safe fetch) or HTML: JSON-LD (including @graph), microdata (nested itemscope / itemref) and RDFa Lite, normalised to typed items, plus a per-type summary with key facts (product price / currency / availability / rating, article headline / author / dates, breadcrumbs, FAQ questions, events, organisation, recipe) and missing-property warnings for Google rich results. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/schema-org-extract

Validate JSON data against a JSON Schema (Ajv + formats). Body: { "schema": {...}, "data": {...} }. Returns valid boolean and error list. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/schema-validate

The nth large Schröder number. S(0) is 1, S(1) is 2, and S(5) is 394. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/schroder

The nth little Schröder number. It is 1 at n = 0 and half the large Schröder number for n > 0. s(5) is 197. n runs from 0 to 64. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/schroder-little

Institutional holdings from a fund manager's latest SEC 13F-HR: the information table parsed from EDGAR, aggregated by CUSIP (issuer, class, shares, USD value, portfolio weight, put/call, voting authority), with filing period, totals, amendment and recent-filing links. Look up by manager name or CIK, or pin a specific accession. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sec-13f

SEC EDGAR filings search: latest 10-K/10-Q/8-K (or any form) for a company by name, ticker or CIK, with direct document and filing-index links; or full-text search across all EDGAR filings since 2001 (?q=), optionally scoped to one company, form types and a date range. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sec-edgar-search

Normalized financial statements for any SEC filer by ticker or CIK, straight from EDGAR XBRL: revenue, gross profit, operating income, net income, EPS, assets, liabilities, equity, cash, debt, operating cash flow, capex and free cash flow per fiscal year or quarter, with margins, current ratio, leverage, ROE and YoY growth. Handles concept switches (ASC 606) and IFRS 20-F filers; lists the XBRL concepts used. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sec-financials

Insider trading from SEC Form 4: the latest Form 4 filings for a ticker or CIK parsed from EDGAR ownershipDocument XML. Reporting owner and role, every transaction (code + meaning, shares, price, value, acquired/disposed, holdings after, derivative details) and open-market buy/sell totals. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sec-form4

Scan code, config, logs, diffs or prompts for leaked credentials before you commit, share or send them to an LLM: 50+ rules (AWS, GitHub, GitLab, Slack, Stripe, Google, OpenAI, Anthropic, xAI, Hugging Face, npm, PyPI, Twilio, Telegram, Discord, DigitalOcean, Vault, database URLs, JWTs, PEM private keys) plus crypto-wallet secrets (EVM/Solana hex and base58 keys, Solana keypair arrays, checksum-validated Bitcoin WIF, seed phrases) and entropy-checked generic password assignments. Findings carry line/column, severity, entropy and a redacted preview (secrets are never echoed); placeholders and do…

Fetch and validate a site's security.txt (RFC 9116) for vulnerability disclosure: tries /.well-known/security.txt then the legacy /security.txt (SSRF-safe), parses Contact / Expires / Encryption / Policy / Acknowledgments / Preferred-Languages / Canonical / Hiring / CSAF, handles PGP-signed files, and reports RFC errors (missing or expired Expires, non-URI contacts, wrong content type, http links, Canonical mismatch) with days until expiry. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/security-txt

Specificity of one CSS selector, from Selectors Level 4. a is IDs. b is classes, attributes and pseudo-classes. c is elements and pseudo-elements. :is(), :not() and :has() use only the most specific argument. :where() is zero. :nth-child() and :nth-last-child() are one pseudo-class, plus the most specific selector after of. :host() and :host-context() add one pseudo-class plus the argument. ::slotted() adds one pseudo-element plus the argument. ::part() is one pseudo-element. A comma list returns every selector; the top numbers are the most specific, the first on a tie. against compares those …

Semantic versioning toolkit with npm (node-semver) semantics: validate and parse a version, compare two versions, test a range (^, ~, x-ranges, hyphen ranges, || unions, prerelease rules) and show its comparator form, sort a list and pick the max/min version satisfying a range, and bump (major, minor, patch, pre*, prerelease with an identifier). Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/semver

Sentiment analysis with VADER (Hutto & Gilbert 2014; MIT), the lexicon-and-rules model tuned for social media, reviews and short text: compound score (-1..1), positive/neutral/negative proportions and a label, handling negation, intensifiers, ALL-CAPS, "but" contrast, punctuation emphasis, slang, emoticons and emoji. Per-sentence breakdown, or batch up to 50 texts with a summary. Scores match the reference implementation. Offline, English. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sentiment

On-page SEO audit of one URL with a 0-100 score, letter grade and prioritised issues (high/medium/low): title and meta description length, robots meta and X-Robots-Tag noindex, canonical, lang, viewport, charset, favicon, H1/heading outline, image alt coverage, internal/external/nofollow links, OpenGraph and Twitter cards, JSON-LD/microdata types, hreflang, mixed content, word count, plus robots.txt allow/deny for the URL and declared sitemaps. SSRF-safe fetching. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/seo-audit

The sum of the kth powers of the divisors of n. sigma_2(1) is 1, sigma_2(6) is 50, and sigma_2(12) is 210. n runs from 1 to 1000000000000, and k runs from 2 to 12. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sigma-k

The determinant ad-bc of a 2 by 2 integer matrix [a, b, c, d]. The determinant of [1, 1, 0, 1] is 1, and the determinant of [2, 0, 0, 3] is 6. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sl2-det

The inverse of a 2 by 2 integer matrix whose determinant is 1 or -1. The inverse of [1, 1, 0, 1] is [1, -1, 0, 1]. Any other determinant is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sl2-inv

The product of two integer 2 by 2 matrices, each written as [a, b, c, d]. [1, 1, 0, 1] times [1, 0, 1, 1] is [2, 1, 1, 1]. Each entry runs from -1000000 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sl2-mul

The non-negative integer power of a 2 by 2 integer matrix. The exponent 0 is the identity [1, 0, 0, 1]. [1, 1, 0, 1] to the fifth is [1, 5, 0, 1]. [1, 1, 1, 0] to the fifth is [8, 5, 5, 3]. The exponent runs from 0 to 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sl2-pow

The trace a+d of a 2 by 2 integer matrix [a, b, c, d]. The trace of [1, 1, 0, 1] is 2, and the trace of [8, 5, 5, 3] is 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sl2-trace

IPv6 address a host builds for itself from a /64 prefix and a MAC (SLAAC, RFC 4862). The interface id is the modified EUI-64. The prefix must be exactly 64 bits and the low 64 bits of the prefix must be zero. Also returns the link-local address and the solicited-node multicast address. Text is RFC 5952. No zone index and no IPv4 tail. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/slaac-address

Inspect any Solana account: exists or not, SOL balance (lamports), owner program with a readable name, executable flag, data size, rent-exempt minimum and status, and a classification (wallet, token account, mint, program, program data, stake, vote, lookup table, other) with the parsed fields (token amount/mint/owner, mint supply/decimals/authorities, stake delegation...). Public Solana RPC, read-only. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-account

SOL and SPL token balances (classic SPL Token + Token-2022) for a Solana wallet address, via public Solana RPC. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-balance

Solana mainnet status in one call: current slot and block height, epoch with progress % and estimated time to the next epoch, average slot time, total and non-vote TPS from recent performance samples, node software version, total and circulating SOL supply, and the current inflation rate. Public Solana RPC, read-only. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-network

Derive Solana program-derived addresses offline: findProgramAddress (canonical bump search) for any program and typed seeds (utf8, base58 pubkey, hex, u8/u16/u32/u64 little- or big-endian), or the associated token account (ATA) of an owner + mint for SPL Token or Token-2022. Same algorithm as @solana/web3.js (sha256 + ed25519 off-curve check). Useful to locate token accounts, Anchor PDAs and vaults without an RPC. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-pda

Solana priority-fee estimator from getRecentPrioritizationFees (last ~150 slots), globally or for the accounts your transaction writes to: min / p25 / median / p75 / p90 / p95 / max in micro-lamports per compute unit (all slots and non-zero slots), suggested low / medium / high / very-high compute-unit prices, and the resulting fee in lamports and SOL for your compute-unit limit and signature count. Public Solana RPC, read-only. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-priority-fees

Recent transaction signatures that touched a Solana address (wallet, token account, mint or program), newest first, via getSignaturesForAddress: signature, slot, block time and age, success or error, memo and confirmation status, plus a summary (failed count, time span, rough tx/hour). Paginate with before=. Public Solana RPC, read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-signatures

Solana SPL / Token-2022 mint metadata: decimals, total supply, mint & freeze authority, Token-2022 extensions, and name/symbol/uri from on-chain metadata (Token-2022 or Metaplex), with Jupiter token list fallback. Read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-token-meta

Heuristic risk screen for a Solana token mint: mint/freeze authority, Token-2022 extensions (permanent delegate, transfer hook/fee, default-frozen, pausable...), metadata mutability, holder concentration, DEX liquidity and pair age (DexScreener), Jupiter verification. Returns a 0-100 score with itemised flags. Read-only; not a security guarantee. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-token-risk

Fast confirmation check for up to 100 Solana transaction signatures in one call (getSignatureStatuses with history search): found or not, processed / confirmed / finalized, success or the on-chain error, slot and confirmations, plus counts. Built for agents polling payments or swaps they just sent. Public Solana RPC, read-only. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-tx-status

Solana validator set from getVoteAccounts: active and delinquent counts, total active stake, Nakamoto coefficient (fewest validators controlling > 33.3% of stake), the top validators by stake with commission, stake %, last vote, root slot and last-epoch vote credits, or one validator by vote or identity key. Cached 5 minutes. Public Solana RPC, read-only. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sol-validators

Decode a Solana mainnet transaction via public RPC: status, fee, compute units, parsed instructions, inner instructions, account keys, logs. No API key. Unique on Bazaar. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/solana-tx

IPv6 solicited-node multicast address, ff02::1:ffXX:XXXX, from the low 24 bits of an IPv6 address or from the last three octets of a MAC. The U/L flip does not change those 24 bits, so the MAC and its SLAAC address share one solicited-node address. Hex groups only; no zone index. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/solicited-node

The sum of prime factors of n with multiplicity. sopfr(1) is 0, sopfr(12) is 7, and sopfr(36) is 10. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sopfr

Format and lint SQL: consistent keyword case, one clause per line, indented select lists, joins, AND/OR conditions and subqueries, comments and string literals preserved; or minify. The linter flags UPDATE/DELETE without WHERE, SELECT *, implicit comma joins, leading-wildcard LIKE, ORDER BY RAND(), NOT IN with subqueries and string-concatenation injection smells, and lists statement types and referenced tables. POST JSON body {sql}. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sql-format

n divided by its largest square factor. 12 gives 3, 18 gives 2, 36 gives 1, and 45 gives 5. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/square-free-part

Write n = 4^power * odd, with odd not divisible by 4. blocked is true when odd is congruent to 7 mod 8, which is exactly when n is not a sum of three squares. 7 and 28 are blocked. 6 is not. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/square-obstruction

The largest square dividing n. 1 gives 1, 8 gives 4, 12 gives 4, and 18 gives 9. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/square-part

Whether n is squarefree, together with its radical. 1 and 30 are squarefree. 4 and 12 are not. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/squarefree

Inspect SSH public keys and OpenSSH certificates from authorized_keys, known_hosts, .pub, RFC 4716 or PEM input: key type, size / curve, SHA256 and MD5 fingerprints exactly as ssh-keygen prints them, comment and authorized_keys options, FIDO / hardware-backed keys, duplicate detection and a strength verdict (DSA and short RSA flagged); certificates are decoded (user/host, key ID, principals, validity, critical options, extensions, signing CA fingerprint). PEM public keys are converted to OpenSSH format. Private keys are refused. Price: $0.002 USDC per successful call (x402, Solana). Same tool …

abuse.ch SSL Blacklist (SSLBL): check whether a TLS certificate SHA1 fingerprint is blacklisted as malware / botnet C&C infrastructure (listing date and reason, e.g. "QuasarRAT C&C"), check an IP against the SSLBL botnet C2 IP list, or list the most recent blacklisted certificates filtered by reason. Several thousand certificates; CC0, commercial use allowed. Cached locally, refreshed every 30 minutes. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ssl-blacklist

Inspect a live TLS certificate: subject, issuer, SANs, validity window, days to expiry, SHA-256 fingerprint, key type/size, full presented chain, negotiated TLS version/cipher, chain trust and RFC 6125 hostname match. Implicit-TLS ports 443/465/587/636/853/993/995/5223/8443. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ssl-cert-info

The number of ways to place n identical items into k distinct bins, which is C(n+k-1, n). Three items in two bins can be placed in 4 ways. n runs from 0 to 1024 and k runs from 1 to 1024. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stars-bars

Descriptive statistics for one or many numeric series: count / missing, mean, median, mode, range, sample and population variance / SD, standard error, CV, skewness and excess kurtosis (Excel SKEW / KURT), quartiles, IQR, any percentiles (numpy / PERCENTILE.INC), MAD, geometric and harmonic means, a t confidence interval, Tukey outliers and a histogram (numpy "auto" bins). Several named series also get Pearson and Spearman correlation matrices. Accepts numbers, numeric strings, nulls / "NA" (missing) or objects plus a field name. Price: $0.002 USDC per successful call (x402, Solana). Same tool…

Stern's diatomic sequence. s(0) is 0, s(1) is 1, even terms repeat s(n/2), and an odd term is the sum of its two neighbors in the previous row. An optional modulus reduces the term; zero is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stern

The signed Stirling number of the first kind s(n, k). s(4, 2) is 11 and s(5, 2) is -50. s(n, 0) is 0 for n > 0. n runs from 0 to 64, and k must not pass n. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling1

One step of s(n, k) = s(n-1, k-1) - (n-1)*s(n-1, k). For n = 5 and k = 2, the previous term is -6, the scaled term is 44, and the value is -50. n runs from 1 to 64 and k from 1 to n. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling1-rec

Row n of the signed Stirling numbers of the first kind, from s(n, 0) through s(n, n). The absolute values sum to n!. Row 4 is 0, -6, 11, -6, 1. n runs from 0 to 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling1-row

The unsigned Stirling number of the first kind, the absolute value of s(n, k). It counts permutations of n with k cycles. c(5, 2) is 50 and c(5, 1) is 24. n runs from 0 to 64. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling1-unsigned

The Stirling number of the second kind S(n,k), the number of ways to partition n objects into k nonempty unlabeled sets. S(5,2) is 15. S(n,k) is 0 when k is greater than n. n and k run from 0 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling2

The Stirling recurrence S(n,k) = k*S(n-1,k) + S(n-1,k-1). term is the first summand and diag is the second. n and k run from 1 to 80. Past 15 digits a part is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling2-rec

Row n of Stirling numbers of the second kind, from S(n,0) through S(n,n), plus the Bell number that sums the row. n runs from 0 to 80. Past 15 digits an entry is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/stirling2-row

Convert identifiers and phrases between naming conventions: camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case (small words kept lower), Sentence case, plus URL slugs with accent transliteration. Smart word splitting handles acronyms (HTTPServerError), digits and mixed separators. Up to 100 strings. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/string-case

The subfactorial !n, the number of derangements of n objects. !0 is 1, !1 is 0, !2 is 1, and !5 is 44. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/subfactorial

Extractive summary with TextRank (Mihalcea & Tarau 2004): sentences are split (abbreviation / initial / decimal aware), linked by stemmed content-word overlap, ranked with PageRank, and the top N are returned in original order. No LLM, no hallucination: every summary sentence is verbatim from the input, with its index, score and offset. Choose a sentence count or a ratio. Offline, deterministic; 200 KB input. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/summarize-extractive

Sunrise, sunset, solar noon, day length, civil / nautical / astronomical twilight, golden hour and blue hour for any place and date (NOAA solar calculator equations, about a minute of accuracy), with polar day / night handling, observer elevation correction and local times in any IANA zone. Optionally the sun's azimuth and elevation (refraction-corrected) at a given moment. Offline. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/sun-times

The nth Sylvester number. s(0) is 2, and each later term is s*(s-1)+1. A negative index is rejected. n runs up to 8. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/sylvester

The nth tangent number. T1 is 1, T2 is 2, T3 is 16, and T4 is 272. It is read from the Bernoulli number B(2n). n runs from 1 to 20. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tangent-number

Lightweight technology fingerprint from public HTML/headers: CMS, frameworks (Next/Nuxt/React/Vue), CDNs, analytics, payments, generator meta, script/stylesheet samples. No invasive probing. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/tech-stack

Technical analysis on a price series you supply: SMA, EMA, RSI (Wilder), MACD (line, signal, histogram), Bollinger Bands (%B, bandwidth), ATR, Stochastic %K/%D, OBV, VWAP and rate of change, with latest values, optional recent series and plain signals (overbought/oversold, MACD cross, trend vs moving average). Closes only, or OHLCV candles. POST JSON body. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/technical-indicators

The nth Tetranacci number. T0, T1, and T2 are 0, T3 is 1, and each later term is the sum of the previous four. T(10) is 56. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tetranacci

The smallest index n with T(n) equal to value. 0 is index 0, and 1 is index 3. A number that is not a Tetranacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tetranacci-index

T(n) mod m for the Tetranacci sequence. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tetranacci-mod

The Tetranacci step T(n) = T(n-1) + T(n-2) + T(n-3) + T(n-4). a is T(n-4), b is T(n-3), c is T(n-2), and d is T(n-1). n runs from 4 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tetranacci-step

The sum of Tetranacci numbers from lo through hi inclusive. The sum from T0 through T10 is 116. lo must not pass hi. Each index runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tetranacci-sum

Wrap a Helvetica block and give its height. Line breaking is the same as text-wrap. Leading defaults to 1.2 times the font size, rounded half away from zero to 0.001 pt. Block height is the line count times the leading, and a blank line from a hard break counts. An empty string has height zero. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/text-block

Split text into retrieval-ready chunks for RAG and embeddings: recursive (paragraph > line > sentence > clause > word), markdown-aware (splits on headings, keeps the heading path per chunk, respects code fences), sentence, or fixed windows; sized in estimated tokens or characters with overlap. Returns each chunk with Unicode start/end offsets, character and token estimates, plus totals. Deterministic and offline; 200 KB input. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/text-chunk

Clean and normalise messy text before embedding, indexing or prompting: repairs mojibake (UTF-8 read as Windows-1252), strips control and invisible characters (zero-width, bidi overrides used in Trojan Source attacks, soft hyphens, BOM), normalises exotic whitespace, curly quotes, dashes, ligatures and full-width forms, re-joins words hyphenated across line breaks, optionally unwraps hard-wrapped lines, strips HTML, decodes entities, removes emoji / URLs / emails, transliterates to ASCII or lowercases. Reports how many fixes of each kind were made. Offline; 500 KB. Price: $0.001 USDC per succe…

Diff two texts: unified line diff byte-compatible with GNU diff -u (hunks, context, "No newline at end of file"), or word-level / character-level diff with [-removed-]{+added+} inline markup and merged ops. Myers shortest edit script with a patience fallback for very different inputs; options to ignore whitespace, case and CRLF/LF. Returns added/removed/unchanged counts and a similarity ratio. Offline; 20,000 lines or tokens per text. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/text-diff

Cut one Helvetica line so it fits a width, ending with an ellipsis (…) when the text is too long. The ellipsis is the WinAnsi character. If the whole line already fits, it is returned unchanged. If even the ellipsis is wider than the measure, the call is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/text-ellipsis

Largest Helvetica size, on a fixed step, at which one line still fits a width. Sizes run from minSize to maxSize in steps (defaults 6, 72 and 0.5 points). Empty text fits at maxSize. If the line does not fit at minSize, the call is rejected. Width uses the same AFM rounding as text-width, so the size is not a float division of the two widths. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/text-fit

Document similarity and near-duplicate detection: compare two texts (a, b) or cluster up to 200 texts. Metrics: TF-IDF cosine on stemmed content words, word Jaccard, k-word shingle Jaccard and containment, 64-bit SimHash with Hamming distance, and character edit ratio for short texts, plus a verdict (identical / near-duplicate / similar / related / different). Batch mode returns the most similar pairs and duplicate clusters. Offline, deterministic. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/text-similarity

Text statistics: characters, words, unique words, sentences, paragraphs, reading/speaking time, Flesch readability (English), language detection (27 languages/scripts), top keywords. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/text-stats

Width of one line in Helvetica or Helvetica-Bold, in points. Glyph widths are the Adobe standard-14 AFM numbers in WinAnsi (the same numbers ReportLab ships). The width is the sum times the font size, rounded half away from zero to 0.001 pt. Characters outside that encoding, and control characters, are rejected. A newline belongs in text-wrap. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/text-width

Wrap text to a measure in Helvetica or Helvetica-Bold. Hard breaks are LF, CR, or CRLF. Inside a paragraph, spaces collapse to one and leading and trailing spaces are dropped. A word moves to the next line when it does not fit. A word wider than the whole measure breaks between characters, and those lines are marked broken. The width of each line uses the same AFM rounding as text-width. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/text-wrap

Whether n is a sum of three integer squares, and one nonnegative witness x <= y <= z when it is. It is impossible exactly when n = 4^power * odd with odd congruent to 7 mod 8. 3 is 1, 1, 1. 7 is impossible. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/three-squares

Find a cube in a 0/1 string, a block xxx. 000 is a cube at index 0 of length 1. A Thue-Morse prefix has no cube. An empty string or a character other than 0 or 1 is rejected. The string stops at 512 characters. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/thue-cube

The nth Thue-Morse bit, the parity of the number of 1-bits in n. t(0) is 0, t(1) is 1, and t(2) is 1. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/thue-morse

The first n Thue-Morse bits as a string of 0 and 1. The first 8 bits are 01101001. n runs from 1 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/thue-prefix

The number of 1-bits in the Thue-Morse sequence from lo through hi inclusive. The sum from t(0) through t(7) is 4. lo must not pass hi. Each index runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/thue-sum

The number of 1s in t(0) through t(n), and the bit t(n) itself. Through n = 7 the weight is 4. n runs from 0 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/thue-weight

Resolve a stock ticker (or CIK) to the SEC CIK, registrant name, exchange and sibling share classes from SEC EDGAR's company_tickers_exchange list, plus the issuer's Legal Entity Identifier (LEI) from GLEIF matched by normalised legal name, with match confidence, registration status, jurisdiction and alternatives. BRK.B / BRK-B forms accepted. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/ticker-resolver

Add a signed frame count to a timecode and stay inside the same day. A result before midnight or at the next midnight is rejected. The semicolon, if present, keeps the result in drop-frame. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timecode-add

How many frames from one timecode to another, at the same rate. Positive means to is later. Both codes use a colon, or both use a semicolon. Mixing drop-frame with non-drop is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timecode-diff

Exact length of a frame count. 24, 25 and non-drop 30 use 1/rate second per frame. Drop-frame 30 uses the NTSC frame, 1001/30000 second. Pass a timecode or a frame count, not both. The semicolon selects drop-frame when you pass a code. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timecode-duration

Count the frames in an SMPTE timecode from midnight. Rates are 24, 25 and 30. A colon is non-drop and a semicolon is drop-frame, which is only legal at 30. Drop-frame skips 00 and 01 at the start of each minute except every tenth minute, so 01:00:00;00 is frame 107892 rather than 108000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timecode-frames

Convert any timestamp: auto-detects Unix seconds / milliseconds / microseconds / nanoseconds, ISO 8601 / RFC 3339, RFC 2822, HTTP dates, Excel serial dates and "now", and returns all of them plus local time in any IANA time zone, ISO week, day of year, Julian day, a relative "3 days ago" phrase and Snowflake-style IDs decoding (Discord/Twitter) when asked. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timestamp-convert

Convert a time between IANA time zones with DST awareness: local time, UTC offset, abbreviation and DST flag on both sides, the offset difference and day shift, and each zone's next DST/offset transition (when, which way, how much). Flags nonexistent (spring-forward gap) and ambiguous (fall-back) wall times. Accepts ISO 8601, HH:MM, epoch seconds/milliseconds or "now"; up to 10 target zones. Offline (PHP's bundled tz database). Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/timezone-convert

Exact (string-math, no floating point) conversion between human token amounts and on-chain base units: wei / gwei / ether, lamports / SOL, sats / BTC, USDC/USDT (6 decimals) or any token with a decimals value. Returns the converted amount, the integer base units (decimal and hex) and every unit of the family. Accepts decimals, scientific notation and 0x-hex raw amounts. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/token-units

Euler totient phi(n), the count of integers from 1 to n that are coprime to n. phi(1) is 1. n = 0 is rejected. n runs up to 10^12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/totient

TOTP / HOTP two-factor codes (RFC 6238 / 4226), compatible with Google Authenticator, Authy, 1Password and pyotp: generate the current code (plus previous / next and seconds remaining), verify a code with a drift window, create a new base32 secret with its otpauth:// URI for QR enrolment, or parse an otpauth URI. SHA1 / SHA256 / SHA512, 6–8 digits, any period; set time for reproducible results or counter for HOTP. POST so secrets never appear in URLs; secrets are not stored. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/t…

US Treasury rates: the daily par yield curve (1M-30Y, from treasury.gov) with day-over-day change in bp, 2s10s spread and 3m10y inversion flag, optional TIPS real yield curve, plus Debt to the Penny (total public debt, debt held by the public, intragovernmental holdings) from the Fiscal Data API. Latest by default or as of a past date. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/treasury-rates

Classify a strict integer triangle. sides is equilateral, isosceles, or scalene. angles is acute, right, or obtuse, from comparing the squares of the sides. A degenerate triple is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/triangle-shape

The smallest index n with T(n) equal to value. 0 is index 0, and 1 is index 2. A number that is not a Tribonacci term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/trib-index

T(n) mod m. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 4096. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/trib-mod

The Tribonacci step T(n) = T(n-1) + T(n-2) + T(n-3). left is T(n-3), mid is T(n-2), and right is T(n-1). n runs from 3 to 4096. Past 15 digits a term is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/trib-step

The sum of Tribonacci numbers from lo through hi inclusive. The sum from T0 through T10 is 177. lo must not pass hi. Each index runs from 0 to 4096. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/trib-sum

The nth Tribonacci number. T0 and T1 are 0, T2 is 1, and each later term is the sum of the previous three. An optional modulus reduces the term, and zero is rejected. n runs from 0 to 4096. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/tribonacci

How many integer pairs (x, y), counting order and signs, satisfy x^2 + y^2 = n. There is 1 for 0, 4 for 1, and 8 for 5. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/two-squares

Nonnegative integers x and y with x <= y and x^2 + y^2 = n, choosing the greatest y. 5 is 1 and 2. 25 is 0 and 5. A number that is not a sum of two squares is rejected. n runs from 0 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/two-squares-pair

Mode of a file or directory created under a umask. A file starts from 666 and a directory from 777, then the umask bits are cleared. 022 makes a file 644 and a directory 755. masked lists the bits the umask turns off. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/umask-mode

Unit conversion across 14 categories with exact defined factors: length, mass, volume (US and imperial), area, speed, time, data (SI kB vs IEC KiB, bits vs bytes), pressure, energy, power, angle, frequency, temperature (C, F, K, Rankine) and fuel economy (mpg US/UK, L/100 km, km/L). Common names and abbreviations accepted; optionally lists the value in every unit of the category. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/unit-convert

SaaS / subscription unit economics: customer lifetime value (margin-adjusted), LTV:CAC ratio, CAC payback months, average lifetime, MRR/ARR, break-even customer count and cash runway, with health ratings against common benchmarks (LTV:CAC >= 3, payback <= 12 months). For startups, API businesses and agent services. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/unit-economics

The reduced sum of unit fractions 1/d. Dens must be positive. An empty list or a non-positive denominator is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/unit-sum

How many unitary divisors n has. The count is 2 to the number of distinct prime factors, and 1 has one unitary divisor. 7 has 2, 12 has 4, and 30 has 8. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/unitary-count

The sum of the unitary divisors of n. A unitary divisor shares no prime factor with the complementary divisor. The sum is 1 for 1, 12 for 6, 20 for 12, and 72 for 30. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/unitary-sigma

Extract every link on a page as absolute URLs (RFC 3986 resolution, <base href> aware), classified internal/external/other with anchor text, rel and nofollow. Options: filter, dedupe, max_links. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/url-links-extract

Fetch a public HTML page and convert main/article content to Markdown (Turndown). Scripts/styles stripped; output capped. Good for RAG/agent ingestion. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/url-markdown

Parse, normalize and clean URLs offline: scheme, credentials (redacted), host type, port, path segments, decoded query parameters and fragment; registrable domain / subdomain / public suffix; IDN to punycode and back; RFC 3986 normalization (case, default ports, dot segments, percent-encoding) plus optional removal of known click-tracking parameters (utm_*, gclid, fbclid, msclkid, _hsenc, mc_eid...), query sorting and fragment stripping; flags URL shorteners. Up to 50 URLs. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/url…

US macro dashboard from BLS in one call: CPI and core CPI, unemployment, nonfarm payrolls, hourly earnings, participation, PPI and JOLTS openings. Latest value, month, MoM / YoY change and 13-month history. Includes BLS retrieval date and disclaimer. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/us-macro

Federal contracts, IDVs, grants, loans and direct payments from USAspending.gov by recipient, awarding agency (name or abbreviation such as DOD, NASA, HHS), NAICS code or keyword, for a date range (default last 12 months). Returns the top awards by amount or start date with award id, recipient and UEI, amount, outlays, dates, agency and sub-agency, award type, NAICS/PSC and a link, plus the total matching award count. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/usaspending-awards

Parse User-Agent strings: browser and version, rendering engine, OS and version, device type (mobile, tablet, desktop, TV, console, bot) with vendor/model, and bot detection that names 100+ crawlers and HTTP clients by operator and category, including AI crawlers and AI assistants (GPTBot, ClaudeBot, PerplexityBot, Bytespider, CCBot, meta-externalagent...), search, social, SEO and monitoring bots and scripted clients (curl, python-requests, headless Chrome). Up to 50 UAs per call. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402…

Offline format validator for up to 100 values: email, URL, IPv4/IPv6, domain, UUID (version/variant), credit card (Luhn + brand, number masked in output), IBAN (mod-97 + country length), phone (E.164), JSON, base64/base64url. POST JSON body only (never in the URL): single {"type","value"} or batch {"items":[{"type","value"},...]}. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/validate-batch

The Vandermonde convolution. The sum of C(m, k)*C(n, r-k) equals C(m+n, r). For m = 3, n = 3, and r = 2 the value is 15. m and n run from 0 to 256, and r must not pass m+n. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/vandermonde

Decode a 17-character Vehicle Identification Number: offline structure check (allowed characters, ISO 3779 check digit, region and WMI, model-year code) plus NHTSA vPIC decoding (make, model, model year, trim, body class, vehicle type, doors, drive type, engine cylinders/displacement/fuel, transmission, manufacturer, plant city/country, GVWR, safety equipment) and optional open NHTSA safety recalls for that make/model/year. Public US government data. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/vin-decode

Unloaded voltage divider. r1 is the top resistor, from the supply to the output. r2 is the bottom resistor, from the output to ground. Returns the output voltage, the string current, and the power in each resistor as exact rationals. Both resistors must be positive. A zero supply gives zero output, zero current and zero power. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/voltage-divider

The von Staudt-Clausen integer. For even m at least 2, B(m) plus the sum of 1/p over primes p with p-1 dividing m is an integer. For m = 2, 4, 6, and 10 that integer is 1. An odd m is rejected. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/von-staudt

Gross pay in exact cents. Hourly: regular hours at the rate, overtime hours at a multiplier (default 1.5) and double-time hours at a multiplier (default 2). Weekly: hours above the threshold (default 40) are overtime. Salary: the annual amount is split across 52, 26, 24 or 12 periods so the paychecks add back to the annual amount. Extra straight-time hours are paid at annual / 2080 (52 × 40). Overtime and double-time hours use that same base rate times their multipliers. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/wage-c…

Basic heuristic risk screen for a Solana or EVM (Ethereum/Base/Arbitrum) wallet: activity & age, bundled OFAC-SDN / mixer list matches for the address and recent counterparties, and (EVM) live token-approval exposure (unlimited allowances, approvals to EOAs or flagged spenders). Read-only; heuristic only, not a compliance determination or security guarantee. Price: $0.02 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/wallet-risk-basic

Check Internet Archive Wayback Machine availability for a URL (closest snapshot timestamp + archived URL). Public availability API. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/wayback

Worldwide weather forecast for any latitude/longitude from MET Norway Locationforecast 2.0 (the Norwegian Meteorological Institute; CC BY 4.0): current conditions (temperature, humidity, wind speed and direction, pressure, cloud cover, next-hour precipitation, condition text) and up to 9 daily summaries (min/max, precipitation total, max wind, dominant condition), optional hourly series, metric or imperial units, local-time grouping by any IANA zone. Cached per MET Norway Expires headers. Use /v1/weather-nws for US NWS alerts. Price: $0.005 USDC per successful call (x402, Solana). Same tool ov…

US weather from the National Weather Service for a latitude/longitude: 7-day (or hourly) forecast periods with temperature, precipitation chance, wind and text forecast, plus all active NWS watches, warnings and advisories for that point. US states, territories and coastal waters only. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/weather-nws

Fetch a public web page and return its main content as clean plain text (boilerplate stripped, lists as bullets, tables tab-separated) plus title, description, language, word count. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/web-to-text

Verify (or create) webhook signatures for Stripe, GitHub, Slack, Shopify, Twilio, Standard Webhooks / Svix, Paddle, Square, Zoom, Mailgun, Intercom, Linear, Typeform and HubSpot v3, or any generic HMAC scheme — the step agents get wrong when wiring up webhook receivers. Pass the raw body, the received headers (or just the signature) and the signing secret: returns valid, the timestamp age against a replay tolerance, and on failure a diagnosis (body re-serialised or trimmed, wrong secret format, hex vs base64, stale timestamp). mode=sign produces the exact headers a provider would send, for tes…

The nth Wedderburn-Etherington number. a(1) is 1, and a(1) through a(6) are 1, 1, 1, 2, 3, 6. Even and odd indices use the binary-tree split, with the middle term only on an even index. n runs from 1 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wedderburn

The smallest index n with Wedderburn-Etherington number a(n) equal to value. 1 is index 1, and 6 is index 6. A number that is not a term, or a leading zero, is rejected. value is a decimal integer of at most 600 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wedderburn-index

a(n) mod m for the Wedderburn-Etherington numbers. The modulus is a positive decimal integer, and zero is rejected. n runs from 1 to 80. The residue is smaller than the modulus. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wedderburn-mod

The Wedderburn-Etherington split of n. cross is the sum of a(i)*a(n-i) over the pairs below the middle, and middle is a(k)*(a(k)+1)/2 when n = 2k and 0 when n is odd. n = 6 gives cross 5, middle 1, and value 6. n runs from 1 to 80. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wedderburn-split

The sum of Wedderburn-Etherington numbers from lo through hi inclusive. The sum from a(1) through a(6) is 14. lo must not pass hi. Each index runs from 1 to 80. Past 15 digits the value is a decimal string. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wedderburn-sum

Wikipedia in one call: search any of 340+ language editions (titles, descriptions, snippets, thumbnails) and get the top hit's summary, or fetch a summary by exact title. Returns title, short description, lead extract, canonical URL, thumbnail/lead image, Wikidata id, coordinates and last-modified, with the CC BY-SA attribution block. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/wikipedia

The nth lower Wythoff number, floor(n*phi), where phi is (1+sqrt(5))/2. A(1) is 1, A(2) is 3, and A(5) is 8. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wythoff

Which Wythoff sequence contains m, and at which index. 1 is the lower number at index 1. 2 is the upper number at index 1. Every positive integer is in exactly one sequence. m runs from 1 to 1600000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wythoff-inverse

The nth Wythoff pair. lower is floor(n*phi) and upper is lower+n. The pair for n = 1 is 1 and 2. The pair for n = 5 is 8 and 13. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wythoff-pair

The nth upper Wythoff number, floor(n*phi^2), which is A(n)+n. B(1) is 2, B(2) is 5, and B(5) is 13. n runs from 1 to 1000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/wythoff-upper

x402 preflight for AI agents: inspect any paid endpoint BEFORE paying. Fetches the unpaid 402, decodes PAYMENT-REQUIRED (v2 header or v1 body), normalises price to USD, lists networks/assets/payTo/feePayer, validates the offer and Bazaar discovery schema, checks PayAI and Coinbase CDP discovery listing, and returns an OK/RISKY/BROKEN verdict. Never pays the target. Price: $0.005 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/x402-probe

Decode PEM/DER X.509 certificates, chains and CSRs offline: subject/issuer DN, serial, validity and days left, SANs, key type/size/curve, signature algorithm, key usage / EKU / basic constraints, AKI/SKI, OCSP / CA-issuer / CRL URLs, policies and embedded SCT count, SHA-1/SHA-256 fingerprints and SPKI pin; verifies each chain link signature and order, flags self-signed, expired / expiring, weak keys, SHA-1 signatures and over-long lifetimes, and checks hostname coverage (RFC 6125 wildcards). Private keys are refused. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: …

Run XPath 1.0 queries over XML you supply (RSS/Atom, SOAP, sitemaps, SVG, config) or over HTML for scraping: returns matched elements/attributes/text with their paths, text, attributes and outer markup, or the number/string/boolean result of an expression. Namespaces are auto-registered (default namespace as prefix d). Safe parser: no network, no external entities, DTD entities rejected. POST JSON body {xml or html, xpath}. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/xml-xpath

The Zeckendorf representation of n. Fibonacci numbers start F1 = 1, F2 = 1, F3 = 2, and no two used indices are consecutive. 4 is F4 + F2, and 100 is F11 + F6 + F4. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/zeckendorf

The Zeckendorf bit string of n, from the largest used Fibonacci index down to F2. The bit string of 1 is 1, of 4 is 101, and of 100 is 1000010100. n runs from 1 to 1000000000000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/zeckendorf-bits

Sum Fibonacci numbers by index, using F1 = 1 and F2 = 1. Indices must be at least 2 and no two may be consecutive. Indices 11, 6, and 4 sum to 100. An empty list is rejected. At most 64 indices, each at most 512. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/zeckendorf-sum