mcp server

TinyFn

500+ deterministic tools for AI agents: math, conversion, validation, hashing, encoding, date/time.

Description as published by the maintainer. Source

• version 1.0.2
• active

active — Registry entry last updated 2026-06-19.

What this server can do

572 functions, named and described by the server itself. Parameter names are shown because they say more about what a function does than its name usually does.

absolute_value(number)

Get the absolute value of a number. Required: number.

acres_to_hectares(acres)

Convert acres to hectares. Required: acres.

add(numbers)

Add two or more numbers together. Required: numbers.

add_business_days(days, start_date)

Add business days to a date. Required: start_date, days.

add_query_param(key, url, value)

Add a query parameter to a URL. Required: url, key, value.

add_time(date, days, hours, weeks, minutes, seconds)

Add time to a date. Required: date.

add_time_2(days, hours, minutes, seconds, datetime_str)

Add time to a datetime. Required: datetime_str.

adler32_checksum(text)

Calculate Adler-32 checksum. Required: text.

analogous_colors(hex_color)

Get analogous colors (adjacent colors on color wheel). Required: hex_color.

analyze_password(password)

Analyze password strength and characteristics. Required: password.

array_compact(items)

Remove falsy values (empty strings) from array. Required: items.

array_dedupe(items, preserve_order)

Remove duplicates from array. Required: items.

array_difference(array1, array2)

Get difference of two arrays (items in array1 not in array2). Required: array1, array2.

array_fill(value, length)

Create an array filled with a value. Required: value, length.

array_first(n, items)

Get first n items from array. Required: items.

array_frequency(items)

Count frequency of each item. Required: items.

array_interleave(array1, array2)

Interleave two arrays. Required: array1, array2.

array_intersection(array1, array2)

Get intersection of two arrays. Required: array1, array2.

array_last(n, items)

Get last n items from array. Required: items.

array_nth(index, items)

Get item at specific index. Required: items, index.

array_partition(size, items)

Partition array into chunks of specified size. Required: items, size.

array_repeat(items, times)

Repeat an array n times. Required: items, times.

array_reverse(items)

Reverse an array. Required: items.

array_rotate(items, positions)

Rotate an array by n positions. Required: items, positions.

array_slice(end, items, start)

Slice an array. Required: items.

array_symmetric_difference(array1, array2)

Get symmetric difference (items in either but not both). Required: array1, array2.

array_union(array1, array2)

Get union of two arrays. Required: array1, array2.

array_unzip(pairs)

Unzip array of pairs into two arrays. Required: pairs.

array_zip(array1, array2)

Zip two arrays together. Required: array1, array2.

ascii_decode(codes)

Convert ASCII codes to text. Required: codes.

ascii_encode(text)

Get ASCII codes for text. Required: text.

average(numbers)

Calculate the average of a list of numbers. Required: numbers.

base_convert(number, to_base, from_base)

Convert a number between different bases. Required: number, from_base, to_base.

base64_decode(encoded)

Decode base64 to text. Required: encoded.

base64_encode(text)

Encode text to base64. Properly handles Unicode. Required: text.

basic_sentiment(text)

Basic sentiment analysis using word lists. Required: text.

binary_decode(binary)

Decode binary to text. Required: binary.

binary_encode(text)

Encode text to binary. Required: text.

binary_to_decimal(binary)

Convert binary to decimal. Required: binary.

blend_colors(color1, color2, weight)

Blend two colors together. Required: color1, color2.

bounding_box(lat, lon, unit, radius)

Calculate bounding box around a point. Required: lat, lon, radius.

break_even(fixed_costs, cost_per_unit, price_per_unit)

Calculate break-even point. Required: fixed_costs, price_per_unit, cost_per_unit.

build_url(base, path, params)

Build a URL from components. Required: base.

build_url_2(host, path, port, query, scheme)

Build a URL from components. Required: host.

business_days(end_date, start_date)

Count business days between two dates (excluding weekends). Required: start_date, end_date.

bytes_to_human(bytes_val)

Convert bytes to human-readable format. Required: bytes_val.

calculate_age(birthdate)

Calculate age from birthdate. Required: birthdate.

calculate_age_2(as_of, birthdate)

Calculate age from birthdate. Required: birthdate.

calculate_bearing(lat1, lat2, lon1, lon2)

Calculate bearing (direction) between two coordinates. Required: lat1, lon1, lat2, lon2.

calculate_bmi(height_cm, weight_kg)

Calculate Body Mass Index (BMI). Required: weight_kg, height_cm.

calculate_bmr(age, sex, height_cm, weight_kg)

Calculate Basal Metabolic Rate (BMR) using Mifflin-St Jeor equation. Required: weight_kg, height_cm, age, sex.

calculate_correlation(x, y)

Calculate Pearson correlation coefficient. Required: x, y.

calculate_covariance(x, y, population)

Calculate covariance between two datasets. Required: x, y.

calculate_discount(original_price, discount_percent)

Calculate discounted price. Required: original_price, discount_percent.

calculate_macros(goal, calories)

Calculate macronutrient targets. Required: calories.

calculate_margin(cost, selling_price)

Calculate profit margin. Required: selling_price, cost.

calculate_markup(cost, markup_percent)

Calculate selling price from cost and markup. Required: cost, markup_percent.

calculate_mean(numbers)

Calculate arithmetic mean (average). Required: numbers.

calculate_median(numbers)

Calculate median. Required: numbers.

calculate_midpoint(lat1, lat2, lon1, lon2)

Calculate geographic midpoint between two coordinates. Required: lat1, lon1, lat2, lon2.

calculate_mode(numbers)

Calculate mode (most frequent value). Required: numbers.

calculate_percentile(numbers, percentile)

Calculate a specific percentile. Required: numbers, percentile.

calculate_product(numbers)

Calculate product of numbers. Required: numbers.

calculate_quartiles(numbers)

