ScorpTech x402 API

Build EVM calldata offline: function selector + ABI-encoded arguments from a human signature such as transfer(address,uint256) or exactInputSingle((address,address,uint24,address,uint256,uint256,uint160)). Tuples/structs, fixed and dynamic arrays, bytes, strings and signed ints supported. mode=params gives abi.encode without a selector, mode=packed gives abi.encodePacked plus its keccak256 (as used for hashes and signatures). Returns hex, 32-byte words and length. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/abi-encode

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

The abundancy sigma(n)/n as a reduced fraction. 1 is 1/1, 4 is 7/4, 6 is 2/1, and 12 is 7/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/abundancy

Whether n is an Achilles number: powerful, but not a perfect power. 72 and 108 are Achilles. 36 is a square, and 1 is a perfect power, so neither is Achilles. 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/achilles

Additive persistence: how many times the decimal digits of n must be summed to reach a single digit, and that digit. 199 takes 3 steps and ends at 1. A single digit takes 0 steps. 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/additive-persistence

US airport delay status from the FAA NAS Status feed (ground delay programs, ground stops, closures, arrival/departure delays) plus OurAirports metadata (name, city, ICAO/IATA, lat/lon). Pass ?airport=SFO (IATA) or KSFO (ICAO), or omit for a nationwide overview. Public-domain sources. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/airport-status

The aliquot part of n, the sum of proper divisors. The aliquot part of 1 is 0, of 9 is 4, and of 6 is 6. n runs from 1 to 1000000000000. 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/aliquot

Whether sigma(n) = 2*n - 1. Powers of two, including 1, are almost perfect. 16 gives sigma 31. 6 and 10 are not. 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/almost-perfect

The alternating factorial a(n) = n! - a(n-1), with a(1) = 1. a(3) is 5, a(4) is 19, a(5) is 101, a(6) is 619, and a(8) is 35899. n runs from 1 to 18. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/alternating-factorial

The alternating factorial a(n) modulo m. a(5) mod 10 is 1, a(6) mod 100 is 19, and a(4) mod 5 is 4. n runs from 1 to 18 and m 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/alternating-mod

The smallest m at least n, and at most 12, whose alternating factorial is prime. 1 gives 3, 3 stays 3, and 9 gives 10. If none remains through 12, the input is rejected. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/alternating-next

Whether the alternating factorial a(n) is prime. It is for 3, 4, 5, 6, 7, 8, and 10. It is not for 1, 2, 9, or 12. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/alternating-prime

The sum of the alternating factorials from 1 through n. Through 1 it is 1, through 3 it is 7, through 5 it is 127, through 6 it is 746, and through 8 it is 41066. n runs from 1 to 18. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/alternating-sum

The alternating factorial af(n) = n! - (n-1)! + (n-2)! - ... ending at 1. af(1) is 1, af(3) is 5, and af(4) is 19. n runs from 1 to 200. 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/alt-factorial

The sum of alternating factorials from lo through hi inclusive. The sum from af(1) through af(5) is 127. lo must not pass hi. Each index runs from 1 to 200. 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/alt-sum

Whether n is amicable, and its partner when it is. The partner of 220 is 284, and the partner of 284 is 220. A perfect number such as 6 is not amicable, and then the partner is 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/amicable

The Apery number A(n), the sum of C(n,k)^2 * C(n+k,k)^2 for k from 0 to n. A(0) is 1, A(1) is 5, A(2) is 73, A(3) is 1445, and A(5) is 819005. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/apery

A(n) modulo m. A(1) mod 2 is 1, A(5) mod 10 is 5, and A(8) mod 1000 is 425. n runs from 0 to 11 and m 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/apery-mod

Whether the Apery number A(n) is prime. A(1) and A(2) are prime. A(0), A(3), A(5), and A(8) are not. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/apery-prime

The sum of the Apery numbers A(0) through A(n). Through 0 it is 1, through 2 it is 79, and through 5 it is 853530. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/apery-sum

One summand of the Apery number, C(n,k)^2 * C(n+k,k)^2. The k=1 summand of A(2) is 36 and the k=0 summand is 1. A k past n is 0. n and k run from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/apery-term

How many arithmetic numbers are at most n. Through 1 there is 1, through 2 there is 1, through 6 there are 4, through 15 there are 9, and through 20 there are 12. n 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/arithmetic-count

The arithmetic derivative of n. 0 and 1 give 0, a prime gives 1, 4 gives 4, 6 gives 5, 8 gives 12, and 12 gives 16. 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/arithmetic-derivative

The average of the divisors of n, when that average is an integer. 1 gives 1, 3 gives 2, 6 gives 3, 7 gives 4, 15 gives 6, and 20 gives 7. A non-integer average is rejected. 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/arithmetic-mean

The smallest arithmetic number that is at least n. 1 stays 1, 2 gives 3, 4 gives 5, 8 gives 11, and 13 stays 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/arithmetic-next