Calculate quartiles (Q1, Q2, Q3). Required: numbers.

calculate_range(numbers)

Calculate range (max - min). Required: numbers.

calculate_stddev(numbers, population)

Calculate standard deviation. Required: numbers.

calculate_sum(numbers)

Calculate sum of numbers. Required: numbers.

calculate_tip(split, amount, tip_percent)

Calculate tip and split bill. Required: amount.

calculate_variance(numbers, population)

Calculate variance. Required: numbers.

calculate_vat(amount, vat_rate, inclusive)

Calculate VAT (Value Added Tax). Required: amount.

calculate_zscore(mean, value, stddev)

Calculate z-score (standard score). Required: value, mean, stddev.

calories_burned(activity, weight_kg, duration_minutes)

Estimate calories burned during activities. Required: activity, duration_minutes, weight_kg.

camel_case(text)

Convert text to camelCase. Required: text.

capitalize(text)

Capitalize the first letter of each word. Required: text.

capitalize_text(text)

Capitalize first letter only. Required: text.

ceil(number)

Round up to nearest integer. Required: number.

celsius_to_fahrenheit(celsius)

Convert Celsius to Fahrenheit. Required: celsius.

celsius_to_kelvin(celsius)

Convert Celsius to Kelvin. Required: celsius.

centimeters_to_inches(centimeters)

Convert centimeters to inches. Required: centimeters.

chunk_array(size, items)

Split items into chunks of specified size. Required: items.

cidr_info(cidr)

Get information about a CIDR range. Required: cidr.

cidr_to_netmask(prefix)

Convert CIDR prefix length to subnet mask. Required: prefix.

clamp(number, maximum, minimum)

Clamp a number within a range. Required: number, minimum, maximum.

cmyk_to_hex(c, k, m, y)

Convert CMYK to hex color. Required: c, m, y, k.

collatz_sequence(number)

Generate Collatz sequence for a number. Required: number.

compare(a, b)

Compare two numbers (e.g., is 0.9 greater than 0.11?). Required: a, b.

compare_2(a, b)

Compare two values. Required: a, b.

compare_decimals(a, b)

Compare decimal numbers with detailed explanation (handles 0.9 vs 0.11 correctly). Required: a, b.

compare_hashes(hash1, hash2)

Compare two hashes in constant time (timing-safe). Required: hash1, hash2.

complement_color(hex_color)

Get the complementary color (opposite on color wheel). Required: hex_color.

compound_interest(rate, time, principal, compounds_per_year)

Calculate compound interest. Required: principal, rate, time.

constant_time_compare(a, b)

Compare two strings in constant time (timing-safe). Required: a, b.

contains(text, search, case_sensitive)

Check if text contains a substring. Required: text, search.

contrast_ratio(color1, color2)

Calculate contrast ratio between two colors (WCAG). Required: color1, color2.

convert_all_cases(text)

Convert text to all case formats at once. Required: text.

convert_timestamp(timestamp)

Convert Unix timestamp to date. Required: timestamp.

convert_timestamp_ms(timestamp_ms)

Convert Unix timestamp (milliseconds) to date. Required: timestamp_ms.

convert_timezone(to_tz, from_tz, datetime_str)

Convert datetime between timezones. Required: datetime_str.

cos(angle)

Calculate the cosine of an angle. Required: angle.

count_all_chars(text)

Count occurrences of each character in text. Required: text.

count_char(char, text, case_sensitive)

Count occurrences of a character (e.g., how many 'r' in 'strawberry'). Required: text, char.

count_digits(number)

Count the number of digits. Required: number.

count_items(items)

Count occurrences of each item. Required: items.

count_substring(text, substring, overlapping, case_sensitive)

Count occurrences of a substring. Required: text, substring.

crc32_checksum(text)

Calculate CRC32 checksum. Required: text.

cube(number)

Calculate the cube of a number. Required: number.

cube_root(number)

Calculate the cube root of a number. Required: number.

cups_to_milliliters(cups)

Convert US cups to milliliters. Required: cups.

current_time(timezone_name)

Get current time in specified timezone.

dad_joke

Get a random dad joke.

daily_water_intake(weight_kg, activity_level)

Calculate recommended daily water intake. Required: weight_kg.

darken_color(amount, hex_color)

Darken a color by a percentage. Required: hex_color.

date_diff(date1, date2)

Calculate difference between two dates. Required: date1, date2.

date_to_timestamp(date)

Convert date to Unix timestamp. Required: date.

datetime_to_unix(datetime_str)

Convert datetime to Unix timestamp. Required: datetime_str.

day_of_year(date)

Get the day of year for a date. Required: date.

days_in_month(year, month)

Get the number of days in a month. Required: year, month.

days_in_month_2(year, month)

Get the number of days in a month. Required: year, month.

decimal_to_binary(number)

Convert decimal to binary. Required: number.

decimal_to_dms(decimal, coordinate_type)

Convert decimal degrees to DMS (degrees, minutes, seconds). Required: decimal, coordinate_type.

decimal_to_hexadecimal(number)

Convert decimal to hexadecimal. Required: number.

decimal_to_octal(number)

Convert decimal to octal. Required: number.

deg_to_rad(degrees)

Convert degrees to radians. Required: degrees.

desaturate_color(amount, hex_color)

Decrease color saturation by a percentage. Required: hex_color.

describe_data(numbers)

Get descriptive statistics for a dataset. Required: numbers.

deslugify(slug, separator, capitalize)

Convert a slug back to readable text. Required: slug.

destination_point(lat, lon, unit, bearing, distance)

Calculate destination point given start, bearing, and distance. Required: lat, lon, bearing, distance.

detect_case(text)

Detect the case style of text. Required: text.

digital_root(number)

Calculate the digital root (repeated digit sum until single digit). Required: number.

distance(x1, x2, y1, y2)

Calculate Euclidean distance between two points. Required: x1, y1, x2, y2.

divide(a, b)

Divide a by b. Required: a, b.

dms_to_decimal(degrees, minutes, seconds, direction)

Convert DMS (degrees, minutes, seconds) to decimal degrees. Required: degrees, minutes, seconds, direction.

echo(message)

Echo back the message. For testing. Required: message.

empty_array

Returns an empty array.

empty_object

Returns an empty object.

end_of_period(period, datetime_str)

Get the end of a time period. Required: datetime_str.

ends_with(text, suffix)

Check if text ends with a suffix. Required: text, suffix.

escape_pattern(text)

Escape special regex characters in text. Required: text.

estimate_body_fat(sex, hip_cm, neck_cm, waist_cm, height_cm)

Estimate body fat percentage using US Navy method. Required: waist_cm, neck_cm, height_cm, sex.

estimate_hash_time(password)

Estimate time to crack a password using brute force. Required: password.

exp(number)

Calculate e raised to the power of number. Required: number.

expand_cidr(limit, network)

Expand a CIDR to list of individual IPs. Required: network.

extract_domain(url, include_subdomain)

Extract domain from a URL. Required: url.

extract_emails(text)

Extract all email addresses from text. Required: text.

extract_groups(text, pattern)

Extract capture groups from a pattern match. Required: pattern, text.

extract_keywords(text, top_n)

Extract keywords from text based on frequency. Required: text.

extract_numbers(text)

Extract all numbers from text. Required: text.

extract_urls(text)

Extract all URLs from text. Required: text.

factorial(number)

Calculate the factorial of a number. Required: number.

fahrenheit_to_celsius(fahrenheit)

Convert Fahrenheit to Celsius. Required: fahrenheit.

false_endpoint

Returns false.

feet_to_meters(feet)

Convert feet to meters. Required: feet.

fibonacci(n)

Get the nth Fibonacci number. Required: n.

file_checksum_guide(algorithm)

Get command-line instructions for file checksums.

filename_safe(filename, max_length, replacement)

Convert a string to a safe filename. Required: filename.

find_all_matches(text, flags, pattern)

Find all matches of a pattern in text. Required: pattern, text.

fizzbuzz(n)

The classic FizzBuzz. Enterprise-grade. Required: n.

flatten_array(json_array)

Flatten a nested array. Required: json_array.

flatten_json(separator, json_string)

Flatten a nested JSON object. Required: json_string.

flip_coin(count)

Flip a coin.

floor(number)

Round down to nearest integer. Required: number.

format_bytes(binary, bytes_value)

Format bytes to human-readable size. Required: bytes_value.

format_credit_card(number)

Format a credit card number with spaces. Required: number.

format_currency(amount, locale, currency)

Format an amount as currency. Required: amount.

format_date(date, format)

Format a date string. Required: date.

format_duration(seconds, verbose)

Format seconds as duration. Required: seconds.

format_list(items, conjunction, oxford_comma)

Format a list of items with proper grammar. Required: items.

format_number(locale, number, decimals)

Format a number with locale-specific separators. Required: number.

format_ordinal(number)

Convert a number to its ordinal form (1st, 2nd, 3rd, etc.). Required: number.

format_percentage(value, decimals, multiply)

Format a number as a percentage. Required: value.

format_phone(number, country)

Format a phone number according to country conventions. Required: number.

format_relative_time(seconds)

Format seconds as relative time (e.g., '2 hours ago', 'in 3 days'). Required: seconds.

format_ssn(number)

Format a Social Security Number. Required: number.

format_truncate(text, length, suffix)

Truncate text to a maximum length. Required: text.

fortune_cookie

Get a fortune cookie message.

friendly_roast(name)

Generate a friendly roast.

future_value(rate, years, present_value)

Calculate future value of an investment. Required: present_value, rate, years.

gallons_uk_to_liters(gallons)

Convert UK gallons to liters. Required: gallons.

gallons_us_to_liters(gallons)

Convert US gallons to liters. Required: gallons.

gcd(a, b)

Calculate the greatest common divisor. Required: a, b.

generate_acronym(text)

Generate acronym from text. Required: text.

generate_addresses(count)

Generate random placeholder addresses.

generate_color(count, format)

Generate random color(s).

generate_companies(count)

Generate random placeholder company names.

generate_dates(count, format, end_year, start_year)

Generate random dates.

generate_emails(count, domain)

Generate random placeholder email addresses.

generate_gradient(steps, color1, color2)

Generate a gradient between two colors. Required: color1, color2.

generate_hash(text, algorithm)

Generate hash of text. Required: text.

generate_hmac(key, message, algorithm)

Generate HMAC signature. Required: message, key.

generate_lorem(paragraphs, sentences_per_paragraph)

Generate lorem ipsum text using Faker.

generate_memorable(pattern)

Generate a memorable password based on a pattern.

generate_names(count, include_last)

Generate random placeholder names.

generate_ngrams(n, text)

Generate n-grams from text. Required: text.

generate_passphrase(words, separator, capitalize, include_number)

Generate a passphrase from random words.

generate_password(count, length, numbers, symbols, lowercase, uppercase, exclude_ambiguous)

Generate secure password(s).

generate_password_2(digits, length, special, lowercase, uppercase, exclude_chars, exclude_ambiguous)

Generate a secure random password.

generate_phones(count, format)

Generate random placeholder phone numbers.

generate_pin(length)

Generate a random PIN.

generate_sequence(end, step, start)

Generate a number sequence.

generate_shades(count, hex_color)

Generate shades (darker variations) of a color. Required: hex_color.

generate_tints(count, hex_color)

Generate tints (lighter variations) of a color. Required: hex_color.

generate_token(format, length)

Generate cryptographically secure token.

generate_uuid(count, version)

Generate UUID(s).

generate_uuid_v7(count)

Generate UUID v7 (time-ordered).

generate_uuids(count)