Whether the average of the divisors of n is an integer. 1, 3, 6, 15, and 20 are. 2, 4, 8, and 12 are not. 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/arithmetic-number

The second arithmetic derivative of n. 6 goes 5 then 1. 8 goes 12 then 16. 4 stays 4. 0 and 1 stay 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/arithmetic-second

The sum of the arithmetic numbers that are at most n. Through 1 it is 1, through 6 it is 15, through 15 it is 75, and through 20 it is 131. n 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/arithmetic-sum

Search arXiv papers: title, authors, full abstract, categories, dates, DOI/journal ref and direct abs + PDF links. Plain keywords or arXiv field syntax (ti:, au:, abs:, cat:, AND/OR), optional category filter and sort by relevance or date. Price: $0.01 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/arxiv-search

Whether n^2 ends with n. 1, 5, 6, 25, 76, 376, 625, and 9376 do. 10 does not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/automorphic

Whether n is prime and equal to the average of the previous prime and the next prime. 5, 53, 157, and 1103 are. 2, 3, 7, and 11 are not. n 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/balanced-prime

The balanced ternary digits of n. -1 is written as T. 0 is "0", 2 is "1T", 4 is "11", 5 is "1TT", and 6 is "1T0". 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/balanced-ternary

The ballot number B(n, k) = (n-k+1)/(n+1) * binom(n+k, k), for 0 <= k <= n. B(n, n) is the nth Catalan number. k above n is rejected. Both indexes run up to 2048. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/ballot

Validate bank routing identifiers offline (IBAN is covered by /v1/iban-validate): US ABA routing numbers (3-7-1 checksum, Federal Reserve district, thrift / electronic ranges), SWIFT / BIC (bank, ISO country, location, branch, test and passive BICs), Mexican CLABE (checksum, bank, plaza), Argentine CBU (both check digits), Canadian routing numbers (EFT 0YYYXXXXX and MICR XXXXX-YYY, institution names), UK sort codes, Australian BSB (bank and state) and Indian IFSC (bank). Auto-detects the type from the format. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/bank-id-validate

Generate a 1D barcode as SVG (plus base64 data URI and the raw module pattern): Code 128 (any ASCII, automatic A / B / C subset switching for the shortest symbol), GS1-128 shipping / logistics labels from "(01)…(17)…(10)…" application identifiers (FNC1 separators, SSCC / GTIN check digits verified), EAN-13, EAN-8, UPC-A and ITF-14 (check digit computed when omitted, verified when given) and Code 39 (optional mod-43 check). Options: module width, bar height, quiet zone, human-readable text, colours. For product labels, shipping cartons, inventory and tickets. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/barcode-generate

Convert an integer from one base to another. Bases run from 2 to 36, and letters may be any case. A digit that is not valid in the source base is rejected. The result is the digit string in the target base. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/base-convert

The Baum-Sweet bit of n. It is 1 when every run of 0s in the binary expansion has even length, and 0 when some run of 0s has odd length. b(0) is 1 and b(2) 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/baum-sweet

The Beatty term floor(nsqrt(d)). floor(5sqrt(2)) is 7, and floor(2*sqrt(3)) is 3. n runs from 0 to 1000000 and d 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/beatty

floor(n*sqrt(2)). n=1 gives 1, n=2 gives 2, n=3 gives 4, n=5 gives 7, and n=10 gives 14. 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/beatty-sqrt2

The Beatty complement of sqrt(2), floor(n*(2+sqrt(2))). n=1 gives 3, n=2 gives 6, n=3 gives 10, and n=5 gives 17. 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/beatty-sqrt2-comp

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

Whether n and m are betrothed: the sum of proper divisors of n is m+1, and the sum for m is n+1, with m different from n. 48 pairs with 75, and 140 pairs with 195. The partner is 0 when n is not betrothed. 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/betrothed

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 sum of the binary partition numbers from b(0) through b(n). Through 0 it is 1, through 4 it is 10, through 10 it is 60, and through 20 it is 390. 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-sum

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

The bit length of n: 0 for 0, and one more than the position of the highest 1 bit otherwise. 1 has length 1, 255 has length 8, and 256 has length 9. 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/bit-length

Reverse the lowest width bits of n. 13 reversed in width 4 is 11. 1 reversed in width 8 is 128. n must be smaller than 2^width. width runs from 1 to 62, and 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/bit-reverse

Whether every 1 bit of a is also a 1 bit of b. 3 is a bit-subset of 7. 3 is not a bit-subset of 5. 0 is a bit-subset of 0. Both run 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/bit-subset

Whether the bi-unitary divisors of n sum to more than 2n. 24 and 48 do. 6, 16, and 36 do not. 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/biunitary-abundant

How many bi-unitary divisors n has. 1 has 1, 4 and 9 have 2, 8 has 4, and 16 has 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/biunitary-count

Whether the bi-unitary divisors of n sum to less than 2n. 1, 16, and 36 do. 6, 24, and 48 do not. 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/biunitary-deficient