Generate random UUIDs.

geohash_decode(geohash)

Decode geohash to coordinates. Required: geohash.

geohash_encode(lat, lon, precision)

Encode coordinates to geohash. Required: lat, lon.

geometric_mean(numbers)

Calculate geometric mean. Required: numbers.

get_credit_card_pattern(card_type)

Get regex pattern for credit card validation.

get_date_pattern(format)

Get regex pattern for date validation.

get_divisors(number)

Get all divisors of a number. Required: number.

get_email_pattern(strict)

Get regex pattern for email validation.

get_hex_color_pattern

Get regex pattern for hex color validation.

get_initials(name, separator)

Get initials from a name. Required: name.

get_ipv4_pattern

Get regex pattern for IPv4 address validation.

get_ipv6_pattern

Get regex pattern for IPv6 address validation.

get_json_path(path, json_string)

Extract a value from JSON using a path expression. Required: json_string, path.

get_json_type(json_string)

Get the type of a JSON value. Required: json_string.

get_keys(json_string)

Get all keys from a JSON object. Required: json_string.

get_luminance(hex_color)

Calculate relative luminance of a color. Required: hex_color.

get_now(tz)

Get current date and time.

get_password_pattern(min_length, require_digit, require_special, require_lowercase, require_uppercase)

Get regex pattern for password validation with custom requirements.

get_phone_pattern(country)

Get regex pattern for phone number validation.

get_quarter(datetime_str)

Get the quarter for a date. Required: datetime_str.

get_slug_pattern

Get regex pattern for URL slug validation.

get_time_pattern(format)

Get regex pattern for time validation.

get_url_pattern(require_protocol)

Get regex pattern for URL validation.

get_uuid_pattern(version)

Get regex pattern for UUID validation.

get_values(json_string)

Get all values from a JSON object. Required: json_string.

grams_to_ounces(grams)

Convert grams to ounces. Required: grams.

grayscale_color(hex_color)

Convert color to grayscale. Required: hex_color.

group_by_length(items)

Group items by their string length. Required: items.

harmonic_mean(numbers)

Calculate harmonic mean. Required: numbers.

hash_adler32(text)

Calculate Adler-32 checksum. Required: text.

hash_all(text)

Generate hashes using multiple algorithms at once. Required: text.

hash_blake2b(text, digest_size)

Generate BLAKE2b hash of text. Required: text.

hash_blake2s(text, digest_size)

Generate BLAKE2s hash of text. Required: text.

hash_crc32(text)

Calculate CRC32 checksum. Required: text.

hash_md5(text)

Generate MD5 hash of text. Required: text.

hash_sha1(text)

Generate SHA-1 hash of text. Required: text.

hash_sha256(text)

Generate SHA-256 hash of text. Required: text.

hash_sha3_256(text)

Generate SHA3-256 hash of text. Required: text.

hash_sha3_512(text)

Generate SHA3-512 hash of text. Required: text.

hash_sha384(text)

Generate SHA-384 hash of text. Required: text.

hash_sha512(text)

Generate SHA-512 hash of text. Required: text.

haversine_distance(lat1, lat2, lon1, lon2, unit)

Calculate distance between two coordinates using Haversine formula. Required: lat1, lon1, lat2, lon2.

heart_rate_zones(age, resting_hr)

Calculate heart rate training zones. Required: age.

hello_world(name)

Hello World as a Service.

hex_decode(encoded)

Decode hexadecimal to text. Required: encoded.

hex_encode(text)

Encode text to hexadecimal. Required: text.

hex_to_cmyk(hex_color)

Convert hex color to CMYK. Required: hex_color.

hex_to_hsl(hex_color)

Convert hex color to HSL. Required: hex_color.

hex_to_hsv(hex_color)

Convert hex color to HSV. Required: hex_color.

hex_to_rgb(hex_color)

Convert hex color to RGB. Required: hex_color.

hexadecimal_to_decimal(hexadecimal)

Convert hexadecimal to decimal. Required: hexadecimal.

hmac_md5(key, message)

Generate HMAC-MD5. Required: message, key.

hmac_sha256(key, message)

Generate HMAC-SHA256. Required: message, key.

hmac_sha512(key, message)

Generate HMAC-SHA512. Required: message, key.

hours_to_minutes(hours)

Convert hours to minutes. Required: hours.

hsl_to_hex(h, l, s)

Convert HSL to hex color. Required: h, s, l.

hsv_to_hex(h, s, v)

Convert HSV to hex color. Required: h, s, v.

html_decode(encoded)

HTML decode text (unescape special characters). Required: encoded.

html_encode(text)

HTML encode text (escape special characters). Required: text.

http_method_info(method)

Get information about an HTTP method. Required: method.

hypotenuse(a, b)

Calculate the hypotenuse of a right triangle. Required: a, b.

ideal_weight(sex, height_cm)

Calculate ideal body weight using various formulas. Required: height_cm, sex.

identify_hash(hash_string)

Identify the possible algorithm of a hash based on its format. Required: hash_string.

in_range(value, max_val, min_val)

Check if a value is within a range. Required: value, min_val, max_val.

inches_to_centimeters(inches)

Convert inches to centimeters. Required: inches.

integer_to_ip(integer, version)

Convert integer to IP address. Required: integer.

inverse_case(text)

Inverse the case of each character (same as swap). Required: text.

invert_color(hex_color)

Invert a color. Required: hex_color.

ip_in_network(ip, network)

Check if an IP address is within a network. Required: ip, network.

ip_in_range(ip, cidr)

Check if an IP address is within a CIDR range. Required: ip, cidr.

ip_info(ip)

Get detailed information about an IP address. Required: ip.

ip_info_2(ip)

Get basic information about an IP address. Required: ip.

ip_to_binary(ip)

Convert IP address to binary representation. Required: ip.

ip_to_integer(ip)

Convert IP address to integer. Required: ip.

ipv4_to_ipv6(ipv4)

Convert IPv4 address to IPv6 mapped address. Required: ipv4.

ipv4_to_ipv6_2(ipv4)

Convert IPv4 address to IPv6 mapped format. Required: ipv4.

ipv6_to_ipv4(ipv6)

Extract IPv4 address from IPv6 mapped address. Required: ipv6.

is_armstrong_number(number)

Check if a number is an Armstrong number (narcissistic number). Required: number.

is_between(lower, upper, number, inclusive)

Check if a number is between two bounds. Required: number, lower, upper.

is_common_password(password)

Check if password is in common password list. Required: password.

is_divisible(number, divisor)

Check if a number is divisible by another number. Required: number, divisor.

is_empty(text)

Check if text is empty or whitespace only.

is_even(number)

Check if a number is even. Required: number.

is_fibonacci(number)

Check if a number is a Fibonacci number. Required: number.

is_integer(number)

Check if a number is an integer. Required: number.

is_leap_year(year)

Check if a year is a leap year. Required: year.

is_leap_year_2(year)

Check if a year is a leap year. Required: year.

is_negative(number)

Check if a number is negative. Required: number.

is_odd(number)

Check if a number is odd. Required: number.

is_palindrome(text, ignore_case, ignore_spaces)

Check if text is a palindrome. Required: text.

is_palindrome_number(number)

Check if a number is a palindrome. Required: number.

is_perfect_number(number)

Check if a number is a perfect number (sum of proper divisors equals the number). Required: number.

is_perfect_square(number)

Check if a number is a perfect square. Required: number.

is_positive(number)

Check if a number is positive. Required: number.

is_power_of(base, number)

Check if a number is a power of another number. Required: number, base.

is_prime(number)

Check if a number is prime. Required: number.

is_private_ip(ip)

Check if an IP address is private (RFC 1918 for IPv4). Required: ip.

is_subset(array1, array2)

Check if array1 is a subset of array2. Required: array1, array2.

is_triangular(number)

Check if a number is a triangular number. Required: number.

is_valid_coordinates(lat, lon)

Check if coordinates are valid. Required: lat, lon.

is_valid_hex(hex_color)

Check if a string is a valid hex color. Required: hex_color.

is_valid_slug(slug)

Check if a string is a valid URL slug. Required: slug.

is_valid_url(url, require_protocol)

Validate if a string is a valid URL. Required: url.

is_weekend(date)

Check if a date is a weekend. Required: date.

is_zero(number)

Check if a number is zero. Required: number.

join(items, delimiter)

Join items with a delimiter. Required: items.

join_path(parts, separator)

Join path parts safely. Required: parts.

json_diff(json1, json2)

Compare two JSON objects and find differences. Required: json1, json2.

json_minify(json_str)

Minify JSON (remove whitespace). Required: json_str.

json_prettify(indent, json_str)

Prettify JSON (format with indentation). Required: json_str.

json_stats(json_string)

Get statistics about a JSON structure. Required: json_string.

json_to_query_string(json_string)

Convert a JSON object to URL query string. Required: json_string.

jwt_decode(token)

Decode JWT token (without signature verification). Required: token.

kebab_case(text)

Convert text to kebab-case. Required: text.

kelvin_to_celsius(kelvin)

Convert Kelvin to Celsius. Required: kelvin.

kilobytes_to_megabytes(kilobytes)

Convert kilobytes to megabytes. Required: kilobytes.

kilograms_to_pounds(kilograms)

Convert kilograms to pounds. Required: kilograms.

kilometers_to_miles(kilometers)

Convert kilometers to miles. Required: kilometers.

knots_to_kph(knots)

Convert knots to kilometers per hour. Required: knots.

kph_to_mph(kph)

Convert kilometers per hour to miles per hour. Required: kph.

lcm(a, b)

Calculate the least common multiple. Required: a, b.

leetspeak_password(level, password)

Convert a password to leetspeak (for demonstration, not security). Required: password.

levenshtein_distance(text1, text2)

Calculate Levenshtein (edit) distance between two strings. Required: text1, text2.

lighten_color(amount, hex_color)

Lighten a color by a percentage. Required: hex_color.

list_locales

List available locales for Faker-powered endpoints.

list_timezones

List all available timezone abbreviations.

liters_to_gallons_uk(liters)

Convert liters to UK gallons. Because a UK gallon isn't a US gallon. Required: liters.

liters_to_gallons_us(liters)

Convert liters to US gallons. Required: liters.

loan_payment(rate, months, principal)

Calculate monthly loan payment. Required: principal, rate, months.

log(base, number)

Calculate logarithm. Natural log if no base specified. Required: number.

log10(number)

Calculate base-10 logarithm. Required: number.

log2(number)

Calculate base-2 logarithm. Required: number.

lorem_bytes(size)

Generate lorem ipsum of approximately specified byte size.

lorem_html(paragraphs, include_headings)

Generate lorem ipsum as HTML.

lorem_markdown(paragraphs, include_list, include_headings)

Generate lorem ipsum as Markdown.

lorem_paragraphs(count, start_with_lorem)

Generate lorem ipsum paragraphs.

lorem_sentences(count, start_with_lorem)

Generate lorem ipsum sentences.

lorem_words(count)

Generate lorem ipsum words.

lorem_words_2(count, start_with_lorem)

Generate lorem ipsum words.

lowercase(text)

Convert text to lowercase. Required: text.

magic_8_ball(question)

Ask the Magic 8-Ball. Required: question.

mask_text(end, text, start, mask_char)

Mask text, keeping only start/end characters visible. Required: text.

max_value(numbers)

Find maximum value. Required: numbers.

maximum(numbers)

Find the maximum value. Required: numbers.

md5_checksum(text)

Generate MD5 checksum. Required: text.

megabytes_to_gigabytes(megabytes)

Convert megabytes to gigabytes. Required: megabytes.