Whether the bi-unitary divisors of n sum to 2n. 6, 60, and 90 do. 16, 24, 36, and 48 do not. 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/biunitary-perfect

The sum of the bi-unitary divisors of n. For a prime power p^e the exponents run from 0 through e, skipping the middle one when e is even. 6 gives 12, 16 gives 27, 36 gives 50, and 48 gives 108. 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/biunitary-sigma

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

Whether n is a product of two distinct primes that are both 3 mod 4. 21, 33, and 77 are. 9, 15, 25, 35, and 49 are not. 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/blum

How many Blum integers are at most n. Through 20 there are 0, through 21 there is 1, through 33 there are 2, and through 100 there are 6. n 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/blum-count

The two prime factors of a Blum integer, smaller first. 21 gives 3,7. 33 gives 3,11. 77 gives 7,11. A non-Blum integer is rejected. 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/blum-factors

The smallest Blum integer that is at least n. 1 gives 21, 22 gives 33, 34 gives 57, and 78 gives 93. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/blum-next

The sum of the Blum integers that are at most n. Through 21 it is 21, through 33 it is 54, through 77 it is 257, and through 100 it is 350. n 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/blum-sum

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

Whether n! + 1 is a perfect square. 4! + 1 = 5^2, 5! + 1 = 11^2, and 7! + 1 = 71^2. The root is 0 when it is not a square. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/brocard

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 cake number, the most pieces of space cut by n planes: (n^3 + 5*n + 6)/6. Zero planes give 1, three give 8, and five give 26. 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/cake-number

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.it.com/api/x402/v1/card-validate

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

How many Carmichael numbers are at most n. Through 560 there are 0, through 561 there is 1, through 1729 there are 3, and through 10000 there are 7. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael-count

The prime factors of a Carmichael number, ascending and comma-separated. 561 gives 3,11,17. 1105 gives 5,13,17. 1729 gives 7,13,19. A non-Carmichael number is rejected. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael-factors

The smallest Carmichael number that is at least n. 1 gives 561, 562 gives 1105, 2000 gives 2465, and 2822 gives 6601. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael-next

Whether n is a Carmichael number: composite, squarefree, and p-1 divides n-1 for every prime p dividing n. 561, 1105, and 1729 are. 1, 91, and 341 are not. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael-number

The sum of the Carmichael numbers that are at most n. Through 561 it is 561, through 1105 it is 1666, through 1729 it is 3395, and through 8911 it is 24193. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/carmichael-sum

The nth Carol number, (2^n - 1)^2 - 2. n=1 gives -1, n=2 gives 7, and n=3 gives 47. n runs from 1 to 128. 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/carol

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

The number of trees on n labeled vertices, n^(n-2). One vertex gives 1, two give 1, three give 3, and four give 16. n runs from 1 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/cayley

The number of rooted trees on n labeled vertices, n^(n-1). Four vertices give 64. n runs from 1 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/cayley-rooted

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

The nth centered s-gonal number, sn(n-1)/2 + 1. Centered triangular 4 is 19, centered square 2 is 5, and centered hexagonal 3 is 19. s runs from 3 to 20 and n 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/centered-polygonal

The nth central binomial coefficient (2n)!/(n!)^2. C(0) is 1, C(1) is 2, C(5) is 252, and C(10) is 184756. n runs from 0 to 200. 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/central-binomial

The index n with central binomial coefficient C(n) equal to value. 1 is index 0, and 2 is index 1. 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/central-index

C(n) mod m for the central binomial coefficients. C(10) mod 7 is 5. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 200. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/central-mod

The ratio C(n)/C(n-1) = (4n-2)/n in lowest terms. For 1 it is 2/1, for 2 it is 3/1, and for 3 it is 10/3. n runs from 1 to 200. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/central-ratio

The sum of central binomial coefficients from lo through hi. The sum from C(0) through C(5) is 351. lo must not pass hi. Each index runs from 0 to 200. 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/central-sum

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

The digit in place pos of 123456789101112..., counting from 1. Place 9 is 9, place 10 is 1, place 11 is 0, and place 190 is 1. pos runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/champernowne-digit

How many digits are used to write the integers from 1 through m. Through 9 there are 9, through 10 there are 11, through 13 there are 17, and through 100 there are 192. m runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/champernowne-len

Which integer owns place pos in the Champernowne digit stream. Place 10 and 11 belong to 10, place 12 belongs to 11, and place 190 belongs to 100. pos runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/champernowne-owner

Where place pos sits inside its integer, counting from 1 on the left. Place 10 is position 1 of 10, place 11 is position 2, and place 12 is position 1 of 11. pos runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/champernowne-place

The first Champernowne place occupied by the integer m. 1 starts at 1, 10 starts at 10, 11 starts at 12, and 100 starts at 190. m runs from 1 to 999999999999. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/champernowne-start

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 2xprev - 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

Whether n is prime and n+2 is either prime or a product of two primes, counted with multiplicity. 2, 41, and 47 are. 43 is not, because 45 has three prime factors. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/chen-prime

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 over HTTPS: GET https://scorptech.it.com/api/x402/v1/chmod-apply

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. Offline data: IANA registry, OpenSSL 3.6 and GnuTLS names. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/cipher-suite-info

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 ax + by = 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

How many Collatz steps until the value is strictly below the start. 1 is already at the bottom and takes 0. 2 takes 1, 6 takes 1, 3 takes 6, and 7 takes 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/collatz-drop

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 largest value on the Collatz path from n through 1, including n. 1 peaks at 1, 3 peaks at 16, 7 peaks at 52, and 27 peaks at 9232. 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/collatz-max

One Collatz step. An even number is halved and an odd number goes to 3n+1. 1 goes to 4, 2 goes to 1, 3 goes to 10, and 6 goes to 3. 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-next

How many odd terms appear before the Collatz path reaches 1. The final 1 is not counted. 1 and 2 give 0, 3 and 6 give 2, and 7 gives 5. 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/collatz-odd

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

How many Collatz steps it takes to reach 1. 1 takes 0, 2 takes 1, 3 takes 7, 6 takes 8, 7 takes 16, and 27 takes 111. 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/collatz-steps

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

The integer complexity of n, the fewest 1s added and multiplied to reach n. 1 is 1, 6 is 5, 12 is 7, and 23 is 11. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/complexity

How many integers from 1 through n have the same complexity as n. 5 has 1, 6 has 2, 10 has 1, and 12 has 2. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/complexity-count

The smallest positive integer whose complexity is k. k=1 gives 1, k=6 gives 7, k=8 gives 11, k=11 gives 23, and k=12 gives 41. k runs from 1 to 19. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/complexity-least

The largest integer complexity attained from 1 through n. Through 1 it is 1, through 10 it is 7, and through 12 it is 8. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/complexity-max

The sum of the integer complexities from 1 through n. Through 1 it is 1, through 10 it is 45, and through 12 it is 60. n runs from 1 to 1000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/complexity-sum

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 over HTTPS: GET https://scorptech.it.com/api/x402/v1/contact-extract

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

The cototient n - totient(n): how many integers from 1 to n share a factor with n. 1 gives 0, 6 gives 4, 9 gives 3, and 10 gives 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/cototient

Whether n and n+4 are both prime. 3 pairs with 7, and 7 pairs with 11. 5 does not pair with 9. n runs from 1 to 1000000000000. The partner is n+4. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cousin-prime

The first index, counting from 1, where Narayana's cow sequence equals n. 0 means n is not a term. 1 is 1, 2 is 4, 4 is 6, 28 is 11, and 5 is 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/cows-index

Narayana's cow term a(n) modulo m. a(11) mod 5 is 3, and a(15) mod 10 is 9. n runs from 1 to 60 and m 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/cows-mod

The smallest Narayana cow number that is at least n. 1 gives 1, 3 gives 3, 5 gives 6, and 130 gives 189. 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/cows-next

The sum of the first n Narayana cow numbers. The first term sums to 1, the first 3 sum to 3, the first 6 sum to 12, and the first 11 sum to 87. 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/cows-sum

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

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

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

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, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/csp-evaluate

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 no cube divides n. 1, 12, 18, and 36 are cubefree. 8, 16, 24, and 72 are not. 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/cubefree

How many cubefree positive integers are at most n. Through 7 there are 7, through 8 there are still 7, through 16 there are 14, and through 24 there are 21. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cubefree-count

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

The fewest positive cubes that add to n. 0 takes 0, 1 takes 1, 8 takes 1, 9 takes 2, 23 takes 9, and 29 takes 3. n runs from 0 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cube-min

The sum of the first n cubes, (n*(n+1)/2)^2. The sum through 2 is 9, and through 10 is 3025. n runs from 0 to 100000. 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/cube-sum

How many ways n is a sum of positive cubes, ignoring order and allowing repeats. 0 has 1 empty sum, 2 has 1, 8 has 2, and 16 has 3. n runs from 0 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cube-ways

The nth Cullen number, n*2^n + 1. The 1st is 3, the 2nd is 9, and the 5th is 161. n runs from 1 to 256. 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/cullen

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 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/curl-to-code

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 arithmetic, no floats. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/currency-format

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

The cyclotomic value Phi_n(a) for an integer a at least 2. Phi_1(2) is 1, Phi_5(2) is 31, Phi_6(3) is 7, and Phi_1(5) is 4. n runs from 1 to 40 and a from 2 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/cyclotomic

The coefficient of x^k in Phi_n. Phi_6 has coefficients 1, -1, 1, so k=1 is -1. The coefficient of x^7 in Phi_105 is -2. k past the degree is rejected. n runs from 1 to 120. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cyclotomic-coeff

The largest absolute coefficient of Phi_n. Phi_1 through Phi_15 have height 1. Phi_105 has height 2. n runs from 1 to 120. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cyclotomic-height