merge_json(deep, json1, json2)

Merge two JSON objects. Required: json1, json2.

metaphone(text)

Generate Metaphone phonetic encoding. Required: text.

meters_per_second_to_mph(mps)

Convert meters per second to miles per hour. Required: mps.

meters_to_feet(meters)

Convert meters to feet. Required: meters.

miles_to_kilometers(miles)

Convert miles to kilometers. Required: miles.

milliliters_to_cups(milliliters)

Convert milliliters to US cups. Required: milliliters.

milliliters_to_fluid_ounces(milliliters)

Convert milliliters to US fluid ounces. Required: milliliters.

min_value(numbers)

Find minimum value. Required: numbers.

minify_json(json_string)

Minify (compress) a JSON string. Required: json_string.

minimum(numbers)

Find the minimum value. Required: numbers.

minutes_to_seconds(minutes)

Convert minutes to seconds. Required: minutes.

modulo(a, b)

Calculate a modulo b (remainder of a divided by b). Required: a, b.

morse_decode(morse)

Decode Morse code to text. Required: morse.

morse_encode(text)

Encode text to Morse code. Required: text.

mortgage_calculator(rate, years, home_price, down_payment)

Calculate mortgage details. Required: home_price, rate.

mph_to_kph(mph)

Convert miles per hour to kilometers per hour. Required: mph.

multiply(numbers)

Multiply two or more numbers together. Required: numbers.

name_to_hex(name)

Convert a CSS color name to hex. Required: name.

nearest_power(base, number)

Find the nearest power of a base to a number. Required: number.

netmask_to_cidr(netmask)

Convert subnet mask to CIDR prefix length. Required: netmask.

network_info(network)

Get information about a network. Required: network.

normalize_url(url, sort_params, lowercase_host, remove_default_port, remove_trailing_slash)

Normalize a URL to a canonical form. Required: url.

normalize_whitespace(text)

Normalize whitespace (multiple spaces to single). Required: text.

nth_cube(n)

Get the nth cube number. Required: n.

nth_prime(n)

Get the nth prime number. Required: n.

nth_root(n, number)

Calculate the nth root of a number. Required: number, n.

nth_square(n)

Get the nth square number. Required: n.

nth_triangular(n)

Get the nth triangular number. Required: n.

null

Returns null. For when you need a null.

number_to_roman(number)

Convert a number to Roman numerals. Required: number.

number_to_words(number)

Convert a number to words. Required: number.

ounces_to_grams(ounces)

Convert ounces to grams. Required: ounces.

pad(char, side, text, length)

Pad text to a specified length. Required: text, length.

parse_date(date, format)

Parse a date string. Required: date.

parse_url(url)

Parse a URL into its components. Required: url.

parse_url_2(url)

Parse a URL into its components. Required: url.

pascal_case(text)

Convert text to PascalCase. Required: text.

password_entropy(password)

Calculate password entropy (bits of randomness). Required: password.

percentage(total, value)

Calculate what percentage value is of total. Required: value, total.

percentage_change(new_value, old_value)

Calculate percentage change between two values. Required: old_value, new_value.

pick_random(count, items)

Pick random item(s) from a list. Required: items.

ping

Ping endpoint. Returns pong.

point_in_polygon(lat, lon, polygon)

Check if a point is inside a polygon (ray casting algorithm). Required: lat, lon, polygon.

polygon_area(unit, polygon)

Calculate area of a polygon on Earth's surface. Required: polygon.

polygon_centroid(polygon)

Calculate centroid of a polygon. Required: polygon.

polyline_length(unit, polyline)

Calculate total length of a polyline. Required: polyline.

port_info(port)

Get information about a port number. Required: port.

pounds_to_kilograms(pounds)

Convert pounds to kilograms. Required: pounds.

power(base, exponent)

Calculate base raised to the power of exponent. Required: base, exponent.

present_value(rate, years, future_value)

Calculate present value of a future amount. Required: future_value, rate, years.

prettify_json(indent, sort_keys, json_string)

Prettify (format) a JSON string. Required: json_string.

prime_factors(number)

Get prime factors of a number. Required: number.

primes_in_range(end, start)

Get all prime numbers in a range. Required: start, end.

private_ip_ranges

Get RFC 1918 private IP address ranges.

punycode_decode(encoded)

Decode Punycode to Unicode. Required: encoded.

punycode_encode(text)

Encode Unicode to Punycode (for internationalized domain names). Required: text.

query_string_to_json(query_string)

Convert a URL query string to JSON object. Required: query_string.

rad_to_deg(radians)

Convert radians to degrees. Required: radians.

random_address(count, locale)

Generate random address(es) using Faker with locale support.

random_boolean(count, true_weight)

Generate random boolean value(s).

random_bytes(length, encoding)

Generate cryptographically secure random bytes.

random_bytes_2(format, length)

Generate cryptographically secure random bytes.

random_card(count, include_jokers)

Draw random playing card(s) from a deck.

random_choice(count, items, allow_duplicates)

Pick random item(s) from a list. Required: items.

random_coin(bias, count)

Flip a coin (optionally biased).

random_color

Generate a random color.

random_color_2(count, format)

Generate random color(s).

random_company(count, locale)

Generate random company name(s) using Faker.

random_compliment(name)

Generate a random compliment.

random_coordinates(count, region, decimals)

Generate random geographic coordinates.

random_credit_card(type, count)

Generate random credit card details (fake, for testing only).

random_date(end, count, start, format)

Generate random date(s) within a range.

random_dice(count, sides)

Roll dice with configurable sides.

random_element(count)

Get random chemical element(s).

random_email(safe, count, domain, locale)

Generate random email address(es) using Faker.

random_emoji(count, category)

Get random emoji(s).

random_emoji_2(count, category)

Get random emoji(s).

random_excuse(context)

Generate a random excuse.