Phi_n(-1). n=1 gives -2, n=2 gives 0, n=6 gives 3, and n=10 gives 5. n runs from 1 to 120. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/cyclotomic-neg

Phi_n(1). It is 0 when n is 1. When n is a power of a prime p, it is p. Otherwise it is 1. Phi_4(1) is 2, Phi_6(1) is 1, and Phi_9(1) is 3. 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/cyclotomic-one

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://scorptech.it.com/api/x402/v1/day-count

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 every duplicate group with its score. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dedupe-records

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

Whether odd n is never a prime plus a power of two, counting 2^0. 1 qualifies, because nothing smaller works. 3 is 2+1, so it does not. 127 is the next, and 905 is another. Even n is rejected. 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/depolignac

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

Whether n equals its arithmetic derivative. 0, 4, 27, and 3125 do. 1, 6, and 16 do not. 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/derivative-fixed

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 sum of the digits of n each raised to k. 0 to any k from 1 up is 0. 153 to the 3 is 153. 4150 to the 5 is 4150, and 4150 to the 4 is 882. n runs from 0 to 999999999999999 and k runs from 1 to 15. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/digit-power-sum

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 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 largest number of divisors attained by any integer from 1 through n, and the smallest integer that attains it. Through 10 the record is 4 at 6. Through 12 it is 6 at 12. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/divisor-record

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 network lookups. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dmarc-report-parse

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 Domb number D(n), the sum of C(n,k)^2 * C(2k,k) * C(2n-2k,n-k) for k from 0 to n. D(0) is 1, D(1) is 4, D(2) is 28, D(3) is 256, and D(5) is 31504. n runs from 0 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/domb

The greatest common divisor of D(n) and D(n+1). n=0 gives 1, n=1 gives 4, and n=6 gives 64. n runs from 0 to 11. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/domb-gcd

D(n) modulo m. D(5) mod 100 is 4, D(6) mod 1000 is 136, and D(1) mod 3 is 1. n runs from 0 to 12 and m 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/domb-mod

The sum of the Domb numbers D(0) through D(n). Through 0 it is 1, through 2 it is 33, through 4 it is 3005, and through 5 it is 34509. n runs from 0 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/domb-sum

One summand of the Domb number, C(n,k)^2 * C(2k,k) * C(2n-2k,n-k). The k=1 summand of D(2) is 16 and the k=0 summand of D(3) is 20. A k past n is 0. n and k run from 0 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/domb-term

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

Whether n is a perfect cube and its digits add to the cube root. 1, 512, 4913, 5832, 17576, and 19683 are. 100 is not a cube. n runs from 1 to 200000. The root is 0 when n is not a Dudeney number. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/dudeney

Whether n is composite and coprime to its divisor sum. 4, 8, 9, 21, and 25 are. 1, 6, 7, and 15 are not. 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/duffinian

How many Duffinian numbers are at most n. Through 1 there are 0, through 4 there is 1, through 9 there are 3, and through 30 there are 7. n 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/duffinian-count

The greatest common divisor of n and its divisor sum. 4 gives 1, 6 gives 6, 9 gives 1, and 15 gives 3. 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/duffinian-gcd

The smallest Duffinian number that is at least n. 1 gives 4, 5 gives 8, 10 gives 16, and 22 gives 25. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/duffinian-next

The sum of the Duffinian numbers that are at most n. Through 4 it is 4, through 9 it is 21, through 20 it is 37, and through 30 it is 110. n 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/duffinian-sum

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

The partial quotients of e from index 0 through n, comma-separated. Through 0 it is "2". Through 5 it is "2,1,2,1,1,4". Through 8 it is "2,1,2,1,1,4,1,1,6". 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/e-cf-prefix

The sum of the partial quotients of e from index 0 through n. Through 0 it is 2, through 2 it is 5, through 5 it is 11, and through 8 it is 19. n runs from 0 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/e-cf-sum

The nth partial quotient of e, starting at n=0. It is 2, then 1, 2, 1, 1, 4, 1, 1, 6. n=0 gives 2, n=5 gives 4, and n=8 gives 6. n runs from 0 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/e-cf-term

The nth convergent of e, as numerator and denominator. n=0 is 2/1, n=1 is 3/1, n=2 is 8/3, and n=5 is 87/32. n runs from 0 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/e-convergent

Extended gcd of a and b. Returns g, x, and y with g = ax + by 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

The greedy Egyptian-fraction denominators of a/b, written comma-separated. 3/7 gives 3,11,231. 5/6 gives 2,3. 1/2 gives 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egyptian

The first denominator in the greedy Egyptian expansion of a/b. 3/7 starts at 3, 5/6 starts at 2, and 2/3 starts at 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egyptian-first

The last denominator in the greedy Egyptian expansion of a/b. 3/7 ends at 231, 8/11 ends at 4070, and 1/2 ends at 2. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egyptian-last

How many unit fractions the greedy Egyptian expansion of a/b uses. 1/2 uses 1, 5/6 uses 2, 3/7 uses 3, and 8/11 uses 4. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egyptian-length

The sum of the denominators in the greedy Egyptian expansion of a/b. 3/7 sums to 245, 5/6 sums to 5, and 8/11 sums to 4114. The fraction must be proper. a and b run from 1 to 30, with b at least 2. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/egyptian-sum

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 per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/email-parse

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: POST https://scorptech.it.com/api/x402/v1/entity-extract

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-check

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 unique, none, or infinitely many solutions in parametric form. Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/equation-solve

Whether the written factorization uses exactly as many digits as n. 1, 10, 16, and 25 do. 4 and 125 do not. 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/equidigital

The partial sum of 1/k! from k=0 through n, as a reduced fraction. n=0 is 1/1, n=2 is 5/2, n=3 is 8/3, n=4 is 65/24, and n=5 is 163/60. n runs from 0 to 15. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/e-series

The nth Euclid-Mullin prime. a(1) is 2, a(4) is 43, a(7) is 5, and a(8) is 6221671. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euclid-mullin

One more than the product of the earlier terms, divided by a(n). It is 1 when that Euclid number is itself prime. n=5 gives 139, n=6 gives 443, n=7 gives 248867, and n=8 gives 1. n runs from 2 to 8. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euclid-mullin-cofactor

Where p sits among the first eight Euclid-Mullin primes, or 0 if it does not. 2 is 1, 43 is 4, 5 is 7, and 11 is 0. p runs from 2 to 6221671. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euclid-mullin-index

The product of the first n Euclid-Mullin primes. n=1 gives 2, n=4 gives 1806, n=7 gives 6221670, and n=8 gives 38709183810570. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euclid-mullin-prod

The sum of the first n Euclid-Mullin primes. Through 1 it is 2, through 4 it is 55, through 7 it is 126, and through 8 it is 6221797. n runs from 1 to 8. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/euclid-mullin-sum

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 Eulerian number A(n, k), the number of permutations of n with k ascents. A(4, 1) is 11, A(5, 2) is 66, and A(n, 0) is 1. k runs from 0 through n-1. n runs from 1 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/eulerian

A(n, k) mod m for the Eulerian numbers. The modulus is a positive decimal integer, and zero is rejected. k must be an ascent of n. n runs from 1 to 60. 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/eulerian-mod

The Eulerian polynomial A_n(x) = sum A(n, k) * x^k. A_3(2) is 13, A_4(1) is 24, and A_5(0) is 1. n runs from 1 to 20, and x runs from 0 to 10. 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/eulerian-poly

The Eulerian row A(n, 0) through A(n, n-1), comma-separated. The row for 5 is 1,26,66,26,1. It is symmetric and sums to n!. n runs from 1 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/eulerian-row

The sum of Eulerian numbers A(n, k) for k from lo through hi. The whole row sums to n!. A(4, 0) through A(4, 1) is 12. lo must not pass hi, and hi must be an ascent of n. 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/eulerian-sum

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

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

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.com/api/x402/v1/evm-contract-info

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/api/x402/v1/evm-selector-decode

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-verify-signature

How many exponential divisors n has. 1 and 6 have 1, 8 and 12 have 2, 16 has 3, and 36 has 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/exp-count

The exponential divisors of n, comma-separated and ascending. 8 gives 2,8. 12 gives 6,12. 16 gives 2,4,16. 36 gives 6,12,18,36. 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/exp-divisors

The smallest exponential perfect number that is at least n. 1 gives 36, 37 gives 180, 180 stays 180, and 181 gives 252. n 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/exp-next

Whether the exponential divisors of n sum to 2n. 36 and 180 do. 6, 12, 16, and 60 do not. 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/exp-perfect

The sum of the exponential divisors of n. 1 gives 1, 8 gives 10, 12 gives 18, 16 gives 22, and 36 gives 72. 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/exp-sigma

Whether the written factorization uses more digits than n. 4, 6, and 12 do. 10 and 125 do not. 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/extravagant

The factorial-base digits of n, from the highest place down through the 0! place, comma-separated. The last digit is always 0. 0 is "0", 5 is "2,1,0", 23 is "3,2,1,0", and 463 is "3,4,1,0,1,0". 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/factoradic

The integer value of factorial-base digits. The last entry is the 0! place. [2, 1, 0] is 5 and [3, 2, 1, 0] is 23. A digit in the k! place must be from 0 through k. At most 20 digits. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/factoradic-decode

The digit of the k! place of n. It is floor(n / k!) mod (k+1), and it is 0 when k! exceeds n. The 0! digit is always 0. For 463 the 5! digit is 3 and the 4! digit is 4. k runs from 0 to 20. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/factoradic-digit

How many factorial-base digits n has, including the 0! place. 0 has 1, 5 has 3, 23 has 4, and 24 has 5. 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/factoradic-length