random_float(count, max_val, min_val, decimals)

Generate random float(s).

random_float_2(count, max_val, min_val, decimals)

Generate random floating-point number(s).

random_gaussian(mean, count, std_dev, decimals)

Generate random number(s) from a Gaussian (normal) distribution.

random_hex(count, length, prefix, uppercase)

Generate random hexadecimal string(s).

random_integer(count, unique, max_val, min_val)

Generate random integer(s) within a range.

random_ip(count, private, version)

Generate random IP address(es).

random_job(count, locale)

Generate random job title(s) using Faker.

random_mac(count, separator, uppercase)

Generate random MAC address(es).

random_name(type, count, gender, locale)

Generate random name(s) using Faker with locale support.

random_number(count, max_val, min_val)

Generate random integer(s).

random_password(count, length, numbers, symbols, lowercase, uppercase, exclude_ambiguous)

Generate secure random password(s).

random_person(count, gender, locale)

Generate complete random person profile(s) using Faker.

random_phone(count, locale)

Generate random phone number(s) using Faker with locale-appropriate formats.

random_shuffle(items)

Randomly shuffle a list of items. Required: items.

random_string(count, length, charset)

Generate random string(s).

random_string_2(count, length, charset)

Generate random string(s) from specified character set.

random_text(type, count, locale)

Generate random text using Faker.

random_time(count, format, include_seconds)

Generate random time(s) of day.

random_trivia

Get a random trivia fact.

random_url(count)

Generate random URL(s) using Faker.

random_username(count, locale)

Generate random username(s) using Faker.

random_uuid(count, version)

Generate random UUID(s).

random_weighted_choice(count, items, weights)

Pick random item(s) with weighted probabilities. Required: items, weights.

range_to_cidr(end_ip, start_ip)

Convert an IP range to CIDR notation. Required: start_ip, end_ip.

rank_numbers(order, numbers)

Rank a list of numbers from largest to smallest (or vice versa). Required: numbers.

readability_score(text)

Calculate readability scores (Flesch-Kincaid, etc.). Required: text.

regex_replace(text, flags, pattern, replacement)

Replace pattern matches in text. Required: pattern, replacement, text.

regex_split(text, pattern, max_split)

Split text by regex pattern. Required: pattern, text.

relative_time(date)

Get relative time description (e.g., '2 days ago'). Required: date.

remove_duplicate_words(text)

Remove consecutive duplicate words. Required: text.

remove_query_param(key, url)

Remove a query parameter from a URL. Required: url, key.

remove_whitespace(text)

Remove all whitespace from text. Required: text.

repeat(text, times, separator)

Repeat text a specified number of times. Required: text, times.

replace(text, search, replacement)

Replace occurrences in text. Required: text, search.

return_on_investment(cost, gain)

Calculate Return on Investment (ROI). Required: gain, cost.

reverse_number(number)

Reverse the digits of a number. Required: number.

reverse_string(text)

Reverse a string. Required: text.

rgb_to_hex(b, g, r)

Convert RGB to hex color. Required: r, g, b.

rgb_to_hsl(b, g, r)

Convert RGB to HSL color. Required: r, g, b.

roll_dice(count, sides)

Roll dice.

roman_to_number(roman)

Convert Roman numerals to a number. Required: roman.

rot13(text)

Apply ROT13 cipher (encoding and decoding are the same operation). Required: text.

round_number(number, decimals)

Round a number to specified decimal places. Required: number.

rule_of_72(rate)

Calculate time to double investment using Rule of 72. Required: rate.

saturate_color(amount, hex_color)

Increase color saturation by a percentage. Required: hex_color.

seconds_to_hms(seconds)

Convert seconds to hours:minutes:seconds. Required: seconds.

sentence_case(text)

Convert text to sentence case. Required: text.

sha1_checksum(text)

Generate SHA1 checksum. Required: text.

sha256_checksum(text)

Generate SHA256 checksum. Required: text.

sha512_checksum(text)

Generate SHA512 checksum. Required: text.

shuffle_list(items)

Shuffle a list of items. Required: items.

sign(number)

Get the sign of a number (-1, 0, or 1). Required: number.

simple_interest(rate, time, principal)

Calculate simple interest. Required: principal, rate, time.

sin(angle)

Calculate the sine of an angle. Required: angle.

sleep_cycles(wake_time, sleep_time)

Calculate optimal sleep/wake times based on 90-minute sleep cycles.

slug(text)

Convert text to URL-friendly slug. Required: text.

slugify(text, lowercase, separator, max_length)

Convert text to URL-friendly slug. Required: text.

smart_title_case(text)

Smart title case (handles articles, prepositions). Required: text.

snake_case(text)

Convert text to snake_case. Required: text.

sort_items(items, order, numeric)

Sort a list of items. Required: items.

soundex(text)

Generate Soundex phonetic encoding. Required: text.

split(text, delimiter)

Split text by delimiter. Required: text.

split_complementary_colors(hex_color)

Get split-complementary colors. Required: hex_color.

square(number)

Calculate the square of a number. Required: number.

square_feet_to_square_meters(square_feet)

Convert square feet to square meters. Required: square_feet.

square_meters_to_square_feet(square_meters)

Convert square meters to square feet. Required: square_meters.

square_root(number)

Calculate the square root of a number. Required: number.

start_of_period(period, datetime_str)

Get the start of a time period. Required: datetime_str.

starts_with(text, prefix)

Check if text starts with a prefix. Required: text, prefix.

status_code_info(code)

Get information about an HTTP status code. Required: code.

stone_to_kilograms(stone)

Convert stone to kilograms. Required: stone.

string_length(text)

Get the length of a string. Required: text.

subnet_calculator(network, new_prefix)

Calculate subnets from a network. Required: network, new_prefix.

subnet_mask_info(prefix_length)

Get subnet mask from prefix length. Required: prefix_length.

subtract(a, b)