The sum of the factorial-base digits of n. 0 sums to 0, 5 sums to 3, 23 sums to 6, and 463 sums to 9. 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/factoradic-sum

One concatenation of the prime factors of n, repeats included and primes left unchanged. 2 gives 2, 4 gives 22, 8 gives 222, 9 gives 33, and 10 gives 25. n runs from 2 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/factor-concat

How many digits the written prime factorization uses, omitting exponents of 1. 1 uses 1, 4 uses 2, 12 uses 3, 16 uses 2, and 125 uses 2. 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/factor-digits

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

Whether n! + 1 and n! - 1 are prime. Both are prime for n=3. For n=11, only n! + 1 is prime. For n=12, only n! - 1 is prime. n! - 1 is not prime for n=0 or 1. n runs from 0 to 12. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/factorial-prime

The p-adic valuation of n!, the exponent of the prime p in n!. v_2(10!) is 8, v_3(10!) is 4, and v_2(100!) is 97. p must be prime. 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/factorial-valuation

Whether n equals the sum of the factorials of its digits. 1, 2, 145, and 40585 do. 24 and 10 do not. 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/factorion

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 card test numbers. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fake-data

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

How many reduced fractions lie in the Farey sequence of order n, from 0/1 through 1/1. Order 1 has 2, order 5 has 11, and order 6 has 13. The count is one more than the totient sum. 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/farey-count

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 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 Fermat number 2^(2^n) + 1. n=0 gives 3, n=4 gives 65537, and n=5 gives 4294967297. n runs from 0 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/fermat-number

Whether the Fermat number 2^(2^n) + 1 is prime. n from 0 through 4 gives a prime. n=5 does not: 4294967297 = 641*6700417. n runs from 0 to 5. This checks the given n. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/fermat-prime

Whether the binary expansion of n has no two adjacent 1 bits. 0, 1, 2, 5, 10, and 21 do. 3, 6, and 7 do not. 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/fibbinary

How many fibbinary numbers from 0 through n there are. Through 0 there is 1, through 2 there are 3, through 3 there are 3, through 5 there are 5, through 10 there are 8, and through 21 there are 13. 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/fibbinary-count

The position of n among the fibbinary numbers, counting from 1, or 0 if n is not fibbinary. 0 is 1, 1 is 2, 5 is 5, 10 is 8, 16 is 9, and 3 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/fibbinary-index

The smallest fibbinary number that is at least n. 0 stays 0, 3 gives 4, 6 and 7 give 8, 11 gives 16, and 21 stays 21. 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/fibbinary-next

The nth fibbinary number, counting from 1, with 0 in position 1. The 1st is 0, the 4th is 4, the 8th is 10, the 10th is 17, and the 15th is 33. n 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/fibbinary-nth

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

The sum of the first n fifth powers, n^2(n+1)^2(2n^2+2n-1)/12. The sum through 10 is 220825. n runs from 0 to 10000. 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/fifth-sum

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 URL (first 64 KB, SSRF-safe). Price: $0.002 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/file-type-detect

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 successful call (x402, Solana). Same tool over HTTPS: GET https://scorptech.it.com/api/x402/v1/fitness-calc

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-convert

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

Whether no fourth power divides n. 1, 8, 12, and 36 qualify. 16, 32, 48, and 81 do not. 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/fourth-free

The sum of the first n fourth powers, n(n+1)(2n+1)(3n^2+3n-1)/30. The sum through 0 is 0, through 1 is 1, and through 10 is 25333. n runs from 0 to 10000. 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/fourth-sum

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 Franel number F(n), the sum of C(n,k)^3 for k from 0 to n. F(0) is 1, F(1) is 2, F(2) is 10, F(4) is 346, and F(5) is 2252. n runs from 0 to 16. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/franel

The middle summand of the Franel number, C(n, floor(n/2))^3. n=0 gives 1, n=2 gives 8, n=4 gives 216, n=5 gives 1000, and n=6 gives 8000. n runs from 0 to 16. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/franel-central

The greatest common divisor of F(n) and F(n+1). n=0 gives 1, n=1 gives 2, and n=6 gives 16. n runs from 0 to 15. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/franel-gcd

F(n) modulo m. F(4) mod 7 is 3, F(5) mod 10 is 2, and F(8) mod 100 is 62. n runs from 0 to 16 and m 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/franel-mod

The sum of the Franel numbers F(0) through F(n). Through 0 it is 1, through 1 it is 3, through 4 it is 415, and through 6 it is 17851. n runs from 0 to 16. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/franel-sum

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

Whether the written factorization uses fewer digits than n. 125 and 128 do. 1, 16, and 12 do not. 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/frugal

How many frugal numbers are at most n. Through 124 there are none, through 125 there is 1, and through 200 there are 2. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/frugal-count

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(pn+1, n) / (pn+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(pn+1, n), den is pn+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/fuzzy-match

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 sum of gcd(x, y) over 1 <= x,y <= n. Through 1 it is 1, through 5 it is 37, and through 10 it is 189. n 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/gcd-sum

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

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

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

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. Findings carry line numbers, severity and the fix. Price: $0.003 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/gha-workflow-lint

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 Goldbach split of an even n with the smallest prime p, so n = p+q and p <= q. 10 gives 3 and 7. 20 gives 3 and 17. 4 gives 2 and 2. n is even, from 4 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/goldbach

Whether p and n-p are both prime. For n=10, p=3 and p=5 work, and p=2 does not. n is even, from 4 to 10000, and p runs from 2 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/goldbach-check

How many Goldbach splits an even n has, with p <= q. 10 has 2, 20 has 2, and 100 has 6. n is even, from 4 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/goldbach-count

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

Whether n is a Hamming number, that is 5-smooth. 1, 10, 30, and 36 are. 7 and 14 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/hamming

How many Hamming numbers are at most n. Through 1 there is 1, through 7 there are 6, through 10 there are 9, through 12 there are 10, and through 30 there are 18. 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/hamming-count

The Hamming distance of a and b: how many bit positions differ. 13 and 7 differ in 2 places. 0 and 0 differ in none. Both run 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/hamming-dist

Where n sits in the Hamming sequence, counting from 1, or 0 if it is not Hamming. 1 is 1, 12 is 10, 36 is 20, and 7 is 0. 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/hamming-index

The smallest Hamming number that is at least n. 7 gives 8, 10 stays 10, 11 gives 12, and 31 gives 32. 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/hamming-next

The nth Hamming number, counting from 1. The 1st is 1, the 10th is 12, the 18th is 30, and the 20th is 36. n runs from 1 to 400. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hamming-nth

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 tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hash-encode

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) = 2nH(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

The nth hexanacci number. H(0) through H(4) are 0, H(5) is 1, and H(10) is 16. Each later term adds the previous six. n 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/hexanacci

The smallest index n with hexanacci number H(n) equal to value. 0 is index 0, and 1 is index 5. 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/hexanacci-index

H(n) mod m for the hexanacci numbers. H(10) mod 7 is 2, and H(57) mod 97 is 61. The modulus is a positive decimal integer, and zero is rejected. n runs from 0 to 512. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hexanacci-mod

The hexanacci step H(n) = H(n-1) + H(n-2) + H(n-3) + H(n-4) + H(n-5) + H(n-6). a through f are those six earlier terms, from oldest to newest. n runs from 6 to 512. 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/hexanacci-step

The sum of hexanacci numbers from lo through hi. The sum from H(0) through H(10) is 32. lo must not pass hi. Each index 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/hexanacci-sum

Whether n is a Higgs prime for exponent 2. 2, 13, and 19 are. 4, 9, and 17 are not. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/higgs

How many Higgs primes for exponent 2 are at most n. Through 1 there are 0, through 16 there are 6, through 19 there are 7, and through 100 there are 19. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/higgs-count

The distance from a Higgs prime to the next one. 2 gives 1, 7 gives 4, 13 gives 6, and 71 gives 8. A number that is not a Higgs prime is rejected. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/higgs-gap

The 1-based place of n in the Higgs primes for exponent 2, or 0 when n is absent. 2 is place 1, 19 is place 7, and 17 is absent. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/higgs-index

The smallest Higgs prime for exponent 2 that is at least n. 1 gives 2, 14 gives 19, 17 gives 19, and 73 gives 79. n runs from 1 to 2000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/higgs-next

Whether sigma(n) is strictly larger than sigma(m) for every m below n. 1, 6, 8, and 16 are. 5 and 9 are not. n runs from 1 to 10000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/highly-abundant

Whether n is highly composite: it has strictly more divisors than every smaller positive integer. 1, 2, 6, 12, 60, and 5040 are. 3 and 30 are not. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/highly-composite

How many highly composite numbers are from 1 through n. There are 4 through 10, 9 through 60, and 10 through 120. n runs from 1 to 20000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/highly-composite-count

The least highly composite number greater than or equal to n. 1 gives 1, 3 gives 4, 7 gives 12, and 5041 gives 7560. n runs from 1 to 7560. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/highly-composite-next

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

Whether n is a composite hoax number: its digit sum equals the digit sum of its distinct prime factors. 22, 58, and 84 are. 4 is Smith but not hoax. Primes are not. 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/hoax

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

Hofstadter G. G(0) is 0, G(1) and G(2) are 1, G(5) is 3, and G(10) is 6. The rule is G(n) = n - G(G(n-1)). n runs from 0 to 5000. Price: $0.001 USDC per successful call (x402, Solana). Same tool over HTTPS: POST https://scorptech.it.com/api/x402/v1/hofstadter

Conway's Hofstadter sequence. a(1) and a(2) are 1, a(6) is 4, a(10) is 6, and a(16) is 8. The rule is a(n) = a(a(n-1)) + a(n-a(n-1)). n 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/hofstadter-conway