Subtract b from a. Required: a, b.

subtract_time(date, days, hours, weeks, minutes, seconds)

Subtract time from a date. Required: date.

subtract_time_2(days, hours, minutes, seconds, datetime_str)

Subtract time from a datetime. Required: datetime_str.

suggest_improvements(password)

Suggest improvements for a password. Required: password.

sum_digits(number)

Sum the digits of a number. Required: number.

sum_numbers(numbers)

Calculate the sum of numbers. Required: numbers.

sun_position(day, lat, lon, hour, year, month)

Calculate approximate sun position (azimuth and elevation). Required: lat, lon, year, month, day.

supernet_calculator(networks)

Calculate the supernet that contains all given networks. Required: networks.

swap_case(text)

Swap case of each character. Required: text.

tan(angle)

Calculate the tangent of an angle. Required: angle.

test_pattern(text, flags, pattern)

Test if a regex pattern matches text. Required: pattern, text.

tetradic_colors(hex_color)

Get tetradic colors (four colors forming a rectangle on color wheel). Required: hex_color.

text_similarity(text1, text2)

Calculate similarity between two texts (Jaccard similarity). Required: text1, text2.

time_difference(datetime1, datetime2)

Calculate difference between two datetimes. Required: datetime1, datetime2.

timezone_offset(lon)

Estimate timezone offset from longitude (approximate). Required: lon.

title_case(text)

Convert text to title case. Required: text.

to_alternating_case(text, start_upper)

Convert text to aLtErNaTiNg case. Required: text.

to_camel_case(text)

Convert text to camelCase. Required: text.

to_constant_case(text)

Convert text to CONSTANT_CASE (alias for screaming snake). Required: text.

to_dot_case(text)

Convert text to dot.case. Required: text.

to_header_case(text)

Convert text to Header-Case (HTTP header style). Required: text.

to_kebab_case(text)

Convert text to kebab-case. Required: text.

to_lower_case(text)

Convert text to lowercase. Required: text.

to_pascal_case(text)

Convert text to PascalCase. Required: text.

to_path_case(text)

Convert text to path/case. Required: text.

to_roman(number)

Convert number to Roman numerals. Required: number.

to_screaming_snake_case(text)

Convert text to SCREAMING_SNAKE_CASE. Required: text.

to_sentence_case(text)

Convert text to Sentence case. Required: text.

to_snake_case(text)

Convert text to snake_case. Required: text.

to_title_case(text)

Convert text to Title Case. Required: text.

to_train_case(text)

Convert text to Train-Case. Required: text.

to_upper_case(text)

Convert text to UPPERCASE. Required: text.

triadic_colors(hex_color)

Get triadic colors (three colors equally spaced on color wheel). Required: hex_color.

trim(text)

Trim whitespace from text. Required: text.

true_endpoint

Returns true.

truncate(number)

Truncate to integer (remove decimal part). Required: number.

truncate_2(text, length, suffix)

Truncate text to a specified length. Required: text.

unflatten_json(separator, json_string)

Unflatten a flat JSON object back to nested structure. Required: json_string.

unique_items(items)

Get unique items from a list. Required: items.

unix_to_datetime(timestamp, timezone_name)

Convert Unix timestamp to datetime. Required: timestamp.

uppercase(text)

Convert text to uppercase. Required: text.

url_decode(encoded)

URL decode text. Required: encoded.

url_decode_2(text)

URL decode a string. Required: text.

url_encode(text)

URL encode text. Required: text.

url_encode_2(safe, text)

URL encode a string. Required: text.

user_agent(ua)

Parse a user agent string. Required: ua.

validate_alphanumeric(text)

Check if text is alphanumeric. Required: text.

validate_base64(base64_str)

Validate a base64 string. Required: base64_str.

validate_credit_card(number)

Validate a credit card number using Luhn algorithm. Required: number.

validate_date(format, date_str)

Validate a date string. Required: date_str.

validate_domain(domain)

Validate a domain name. Required: domain.

validate_email(email)

Validate an email address. Required: email.

validate_hex(hex_str)

Validate a hexadecimal string. Required: hex_str.

validate_ip(ip)

Validate an IP address (v4 or v6). Required: ip.

validate_ip_2(ip)

Validate if a string is a valid IP address. Required: ip.

validate_json(json_str)

Validate JSON syntax. Required: json_str.

validate_json_2(json_string)

Validate if a string is valid JSON. Required: json_string.

validate_mac(mac)

Validate a MAC address. Required: mac.

validate_password_strength(password)

Check password strength. Required: password.

validate_pattern(pattern)

Validate if a regex pattern is syntactically correct. Required: pattern.

validate_phone(phone, country)

Validate a phone number. Required: phone.

validate_semver(version)

Validate a semantic version string. Required: version.

validate_url(url)

Validate a URL. Required: url.

validate_uuid(uuid_str)

Validate a UUID. Required: uuid_str.

verify_hash(text, algorithm, hash_value)

Verify a hash matches the text. Required: text, hash_value.

week_number(date)

Get the ISO week number of a date. Required: date.

week_number_2(datetime_str)

Get the ISO week number for a date. Required: datetime_str.

word_count(text)

Count words in text. Required: text.

would_you_rather

Get a 'Would You Rather' question.

yes_no(question)

Get a random yes or no answer. Required: question.

Last successful function declaration observed on 2026-08-13. Source: https://api.tinyfn.io/mcp/all/. We list what the server declared; we do not call any of these functions.

Endpoint status observed on 2026-08-13. Source: https://api.tinyfn.io/mcp/all/.

Signals

These are separate measurements of different things. They are deliberately not combined into one score, because a popularity number that mixes website traffic with saves and stars cannot be checked or acted on.

Where to get it

• Repository — https://github.com/tinyfn-io/tinyfn-mcp
• Remote endpoint (streamable-http) — https://api.tinyfn.io/mcp/all/